add search engine code in example/
authorYanhua Yanhua <sun51@illinois.edu>
Fri, 11 Feb 2011 22:09:10 +0000 (16:09 -0600)
committerYanhua Yanhua <sun51@illinois.edu>
Fri, 11 Feb 2011 22:09:10 +0000 (16:09 -0600)
87 files changed:
examples/charm++/state_space_searchengine/3SAT/Makefile [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/defines.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/main.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/main.ci [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/Makefile [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/Solver.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/Solver.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/SolverTypes.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/depend.mk [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/all-wcprops [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/entries [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/format [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Alg.h.svn-base [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/BasicHeap.h.svn-base [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/BoxedVec.h.svn-base [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Map.h.svn-base [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Queue.h.svn-base [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Sort.h.svn-base [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Vec.h.svn-base [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/minisatHeap.h.svn-base [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/template.mk.svn-base [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Alg.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/BasicHeap.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/BoxedVec.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Map.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Queue.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Sort.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Vec.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/minisatHeap.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/minisat/mtl/template.mk [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/searchEngineAPI.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/searchEngineAPI.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/soln-checker.py [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/solvers_convertor.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/solvers_convertor.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/uf125-01.cnf [new file with mode: 0644]
examples/charm++/state_space_searchengine/3SAT/uf200-055.cnf [new file with mode: 0644]
examples/charm++/state_space_searchengine/BalancedTree/Makefile [new file with mode: 0644]
examples/charm++/state_space_searchengine/BalancedTree/main.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/BalancedTree/main.ci [new file with mode: 0644]
examples/charm++/state_space_searchengine/BalancedTree/searchEngineAPI.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/Makefile [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/data/alb1000.hcp [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/data/ham300.hcp [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/data/imp0020.hcp [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/data/imp0048.hcp [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/data/imp0105.hcp [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/data/knights-tour-30.hcp [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/data/knights-tour-48.hcp [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/data/mytest.hcp [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/data/sgl0010.hcp [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/hamiltonian.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/main.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/main.ci [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/searchEngineAPI.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/Hamiltonian_SE/searchEngineAPI.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/Makefile [new file with mode: 0644]
examples/charm++/state_space_searchengine/Makefile.common [new file with mode: 0644]
examples/charm++/state_space_searchengine/NQueens/Makefile [new file with mode: 0644]
examples/charm++/state_space_searchengine/NQueens/main.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/NQueens/main.ci [new file with mode: 0644]
examples/charm++/state_space_searchengine/NQueens/searchEngineAPI.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/README [new file with mode: 0644]
examples/charm++/state_space_searchengine/TSP_SE/Makefile [new file with mode: 0644]
examples/charm++/state_space_searchengine/TSP_SE/exampleTsp.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/TSP_SE/main.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/TSP_SE/main.ci [new file with mode: 0644]
examples/charm++/state_space_searchengine/TSP_SE/searchEngineAPI.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/Makefile [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/main.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/main.ci [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/rng/alfg.c [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/rng/alfg.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/rng/brg_endian.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/rng/brg_sha1.c [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/rng/brg_sha1.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/rng/brg_types.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/rng/rng.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/sample_trees.sh [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/searchEngineAPI.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/uts.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/UnbalancedTreeSearch_SE/uts.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/searchengineLib/Makefile [new file with mode: 0644]
examples/charm++/state_space_searchengine/searchengineLib/searchEngine.C [new file with mode: 0644]
examples/charm++/state_space_searchengine/searchengineLib/searchEngine.ci [new file with mode: 0644]
examples/charm++/state_space_searchengine/searchengineLib/searchEngine.h [new file with mode: 0644]
examples/charm++/state_space_searchengine/searchengineLib/searchEngine_impl.h [new file with mode: 0644]

diff --git a/examples/charm++/state_space_searchengine/3SAT/Makefile b/examples/charm++/state_space_searchengine/3SAT/Makefile
new file mode 100644 (file)
index 0000000..6fb7873
--- /dev/null
@@ -0,0 +1,44 @@
+CHARMC=charmc
+SRC_DIR=./
+MINISAT_DIR=./minisat
+OPTS =-g -I. -DUSEPRIORITY -DOPTIMIZE -D__ALWAYS_INLINE -DSTATISTIC -DONESOLUTION 
+
+OPTS += -I../searchengineLib -L../searchengineLib
+
+include ../Makefile.common
+
+all: main main_minisat
+
+include ../Makefile.common
+
+CMINISATFLAGS = -I$(MINISAT) -DMINISAT
+
+main:  main.o searchEngineAPI.o 
+       $(CHARMC) $(OPTS) -language charm++ main.o searchEngineAPI.o -o main -module searchEngine
+
+main.decl.h: $(SRC_DIR)/main.ci
+       $(CHARMC) $(OPTS) $(SRC_DIR)/main.ci
+
+main.o: $(SRC_DIR)/defines.h $(SRC_DIR)/main.C main.decl.h
+       $(CHARMC) $(OPTS) -c $(SRC_DIR)/main.C
+
+searchEngine.decl.h: $(SRC_DIR)/searchEngine.ci
+       $(CHARMC) $(OPTS) -E $(SRC_DIR)/searchEngine.ci
+
+searchEngineAPI.o: $(SRC_DIR)/searchEngineAPI.C $(SRC_DIR)/searchEngineAPI.h
+       $(CHARMC) -c  $(SRC_DIR)/searchEngineAPI.C
+
+main_minisat:  main.o searchEngineAPI_minisat.o Solver.o solvers_convertor.o 
+       $(CHARMC) $(OPTS) -language charm++ main.o searchEngineAPI_minisat.o Solver.o solvers_convertor.o -o main_minisat -module searchEngine
+
+searchEngineAPI_minisat.o: $(SRC_DIR)/searchEngineAPI.C $(SRC_DIR)/searchEngineAPI.h
+       $(CHARMC) $(CMINISATFLAGS) -o searchEngineAPI_minisat.o -c  $(SRC_DIR)/searchEngineAPI.C
+
+Solver.o: $(MINISAT_DIR)/Solver.C $(MINISAT_DIR)/Solver.h  $(MINISAT_DIR)/SolverTypes.h 
+       $(CHARMC) $(CMINISATFLAGS)  -c $(MINISAT_DIR)/Solver.C
+
+solvers_convertor.o: $(SRC_DIR)/solvers_convertor.C
+       $(CHARMC) $(CMINISATFLAGS) -c $(SRC_DIR)/solvers_convertor.C
+
+clean:
+       rm -f *.decl.h *.def.h conv-host *.o main main_minisat charmrun *~
diff --git a/examples/charm++/state_space_searchengine/3SAT/defines.h b/examples/charm++/state_space_searchengine/3SAT/defines.h
new file mode 100644 (file)
index 0000000..21fd481
--- /dev/null
@@ -0,0 +1,18 @@
+/*
+ * defines.h
+ *
+ *     Project: 3SAT
+ *  Created on: Nov 2, 2010 2:32:13 PM
+ *      Author: xing
+ */
+
+#ifndef DEFINES_H_
+#define DEFINES_H_
+
+#ifdef __ALWAYS_INLINE
+#define __INLINE __attribute__((always_inline)) inline
+#else
+#define __INLINE inline
+#endif /* __ALWAYS_INLINE */
+
+#endif /* DEFINES_H_ */
diff --git a/examples/charm++/state_space_searchengine/3SAT/main.C b/examples/charm++/state_space_searchengine/3SAT/main.C
new file mode 100644 (file)
index 0000000..933b063
--- /dev/null
@@ -0,0 +1,25 @@
+#include "main.decl.h"
+
+#include "searchEngine.h"
+int initial_grainsize;
+char inputfile[50];
+
+class Main
+{
+public:
+    Main(CkArgMsg* msg )
+    {
+        if(msg->argc > 2)
+        {
+            initial_grainsize = atoi(msg->argv[2]);
+        }
+        delete msg;
+
+        CkPrintf("\nInstance file:%s\ngrainsize:t%d\nprocessor number:%d\n", msg->argv[1], initial_grainsize, CkNumPes()); 
+        strcpy(inputfile, msg->argv[1]);
+        searchEngineProxy.start();
+    }
+
+};
+
+#include "main.def.h"
diff --git a/examples/charm++/state_space_searchengine/3SAT/main.ci b/examples/charm++/state_space_searchengine/3SAT/main.ci
new file mode 100644 (file)
index 0000000..385a123
--- /dev/null
@@ -0,0 +1,9 @@
+mainmodule main
+{
+       extern module searchEngine;
+    readonly int initial_grainsize;
+    mainchare Main
+       {
+               entry Main(CkArgMsg *m);
+       }
+}
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/Makefile b/examples/charm++/state_space_searchengine/3SAT/minisat/Makefile
new file mode 100644 (file)
index 0000000..0b520c2
--- /dev/null
@@ -0,0 +1,53 @@
+MTL       = ../mtl
+EXEC      = par_minisat
+
+#CHARMDIR = /Users/yanhuasun/PPL/charm/charm-6.1.2/multicore-darwin-x86_64
+OPTS = -g
+CXX ?= charmc $(OPTS)  
+default: all
+all: sat
+
+
+CXX       ?= g++
+CFLAGS    ?= -I$(MTL) -Wall -ffloat-store
+LFLAGS    ?= -Wall -lz -language charm++
+
+COPTIMIZE ?= -O3
+
+## Compile options
+%.o:                   CFLAGS +=$(COPTIMIZE) -ggdb -D DEBUG
+
+
+CSRCS     ?= $(wildcard *.C)
+CHDRS     ?= $(wildcard *.h)
+COBJS     ?= $(addsuffix .o, $(basename $(CSRCS)))
+
+
+$(EXEC):        $(COBJS)
+
+## Build rule
+%.o:   %.C
+       @echo Compiling: "$@ ( $< )"
+       @$(CXX) $(CFLAGS) -c -o $@ $<
+
+## Linking rules (standard/profile/debug/release)
+$(EXEC):
+       @echo Linking: "$@ ( $^ )"
+        @$(CXX) $^ $(LFLAGS) -o $@
+
+main.o : main.C main.decl.h main.def.h 
+
+par_Solver.o : par_Solver.C par_SolverTypes.h par_Solver.h Solver.C Solver.h
+
+main.def.h main.decl.h : main.ci
+       $(CHARMC) main.ci
+
+Solver.o: Solver.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \
+  ../mtl/Alg.h SolverTypes.h ../mtl/Sort.h ../mtl/Vec.h
+
+## Clean rule
+clean:
+       @rm -f $(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static \
+         $(COBJS) $(PCOBJS) $(DCOBJS) $(RCOBJS) *.core depend.mak lib$(LIB).a lib$(LIB)d.a
+
+
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/Solver.C b/examples/charm++/state_space_searchengine/3SAT/minisat/Solver.C
new file mode 100644 (file)
index 0000000..8e6bd73
--- /dev/null
@@ -0,0 +1,780 @@
+/****************************************************************************************[Solver.C]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+//#include <vector>
+#include "Solver.h"
+#include "mtl/Sort.h"
+#include <cmath>
+
+//using namespace std;
+
+//=================================================================================================
+// Constructor/Destructor:
+
+
+Solver::Solver() :
+
+    // Parameters: (formerly in 'SearchParams')
+    var_decay(1 / 0.95), clause_decay(1 / 0.999), random_var_freq(0.02)
+  , restart_first(100), restart_inc(1.5), learntsize_factor((double)1/(double)3), learntsize_inc(1.1)
+
+    // More parameters:
+    //
+  , expensive_ccmin  (true)
+  , polarity_mode    (polarity_false)
+  , verbosity        (0)
+
+    // Statistics: (formerly in 'SolverStats')
+    //
+  , starts(0), decisions(0), rnd_decisions(0), propagations(0), conflicts(0)
+  , clauses_literals(0), learnts_literals(0), max_literals(0), tot_literals(0)
+
+  , ok               (true)
+  , cla_inc          (1)
+  , var_inc          (1)
+  , qhead            (0)
+  , simpDB_assigns   (-1)
+  , simpDB_props     (0)
+  , order_heap       (VarOrderLt(activity))
+  , random_seed      (91648253)
+  , progress_estimate(0)
+  , remove_satisfied (true)
+{}
+
+
+Solver::~Solver()
+{
+    for (int i = 0; i < learnts.size(); i++) free(learnts[i]);
+    for (int i = 0; i < clauses.size(); i++) free(clauses[i]);
+}
+
+
+/******* framework of sequential solver */
+
+bool seq_processing(int var_size, const vector< vector<int> >& clauses, signed int *v)
+{
+  //   translation from charm program data structure to minisat data structure 
+    
+    Solver      S;
+    S.verbosity = 1;
+    printf(" Now in sequential processing, clauses size:%d\n", clauses.size());
+    for(int i=0; i<clauses.size(); i++)
+    {
+        vector<int> cl = clauses[i];
+
+        vec<Lit> lits;
+        int parsed_lit, var;
+        for(int j=0; j<cl.size(); j++)
+        {
+            parsed_lit = cl[j];
+            var = abs(parsed_lit)-1;
+            while (var >= S.nVars()) S.newVar();
+            lits.push( (parsed_lit > 0) ? Lit(var) : ~Lit(var) );
+        }
+        S.addClause(lits); 
+    }
+    
+    S.simplify();
+
+    bool ret = S.solve();
+   
+    if(ret)
+        printf(" By sequential, satisfiable\n");
+    else
+        printf(" NOT SAT\n");
+    return ret;
+}
+//=================================================================================================
+// Minor methods:
+
+
+// Creates a new SAT variable in the solver. If 'decision_var' is cleared, variable will not be
+// used as a decision variable (NOTE! This has effects on the meaning of a SATISFIABLE result).
+//
+Var Solver::newVar(bool sign, bool dvar)
+{
+    int v = nVars();
+    watches   .push();          // (list for positive literal)
+    watches   .push();          // (list for negative literal)
+    reason    .push(NULL);
+    assigns   .push(toInt(l_Undef));
+    level     .push(-1);
+    activity  .push(0);
+    seen      .push(0);
+
+    polarity    .push((char)sign);
+    decision_var.push((char)dvar);
+
+    insertVarOrder(v);
+    return v;
+}
+
+
+bool Solver::addClause(vec<Lit>& ps)
+{
+    assert(decisionLevel() == 0);
+
+    if (!ok)
+        return false;
+    else{
+        // Check if clause is satisfied and remove false/duplicate literals:
+        sort(ps);
+        Lit p; int i, j;
+        for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
+            if (value(ps[i]) == l_True || ps[i] == ~p)
+                return true;
+            else if (value(ps[i]) != l_False && ps[i] != p)
+                ps[j++] = p = ps[i];
+        ps.shrink(i - j);
+    }
+
+    if (ps.size() == 0)
+        return ok = false;
+    else if (ps.size() == 1){
+        assert(value(ps[0]) == l_Undef);
+        uncheckedEnqueue(ps[0]);
+        return ok = (propagate() == NULL);
+    }else{
+        Clause* c = new Clause(ps, false);
+        //Clause* c = Clause_new(ps, false);
+        clauses.push(c);
+        attachClause(*c);
+    }
+
+    return true;
+}
+
+
+void Solver::attachClause(Clause& c) {
+    assert(c.size() > 1);
+    watches[toInt(~c[0])].push(&c);
+    watches[toInt(~c[1])].push(&c);
+    if (c.learnt()) learnts_literals += c.size();
+    else            clauses_literals += c.size(); }
+
+
+void Solver::detachClause(Clause& c) {
+    assert(c.size() > 1);
+    assert(find(watches[toInt(~c[0])], &c));
+    assert(find(watches[toInt(~c[1])], &c));
+    remove(watches[toInt(~c[0])], &c);
+    remove(watches[toInt(~c[1])], &c);
+    if (c.learnt()) learnts_literals -= c.size();
+    else            clauses_literals -= c.size(); }
+
+
+void Solver::removeClause(Clause& c) {
+    detachClause(c);
+    free(&c); }
+
+
+bool Solver::satisfied(const Clause& c) const {
+    for (int i = 0; i < c.size(); i++)
+        if (value(c[i]) == l_True)
+            return true;
+    return false; }
+
+
+// Revert to the state at given level (keeping all assignment at 'level' but not beyond).
+//
+void Solver::cancelUntil(int level) {
+    if (decisionLevel() > level){
+        for (int c = trail.size()-1; c >= trail_lim[level]; c--){
+            Var     x  = var(trail[c]);
+            assigns[x] = toInt(l_Undef);
+            insertVarOrder(x); }
+        qhead = trail_lim[level];
+        trail.shrink(trail.size() - trail_lim[level]);
+        trail_lim.shrink(trail_lim.size() - level);
+    } }
+
+
+//=================================================================================================
+// Major methods:
+
+
+Lit Solver::pickBranchLit(int polarity_mode, double random_var_freq)
+{
+    Var next = var_Undef;
+
+    // Random decision:
+    if (drand(random_seed) < random_var_freq && !order_heap.empty()){
+        next = order_heap[irand(random_seed,order_heap.size())];
+        if (toLbool(assigns[next]) == l_Undef && decision_var[next])
+            rnd_decisions++; }
+
+    // Activity based decision:
+    while (next == var_Undef || toLbool(assigns[next]) != l_Undef || !decision_var[next])
+        if (order_heap.empty()){
+            next = var_Undef;
+            break;
+        }else
+            next = order_heap.removeMin();
+
+    bool sign = false;
+    switch (polarity_mode){
+    case polarity_true:  sign = false; break;
+    case polarity_false: sign = true;  break;
+    case polarity_user:  sign = polarity[next]; break;
+    case polarity_rnd:   sign = irand(random_seed, 2); break;
+    default: assert(false); }
+
+    return next == var_Undef ? lit_Undef : Lit(next, sign);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyze : (confl : Clause*) (out_learnt : vec<Lit>&) (out_btlevel : int&)  ->  [void]
+|  
+|  Description:
+|    Analyze conflict and produce a reason clause.
+|  
+|    Pre-conditions:
+|      * 'out_learnt' is assumed to be cleared.
+|      * Current decision level must be greater than root level.
+|  
+|    Post-conditions:
+|      * 'out_learnt[0]' is the asserting literal at level 'out_btlevel'.
+|  
+|  Effect:
+|    Will undo part of the trail, upto but not beyond the assumption of the current decision level.
+|________________________________________________________________________________________________@*/
+void Solver::analyze(Clause* confl, vec<Lit>& out_learnt, int& out_btlevel)
+{
+    int pathC = 0;
+    Lit p     = lit_Undef;
+
+    // Generate conflict clause:
+    //
+    out_learnt.push();      // (leave room for the asserting literal)
+    int index   = trail.size() - 1;
+    out_btlevel = 0;
+
+    do{
+        assert(confl != NULL);          // (otherwise should be UIP)
+        Clause& c = *confl;
+
+        if (c.learnt())
+            claBumpActivity(c);
+
+        for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
+            Lit q = c[j];
+
+            if (!seen[var(q)] && level[var(q)] > 0){
+                varBumpActivity(var(q));
+                seen[var(q)] = 1;
+                if (level[var(q)] >= decisionLevel())
+                    pathC++;
+                else{
+                    out_learnt.push(q);
+                    if (level[var(q)] > out_btlevel)
+                        out_btlevel = level[var(q)];
+                }
+            }
+        }
+
+        // Select next clause to look at:
+        while (!seen[var(trail[index--])]);
+        p     = trail[index+1];
+        confl = reason[var(p)];
+        seen[var(p)] = 0;
+        pathC--;
+
+    }while (pathC > 0);
+    out_learnt[0] = ~p;
+
+    // Simplify conflict clause:
+    //
+    int i, j;
+    if (expensive_ccmin){
+        uint32_t abstract_level = 0;
+        for (i = 1; i < out_learnt.size(); i++)
+            abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict)
+
+        out_learnt.copyTo(analyze_toclear);
+        for (i = j = 1; i < out_learnt.size(); i++)
+            if (reason[var(out_learnt[i])] == NULL || !litRedundant(out_learnt[i], abstract_level))
+                out_learnt[j++] = out_learnt[i];
+    }else{
+        out_learnt.copyTo(analyze_toclear);
+        for (i = j = 1; i < out_learnt.size(); i++){
+            Clause& c = *reason[var(out_learnt[i])];
+            for (int k = 1; k < c.size(); k++)
+                if (!seen[var(c[k])] && level[var(c[k])] > 0){
+                    out_learnt[j++] = out_learnt[i];
+                    break; }
+        }
+    }
+    max_literals += out_learnt.size();
+    out_learnt.shrink(i - j);
+    tot_literals += out_learnt.size();
+
+    // Find correct backtrack level:
+    //
+    if (out_learnt.size() == 1)
+        out_btlevel = 0;
+    else{
+        int max_i = 1;
+        for (int i = 2; i < out_learnt.size(); i++)
+            if (level[var(out_learnt[i])] > level[var(out_learnt[max_i])])
+                max_i = i;
+        Lit p             = out_learnt[max_i];
+        out_learnt[max_i] = out_learnt[1];
+        out_learnt[1]     = p;
+        out_btlevel       = level[var(p)];
+    }
+
+
+    for (int j = 0; j < analyze_toclear.size(); j++) seen[var(analyze_toclear[j])] = 0;    // ('seen[]' is now cleared)
+}
+
+
+// Check if 'p' can be removed. 'abstract_levels' is used to abort early if the algorithm is
+// visiting literals at levels that cannot be removed later.
+bool Solver::litRedundant(Lit p, uint32_t abstract_levels)
+{
+    analyze_stack.clear(); analyze_stack.push(p);
+    int top = analyze_toclear.size();
+    while (analyze_stack.size() > 0){
+        assert(reason[var(analyze_stack.last())] != NULL);
+        Clause& c = *reason[var(analyze_stack.last())]; analyze_stack.pop();
+
+        for (int i = 1; i < c.size(); i++){
+            Lit p  = c[i];
+            if (!seen[var(p)] && level[var(p)] > 0){
+                if (reason[var(p)] != NULL && (abstractLevel(var(p)) & abstract_levels) != 0){
+                    seen[var(p)] = 1;
+                    analyze_stack.push(p);
+                    analyze_toclear.push(p);
+                }else{
+                    for (int j = top; j < analyze_toclear.size(); j++)
+                        seen[var(analyze_toclear[j])] = 0;
+                    analyze_toclear.shrink(analyze_toclear.size() - top);
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  analyzeFinal : (p : Lit)  ->  [void]
+|  
+|  Description:
+|    Specialized analysis procedure to express the final conflict in terms of assumptions.
+|    Calculates the (possibly empty) set of assumptions that led to the assignment of 'p', and
+|    stores the result in 'out_conflict'.
+|________________________________________________________________________________________________@*/
+void Solver::analyzeFinal(Lit p, vec<Lit>& out_conflict)
+{
+    out_conflict.clear();
+    out_conflict.push(p);
+
+    if (decisionLevel() == 0)
+        return;
+
+    seen[var(p)] = 1;
+
+    for (int i = trail.size()-1; i >= trail_lim[0]; i--){
+        Var x = var(trail[i]);
+        if (seen[x]){
+            if (reason[x] == NULL){
+                assert(level[x] > 0);
+                out_conflict.push(~trail[i]);
+            }else{
+                Clause& c = *reason[x];
+                for (int j = 1; j < c.size(); j++)
+                    if (level[var(c[j])] > 0)
+                        seen[var(c[j])] = 1;
+            }
+            seen[x] = 0;
+        }
+    }
+
+    seen[var(p)] = 0;
+}
+
+
+void Solver::uncheckedEnqueue(Lit p, Clause* from)
+{
+    assert(value(p) == l_Undef);
+    assigns [var(p)] = toInt(lbool(!sign(p)));  // <<== abstract but not uttermost effecient
+    level   [var(p)] = decisionLevel();
+    reason  [var(p)] = from;
+    trail.push(p);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  propagate : [void]  ->  [Clause*]
+|  
+|  Description:
+|    Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned,
+|    otherwise NULL.
+|  
+|    Post-conditions:
+|      * the propagation queue is empty, even if there was a conflict.
+|________________________________________________________________________________________________@*/
+Clause* Solver::propagate()
+{
+    Clause* confl     = NULL;
+    int     num_props = 0;
+
+    while (qhead < trail.size()){
+        Lit            p   = trail[qhead++];     // 'p' is enqueued fact to propagate.
+        vec<Clause*>&  ws  = watches[toInt(p)];
+        Clause         **i, **j, **end;
+        num_props++;
+
+        for (i = j = (Clause**)ws, end = i + ws.size();  i != end;){
+            Clause& c = **i++;
+
+            // Make sure the false literal is data[1]:
+            Lit false_lit = ~p;
+            if (c[0] == false_lit)
+                c[0] = c[1], c[1] = false_lit;
+
+            assert(c[1] == false_lit);
+
+            // If 0th watch is true, then clause is already satisfied.
+            Lit first = c[0];
+            if (value(first) == l_True){
+                *j++ = &c;
+            }else{
+                // Look for new watch:
+                for (int k = 2; k < c.size(); k++)
+                    if (value(c[k]) != l_False){
+                        c[1] = c[k]; c[k] = false_lit;
+                        watches[toInt(~c[1])].push(&c);
+                        goto FoundWatch; }
+
+                // Did not find watch -- clause is unit under assignment:
+                *j++ = &c;
+                if (value(first) == l_False){
+                    confl = &c;
+                    qhead = trail.size();
+                    // Copy the remaining watches:
+                    while (i < end)
+                        *j++ = *i++;
+                }else
+                    uncheckedEnqueue(first, &c);
+            }
+        FoundWatch:;
+        }
+        ws.shrink(i - j);
+    }
+    propagations += num_props;
+    simpDB_props -= num_props;
+
+    return confl;
+}
+
+/*_________________________________________________________________________________________________
+|
+|  reduceDB : ()  ->  [void]
+|  
+|  Description:
+|    Remove half of the learnt clauses, minus the clauses locked by the current assignment. Locked
+|    clauses are clauses that are reason to some assignment. Binary clauses are never removed.
+|________________________________________________________________________________________________@*/
+struct reduceDB_lt { bool operator () (Clause* x, Clause* y) { return x->size() > 2 && (y->size() == 2 || x->activity() < y->activity()); } };
+void Solver::reduceDB()
+{
+    int     i, j;
+    double  extra_lim = cla_inc / learnts.size();    // Remove any clause below this activity
+
+    sort(learnts, reduceDB_lt());
+    for (i = j = 0; i < learnts.size() / 2; i++){
+        if (learnts[i]->size() > 2 && !locked(*learnts[i]))
+            removeClause(*learnts[i]);
+        else
+            learnts[j++] = learnts[i];
+    }
+    for (; i < learnts.size(); i++){
+        if (learnts[i]->size() > 2 && !locked(*learnts[i]) && learnts[i]->activity() < extra_lim)
+            removeClause(*learnts[i]);
+        else
+            learnts[j++] = learnts[i];
+    }
+    learnts.shrink(i - j);
+}
+
+
+void Solver::removeSatisfied(vec<Clause*>& cs)
+{
+    int i,j;
+    for (i = j = 0; i < cs.size(); i++){
+        if (satisfied(*cs[i]))
+            removeClause(*cs[i]);
+        else
+            cs[j++] = cs[i];
+    }
+    cs.shrink(i - j);
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  simplify : [void]  ->  [bool]
+|  
+|  Description:
+|    Simplify the clause database according to the current top-level assigment. Currently, the only
+|    thing done here is the removal of satisfied clauses, but more things can be put here.
+|________________________________________________________________________________________________@*/
+bool Solver::simplify()
+{
+    assert(decisionLevel() == 0);
+
+    if (!ok || propagate() != NULL)
+        return ok = false;
+
+    if (nAssigns() == simpDB_assigns || (simpDB_props > 0))
+        return true;
+
+    // Remove satisfied clauses:
+    removeSatisfied(learnts);
+    if (remove_satisfied)        // Can be turned off.
+        removeSatisfied(clauses);
+
+    // Remove fixed variables from the variable heap:
+    order_heap.filter(VarFilter(*this));
+
+    simpDB_assigns = nAssigns();
+    simpDB_props   = clauses_literals + learnts_literals;   // (shouldn't depend on stats really, but it will do for now)
+
+    return true;
+}
+
+
+/*_________________________________________________________________________________________________
+|
+|  search : (nof_conflicts : int) (nof_learnts : int) (params : const SearchParams&)  ->  [lbool]
+|  
+|  Description:
+|    Search for a model the specified number of conflicts, keeping the number of learnt clauses
+|    below the provided limit. NOTE! Use negative value for 'nof_conflicts' or 'nof_learnts' to
+|    indicate infinity.
+|  
+|  Output:
+|    'l_True' if a partial assigment that is consistent with respect to the clauseset is found. If
+|    all variables are decision variables, this means that the clause set is satisfiable. 'l_False'
+|    if the clause set is unsatisfiable. 'l_Undef' if the bound on number of conflicts is reached.
+|________________________________________________________________________________________________@*/
+lbool Solver::search(int nof_conflicts, int nof_learnts)
+{
+    assert(ok);
+    int         backtrack_level;
+    int         conflictC = 0;
+    vec<Lit>    learnt_clause;
+
+    starts++;
+
+    bool first = true;
+
+    for (;;){
+        Clause* confl = propagate();
+        if (confl != NULL){
+            // CONFLICT
+            conflicts++; conflictC++;
+            if (decisionLevel() == 0) return l_False;
+
+            first = false;
+
+            learnt_clause.clear();
+            analyze(confl, learnt_clause, backtrack_level);
+            cancelUntil(backtrack_level);
+            assert(value(learnt_clause[0]) == l_Undef);
+
+            if (learnt_clause.size() == 1){
+                uncheckedEnqueue(learnt_clause[0]);
+            }else{
+               // Clause* c = Clause_new(learnt_clause, true);
+                Clause* c = new Clause(learnt_clause, true);
+                learnts.push(c);
+                attachClause(*c);
+                claBumpActivity(*c);
+                uncheckedEnqueue(learnt_clause[0], c);
+            }
+
+            varDecayActivity();
+            claDecayActivity();
+
+        }else{
+            // NO CONFLICT
+
+            if (nof_conflicts >= 0 && conflictC >= nof_conflicts){
+                // Reached bound on number of conflicts:
+                progress_estimate = progressEstimate();
+                cancelUntil(0);
+                return l_Undef; }
+
+            // Simplify the set of problem clauses:
+            if (decisionLevel() == 0 && !simplify())
+                return l_False;
+
+            if (nof_learnts >= 0 && learnts.size()-nAssigns() >= nof_learnts)
+                // Reduce the set of learnt clauses:
+                reduceDB();
+
+            Lit next = lit_Undef;
+            while (decisionLevel() < assumptions.size()){
+                // Perform user provided assumption:
+                Lit p = assumptions[decisionLevel()];
+                if (value(p) == l_True){
+                    // Dummy decision level:
+                    newDecisionLevel();
+                }else if (value(p) == l_False){
+                    analyzeFinal(~p, conflict);
+                    return l_False;
+                }else{
+                    next = p;
+                    break;
+                }
+            }
+
+            if (next == lit_Undef){
+                // New variable decision:
+                decisions++;
+                next = pickBranchLit(polarity_mode, random_var_freq);
+
+                if (next == lit_Undef)
+                    // Model found:
+                    return l_True;
+            }
+
+            // Increase decision level and enqueue 'next'
+            assert(value(next) == l_Undef);
+            newDecisionLevel();
+            uncheckedEnqueue(next);
+        }
+    }
+}
+
+
+double Solver::progressEstimate() const
+{
+    double  progress = 0;
+    double  F = 1.0 / nVars();
+
+    for (int i = 0; i <= decisionLevel(); i++){
+        int beg = i == 0 ? 0 : trail_lim[i - 1];
+        int end = i == decisionLevel() ? trail.size() : trail_lim[i];
+        progress += pow(F, i) * (end - beg);
+    }
+
+    return progress / nVars();
+}
+
+
+bool Solver::solve(const vec<Lit>& assumps)
+{
+    model.clear();
+    conflict.clear();
+
+    if (!ok) return false;
+
+    assumps.copyTo(assumptions);
+
+    double  nof_conflicts = restart_first;
+    double  nof_learnts   = nClauses() * learntsize_factor;
+    lbool   status        = l_Undef;
+
+    if (verbosity >= 1){
+        reportf("============================[ Search Statistics ]==============================\n");
+        reportf("| Conflicts |          ORIGINAL         |          LEARNT          | Progress |\n");
+        reportf("|           |    Vars  Clauses Literals |    Limit  Clauses Lit/Cl |          |\n");
+        reportf("===============================================================================\n");
+    }
+
+    // Search:
+    while (status == l_Undef){
+        if (verbosity >= 1)
+            reportf("| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", (int)conflicts, order_heap.size(), nClauses(), (int)clauses_literals, (int)nof_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progress_estimate*100), fflush(stdout);
+        status = search((int)nof_conflicts, (int)nof_learnts);
+        nof_conflicts *= restart_inc;
+        nof_learnts   *= learntsize_inc;
+    }
+
+    if (verbosity >= 1)
+        reportf("===============================================================================\n");
+
+
+    if (status == l_True){
+        // Extend & copy model:
+        model.growTo(nVars());
+        for (int i = 0; i < nVars(); i++) model[i] = value(i);
+#ifndef NDEBUG
+        verifyModel();
+#endif
+    }else{
+        assert(status == l_False);
+        if (conflict.size() == 0)
+            ok = false;
+    }
+
+    cancelUntil(0);
+    return status == l_True;
+}
+
+//=================================================================================================
+// Debug methods:
+
+
+void Solver::verifyModel()
+{
+    bool failed = false;
+    for (int i = 0; i < clauses.size(); i++){
+        assert(clauses[i]->mark() == 0);
+        Clause& c = *clauses[i];
+        for (int j = 0; j < c.size(); j++)
+            if (modelValue(c[j]) == l_True)
+                goto next;
+
+        reportf("unsatisfied clause: ");
+        printClause(*clauses[i]);
+        reportf("\n");
+        failed = true;
+    next:;
+    }
+
+    assert(!failed);
+
+    reportf("Verified %d original clauses.\n", clauses.size());
+}
+
+
+void Solver::checkLiteralCount()
+{
+    // Check that sizes are calculated correctly:
+    int cnt = 0;
+    for (int i = 0; i < clauses.size(); i++)
+        if (clauses[i]->mark() == 0)
+            cnt += clauses[i]->size();
+
+    if ((int)clauses_literals != cnt){
+        fprintf(stderr, "literal count: %d, real value = %d\n", (int)clauses_literals, cnt);
+        assert((int)clauses_literals == cnt);
+    }
+}
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/Solver.h b/examples/charm++/state_space_searchengine/3SAT/minisat/Solver.h
new file mode 100644 (file)
index 0000000..cefb7c8
--- /dev/null
@@ -0,0 +1,308 @@
+/****************************************************************************************[Solver.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Solver_h
+#define Solver_h
+
+#include <cstdio>
+
+#include "mtl/Vec.h"
+#include "mtl/minisatHeap.h"
+#include "mtl/Alg.h"
+
+#include "SolverTypes.h"
+
+#include <vector>
+
+using namespace std;
+
+//=================================================================================================
+// Solver -- the main class:
+
+
+bool seq_processing(int var_size, const vector< vector<int> >& clauses, signed int *v);
+
+    class Solver {
+public:
+
+    // Constructor/Destructor:
+    //
+    Solver();
+    ~Solver();
+
+
+    // Problem specification:
+    //
+    Var     newVar    (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
+    bool    addClause (vec<Lit>& ps);                           // Add a clause to the solver. NOTE! 'ps' may be shrunk by this method!
+
+    // Solving:
+    //
+    bool    simplify     ();                        // Removes already satisfied clauses.
+    bool    solve        (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions.
+    bool    solve        ();                        // Search without assumptions.
+    bool    okay         () const;                  // FALSE means solver is in a conflicting state
+
+    // Variable mode:
+    // 
+    void    setPolarity    (Var v, bool b); // Declare which polarity the decision heuristic should use for a variable. Requires mode 'polarity_user'.
+    void    setDecisionVar (Var v, bool b); // Declare if a variable should be eligible for selection in the decision heuristic.
+
+    // Read state:
+    //
+    lbool   value      (Var x) const;       // The current value of a variable.
+    lbool   value      (Lit p) const;       // The current value of a literal.
+    lbool   modelValue (Lit p) const;       // The value of a literal in the last model. The last call to solve must have been satisfiable.
+    int     nAssigns   ()      const;       // The current number of assigned literals.
+    int     nClauses   ()      const;       // The current number of original clauses.
+    int     nLearnts   ()      const;       // The current number of learnt clauses.
+    int     nVars      ()      const;       // The current number of variables.
+
+    // Extra results: (read-only member variable)
+    //
+    vec<lbool> model;             // If problem is satisfiable, this vector contains the model (if any).
+    vec<Lit>   conflict;          // If problem is unsatisfiable (possibly under assumptions),
+                                  // this vector represent the final conflict clause expressed in the assumptions.
+
+    // Mode of operation:
+    //
+    double    var_decay;          // Inverse of the variable activity decay factor.                                            (default 1 / 0.95)
+    double    clause_decay;       // Inverse of the clause activity decay factor.                                              (1 / 0.999)
+    double    random_var_freq;    // The frequency with which the decision heuristic tries to choose a random variable.        (default 0.02)
+    int       restart_first;      // The initial restart limit.                                                                (default 100)
+    double    restart_inc;        // The factor with which the restart limit is multiplied in each restart.                    (default 1.5)
+    double    learntsize_factor;  // The intitial limit for learnt clauses is a factor of the original clauses.                (default 1 / 3)
+    double    learntsize_inc;     // The limit for learnt clauses is multiplied with this factor each restart.                 (default 1.1)
+    bool      expensive_ccmin;    // Controls conflict clause minimization.                                                    (default TRUE)
+    int       polarity_mode;      // Controls which polarity the decision heuristic chooses. See enum below for allowed modes. (default polarity_false)
+    int       verbosity;          // Verbosity level. 0=silent, 1=some progress report                                         (default 0)
+
+    enum { polarity_true = 0, polarity_false = 1, polarity_user = 2, polarity_rnd = 3 };
+
+    // Statistics: (read-only member variable)
+    //
+    uint64_t starts, decisions, rnd_decisions, propagations, conflicts;
+    uint64_t clauses_literals, learnts_literals, max_literals, tot_literals;
+
+protected:
+
+    // Helper structures:
+    //
+    struct VarOrderLt {
+        const vec<double>&  activity;
+        bool operator () (Var x, Var y) const { return activity[x] > activity[y]; }
+        VarOrderLt(const vec<double>&  act) : activity(act) { }
+    };
+
+    friend class VarFilter;
+    struct VarFilter {
+        const Solver& s;
+        VarFilter(const Solver& _s) : s(_s) {}
+        bool operator()(Var v) const { return toLbool(s.assigns[v]) == l_Undef && s.decision_var[v]; }
+    };
+
+    // Solver state:
+    //
+    bool                ok;               // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
+    vec<Clause*>        clauses;          // List of problem clauses.
+    vec<Clause*>        learnts;          // List of learnt clauses.
+    double              cla_inc;          // Amount to bump next clause with.
+    vec<double>         activity;         // A heuristic measurement of the activity of a variable.
+    double              var_inc;          // Amount to bump next variable with.
+    vec<vec<Clause*> >  watches;          // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
+    vec<char>           assigns;          // The current assignments (lbool:s stored as char:s).
+    vec<char>           polarity;         // The preferred polarity of each variable.
+    vec<char>           decision_var;     // Declares if a variable is eligible for selection in the decision heuristic.
+    vec<Lit>            trail;            // Assignment stack; stores all assigments made in the order they were made.
+    vec<int>            trail_lim;        // Separator indices for different decision levels in 'trail'.
+    vec<Clause*>        reason;           // 'reason[var]' is the clause that implied the variables current value, or 'NULL' if none.
+    vec<int>            level;            // 'level[var]' contains the level at which the assignment was made.
+    int                 qhead;            // Head of queue (as index into the trail -- no more explicit propagation queue in MiniSat).
+    int                 simpDB_assigns;   // Number of top-level assignments since last execution of 'simplify()'.
+    int64_t             simpDB_props;     // Remaining number of propagations that must be made before next execution of 'simplify()'.
+    vec<Lit>            assumptions;      // Current set of assumptions provided to solve by the user.
+    Heap<VarOrderLt>    order_heap;       // A priority queue of variables ordered with respect to the variable activity.
+    double              random_seed;      // Used by the random variable selection.
+    double              progress_estimate;// Set by 'search()'.
+    bool                remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
+
+    // Temporaries (to reduce allocation overhead). Each variable is prefixed by the method in which it is
+    // used, exept 'seen' wich is used in several places.
+    //
+    vec<char>           seen;
+    vec<Lit>            analyze_stack;
+    vec<Lit>            analyze_toclear;
+    vec<Lit>            add_tmp;
+
+    // Main internal methods:
+    //
+    void     insertVarOrder   (Var x);                                                 // Insert a variable in the decision order priority queue.
+    Lit      pickBranchLit    (int polarity_mode, double random_var_freq);             // Return the next decision variable.
+    void     newDecisionLevel ();                                                      // Begins a new decision level.
+    void     uncheckedEnqueue (Lit p, Clause* from = NULL);                            // Enqueue a literal. Assumes value of literal is undefined.
+    bool     enqueue          (Lit p, Clause* from = NULL);                            // Test if fact 'p' contradicts current state, enqueue otherwise.
+    Clause*  propagate        ();                                                      // Perform unit propagation. Returns possibly conflicting clause.
+    void     cancelUntil      (int level);                                             // Backtrack until a certain level.
+    void     analyze          (Clause* confl, vec<Lit>& out_learnt, int& out_btlevel); // (bt = backtrack)
+    void     analyzeFinal     (Lit p, vec<Lit>& out_conflict);                         // COULD THIS BE IMPLEMENTED BY THE ORDINARIY "analyze" BY SOME REASONABLE GENERALIZATION?
+    bool     litRedundant     (Lit p, uint32_t abstract_levels);                       // (helper method for 'analyze()')
+    lbool    search           (int nof_conflicts, int nof_learnts);                    // Search for a given number of conflicts.
+    void     reduceDB         ();                                                      // Reduce the set of learnt clauses.
+    void     removeSatisfied  (vec<Clause*>& cs);                                      // Shrink 'cs' to contain only non-satisfied clauses.
+
+    // Maintaining Variable/Clause activity:
+    //
+    void     varDecayActivity ();                      // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     varBumpActivity  (Var v);                 // Increase a variable with the current 'bump' value.
+    void     claDecayActivity ();                      // Decay all clauses with the specified factor. Implemented by increasing the 'bump' value instead.
+    void     claBumpActivity  (Clause& c);             // Increase a clause with the current 'bump' value.
+
+    // Operations on clauses:
+    //
+    void     attachClause     (Clause& c);             // Attach a clause to watcher lists.
+    void     detachClause     (Clause& c);             // Detach a clause to watcher lists.
+    void     removeClause     (Clause& c);             // Detach and free a clause.
+    bool     locked           (const Clause& c) const; // Returns TRUE if a clause is a reason for some implication in the current state.
+    bool     satisfied        (const Clause& c) const; // Returns TRUE if a clause is satisfied in the current state.
+
+    // Misc:
+    //
+    int      decisionLevel    ()      const; // Gives the current decisionlevel.
+    uint32_t abstractLevel    (Var x) const; // Used to represent an abstraction of sets of decision levels.
+    double   progressEstimate ()      const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
+
+    // Debug:
+    void     printLit         (Lit l);
+    template<class C>
+    void     printClause      (const C& c);
+    void     verifyModel      ();
+    void     checkLiteralCount();
+
+    // Static helpers:
+    //
+
+    // Returns a random float 0 <= x < 1. Seed must never be 0.
+    static inline double drand(double& seed) {
+        seed *= 1389796;
+        int q = (int)(seed / 2147483647);
+        seed -= (double)q * 2147483647;
+        return seed / 2147483647; }
+
+    // Returns a random integer 0 <= x < size. Seed must never be 0.
+    static inline int irand(double& seed, int size) {
+        return (int)(drand(seed) * size); }
+};
+
+
+//=================================================================================================
+// Implementation of inline methods:
+
+
+inline void Solver::insertVarOrder(Var x) {
+    if (!order_heap.inHeap(x) && decision_var[x]) order_heap.insert(x); }
+
+inline void Solver::varDecayActivity() { var_inc *= var_decay; }
+inline void Solver::varBumpActivity(Var v) {
+    if ( (activity[v] += var_inc) > 1e100 ) {
+        // Rescale:
+        for (int i = 0; i < nVars(); i++)
+            activity[i] *= 1e-100;
+        var_inc *= 1e-100; }
+
+    // Update order_heap with respect to new activity:
+    if (order_heap.inHeap(v))
+        order_heap.decrease(v); }
+
+inline void Solver::claDecayActivity() { cla_inc *= clause_decay; }
+inline void Solver::claBumpActivity (Clause& c) {
+        if ( (c.activity() += cla_inc) > 1e20 ) {
+            // Rescale:
+            for (int i = 0; i < learnts.size(); i++)
+                learnts[i]->activity() *= 1e-20;
+            cla_inc *= 1e-20; } }
+
+inline bool     Solver::enqueue         (Lit p, Clause* from)   { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); }
+inline bool     Solver::locked          (const Clause& c) const { return reason[var(c[0])] == &c && value(c[0]) == l_True; }
+inline void     Solver::newDecisionLevel()                      { trail_lim.push(trail.size()); }
+
+inline int      Solver::decisionLevel ()      const   { return trail_lim.size(); }
+inline uint32_t Solver::abstractLevel (Var x) const   { return 1 << (level[x] & 31); }
+inline lbool    Solver::value         (Var x) const   { return toLbool(assigns[x]); }
+inline lbool    Solver::value         (Lit p) const   { return toLbool(assigns[var(p)]) ^ sign(p); }
+inline lbool    Solver::modelValue    (Lit p) const   { return model[var(p)] ^ sign(p); }
+inline int      Solver::nAssigns      ()      const   { return trail.size(); }
+inline int      Solver::nClauses      ()      const   { return clauses.size(); }
+inline int      Solver::nLearnts      ()      const   { return learnts.size(); }
+inline int      Solver::nVars         ()      const   { return assigns.size(); }
+inline void     Solver::setPolarity   (Var v, bool b) { polarity    [v] = (char)b; }
+inline void     Solver::setDecisionVar(Var v, bool b) { decision_var[v] = (char)b; if (b) { insertVarOrder(v); } }
+inline bool     Solver::solve         ()              { vec<Lit> tmp; return solve(tmp); }
+inline bool     Solver::okay          ()      const   { return ok; }
+
+
+
+//=================================================================================================
+// Debug + etc:
+
+
+#define reportf(format, args...) ( fflush(stdout), fprintf(stderr, format, ## args), fflush(stderr) )
+
+static inline void logLit(FILE* f, Lit l)
+{
+    fprintf(f, "%sx%d", sign(l) ? "~" : "", var(l)+1);
+}
+
+static inline void logLits(FILE* f, const vec<Lit>& ls)
+{
+    fprintf(f, "[ ");
+    if (ls.size() > 0){
+        logLit(f, ls[0]);
+        for (int i = 1; i < ls.size(); i++){
+            fprintf(f, ", ");
+            logLit(f, ls[i]);
+        }
+    }
+    fprintf(f, "] ");
+}
+
+static inline const char* showBool(bool b) { return b ? "true" : "false"; }
+
+
+// Just like 'assert()' but expression will be evaluated in the release version as well.
+static inline void check(bool expr) { assert(expr); }
+
+
+inline void Solver::printLit(Lit l)
+{
+    reportf("%s%d:%c", sign(l) ? "-" : "", var(l)+1, value(l) == l_True ? '1' : (value(l) == l_False ? '0' : 'X'));
+}
+
+
+template<class C>
+inline void Solver::printClause(const C& c)
+{
+    for (int i = 0; i < c.size(); i++){
+        printLit(c[i]);
+        fprintf(stderr, " ");
+    }
+}
+
+
+//=================================================================================================
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/SolverTypes.h b/examples/charm++/state_space_searchengine/3SAT/minisat/SolverTypes.h
new file mode 100644 (file)
index 0000000..394de08
--- /dev/null
@@ -0,0 +1,203 @@
+/***********************************************************************************[SolverTypes.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+
+#ifndef SolverTypes_h
+#define SolverTypes_h
+
+#include <cassert>
+#include <stdint.h>
+
+//=================================================================================================
+// Variables, literals, lifted booleans, clauses:
+
+
+// NOTE! Variables are just integers. No abstraction here. They should be chosen from 0..N,
+// so that they can be used as array indices.
+
+typedef int Var;
+#define var_Undef (-1)
+
+
+class Lit {
+    int     x;
+ public:
+    Lit() : x(2*var_Undef)                                              { }   // (lit_Undef)
+    explicit Lit(Var var, bool sign = false) : x((var+var) + (int)sign) { }
+
+    // Don't use these for constructing/deconstructing literals. Use the normal constructors instead.
+    friend int  toInt       (Lit p);  // Guarantees small, positive integers suitable for array indexing.
+    friend Lit  toLit       (int i);  // Inverse of 'toInt()'
+    friend Lit  operator   ~(Lit p);
+    friend bool sign        (Lit p);
+    friend int  var         (Lit p);
+    friend Lit  unsign      (Lit p);
+    friend Lit  id          (Lit p, bool sgn);
+
+    bool operator == (Lit p) const { return x == p.x; }
+    bool operator != (Lit p) const { return x != p.x; }
+    bool operator <  (Lit p) const { return x < p.x;  } // '<' guarantees that p, ~p are adjacent in the ordering.
+};
+
+inline  int  toInt       (Lit p)           { return p.x; }
+inline  Lit  toLit       (int i)           { Lit p; p.x = i; return p; }
+inline  Lit  operator   ~(Lit p)           { Lit q; q.x = p.x ^ 1; return q; }
+inline  bool sign        (Lit p)           { return p.x & 1; }
+inline  int  var         (Lit p)           { return p.x >> 1; }
+inline  Lit  unsign      (Lit p)           { Lit q; q.x = p.x & ~1; return q; }
+inline  Lit  id          (Lit p, bool sgn) { Lit q; q.x = p.x ^ (int)sgn; return q; }
+
+const Lit lit_Undef(var_Undef, false);  // }- Useful special constants.
+const Lit lit_Error(var_Undef, true );  // }
+
+
+//=================================================================================================
+// Lifted booleans:
+
+
+class lbool {
+    char     value;
+    explicit lbool(int v) : value(v) { }
+
+public:
+    lbool()       : value(0) { }
+    lbool(bool x) : value((int)x*2-1) { }
+    int toInt(void) const { return value; }
+
+    bool  operator == (lbool b) const { return value == b.value; }
+    bool  operator != (lbool b) const { return value != b.value; }
+    lbool operator ^ (bool b) const { return b ? lbool(-value) : lbool(value); }
+
+    friend int   toInt  (lbool l);
+    friend lbool toLbool(int   v);
+};
+inline int   toInt  (lbool l) { return l.toInt(); }
+inline lbool toLbool(int   v) { return lbool(v);  }
+
+const lbool l_True  = toLbool( 1);
+const lbool l_False = toLbool(-1);
+const lbool l_Undef = toLbool( 0);
+
+//=================================================================================================
+// Clause -- a simple class for representing a clause:
+
+
+class Clause {
+    uint32_t size_etc;
+    union { float act; uint32_t abst; } extra;
+    Lit     data[0];
+
+public:
+    void calcAbstraction() {
+        uint32_t abstraction = 0;
+        for (int i = 0; i < size(); i++)
+            abstraction |= 1 << (var(data[i]) & 31);
+        extra.abst = abstraction;  }
+
+    // NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
+    template<class V>
+    Clause(const V& ps, bool learnt) {
+        
+        //assert(sizeof(Lit)      == sizeof(uint32_t));
+        //assert(sizeof(float)    == sizeof(uint32_t));
+        size_etc = (ps.size() << 3) | (uint32_t)learnt;
+        //&data = (Lit*) malloc(sizeof(uint32_t)*(ps.size()));
+        for (int i = 0; i < ps.size(); i++) data[i] = ps[i];
+        if (learnt) extra.act = 0; else calcAbstraction(); 
+   
+    }
+
+    // -- use this function instead:
+    template<class V>
+    friend Clause* Clause_new(const V& ps, bool learnt = false) {
+        assert(sizeof(Lit)      == sizeof(uint32_t));
+        assert(sizeof(float)    == sizeof(uint32_t));
+        void* mem = malloc(sizeof(Clause) + sizeof(uint32_t)*(ps.size()));
+        return new (mem) Clause(ps, learnt); }
+
+    int          size        ()      const   { return size_etc >> 3; }
+    void         shrink      (int i)         { assert(i <= size()); size_etc = (((size_etc >> 3) - i) << 3) | (size_etc & 7); }
+    void         pop         ()              { shrink(1); }
+    bool         learnt      ()      const   { return size_etc & 1; }
+    uint32_t     mark        ()      const   { return (size_etc >> 1) & 3; }
+    void         mark        (uint32_t m)    { size_etc = (size_etc & ~6) | ((m & 3) << 1); }
+    const Lit&   last        ()      const   { return data[size()-1]; }
+
+    // NOTE: somewhat unsafe to change the clause in-place! Must manually call 'calcAbstraction' afterwards for
+    //       subsumption operations to behave correctly.
+    Lit&         operator [] (int i)         { return data[i]; }
+    Lit          operator [] (int i) const   { return data[i]; }
+    operator const Lit* (void) const         { return data; }
+
+    float&       activity    ()              { return extra.act; }
+    uint32_t     abstraction () const { return extra.abst; }
+
+    Lit          subsumes    (const Clause& other) const;
+    void         strengthen  (Lit p);
+};
+
+
+/*_________________________________________________________________________________________________
+|
+|  subsumes : (other : const Clause&)  ->  Lit
+|  
+|  Description:
+|       Checks if clause subsumes 'other', and at the same time, if it can be used to simplify 'other'
+|       by subsumption resolution.
+|  
+|    Result:
+|       lit_Error  - No subsumption or simplification
+|       lit_Undef  - Clause subsumes 'other'
+|       p          - The literal p can be deleted from 'other'
+|________________________________________________________________________________________________@*/
+inline Lit Clause::subsumes(const Clause& other) const
+{
+    if (other.size() < size() || (extra.abst & ~other.extra.abst) != 0)
+        return lit_Error;
+
+    Lit        ret = lit_Undef;
+    const Lit* c  = (const Lit*)(*this);
+    const Lit* d  = (const Lit*)other;
+
+    for (int i = 0; i < size(); i++) {
+        // search for c[i] or ~c[i]
+        for (int j = 0; j < other.size(); j++)
+            if (c[i] == d[j])
+                goto ok;
+            else if (ret == lit_Undef && c[i] == ~d[j]){
+                ret = c[i];
+                goto ok;
+            }
+
+        // did not find it
+        return lit_Error;
+    ok:;
+    }
+
+    return ret;
+}
+
+
+inline void Clause::strengthen(Lit p)
+{
+    remove(*this, p);
+    calcAbstraction();
+}
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/depend.mk b/examples/charm++/state_space_searchengine/3SAT/minisat/depend.mk
new file mode 100644 (file)
index 0000000..bb089f6
--- /dev/null
@@ -0,0 +1,16 @@
+Main.o: Main.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \
+  ../mtl/Alg.h SolverTypes.h
+Solver.o: Solver.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \
+  ../mtl/Alg.h SolverTypes.h ../mtl/Sort.h ../mtl/Vec.h
+Main.op: Main.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \
+  ../mtl/Alg.h SolverTypes.h
+Solver.op: Solver.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \
+  ../mtl/Alg.h SolverTypes.h ../mtl/Sort.h ../mtl/Vec.h
+Main.od: Main.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \
+  ../mtl/Alg.h SolverTypes.h
+Solver.od: Solver.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \
+  ../mtl/Alg.h SolverTypes.h ../mtl/Sort.h ../mtl/Vec.h
+Main.or: Main.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \
+  ../mtl/Alg.h SolverTypes.h
+Solver.or: Solver.C Solver.h ../mtl/Vec.h ../mtl/Heap.h ../mtl/Vec.h \
+  ../mtl/Alg.h SolverTypes.h ../mtl/Sort.h ../mtl/Vec.h
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/all-wcprops b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/all-wcprops
new file mode 100644 (file)
index 0000000..c849073
--- /dev/null
@@ -0,0 +1,59 @@
+K 25
+svn:wc:ra_dav:version-url
+V 62
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl
+END
+template.mk
+K 25
+svn:wc:ra_dav:version-url
+V 74
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl/template.mk
+END
+Map.h
+K 25
+svn:wc:ra_dav:version-url
+V 68
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl/Map.h
+END
+Vec.h
+K 25
+svn:wc:ra_dav:version-url
+V 68
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl/Vec.h
+END
+BasicHeap.h
+K 25
+svn:wc:ra_dav:version-url
+V 74
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl/BasicHeap.h
+END
+BoxedVec.h
+K 25
+svn:wc:ra_dav:version-url
+V 73
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl/BoxedVec.h
+END
+minisatHeap.h
+K 25
+svn:wc:ra_dav:version-url
+V 76
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl/minisatHeap.h
+END
+Alg.h
+K 25
+svn:wc:ra_dav:version-url
+V 68
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl/Alg.h
+END
+Queue.h
+K 25
+svn:wc:ra_dav:version-url
+V 70
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl/Queue.h
+END
+Sort.h
+K 25
+svn:wc:ra_dav:version-url
+V 69
+/svn/fa10-cs598lvk-3sat/!svn/ver/35/3SAT/trunk/src/minisat/mtl/Sort.h
+END
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/entries b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/entries
new file mode 100644 (file)
index 0000000..a820cb2
--- /dev/null
@@ -0,0 +1,136 @@
+8
+
+dir
+38
+https://subversion.ews.illinois.edu/svn/fa10-cs598lvk-3sat/3SAT/trunk/src/minisat/mtl
+https://subversion.ews.illinois.edu/svn/fa10-cs598lvk-3sat
+
+
+
+2010-11-11T04:04:12.452621Z
+35
+sun51
+
+
+svn:special svn:externals svn:needs-lock
+
+
+
+
+
+
+
+
+
+
+
+25c0b13c-9518-479f-a9db-299f4dc035f1
+\f
+template.mk
+file
+
+
+
+
+2010-11-12T06:33:39.000000Z
+d1e07bebc4d810a6d3e6cf42969bbade
+2010-11-11T04:04:12.452621Z
+35
+sun51
+\f
+Map.h
+file
+
+
+
+
+2010-11-12T06:33:39.000000Z
+492953fcc554bc1cff72877a41500147
+2010-11-11T04:04:12.452621Z
+35
+sun51
+\f
+Vec.h
+file
+
+
+
+
+2010-11-12T06:33:39.000000Z
+d3e983735787ced9cb3dbbc1bdedbf77
+2010-11-11T04:04:12.452621Z
+35
+sun51
+\f
+BasicHeap.h
+file
+
+
+
+
+2010-11-12T06:33:39.000000Z
+e648c02f39215bc0d4cb3a900b0b3aae
+2010-11-11T04:04:12.452621Z
+35
+sun51
+\f
+BoxedVec.h
+file
+
+
+
+
+2010-11-12T06:33:39.000000Z
+adee24e2043832da52cb4227e1fe6021
+2010-11-11T04:04:12.452621Z
+35
+sun51
+\f
+minisatHeap.h
+file
+
+
+
+
+2010-11-12T06:33:39.000000Z
+f8add8d49ce12c2271ed47cbdb1e53c7
+2010-11-11T04:04:12.452621Z
+35
+sun51
+\f
+Alg.h
+file
+
+
+
+
+2010-11-12T06:33:39.000000Z
+99184ef52cacfa1ac36e39370c576117
+2010-11-11T04:04:12.452621Z
+35
+sun51
+\f
+Queue.h
+file
+
+
+
+
+2010-11-12T06:33:39.000000Z
+3b09dc025f4552b79eead2a321d46b21
+2010-11-11T04:04:12.452621Z
+35
+sun51
+\f
+Sort.h
+file
+
+
+
+
+2010-11-12T06:33:39.000000Z
+7d5380fb4ba718230f3c60094a1e07d3
+2010-11-11T04:04:12.452621Z
+35
+sun51
+\f
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/format b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/format
new file mode 100644 (file)
index 0000000..45a4fb7
--- /dev/null
@@ -0,0 +1 @@
+8
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Alg.h.svn-base b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Alg.h.svn-base
new file mode 100644 (file)
index 0000000..240962d
--- /dev/null
@@ -0,0 +1,57 @@
+/*******************************************************************************************[Alg.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Alg_h
+#define Alg_h
+
+//=================================================================================================
+// Useful functions on vectors
+
+
+#if 1
+template<class V, class T>
+static inline void remove(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    assert(j < ts.size());
+    for (; j < ts.size()-1; j++) ts[j] = ts[j+1];
+    ts.pop();
+}
+#else
+template<class V, class T>
+static inline void remove(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    assert(j < ts.size());
+    ts[j] = ts.last();
+    ts.pop();
+}
+#endif
+
+template<class V, class T>
+static inline bool find(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    return j < ts.size();
+}
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/BasicHeap.h.svn-base b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/BasicHeap.h.svn-base
new file mode 100644 (file)
index 0000000..556d98f
--- /dev/null
@@ -0,0 +1,98 @@
+/******************************************************************************************[Heap.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef BasicHeap_h
+#define BasicHeap_h
+
+#include "Vec.h"
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template<class Comp>
+class BasicHeap {
+    Comp     lt;
+    vec<int> heap;     // heap of ints
+
+    // Index "traversal" functions
+    static inline int left  (int i) { return i*2+1; }
+    static inline int right (int i) { return (i+1)*2; }
+    static inline int parent(int i) { return (i-1) >> 1; }
+
+    inline void percolateUp(int i)
+    {
+        int x = heap[i];
+        while (i != 0 && lt(x, heap[parent(i)])){
+            heap[i]          = heap[parent(i)];
+            i                = parent(i);
+        }
+        heap   [i] = x;
+    }
+
+
+    inline void percolateDown(int i)
+    {
+        int x = heap[i];
+        while (left(i) < heap.size()){
+            int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+            if (!lt(heap[child], x)) break;
+            heap[i]          = heap[child];
+            i                = child;
+        }
+        heap[i] = x;
+    }
+
+
+    bool heapProperty(int i) {
+        return i >= heap.size()
+            || ((i == 0 || !lt(heap[i], heap[parent(i)])) && heapProperty(left(i)) && heapProperty(right(i))); }
+
+
+  public:
+    BasicHeap(const C& c) : comp(c) { }
+
+    int  size      ()                     const { return heap.size(); }
+    bool empty     ()                     const { return heap.size() == 0; }
+    int  operator[](int index)            const { return heap[index+1]; }
+    void clear     (bool dealloc = false)       { heap.clear(dealloc); }
+    void insert    (int n)                      { heap.push(n); percolateUp(heap.size()-1); }
+
+
+    int  removeMin() {
+        int r   = heap[0];
+        heap[0] = heap.last();
+        heap.pop();
+        if (heap.size() > 1) percolateDown(0);
+        return r; 
+    }
+
+
+    // DEBUG: consistency checking
+    bool heapProperty() {
+        return heapProperty(1); }
+
+
+    // COMPAT: should be removed
+    int  getmin    ()      { return removeMin(); }
+};
+
+
+//=================================================================================================
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/BoxedVec.h.svn-base b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/BoxedVec.h.svn-base
new file mode 100644 (file)
index 0000000..bddf410
--- /dev/null
@@ -0,0 +1,147 @@
+/*******************************************************************************************[Vec.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef BoxedVec_h
+#define BoxedVec_h
+
+#include <cstdlib>
+#include <cassert>
+#include <new>
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template<class T>
+class bvec {
+
+    static inline int imin(int x, int y) {
+        int mask = (x-y) >> (sizeof(int)*8-1);
+        return (x&mask) + (y&(~mask)); }
+
+    static inline int imax(int x, int y) {
+        int mask = (y-x) >> (sizeof(int)*8-1);
+        return (x&mask) + (y&(~mask)); }
+
+    struct Vec_t {
+        int sz;
+        int cap;
+        T   data[0];
+
+        static Vec_t* alloc(Vec_t* x, int size){
+            x = (Vec_t*)realloc((void*)x, sizeof(Vec_t) + sizeof(T)*size);
+            x->cap = size;
+            return x;
+        }
+        
+    };
+
+    Vec_t* ref;
+
+    static const int init_size = 2;
+    static int   nextSize (int current) { return (current * 3 + 1) >> 1; }
+    static int   fitSize  (int needed)  { int x; for (x = init_size; needed > x; x = nextSize(x)); return x; }
+
+    void fill (int size) {
+        assert(ref != NULL);
+        for (T* i = ref->data; i < ref->data + size; i++)
+            new (i) T();
+    }
+
+    void fill (int size, const T& pad) {
+        assert(ref != NULL);
+        for (T* i = ref->data; i < ref->data + size; i++)
+            new (i) T(pad);
+    }
+
+    // Don't allow copying (error prone):
+    altvec<T>&  operator = (altvec<T>& other) { assert(0); }
+    altvec (altvec<T>& other)                  { assert(0); }
+
+public:
+    void     clear  (bool dealloc = false) { 
+        if (ref != NULL){
+            for (int i = 0; i < ref->sz; i++) 
+                (*ref).data[i].~T();
+
+            if (dealloc) { 
+                free(ref); ref = NULL; 
+            }else 
+                ref->sz = 0;
+        } 
+    }
+
+    // Constructors:
+    altvec(void)                   : ref (NULL) { }
+    altvec(int size)               : ref (Vec_t::alloc(NULL, fitSize(size))) { fill(size);      ref->sz = size; }
+    altvec(int size, const T& pad) : ref (Vec_t::alloc(NULL, fitSize(size))) { fill(size, pad); ref->sz = size; }
+   ~altvec(void) { clear(true); }
+
+    // Ownership of underlying array:
+    operator T*       (void)           { return ref->data; }     // (unsafe but convenient)
+    operator const T* (void) const     { return ref->data; }
+
+    // Size operations:
+    int      size   (void) const       { return ref != NULL ? ref->sz : 0; }
+
+    void     pop    (void)             { assert(ref != NULL && ref->sz > 0); int last = --ref->sz; ref->data[last].~T(); }
+    void     push   (const T& elem) {
+        int size = ref != NULL ? ref->sz  : 0;
+        int cap  = ref != NULL ? ref->cap : 0;
+        if (size == cap){
+            cap = cap != 0 ? nextSize(cap) : init_size;
+            ref = Vec_t::alloc(ref, cap); 
+        }
+        //new (&ref->data[size]) T(elem); 
+        ref->data[size] = elem; 
+        ref->sz = size+1; 
+    }
+
+    void     push   () {
+        int size = ref != NULL ? ref->sz  : 0;
+        int cap  = ref != NULL ? ref->cap : 0;
+        if (size == cap){
+            cap = cap != 0 ? nextSize(cap) : init_size;
+            ref = Vec_t::alloc(ref, cap); 
+        }
+        new (&ref->data[size]) T(); 
+        ref->sz = size+1; 
+    }
+
+    void     shrink (int nelems)             { for (int i = 0; i < nelems; i++) pop(); }
+    void     shrink_(int nelems)             { for (int i = 0; i < nelems; i++) pop(); }
+    void     growTo (int size)               { while (this->size() < size) push(); }
+    void     growTo (int size, const T& pad) { while (this->size() < size) push(pad); }
+    void     capacity (int size)             { growTo(size); }
+
+    const T& last  (void) const              { return ref->data[ref->sz-1]; }
+    T&       last  (void)                    { return ref->data[ref->sz-1]; }
+
+    // Vector interface:
+    const T& operator [] (int index) const  { return ref->data[index]; }
+    T&       operator [] (int index)        { return ref->data[index]; }
+
+    void copyTo(altvec<T>& copy) const { copy.clear(); for (int i = 0; i < size(); i++) copy.push(ref->data[i]); }
+    void moveTo(altvec<T>& dest) { dest.clear(true); dest.ref = ref; ref = NULL; }
+
+};
+
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Map.h.svn-base b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Map.h.svn-base
new file mode 100644 (file)
index 0000000..b6d76a3
--- /dev/null
@@ -0,0 +1,118 @@
+/*******************************************************************************************[Map.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Map_h
+#define Map_h
+
+#include <stdint.h>
+
+#include "Vec.h"
+
+//=================================================================================================
+// Default hash/equals functions
+//
+
+template<class K> struct Hash  { uint32_t operator()(const K& k)               const { return hash(k);  } };
+template<class K> struct Equal { bool     operator()(const K& k1, const K& k2) const { return k1 == k2; } };
+
+template<class K> struct DeepHash  { uint32_t operator()(const K* k)               const { return hash(*k);  } };
+template<class K> struct DeepEqual { bool     operator()(const K* k1, const K* k2) const { return *k1 == *k2; } };
+
+//=================================================================================================
+// Some primes
+//
+
+static const int nprimes          = 25;
+static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 };
+
+//=================================================================================================
+// Hash table implementation of Maps
+//
+
+template<class K, class D, class H = Hash<K>, class E = Equal<K> >
+class Map {
+    struct Pair { K key; D data; };
+
+    H          hash;
+    E          equals;
+
+    vec<Pair>* table;
+    int        cap;
+    int        size;
+
+    // Don't allow copying (error prone):
+    Map<K,D,H,E>&  operator = (Map<K,D,H,E>& other) { assert(0); }
+                   Map        (Map<K,D,H,E>& other) { assert(0); }
+
+    int32_t index  (const K& k) const { return hash(k) % cap; }
+    void   _insert (const K& k, const D& d) { table[index(k)].push(); table[index(k)].last().key = k; table[index(k)].last().data = d; }
+    void    rehash () {
+        const vec<Pair>* old = table;
+
+        int newsize = primes[0];
+        for (int i = 1; newsize <= cap && i < nprimes; i++)
+           newsize = primes[i];
+
+        table = new vec<Pair>[newsize];
+
+        for (int i = 0; i < cap; i++){
+            for (int j = 0; j < old[i].size(); j++){
+                _insert(old[i][j].key, old[i][j].data); }}
+
+        delete [] old;
+
+        cap = newsize;
+    }
+
+    
+    public:
+
+     Map () : table(NULL), cap(0), size(0) {}
+     Map (const H& h, const E& e) : Map(), hash(h), equals(e) {}
+    ~Map () { delete [] table; }
+
+    void insert (const K& k, const D& d) { if (size+1 > cap / 2) rehash(); _insert(k, d); size++; }
+    bool peek   (const K& k, D& d) {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k)){
+                d = ps[i].data;
+                return true; } 
+        return false;
+    }
+
+    void remove (const K& k) {
+        assert(table != NULL);
+        vec<Pair>& ps = table[index(k)];
+        int j = 0;
+        for (; j < ps.size() && !equals(ps[j].key, k); j++);
+        assert(j < ps.size());
+        ps[j] = ps.last();
+        ps.pop();
+    }
+
+    void clear  () {
+        cap = size = 0;
+        delete [] table;
+        table = NULL;
+    }
+};
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Queue.h.svn-base b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Queue.h.svn-base
new file mode 100644 (file)
index 0000000..2cc110c
--- /dev/null
@@ -0,0 +1,82 @@
+/*****************************************************************************************[Queue.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Queue_h
+#define Queue_h
+
+#include "Vec.h"
+
+//=================================================================================================
+
+
+template <class T>
+class Queue {
+    vec<T>  elems;
+    int     first;
+
+public:
+    Queue(void) : first(0) { }
+
+    void insert(T x)   { elems.push(x); }
+    T    peek  () const { return elems[first]; }
+    void pop   () { first++; }
+
+    void clear(bool dealloc = false)   { elems.clear(dealloc); first = 0; }
+    int  size(void)    { return elems.size() - first; }
+
+    //bool has(T x) { for (int i = first; i < elems.size(); i++) if (elems[i] == x) return true; return false; }
+
+    const T& operator [] (int index) const  { return elems[first + index]; }
+
+};
+
+//template<class T>
+//class Queue {
+//    vec<T>  buf;
+//    int     first;
+//    int     end;
+//
+//public:
+//    typedef T Key;
+//
+//    Queue() : buf(1), first(0), end(0) {}
+//
+//    void clear () { buf.shrinkTo(1); first = end = 0; }
+//    int  size  () { return (end >= first) ? end - first : end - first + buf.size(); }
+//
+//    T    peek  () { assert(first != end); return buf[first]; }
+//    void pop   () { assert(first != end); first++; if (first == buf.size()) first = 0; }
+//    void insert(T elem) {   // INVARIANT: buf[end] is always unused
+//        buf[end++] = elem;
+//        if (end == buf.size()) end = 0;
+//        if (first == end){  // Resize:
+//            vec<T>  tmp((buf.size()*3 + 1) >> 1);
+//            //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0);
+//            int     i = 0;
+//            for (int j = first; j < buf.size(); j++) tmp[i++] = buf[j];
+//            for (int j = 0    ; j < end       ; j++) tmp[i++] = buf[j];
+//            first = 0;
+//            end   = buf.size();
+//            tmp.moveTo(buf);
+//        }
+//    }
+//};
+
+//=================================================================================================
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Sort.h.svn-base b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Sort.h.svn-base
new file mode 100644 (file)
index 0000000..1f301f5
--- /dev/null
@@ -0,0 +1,93 @@
+/******************************************************************************************[Sort.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Sort_h
+#define Sort_h
+
+#include "Vec.h"
+
+//=================================================================================================
+// Some sorting algorithms for vec's
+
+
+template<class T>
+struct LessThan_default {
+    bool operator () (T x, T y) { return x < y; }
+};
+
+
+template <class T, class LessThan>
+void selectionSort(T* array, int size, LessThan lt)
+{
+    int     i, j, best_i;
+    T       tmp;
+
+    for (i = 0; i < size-1; i++){
+        best_i = i;
+        for (j = i+1; j < size; j++){
+            if (lt(array[j], array[best_i]))
+                best_i = j;
+        }
+        tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
+    }
+}
+template <class T> static inline void selectionSort(T* array, int size) {
+    selectionSort(array, size, LessThan_default<T>()); }
+
+template <class T, class LessThan>
+void sort(T* array, int size, LessThan lt)
+{
+    if (size <= 15)
+        selectionSort(array, size, lt);
+
+    else{
+        T           pivot = array[size / 2];
+        T           tmp;
+        int         i = -1;
+        int         j = size;
+
+        for(;;){
+            do i++; while(lt(array[i], pivot));
+            do j--; while(lt(pivot, array[j]));
+
+            if (i >= j) break;
+
+            tmp = array[i]; array[i] = array[j]; array[j] = tmp;
+        }
+
+        sort(array    , i     , lt);
+        sort(&array[i], size-i, lt);
+    }
+}
+template <class T> static inline void sort(T* array, int size) {
+    sort(array, size, LessThan_default<T>()); }
+
+
+//=================================================================================================
+// For 'vec's:
+
+
+template <class T, class LessThan> void sort(vec<T>& v, LessThan lt) {
+    sort((T*)v, v.size(), lt); }
+template <class T> void sort(vec<T>& v) {
+    sort(v, LessThan_default<T>()); }
+
+
+//=================================================================================================
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Vec.h.svn-base b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/Vec.h.svn-base
new file mode 100644 (file)
index 0000000..e780aa1
--- /dev/null
@@ -0,0 +1,133 @@
+/*******************************************************************************************[Vec.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Vec_h
+#define Vec_h
+
+#include <cstdlib>
+#include <cassert>
+#include <new>
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template<class T>
+class vec {
+    T*  data;
+    int sz;
+    int cap;
+
+    void     init(int size, const T& pad);
+    void     grow(int min_cap);
+
+    // Don't allow copying (error prone):
+    vec<T>&  operator = (vec<T>& other) { assert(0); return *this; }
+             vec        (vec<T>& other) { assert(0); }
+
+    static inline int imin(int x, int y) {
+        int mask = (x-y) >> (sizeof(int)*8-1);
+        return (x&mask) + (y&(~mask)); }
+
+    static inline int imax(int x, int y) {
+        int mask = (y-x) >> (sizeof(int)*8-1);
+        return (x&mask) + (y&(~mask)); }
+
+public:
+    // Types:
+    typedef int Key;
+    typedef T   Datum;
+
+    // Constructors:
+    vec(void)                   : data(NULL) , sz(0)   , cap(0)    { }
+    vec(int size)               : data(NULL) , sz(0)   , cap(0)    { growTo(size); }
+    vec(int size, const T& pad) : data(NULL) , sz(0)   , cap(0)    { growTo(size, pad); }
+    vec(T* array, int size)     : data(array), sz(size), cap(size) { }      // (takes ownership of array -- will be deallocated with 'free()')
+   ~vec(void)                                                      { clear(true); }
+
+    // Ownership of underlying array:
+    T*       release  (void)           { T* ret = data; data = NULL; sz = 0; cap = 0; return ret; }
+    operator T*       (void)           { return data; }     // (unsafe but convenient)
+    operator const T* (void) const     { return data; }
+
+    // Size operations:
+    int      size   (void) const       { return sz; }
+    void     shrink (int nelems)       { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); }
+    void     shrink_(int nelems)       { assert(nelems <= sz); sz -= nelems; }
+    void     pop    (void)             { sz--, data[sz].~T(); }
+    void     growTo (int size);
+    void     growTo (int size, const T& pad);
+    void     clear  (bool dealloc = false);
+    void     capacity (int size) { grow(size); }
+
+    // Stack interface:
+#if 1
+    void     push  (void)              { if (sz == cap) { cap = imax(2, (cap*3+1)>>1); data = (T*)realloc(data, cap * sizeof(T)); } new (&data[sz]) T(); sz++; }
+    //void     push  (const T& elem)     { if (sz == cap) { cap = imax(2, (cap*3+1)>>1); data = (T*)realloc(data, cap * sizeof(T)); } new (&data[sz]) T(elem); sz++; }
+    void     push  (const T& elem)     { if (sz == cap) { cap = imax(2, (cap*3+1)>>1); data = (T*)realloc(data, cap * sizeof(T)); } data[sz++] = elem; }
+    void     push_ (const T& elem)     { assert(sz < cap); data[sz++] = elem; }
+#else
+    void     push  (void)              { if (sz == cap) grow(sz+1); new (&data[sz]) T()    ; sz++; }
+    void     push  (const T& elem)     { if (sz == cap) grow(sz+1); new (&data[sz]) T(elem); sz++; }
+#endif
+
+    const T& last  (void) const        { return data[sz-1]; }
+    T&       last  (void)              { return data[sz-1]; }
+
+    // Vector interface:
+    const T& operator [] (int index) const  { return data[index]; }
+    T&       operator [] (int index)        { return data[index]; }
+
+
+    // Duplicatation (preferred instead):
+    void copyTo(vec<T>& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) new (&copy[i]) T(data[i]); }
+    void moveTo(vec<T>& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }
+};
+
+template<class T>
+void vec<T>::grow(int min_cap) {
+    if (min_cap <= cap) return;
+    if (cap == 0) cap = (min_cap >= 2) ? min_cap : 2;
+    else          do cap = (cap*3+1) >> 1; while (cap < min_cap);
+    data = (T*)realloc(data, cap * sizeof(T)); }
+
+template<class T>
+void vec<T>::growTo(int size, const T& pad) {
+    if (sz >= size) return;
+    grow(size);
+    for (int i = sz; i < size; i++) new (&data[i]) T(pad);
+    sz = size; }
+
+template<class T>
+void vec<T>::growTo(int size) {
+    if (sz >= size) return;
+    grow(size);
+    for (int i = sz; i < size; i++) new (&data[i]) T();
+    sz = size; }
+
+template<class T>
+void vec<T>::clear(bool dealloc) {
+    if (data != NULL){
+        for (int i = 0; i < sz; i++) data[i].~T();
+        sz = 0;
+        if (dealloc) free(data), data = NULL, cap = 0; } }
+
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/minisatHeap.h.svn-base b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/minisatHeap.h.svn-base
new file mode 100644 (file)
index 0000000..6cb66cc
--- /dev/null
@@ -0,0 +1,169 @@
+/******************************************************************************************[Heap.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef minisatHeap_h
+#define minisatHeap_h
+
+#include "Vec.h"
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template<class Comp>
+class Heap {
+    Comp     lt;
+    vec<int> heap;     // heap of ints
+    vec<int> indices;  // int -> index in heap
+
+    // Index "traversal" functions
+    static inline int left  (int i) { return i*2+1; }
+    static inline int right (int i) { return (i+1)*2; }
+    static inline int parent(int i) { return (i-1) >> 1; }
+
+
+    inline void percolateUp(int i)
+    {
+        int x = heap[i];
+        while (i != 0 && lt(x, heap[parent(i)])){
+            heap[i]          = heap[parent(i)];
+            indices[heap[i]] = i;
+            i                = parent(i);
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+    inline void percolateDown(int i)
+    {
+        int x = heap[i];
+        while (left(i) < heap.size()){
+            int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+            if (!lt(heap[child], x)) break;
+            heap[i]          = heap[child];
+            indices[heap[i]] = i;
+            i                = child;
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+    bool heapProperty (int i) const {
+        return i >= heap.size()
+            || ((i == 0 || !lt(heap[i], heap[parent(i)])) && heapProperty(left(i)) && heapProperty(right(i))); }
+
+
+  public:
+    Heap(const Comp& c) : lt(c) { }
+
+    int  size      ()          const { return heap.size(); }
+    bool empty     ()          const { return heap.size() == 0; }
+    bool inHeap    (int n)     const { return n < indices.size() && indices[n] >= 0; }
+    int  operator[](int index) const { assert(index < heap.size()); return heap[index]; }
+
+    void decrease  (int n) { assert(inHeap(n)); percolateUp(indices[n]); }
+
+    // RENAME WHEN THE DEPRECATED INCREASE IS REMOVED.
+    void increase_ (int n) { assert(inHeap(n)); percolateDown(indices[n]); }
+
+
+    void insert(int n)
+    {
+        indices.growTo(n+1, -1);
+        assert(!inHeap(n));
+
+        indices[n] = heap.size();
+        heap.push(n);
+        percolateUp(indices[n]); 
+    }
+
+
+    int  removeMin()
+    {
+        int x            = heap[0];
+        heap[0]          = heap.last();
+        indices[heap[0]] = 0;
+        indices[x]       = -1;
+        heap.pop();
+        if (heap.size() > 1) percolateDown(0);
+        return x; 
+    }
+
+
+    void clear(bool dealloc = false) 
+    { 
+        for (int i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+#ifdef NDEBUG
+        for (int i = 0; i < indices.size(); i++)
+            assert(indices[i] == -1);
+#endif
+        heap.clear(dealloc); 
+    }
+
+
+    // Fool proof variant of insert/decrease/increase
+    void update (int n)
+    {
+        if (!inHeap(n))
+            insert(n);
+        else {
+            percolateUp(indices[n]);
+            percolateDown(indices[n]);
+        }
+    }
+
+
+    // Delete elements from the heap using a given filter function (-object).
+    // *** this could probaly be replaced with a more general "buildHeap(vec<int>&)" method ***
+    template <class F>
+    void filter(const F& filt) {
+        int i,j;
+        for (i = j = 0; i < heap.size(); i++)
+            if (filt(heap[i])){
+                heap[j]          = heap[i];
+                indices[heap[i]] = j++;
+            }else
+                indices[heap[i]] = -1;
+
+        heap.shrink(i - j);
+        for (int i = heap.size() / 2 - 1; i >= 0; i--)
+            percolateDown(i);
+
+        assert(heapProperty());
+    }
+
+
+    // DEBUG: consistency checking
+    bool heapProperty() const {
+        return heapProperty(1); }
+
+
+    // COMPAT: should be removed
+    void setBounds (int n) { }
+    void increase  (int n) { decrease(n); }
+    int  getmin    ()      { return removeMin(); }
+
+};
+
+
+//=================================================================================================
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/template.mk.svn-base b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/.svn/text-base/template.mk.svn-base
new file mode 100644 (file)
index 0000000..15f023f
--- /dev/null
@@ -0,0 +1,90 @@
+##
+##  Template makefile for Standard, Profile, Debug, Release, and Release-static versions
+##
+##    eg: "make rs" for a statically linked release version.
+##        "make d"  for a debug version (no optimizations).
+##        "make"    for the standard version (optimized, but with debug information and assertions active)
+
+CSRCS     ?= $(wildcard *.C)
+CHDRS     ?= $(wildcard *.h)
+COBJS     ?= $(addsuffix .o, $(basename $(CSRCS)))
+
+PCOBJS     = $(addsuffix p,  $(COBJS))
+DCOBJS     = $(addsuffix d,  $(COBJS))
+RCOBJS     = $(addsuffix r,  $(COBJS))
+
+EXEC      ?= $(notdir $(shell pwd))
+LIB       ?= $(EXEC)
+
+CXX       ?= g++
+CFLAGS    ?= -Wall
+LFLAGS    ?= -Wall
+
+COPTIMIZE ?= -O3
+
+.PHONY : s p d r rs lib libd clean 
+
+s:     $(EXEC)
+p:     $(EXEC)_profile
+d:     $(EXEC)_debug
+r:     $(EXEC)_release
+rs:    $(EXEC)_static
+lib:   lib$(LIB).a
+libd:  lib$(LIB)d.a
+
+## Compile options
+%.o:                   CFLAGS +=$(COPTIMIZE) -ggdb -D DEBUG
+%.op:                  CFLAGS +=$(COPTIMIZE) -pg -ggdb -D NDEBUG
+%.od:                  CFLAGS +=-O0 -ggdb -D DEBUG # -D INVARIANTS
+%.or:                  CFLAGS +=$(COPTIMIZE) -D NDEBUG
+
+## Link options
+$(EXEC):               LFLAGS := -ggdb $(LFLAGS)
+$(EXEC)_profile:       LFLAGS := -ggdb -pg $(LFLAGS)
+$(EXEC)_debug:         LFLAGS := -ggdb $(LFLAGS)
+$(EXEC)_release:       LFLAGS := $(LFLAGS)
+$(EXEC)_static:                LFLAGS := --static $(LFLAGS)
+
+## Dependencies
+$(EXEC):               $(COBJS)
+$(EXEC)_profile:       $(PCOBJS)
+$(EXEC)_debug:         $(DCOBJS)
+$(EXEC)_release:       $(RCOBJS)
+$(EXEC)_static:                $(RCOBJS)
+
+lib$(LIB).a:   $(filter-out Main.or, $(RCOBJS))
+lib$(LIB)d.a:  $(filter-out Main.od, $(DCOBJS))
+
+
+## Build rule
+%.o %.op %.od %.or:    %.C
+       @echo Compiling: "$@ ( $< )"
+       @$(CXX) $(CFLAGS) -c -o $@ $<
+
+## Linking rules (standard/profile/debug/release)
+$(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static:
+       @echo Linking: "$@ ( $^ )"
+       @$(CXX) $^ $(LFLAGS) -o $@
+
+## Library rule
+lib$(LIB).a lib$(LIB)d.a:
+       @echo Library: "$@ ( $^ )"
+       @rm -f $@
+       @ar cq $@ $^
+
+## Clean rule
+clean:
+       @rm -f $(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static \
+         $(COBJS) $(PCOBJS) $(DCOBJS) $(RCOBJS) *.core depend.mak lib$(LIB).a lib$(LIB)d.a
+
+## Make dependencies
+depend.mk: $(CSRCS) $(CHDRS)
+       @echo Making dependencies ...
+       @$(CXX) $(CFLAGS) -MM $(CSRCS) > depend.mk
+       @cp depend.mk /tmp/depend.mk.tmp
+       @sed "s/o:/op:/" /tmp/depend.mk.tmp >> depend.mk
+       @sed "s/o:/od:/" /tmp/depend.mk.tmp >> depend.mk
+       @sed "s/o:/or:/" /tmp/depend.mk.tmp >> depend.mk
+       @rm /tmp/depend.mk.tmp
+
+-include depend.mk
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Alg.h b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Alg.h
new file mode 100644 (file)
index 0000000..240962d
--- /dev/null
@@ -0,0 +1,57 @@
+/*******************************************************************************************[Alg.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Alg_h
+#define Alg_h
+
+//=================================================================================================
+// Useful functions on vectors
+
+
+#if 1
+template<class V, class T>
+static inline void remove(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    assert(j < ts.size());
+    for (; j < ts.size()-1; j++) ts[j] = ts[j+1];
+    ts.pop();
+}
+#else
+template<class V, class T>
+static inline void remove(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    assert(j < ts.size());
+    ts[j] = ts.last();
+    ts.pop();
+}
+#endif
+
+template<class V, class T>
+static inline bool find(V& ts, const T& t)
+{
+    int j = 0;
+    for (; j < ts.size() && ts[j] != t; j++);
+    return j < ts.size();
+}
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/BasicHeap.h b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/BasicHeap.h
new file mode 100644 (file)
index 0000000..556d98f
--- /dev/null
@@ -0,0 +1,98 @@
+/******************************************************************************************[Heap.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef BasicHeap_h
+#define BasicHeap_h
+
+#include "Vec.h"
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template<class Comp>
+class BasicHeap {
+    Comp     lt;
+    vec<int> heap;     // heap of ints
+
+    // Index "traversal" functions
+    static inline int left  (int i) { return i*2+1; }
+    static inline int right (int i) { return (i+1)*2; }
+    static inline int parent(int i) { return (i-1) >> 1; }
+
+    inline void percolateUp(int i)
+    {
+        int x = heap[i];
+        while (i != 0 && lt(x, heap[parent(i)])){
+            heap[i]          = heap[parent(i)];
+            i                = parent(i);
+        }
+        heap   [i] = x;
+    }
+
+
+    inline void percolateDown(int i)
+    {
+        int x = heap[i];
+        while (left(i) < heap.size()){
+            int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+            if (!lt(heap[child], x)) break;
+            heap[i]          = heap[child];
+            i                = child;
+        }
+        heap[i] = x;
+    }
+
+
+    bool heapProperty(int i) {
+        return i >= heap.size()
+            || ((i == 0 || !lt(heap[i], heap[parent(i)])) && heapProperty(left(i)) && heapProperty(right(i))); }
+
+
+  public:
+    BasicHeap(const C& c) : comp(c) { }
+
+    int  size      ()                     const { return heap.size(); }
+    bool empty     ()                     const { return heap.size() == 0; }
+    int  operator[](int index)            const { return heap[index+1]; }
+    void clear     (bool dealloc = false)       { heap.clear(dealloc); }
+    void insert    (int n)                      { heap.push(n); percolateUp(heap.size()-1); }
+
+
+    int  removeMin() {
+        int r   = heap[0];
+        heap[0] = heap.last();
+        heap.pop();
+        if (heap.size() > 1) percolateDown(0);
+        return r; 
+    }
+
+
+    // DEBUG: consistency checking
+    bool heapProperty() {
+        return heapProperty(1); }
+
+
+    // COMPAT: should be removed
+    int  getmin    ()      { return removeMin(); }
+};
+
+
+//=================================================================================================
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/BoxedVec.h b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/BoxedVec.h
new file mode 100644 (file)
index 0000000..bddf410
--- /dev/null
@@ -0,0 +1,147 @@
+/*******************************************************************************************[Vec.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef BoxedVec_h
+#define BoxedVec_h
+
+#include <cstdlib>
+#include <cassert>
+#include <new>
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template<class T>
+class bvec {
+
+    static inline int imin(int x, int y) {
+        int mask = (x-y) >> (sizeof(int)*8-1);
+        return (x&mask) + (y&(~mask)); }
+
+    static inline int imax(int x, int y) {
+        int mask = (y-x) >> (sizeof(int)*8-1);
+        return (x&mask) + (y&(~mask)); }
+
+    struct Vec_t {
+        int sz;
+        int cap;
+        T   data[0];
+
+        static Vec_t* alloc(Vec_t* x, int size){
+            x = (Vec_t*)realloc((void*)x, sizeof(Vec_t) + sizeof(T)*size);
+            x->cap = size;
+            return x;
+        }
+        
+    };
+
+    Vec_t* ref;
+
+    static const int init_size = 2;
+    static int   nextSize (int current) { return (current * 3 + 1) >> 1; }
+    static int   fitSize  (int needed)  { int x; for (x = init_size; needed > x; x = nextSize(x)); return x; }
+
+    void fill (int size) {
+        assert(ref != NULL);
+        for (T* i = ref->data; i < ref->data + size; i++)
+            new (i) T();
+    }
+
+    void fill (int size, const T& pad) {
+        assert(ref != NULL);
+        for (T* i = ref->data; i < ref->data + size; i++)
+            new (i) T(pad);
+    }
+
+    // Don't allow copying (error prone):
+    altvec<T>&  operator = (altvec<T>& other) { assert(0); }
+    altvec (altvec<T>& other)                  { assert(0); }
+
+public:
+    void     clear  (bool dealloc = false) { 
+        if (ref != NULL){
+            for (int i = 0; i < ref->sz; i++) 
+                (*ref).data[i].~T();
+
+            if (dealloc) { 
+                free(ref); ref = NULL; 
+            }else 
+                ref->sz = 0;
+        } 
+    }
+
+    // Constructors:
+    altvec(void)                   : ref (NULL) { }
+    altvec(int size)               : ref (Vec_t::alloc(NULL, fitSize(size))) { fill(size);      ref->sz = size; }
+    altvec(int size, const T& pad) : ref (Vec_t::alloc(NULL, fitSize(size))) { fill(size, pad); ref->sz = size; }
+   ~altvec(void) { clear(true); }
+
+    // Ownership of underlying array:
+    operator T*       (void)           { return ref->data; }     // (unsafe but convenient)
+    operator const T* (void) const     { return ref->data; }
+
+    // Size operations:
+    int      size   (void) const       { return ref != NULL ? ref->sz : 0; }
+
+    void     pop    (void)             { assert(ref != NULL && ref->sz > 0); int last = --ref->sz; ref->data[last].~T(); }
+    void     push   (const T& elem) {
+        int size = ref != NULL ? ref->sz  : 0;
+        int cap  = ref != NULL ? ref->cap : 0;
+        if (size == cap){
+            cap = cap != 0 ? nextSize(cap) : init_size;
+            ref = Vec_t::alloc(ref, cap); 
+        }
+        //new (&ref->data[size]) T(elem); 
+        ref->data[size] = elem; 
+        ref->sz = size+1; 
+    }
+
+    void     push   () {
+        int size = ref != NULL ? ref->sz  : 0;
+        int cap  = ref != NULL ? ref->cap : 0;
+        if (size == cap){
+            cap = cap != 0 ? nextSize(cap) : init_size;
+            ref = Vec_t::alloc(ref, cap); 
+        }
+        new (&ref->data[size]) T(); 
+        ref->sz = size+1; 
+    }
+
+    void     shrink (int nelems)             { for (int i = 0; i < nelems; i++) pop(); }
+    void     shrink_(int nelems)             { for (int i = 0; i < nelems; i++) pop(); }
+    void     growTo (int size)               { while (this->size() < size) push(); }
+    void     growTo (int size, const T& pad) { while (this->size() < size) push(pad); }
+    void     capacity (int size)             { growTo(size); }
+
+    const T& last  (void) const              { return ref->data[ref->sz-1]; }
+    T&       last  (void)                    { return ref->data[ref->sz-1]; }
+
+    // Vector interface:
+    const T& operator [] (int index) const  { return ref->data[index]; }
+    T&       operator [] (int index)        { return ref->data[index]; }
+
+    void copyTo(altvec<T>& copy) const { copy.clear(); for (int i = 0; i < size(); i++) copy.push(ref->data[i]); }
+    void moveTo(altvec<T>& dest) { dest.clear(true); dest.ref = ref; ref = NULL; }
+
+};
+
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Map.h b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Map.h
new file mode 100644 (file)
index 0000000..b6d76a3
--- /dev/null
@@ -0,0 +1,118 @@
+/*******************************************************************************************[Map.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Map_h
+#define Map_h
+
+#include <stdint.h>
+
+#include "Vec.h"
+
+//=================================================================================================
+// Default hash/equals functions
+//
+
+template<class K> struct Hash  { uint32_t operator()(const K& k)               const { return hash(k);  } };
+template<class K> struct Equal { bool     operator()(const K& k1, const K& k2) const { return k1 == k2; } };
+
+template<class K> struct DeepHash  { uint32_t operator()(const K* k)               const { return hash(*k);  } };
+template<class K> struct DeepEqual { bool     operator()(const K* k1, const K* k2) const { return *k1 == *k2; } };
+
+//=================================================================================================
+// Some primes
+//
+
+static const int nprimes          = 25;
+static const int primes [nprimes] = { 31, 73, 151, 313, 643, 1291, 2593, 5233, 10501, 21013, 42073, 84181, 168451, 337219, 674701, 1349473, 2699299, 5398891, 10798093, 21596719, 43193641, 86387383, 172775299, 345550609, 691101253 };
+
+//=================================================================================================
+// Hash table implementation of Maps
+//
+
+template<class K, class D, class H = Hash<K>, class E = Equal<K> >
+class Map {
+    struct Pair { K key; D data; };
+
+    H          hash;
+    E          equals;
+
+    vec<Pair>* table;
+    int        cap;
+    int        size;
+
+    // Don't allow copying (error prone):
+    Map<K,D,H,E>&  operator = (Map<K,D,H,E>& other) { assert(0); }
+                   Map        (Map<K,D,H,E>& other) { assert(0); }
+
+    int32_t index  (const K& k) const { return hash(k) % cap; }
+    void   _insert (const K& k, const D& d) { table[index(k)].push(); table[index(k)].last().key = k; table[index(k)].last().data = d; }
+    void    rehash () {
+        const vec<Pair>* old = table;
+
+        int newsize = primes[0];
+        for (int i = 1; newsize <= cap && i < nprimes; i++)
+           newsize = primes[i];
+
+        table = new vec<Pair>[newsize];
+
+        for (int i = 0; i < cap; i++){
+            for (int j = 0; j < old[i].size(); j++){
+                _insert(old[i][j].key, old[i][j].data); }}
+
+        delete [] old;
+
+        cap = newsize;
+    }
+
+    
+    public:
+
+     Map () : table(NULL), cap(0), size(0) {}
+     Map (const H& h, const E& e) : Map(), hash(h), equals(e) {}
+    ~Map () { delete [] table; }
+
+    void insert (const K& k, const D& d) { if (size+1 > cap / 2) rehash(); _insert(k, d); size++; }
+    bool peek   (const K& k, D& d) {
+        if (size == 0) return false;
+        const vec<Pair>& ps = table[index(k)];
+        for (int i = 0; i < ps.size(); i++)
+            if (equals(ps[i].key, k)){
+                d = ps[i].data;
+                return true; } 
+        return false;
+    }
+
+    void remove (const K& k) {
+        assert(table != NULL);
+        vec<Pair>& ps = table[index(k)];
+        int j = 0;
+        for (; j < ps.size() && !equals(ps[j].key, k); j++);
+        assert(j < ps.size());
+        ps[j] = ps.last();
+        ps.pop();
+    }
+
+    void clear  () {
+        cap = size = 0;
+        delete [] table;
+        table = NULL;
+    }
+};
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Queue.h b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Queue.h
new file mode 100644 (file)
index 0000000..2cc110c
--- /dev/null
@@ -0,0 +1,82 @@
+/*****************************************************************************************[Queue.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Queue_h
+#define Queue_h
+
+#include "Vec.h"
+
+//=================================================================================================
+
+
+template <class T>
+class Queue {
+    vec<T>  elems;
+    int     first;
+
+public:
+    Queue(void) : first(0) { }
+
+    void insert(T x)   { elems.push(x); }
+    T    peek  () const { return elems[first]; }
+    void pop   () { first++; }
+
+    void clear(bool dealloc = false)   { elems.clear(dealloc); first = 0; }
+    int  size(void)    { return elems.size() - first; }
+
+    //bool has(T x) { for (int i = first; i < elems.size(); i++) if (elems[i] == x) return true; return false; }
+
+    const T& operator [] (int index) const  { return elems[first + index]; }
+
+};
+
+//template<class T>
+//class Queue {
+//    vec<T>  buf;
+//    int     first;
+//    int     end;
+//
+//public:
+//    typedef T Key;
+//
+//    Queue() : buf(1), first(0), end(0) {}
+//
+//    void clear () { buf.shrinkTo(1); first = end = 0; }
+//    int  size  () { return (end >= first) ? end - first : end - first + buf.size(); }
+//
+//    T    peek  () { assert(first != end); return buf[first]; }
+//    void pop   () { assert(first != end); first++; if (first == buf.size()) first = 0; }
+//    void insert(T elem) {   // INVARIANT: buf[end] is always unused
+//        buf[end++] = elem;
+//        if (end == buf.size()) end = 0;
+//        if (first == end){  // Resize:
+//            vec<T>  tmp((buf.size()*3 + 1) >> 1);
+//            //**/printf("queue alloc: %d elems (%.1f MB)\n", tmp.size(), tmp.size() * sizeof(T) / 1000000.0);
+//            int     i = 0;
+//            for (int j = first; j < buf.size(); j++) tmp[i++] = buf[j];
+//            for (int j = 0    ; j < end       ; j++) tmp[i++] = buf[j];
+//            first = 0;
+//            end   = buf.size();
+//            tmp.moveTo(buf);
+//        }
+//    }
+//};
+
+//=================================================================================================
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Sort.h b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Sort.h
new file mode 100644 (file)
index 0000000..1f301f5
--- /dev/null
@@ -0,0 +1,93 @@
+/******************************************************************************************[Sort.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Sort_h
+#define Sort_h
+
+#include "Vec.h"
+
+//=================================================================================================
+// Some sorting algorithms for vec's
+
+
+template<class T>
+struct LessThan_default {
+    bool operator () (T x, T y) { return x < y; }
+};
+
+
+template <class T, class LessThan>
+void selectionSort(T* array, int size, LessThan lt)
+{
+    int     i, j, best_i;
+    T       tmp;
+
+    for (i = 0; i < size-1; i++){
+        best_i = i;
+        for (j = i+1; j < size; j++){
+            if (lt(array[j], array[best_i]))
+                best_i = j;
+        }
+        tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
+    }
+}
+template <class T> static inline void selectionSort(T* array, int size) {
+    selectionSort(array, size, LessThan_default<T>()); }
+
+template <class T, class LessThan>
+void sort(T* array, int size, LessThan lt)
+{
+    if (size <= 15)
+        selectionSort(array, size, lt);
+
+    else{
+        T           pivot = array[size / 2];
+        T           tmp;
+        int         i = -1;
+        int         j = size;
+
+        for(;;){
+            do i++; while(lt(array[i], pivot));
+            do j--; while(lt(pivot, array[j]));
+
+            if (i >= j) break;
+
+            tmp = array[i]; array[i] = array[j]; array[j] = tmp;
+        }
+
+        sort(array    , i     , lt);
+        sort(&array[i], size-i, lt);
+    }
+}
+template <class T> static inline void sort(T* array, int size) {
+    sort(array, size, LessThan_default<T>()); }
+
+
+//=================================================================================================
+// For 'vec's:
+
+
+template <class T, class LessThan> void sort(vec<T>& v, LessThan lt) {
+    sort((T*)v, v.size(), lt); }
+template <class T> void sort(vec<T>& v) {
+    sort(v, LessThan_default<T>()); }
+
+
+//=================================================================================================
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Vec.h b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/Vec.h
new file mode 100644 (file)
index 0000000..e780aa1
--- /dev/null
@@ -0,0 +1,133 @@
+/*******************************************************************************************[Vec.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef Vec_h
+#define Vec_h
+
+#include <cstdlib>
+#include <cassert>
+#include <new>
+
+//=================================================================================================
+// Automatically resizable arrays
+//
+// NOTE! Don't use this vector on datatypes that cannot be re-located in memory (with realloc)
+
+template<class T>
+class vec {
+    T*  data;
+    int sz;
+    int cap;
+
+    void     init(int size, const T& pad);
+    void     grow(int min_cap);
+
+    // Don't allow copying (error prone):
+    vec<T>&  operator = (vec<T>& other) { assert(0); return *this; }
+             vec        (vec<T>& other) { assert(0); }
+
+    static inline int imin(int x, int y) {
+        int mask = (x-y) >> (sizeof(int)*8-1);
+        return (x&mask) + (y&(~mask)); }
+
+    static inline int imax(int x, int y) {
+        int mask = (y-x) >> (sizeof(int)*8-1);
+        return (x&mask) + (y&(~mask)); }
+
+public:
+    // Types:
+    typedef int Key;
+    typedef T   Datum;
+
+    // Constructors:
+    vec(void)                   : data(NULL) , sz(0)   , cap(0)    { }
+    vec(int size)               : data(NULL) , sz(0)   , cap(0)    { growTo(size); }
+    vec(int size, const T& pad) : data(NULL) , sz(0)   , cap(0)    { growTo(size, pad); }
+    vec(T* array, int size)     : data(array), sz(size), cap(size) { }      // (takes ownership of array -- will be deallocated with 'free()')
+   ~vec(void)                                                      { clear(true); }
+
+    // Ownership of underlying array:
+    T*       release  (void)           { T* ret = data; data = NULL; sz = 0; cap = 0; return ret; }
+    operator T*       (void)           { return data; }     // (unsafe but convenient)
+    operator const T* (void) const     { return data; }
+
+    // Size operations:
+    int      size   (void) const       { return sz; }
+    void     shrink (int nelems)       { assert(nelems <= sz); for (int i = 0; i < nelems; i++) sz--, data[sz].~T(); }
+    void     shrink_(int nelems)       { assert(nelems <= sz); sz -= nelems; }
+    void     pop    (void)             { sz--, data[sz].~T(); }
+    void     growTo (int size);
+    void     growTo (int size, const T& pad);
+    void     clear  (bool dealloc = false);
+    void     capacity (int size) { grow(size); }
+
+    // Stack interface:
+#if 1
+    void     push  (void)              { if (sz == cap) { cap = imax(2, (cap*3+1)>>1); data = (T*)realloc(data, cap * sizeof(T)); } new (&data[sz]) T(); sz++; }
+    //void     push  (const T& elem)     { if (sz == cap) { cap = imax(2, (cap*3+1)>>1); data = (T*)realloc(data, cap * sizeof(T)); } new (&data[sz]) T(elem); sz++; }
+    void     push  (const T& elem)     { if (sz == cap) { cap = imax(2, (cap*3+1)>>1); data = (T*)realloc(data, cap * sizeof(T)); } data[sz++] = elem; }
+    void     push_ (const T& elem)     { assert(sz < cap); data[sz++] = elem; }
+#else
+    void     push  (void)              { if (sz == cap) grow(sz+1); new (&data[sz]) T()    ; sz++; }
+    void     push  (const T& elem)     { if (sz == cap) grow(sz+1); new (&data[sz]) T(elem); sz++; }
+#endif
+
+    const T& last  (void) const        { return data[sz-1]; }
+    T&       last  (void)              { return data[sz-1]; }
+
+    // Vector interface:
+    const T& operator [] (int index) const  { return data[index]; }
+    T&       operator [] (int index)        { return data[index]; }
+
+
+    // Duplicatation (preferred instead):
+    void copyTo(vec<T>& copy) const { copy.clear(); copy.growTo(sz); for (int i = 0; i < sz; i++) new (&copy[i]) T(data[i]); }
+    void moveTo(vec<T>& dest) { dest.clear(true); dest.data = data; dest.sz = sz; dest.cap = cap; data = NULL; sz = 0; cap = 0; }
+};
+
+template<class T>
+void vec<T>::grow(int min_cap) {
+    if (min_cap <= cap) return;
+    if (cap == 0) cap = (min_cap >= 2) ? min_cap : 2;
+    else          do cap = (cap*3+1) >> 1; while (cap < min_cap);
+    data = (T*)realloc(data, cap * sizeof(T)); }
+
+template<class T>
+void vec<T>::growTo(int size, const T& pad) {
+    if (sz >= size) return;
+    grow(size);
+    for (int i = sz; i < size; i++) new (&data[i]) T(pad);
+    sz = size; }
+
+template<class T>
+void vec<T>::growTo(int size) {
+    if (sz >= size) return;
+    grow(size);
+    for (int i = sz; i < size; i++) new (&data[i]) T();
+    sz = size; }
+
+template<class T>
+void vec<T>::clear(bool dealloc) {
+    if (data != NULL){
+        for (int i = 0; i < sz; i++) data[i].~T();
+        sz = 0;
+        if (dealloc) free(data), data = NULL, cap = 0; } }
+
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/minisatHeap.h b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/minisatHeap.h
new file mode 100644 (file)
index 0000000..6cb66cc
--- /dev/null
@@ -0,0 +1,169 @@
+/******************************************************************************************[Heap.h]
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**************************************************************************************************/
+
+#ifndef minisatHeap_h
+#define minisatHeap_h
+
+#include "Vec.h"
+
+//=================================================================================================
+// A heap implementation with support for decrease/increase key.
+
+
+template<class Comp>
+class Heap {
+    Comp     lt;
+    vec<int> heap;     // heap of ints
+    vec<int> indices;  // int -> index in heap
+
+    // Index "traversal" functions
+    static inline int left  (int i) { return i*2+1; }
+    static inline int right (int i) { return (i+1)*2; }
+    static inline int parent(int i) { return (i-1) >> 1; }
+
+
+    inline void percolateUp(int i)
+    {
+        int x = heap[i];
+        while (i != 0 && lt(x, heap[parent(i)])){
+            heap[i]          = heap[parent(i)];
+            indices[heap[i]] = i;
+            i                = parent(i);
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+    inline void percolateDown(int i)
+    {
+        int x = heap[i];
+        while (left(i) < heap.size()){
+            int child = right(i) < heap.size() && lt(heap[right(i)], heap[left(i)]) ? right(i) : left(i);
+            if (!lt(heap[child], x)) break;
+            heap[i]          = heap[child];
+            indices[heap[i]] = i;
+            i                = child;
+        }
+        heap   [i] = x;
+        indices[x] = i;
+    }
+
+
+    bool heapProperty (int i) const {
+        return i >= heap.size()
+            || ((i == 0 || !lt(heap[i], heap[parent(i)])) && heapProperty(left(i)) && heapProperty(right(i))); }
+
+
+  public:
+    Heap(const Comp& c) : lt(c) { }
+
+    int  size      ()          const { return heap.size(); }
+    bool empty     ()          const { return heap.size() == 0; }
+    bool inHeap    (int n)     const { return n < indices.size() && indices[n] >= 0; }
+    int  operator[](int index) const { assert(index < heap.size()); return heap[index]; }
+
+    void decrease  (int n) { assert(inHeap(n)); percolateUp(indices[n]); }
+
+    // RENAME WHEN THE DEPRECATED INCREASE IS REMOVED.
+    void increase_ (int n) { assert(inHeap(n)); percolateDown(indices[n]); }
+
+
+    void insert(int n)
+    {
+        indices.growTo(n+1, -1);
+        assert(!inHeap(n));
+
+        indices[n] = heap.size();
+        heap.push(n);
+        percolateUp(indices[n]); 
+    }
+
+
+    int  removeMin()
+    {
+        int x            = heap[0];
+        heap[0]          = heap.last();
+        indices[heap[0]] = 0;
+        indices[x]       = -1;
+        heap.pop();
+        if (heap.size() > 1) percolateDown(0);
+        return x; 
+    }
+
+
+    void clear(bool dealloc = false) 
+    { 
+        for (int i = 0; i < heap.size(); i++)
+            indices[heap[i]] = -1;
+#ifdef NDEBUG
+        for (int i = 0; i < indices.size(); i++)
+            assert(indices[i] == -1);
+#endif
+        heap.clear(dealloc); 
+    }
+
+
+    // Fool proof variant of insert/decrease/increase
+    void update (int n)
+    {
+        if (!inHeap(n))
+            insert(n);
+        else {
+            percolateUp(indices[n]);
+            percolateDown(indices[n]);
+        }
+    }
+
+
+    // Delete elements from the heap using a given filter function (-object).
+    // *** this could probaly be replaced with a more general "buildHeap(vec<int>&)" method ***
+    template <class F>
+    void filter(const F& filt) {
+        int i,j;
+        for (i = j = 0; i < heap.size(); i++)
+            if (filt(heap[i])){
+                heap[j]          = heap[i];
+                indices[heap[i]] = j++;
+            }else
+                indices[heap[i]] = -1;
+
+        heap.shrink(i - j);
+        for (int i = heap.size() / 2 - 1; i >= 0; i--)
+            percolateDown(i);
+
+        assert(heapProperty());
+    }
+
+
+    // DEBUG: consistency checking
+    bool heapProperty() const {
+        return heapProperty(1); }
+
+
+    // COMPAT: should be removed
+    void setBounds (int n) { }
+    void increase  (int n) { decrease(n); }
+    int  getmin    ()      { return removeMin(); }
+
+};
+
+
+//=================================================================================================
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/template.mk b/examples/charm++/state_space_searchengine/3SAT/minisat/mtl/template.mk
new file mode 100644 (file)
index 0000000..15f023f
--- /dev/null
@@ -0,0 +1,90 @@
+##
+##  Template makefile for Standard, Profile, Debug, Release, and Release-static versions
+##
+##    eg: "make rs" for a statically linked release version.
+##        "make d"  for a debug version (no optimizations).
+##        "make"    for the standard version (optimized, but with debug information and assertions active)
+
+CSRCS     ?= $(wildcard *.C)
+CHDRS     ?= $(wildcard *.h)
+COBJS     ?= $(addsuffix .o, $(basename $(CSRCS)))
+
+PCOBJS     = $(addsuffix p,  $(COBJS))
+DCOBJS     = $(addsuffix d,  $(COBJS))
+RCOBJS     = $(addsuffix r,  $(COBJS))
+
+EXEC      ?= $(notdir $(shell pwd))
+LIB       ?= $(EXEC)
+
+CXX       ?= g++
+CFLAGS    ?= -Wall
+LFLAGS    ?= -Wall
+
+COPTIMIZE ?= -O3
+
+.PHONY : s p d r rs lib libd clean 
+
+s:     $(EXEC)
+p:     $(EXEC)_profile
+d:     $(EXEC)_debug
+r:     $(EXEC)_release
+rs:    $(EXEC)_static
+lib:   lib$(LIB).a
+libd:  lib$(LIB)d.a
+
+## Compile options
+%.o:                   CFLAGS +=$(COPTIMIZE) -ggdb -D DEBUG
+%.op:                  CFLAGS +=$(COPTIMIZE) -pg -ggdb -D NDEBUG
+%.od:                  CFLAGS +=-O0 -ggdb -D DEBUG # -D INVARIANTS
+%.or:                  CFLAGS +=$(COPTIMIZE) -D NDEBUG
+
+## Link options
+$(EXEC):               LFLAGS := -ggdb $(LFLAGS)
+$(EXEC)_profile:       LFLAGS := -ggdb -pg $(LFLAGS)
+$(EXEC)_debug:         LFLAGS := -ggdb $(LFLAGS)
+$(EXEC)_release:       LFLAGS := $(LFLAGS)
+$(EXEC)_static:                LFLAGS := --static $(LFLAGS)
+
+## Dependencies
+$(EXEC):               $(COBJS)
+$(EXEC)_profile:       $(PCOBJS)
+$(EXEC)_debug:         $(DCOBJS)
+$(EXEC)_release:       $(RCOBJS)
+$(EXEC)_static:                $(RCOBJS)
+
+lib$(LIB).a:   $(filter-out Main.or, $(RCOBJS))
+lib$(LIB)d.a:  $(filter-out Main.od, $(DCOBJS))
+
+
+## Build rule
+%.o %.op %.od %.or:    %.C
+       @echo Compiling: "$@ ( $< )"
+       @$(CXX) $(CFLAGS) -c -o $@ $<
+
+## Linking rules (standard/profile/debug/release)
+$(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static:
+       @echo Linking: "$@ ( $^ )"
+       @$(CXX) $^ $(LFLAGS) -o $@
+
+## Library rule
+lib$(LIB).a lib$(LIB)d.a:
+       @echo Library: "$@ ( $^ )"
+       @rm -f $@
+       @ar cq $@ $^
+
+## Clean rule
+clean:
+       @rm -f $(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static \
+         $(COBJS) $(PCOBJS) $(DCOBJS) $(RCOBJS) *.core depend.mak lib$(LIB).a lib$(LIB)d.a
+
+## Make dependencies
+depend.mk: $(CSRCS) $(CHDRS)
+       @echo Making dependencies ...
+       @$(CXX) $(CFLAGS) -MM $(CSRCS) > depend.mk
+       @cp depend.mk /tmp/depend.mk.tmp
+       @sed "s/o:/op:/" /tmp/depend.mk.tmp >> depend.mk
+       @sed "s/o:/od:/" /tmp/depend.mk.tmp >> depend.mk
+       @sed "s/o:/or:/" /tmp/depend.mk.tmp >> depend.mk
+       @rm /tmp/depend.mk.tmp
+
+-include depend.mk
diff --git a/examples/charm++/state_space_searchengine/3SAT/searchEngineAPI.C b/examples/charm++/state_space_searchengine/3SAT/searchEngineAPI.C
new file mode 100644 (file)
index 0000000..efc997c
--- /dev/null
@@ -0,0 +1,418 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <cstring>
+#include <stdint.h>
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <zlib.h>
+#include <vector>
+#include <map>
+#include <list>
+
+#include "defines.h"
+#include "searchEngine.h"
+#include "searchEngineAPI.h"
+/*   framework for search engine */
+
+#ifdef MINISAT
+#include "solvers_convertor.h"
+#endif
+
+using namespace std;
+
+#define CHUNK_LIMIT 1048576
+#define MAX_LITS 3
+extern int initial_grainsize;
+extern char inputfile[];
+
+void SatStateBase::initialize(int vars, int cl, int l)
+{
+    var_size    =   vars;
+    clause_size =   cl;
+    level       =   l;
+    current_pointer =   0;
+    int offset = 0;
+    offset = sizeof(SatStateBase);
+    clauses = (int*)((char*)this + offset);
+    offset += 3*clause_size*sizeof(int);
+    occurrences =(int*)( (char*)this + offset);
+    offset += var_size *  sizeof(int);
+    positive_occurrences = (int*)((char*)this + offset);
+    for(int __i=0; __i<var_size; __i++)
+    {
+        occurrences[__i] = 0;
+        positive_occurrences[__i] = 0;
+    }
+}
+
+
+int SatStateBase::unsolvedClauses() const
+{
+    int unsolved = 0;
+    for(int i=0; i< clause_size; i++)
+    {
+        if(clauses[i*MAX_LITS]!= 0)
+            unsolved++;
+    }
+    return unsolved;
+}
+
+/* add clause, before adding, check unit conflict */
+bool SatStateBase::addClause(int *ps)
+{
+    /*TODO precheck is needed here */
+    for(int i=0; i<MAX_LITS; i++)
+    {
+        clauses[MAX_LITS*current_pointer + i] = ps[i];
+    }
+    current_pointer++;
+    return true;
+}
+
+
+/**** branching strategy */
+int SatStateBase::makeDecision() const
+{
+    int max_index = -1;
+    int max = 0;
+    for(int __i=0; __i<var_size; __i++)
+    {
+        if(occurrences[__i] > max)
+        {
+            max = occurrences[__i];
+            max_index = __i;
+        }
+    }
+    return max_index;
+
+}
+
+inline void SatStateBase::copy(SatStateBase* org)
+{
+    for(int _i=0; _i<org->clause_size * 3; _i++)
+    {
+        clauses[_i] = org->clauses[_i];
+    }
+
+    for(int _i=0; _i<org->var_size; _i++){
+        occurrences[_i] = org->occurrences[_i];
+        positive_occurrences[_i] = org->positive_occurrences[_i];
+    }
+}
+inline void SatStateBase::copyto(SatStateBase* dest) const
+{
+    for(int _i=0; _i<clause_size * 3; _i++)
+    {
+        (dest->clauses)[_i] = clauses[_i];
+    }
+
+    for(int _i=0; _i<var_size; _i++){
+        (dest->occurrences)[_i] = occurrences[_i];
+        (dest->positive_occurrences)[_i] = positive_occurrences[_i];
+    }
+}
+void SatStateBase::printSolution() const
+{
+  // This is silly! We shouldn't be using CkError to print the solution,
+  // we should be using CkPrintf for this and using CkError for all the other
+  // waypoint diagnostic messages. Still, since we have done it backwards for
+  // all this time, we might as well continue doing it backwards.
+    CkError("One solution:\n");
+    for(int _i=0; _i<var_size; _i++)
+    {
+        CkError("(%d=%s)", _i+1, (occurrences[_i]==-1)?"false":"true");
+    }
+    CkError("\n");
+}
+
+void SatStateBase::printInfo() const
+{
+
+    CkPrintf("\n++++++++");
+    for(int i=0; i<clause_size; i++)
+    {
+        CkPrintf("\n");
+        for(int j=0; j<MAX_LITS; j++)
+        {
+            CkPrintf(" %d", clauses[i*MAX_LITS+j]); 
+        }
+    }
+    CkPrintf("occurence:");
+    for(int i=0; i<var_size; i++)
+    {
+        CkPrintf("(%d, %d)", i+1, occurrences[i]);
+    }
+        CkPrintf("\n");
+}
+void SatStateBase::printState() const
+{ 
+    CkPrintf("\n#######State of chare:%d, %d\n", assigned_lit, occurrences[assigned_lit]);
+    CkPrintf("level=%d var_size=%d, clauses size=%d\n", level, var_size, clause_size);
+    CkPrintf("unsolved clauses  by functions=%d\n",  unsolvedClauses());
+    for(int i=0; i<clause_size*MAX_LITS ; i++)
+    {
+        CkPrintf("%d ",  clauses[i]);
+    }
+    CkPrintf("\n");
+
+    for(int i=0; i<var_size; i++)
+    {
+        if(occurrences[i]!=0)
+            CkPrintf("(Lit%d,%d)", i+1, occurrences[i]);
+    }
+    CkPrintf("\n");
+}
+
+static void createInitialChildren(Solver *solver)
+{
+
+    FILE *file;
+    char line[200];
+    int vars;
+    int clauses;
+    char pstring[10], cnfstring[10];
+    file = fopen(inputfile, "r");
+    if(file == NULL)
+    {
+        CkPrintf("File not exist\n");
+        CkExit();
+    }
+    /* parse the header and get the number of clauses and variables */
+    while(fgets(line, 200, file) != NULL)
+    {
+        if(strncmp(line, "p cnf", 5) == 0)
+        {
+            sscanf(line, "%s %s %d %d", pstring, cnfstring, &vars, &clauses);
+            break;
+        }
+    }
+    CkPrintf("\n====================================\n");
+    CkPrintf("Clauses number:%d, variable number:%d\n\n", clauses, vars);
+    /* fill the data with clauses */ 
+    SatStateBase *root_1 = (SatStateBase*)solver->registerRootState(sizeof(SatStateBase) + 3*clauses*sizeof(int) + 2*vars*sizeof(int), 0, 2);
+    root_1->initialize(vars, clauses, 0);
+
+    int lit, abs_lit;
+    int lit_[3];
+    int cur_pointer = 0;
+    for(int i=0; i<clauses; i++)
+    {
+        fgets(line, 200, file);
+        sscanf(line, "%d %d %d", lit_, lit_+1, lit_+2);
+        for(int j=0; j<MAX_LITS; j++)
+        {
+            lit = lit_[j];
+            abs_lit = abs(lit)-1;
+            root_1->occurrence(abs_lit)++;
+            if(lit>0)
+                root_1->positiveOccurrence(lit)++;
+            root_1->clause(cur_pointer) = lit;
+            cur_pointer++;
+        } 
+    }
+    //root_1->printInfo();
+    /* positive assignment */
+    int decision_index = root_1->makeDecision();
+    root_1->assignedLit() = decision_index+1;
+    root_1->occurrence(decision_index) = -2;
+    /*negative assignment */
+    SatStateBase *root_2 = (SatStateBase*)solver->registerRootState(sizeof(SatStateBase) + 3*clauses*sizeof(int) + 2*vars*sizeof(int), 1, 2);
+    root_2->initialize(vars, clauses, 0);
+    root_2->copy(root_1);
+    root_2->assignedLit() = -decision_index-1;
+    root_2->occurrence(decision_index) = -1;
+    solver->process(root_1);
+    solver->process(root_2);
+}
+
+static void createChildren( StateBase *_base , Solver* solver, bool parallel)
+{
+
+#ifdef MINISAT
+    convertToSequential(_base);
+    return;
+#endif
+    int lit = ((SatStateBase*)_base)->assignedLit();
+    int level =((SatStateBase*)_base)->getLevel();
+    int clause = ((SatStateBase*)_base)->getClauseSize();
+    int vars = ((SatStateBase*)_base)->getVarSize();
+    int state_size = sizeof(SatStateBase) + 3*clause*sizeof(int) + 2*vars* sizeof(int);
+
+    SatStateBase* base = (SatStateBase*)alloca(state_size);
+    
+    base->initialize(vars, clause, 0);
+    base->copy((SatStateBase*)_base);
+
+
+    map<int, list<int> >::iterator pmap;
+    //CkPrintf("\nassigned lit=%d\n", lit);
+    //base->printInfo();
+    SatStateBase *next_state = (SatStateBase*)solver->registerRootState(sizeof(SatStateBase) + 3*clause*sizeof(int) + 2*vars*sizeof(int), 0, 2);
+    next_state->initialize(vars, clause, 0);
+    next_state->copy(base);
+
+    int vars_eliminate = 0;
+    int clause_eliminate = 0;
+   
+    map<int, list<int> > litMaptoClauses;
+    litMaptoClauses.clear();
+    for(int i=0; i<next_state->getClauseSize(); i++)
+    {
+        for(int j=0; j<MAX_LITS &&next_state->clause(i*MAX_LITS+j) !=0; j++)
+        {
+                int lit_index = next_state->clause(i*MAX_LITS + j);
+                litMaptoClauses[lit_index]. push_back(i);
+        }
+    }
+#if 0
+
+    map<int, list<int> >::iterator pmap;
+    for(pmap = litMaptoClauses.begin(); pmap != litMaptoClauses.end(); ++pmap)
+    {
+        list<int> &cl_refer = pmap->second;
+        CkPrintf("\n literal %d in clauses:", pmap->first);
+
+        list<int>::iterator iter;
+        for(iter=cl_refer.begin(); iter != cl_refer.end(); iter++)
+        {
+            CkPrintf("%d  ", *iter);
+        }
+    }
+
+
+#endif
+
+    int _unit_ = -1;
+    vector<int> unit_clause_index;
+    /* Unit propagation */
+    while(1){
+        int pp_ = 1;
+        int pp_i_ = 2;
+        int pp_j_ = 1;
+
+        if(lit < 0)
+        {
+            pp_ = -1;
+            pp_i_ = 1;
+            pp_j_ = 2;
+        }
+        list<int> &inClauses = litMaptoClauses[lit];
+        list<int> &inClauses_opposite = litMaptoClauses[-lit];
+
+        /* literal with same sign, remove all these clauses */
+        list<int>::iterator iter;
+        for( iter=inClauses.begin(); iter!= inClauses.end(); iter++)
+        {
+            int cl_index = *iter;
+            int begin = cl_index * MAX_LITS;
+            int end  = cl_index * MAX_LITS + MAX_LITS;
+            /*for all the literals in this clauses, the occurrence decreases by 1 */
+            for(int k=begin; k< end&&next_state->clause(k)!=0; k++)
+            {
+                int  lit_ = next_state->clause(k);
+                next_state->occurrence(abs(lit_) - 1)--;
+                if(lit_ > 0)
+                {
+                    next_state->positiveOccurrence(lit_-1)--;
+                }
+            } //finish dealing with all literal in the clause
+            next_state->clause(begin) = 0;
+        } //finish dealing with clauses where the literal occur the same
+        /* opposite to the literal */
+        for(iter= inClauses_opposite.begin(); iter!=inClauses_opposite.end(); iter++)
+        {
+            int cl_index_ = *iter;
+            int mm;
+            int begin = cl_index_ *MAX_LITS;
+            int end = cl_index_*MAX_LITS + MAX_LITS;
+
+            if(next_state->clause(begin) == 0)
+                continue;
+            for( mm=begin; mm<end && next_state->clause(mm)!=0;mm++)
+            {
+                if(next_state->clause(mm) == -lit)
+                    break;
+            }
+
+            for(;mm<end-1; mm++)
+            {
+                next_state->clause(mm) = next_state->clause(mm+1);
+            }
+            next_state->clause(end-1) = 0;
+            /*becomes a unit clause */
+            if(next_state->clause(begin) == 0)
+            { /* conflict */
+                //CkPrintf("conflict detected, with assigned lit=%d\n", lit); 
+                solver->deleteState(next_state);
+                return;
+            }else if (next_state->clause(begin+1) == 0)
+            {
+                unit_clause_index.push_back(cl_index_);
+            }
+        }
+        _unit_++;
+        next_state->occurrence(pp_*lit-1) = -pp_i_;
+        if(_unit_ == unit_clause_index.size())
+            break;
+        int cl = next_state->clause(MAX_LITS * unit_clause_index[_unit_]);
+
+        while(cl == 0){
+            _unit_++;
+            if(_unit_ == unit_clause_index.size())
+                break;
+            cl = next_state->clause(MAX_LITS * unit_clause_index[_unit_]);
+        };
+
+        if(_unit_ == unit_clause_index.size())
+            break;
+        lit = cl;
+    }
+    /***************/
+    int unsolved = next_state->unsolvedClauses(); 
+    if(unsolved == 0)
+    {
+        //next_state->printInfo();
+#ifdef DEBUG
+        next_state->printSolution();
+#endif
+        solver->deleteState(next_state);
+        solver->reportSolution();
+        return;
+    }
+    int max_index = next_state->makeDecision();
+    SatStateBase *new_msg2 = (SatStateBase*)solver->registerRootState(sizeof(SatStateBase) + 3*clause*sizeof(int) + 2*vars*sizeof(int), 1, 2);
+    new_msg2->initialize(vars, clause, 0);
+    new_msg2->copy(next_state);
+
+    next_state->assignedLit() = max_index+1;
+    next_state->occurrence(max_index) = -2;
+    new_msg2->assignedLit() = -max_index-1;
+    new_msg2->occurrence(max_index) = -1;
+
+    if(parallel)
+    {
+        solver->process(next_state);
+        solver->process(new_msg2);
+    }
+}
+
+static bool isGoal(StateBase *s){
+    return true;
+}
+
+static bool terminate(StateBase *s){
+    return true;
+}
+
+__INLINE int parallelLevel()
+{
+        return initial_grainsize;
+}
+
+__INLINE int searchDepthLimit()
+{
+       return 2;
+}
+
+SE_Register(SatStateBase, createInitialChildren, createChildren, parallelLevel, searchDepthLimit);
diff --git a/examples/charm++/state_space_searchengine/3SAT/searchEngineAPI.h b/examples/charm++/state_space_searchengine/3SAT/searchEngineAPI.h
new file mode 100644 (file)
index 0000000..8fa5abc
--- /dev/null
@@ -0,0 +1,53 @@
+#ifndef __SEARCHENGINEAPI__
+#define __SEARCHENGINEAPI__
+
+class SatStateBase : public StateBase
+{
+       int             var_size;
+       int             clause_size;
+       int             level;
+       int             assigned_lit;
+       int             *clauses;
+       int             *occurrences;
+       int             *positive_occurrences;
+
+    int             lower;
+    int             higher;
+    int             current_pointer;
+public:
+/********************** par_SolverState implementation ******/
+    void initialize(int vars, int cl, int l);
+    int unsolvedClauses() const;
+    /* add clause, before adding, check unit conflict */
+    bool addClause(int *ps);
+    /**** branching strategy */
+    int makeDecision() const;
+
+    void copy(SatStateBase* org);
+    void copyto(SatStateBase* org) const;
+    void printSolution() const;
+    void printState() const;
+    void printInfo() const;
+
+    int getVarSize() const                             { return var_size; }
+    int getClauseSize() const                          { return clause_size; }
+    int getLevel() const                               { return level; }
+
+    int assignedLit() const                            { return assigned_lit; }
+    int &assignedLit()                                 { return assigned_lit; }
+
+    int clause(int i) const                            { return clauses[i]; }
+    int &clause(int i)                                 { return clauses[i]; }
+
+    int occurrence(int i) const                        { return occurrences[i]; }
+    int &occurrence(int i)                             { return occurrences[i]; }
+
+    int positiveOccurrence(int i) const        { return positive_occurrences[i]; }
+    int &positiveOccurrence(int i)             { return positive_occurrences[i]; }
+private:
+    SatStateBase(const SatStateBase&);
+    SatStateBase& operator = (const SatStateBase&);
+};
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/soln-checker.py b/examples/charm++/state_space_searchengine/3SAT/soln-checker.py
new file mode 100644 (file)
index 0000000..4aaf154
--- /dev/null
@@ -0,0 +1,174 @@
+# Tarun Prabhu
+# 8 Nov 2010
+
+# Checks if the solutions to a k-SAT problem are correct
+# The input file should be in DIMACS format
+# The output file should be in the format
+#   [One solution:
+#    (literal_number=[true|false|1|-1|0])+
+#   ]+
+
+# USAGE: soln-checker.py [problemfile] [solutionfile]
+
+import math
+import re
+import sys
+
+numberRegex = re.compile("[-]?\d+")
+
+# list<int> parseClause (string)
+def parseClause (clauseString):
+    lits = clauseString.split()
+    clause = []
+    for lit in lits:
+        if (numberRegex.match(lit) and int(lit) != 0):
+            clause.append(int(lit))
+    return clause
+
+# list<list<int>> parseClauses (list<string>)
+def parseClauses (clauseStrings):
+    clauses = []
+    for clauseString in clauseStrings:
+        clause = parseClause(clauseString)
+        if (clause != []):
+            clauses.append(clause)
+    return clauses
+
+# list<string> findClauses (list<string>)
+def findClauses (lines):
+    clauseLines = []
+    for line in lines:
+        if (not (line.startswith("c") or line.startswith("p"))):
+            clauseLines.append(line)
+    return clauseLines
+
+# list<list<int>> readProblemFile (string)
+def readProblemFile (problemFileName):
+    file = open(problemFileName, "r")
+    lines = file.readlines()
+    file.close()
+
+    clauses = parseClauses(findClauses(lines))
+    return clauses
+
+# list<string> findSolutions (list<string> linesInSolutionFile)
+def findSolutions(lines):
+    solutions = []
+    foundSolutionTag = False
+    for line in lines:
+        # If the line begins with "One solution", it must be a title line
+        # The line immediately after the "One Solution" line is the solution
+        # This still assumes that the entire solution is printed
+        # on the same line. It's better than before but I'd like it to be a 
+        # little more robust if possible.
+        if (line.startswith("One solution:")):
+            foundSolutionTag = True
+        elif (foundSolutionTag):
+            solutions.append(line)
+            foundSolutionTag = False
+    return solutions
+
+# list<list<int>> findMatchingParens(string, int)
+# Returns a list of pairs of indices for each "(",")" pair
+def findMatchingParens (string):
+    matchingParens = []
+    startIdx = -1
+    endIdx = -1
+    for i in range(0, len(string), 1):
+        if (string[i] == "("):
+            startIdx = i
+        elif(string[i] == ")"):
+            endIdx = i
+            matchingParens.append([startIdx, endIdx])
+    return matchingParens
+
+
+# #dict<int, bool> parseSolution (string solution)
+# Returns a map from literal number to its value
+def parseSolution (solution):
+    map = {}
+    matchingParens = findMatchingParens(solution)
+    for match in matchingParens:
+        start = match[0]
+        end = match[1]
+        string = solution[(start+1):end]
+        (strLit, strVal) = string.split("=")
+        if (strVal == "true" or strVal == "1"):
+            val = True
+        else: #(strVal == "false" or strVal == "0" or strVal == "-1")
+            val = False
+        map[int(strLit)] = val
+    return map
+
+# list<dict<int,bool>> parseSolutions(list<string> solutions)
+def parseSolutions(solutions):
+    solutionMaps = []
+    for solution in solutions:
+        solutionMaps.append(parseSolution(solution))
+    return solutionMaps
+
+# list<dict<int,bool>> readSolutionFile (string solutionFileName)
+# Returns a list of dictionaries where each dictionary represents a solution
+def readSolutionFile (solutionFileName):
+    file = open(solutionFileName)
+    lines = file.readlines()
+    file.close()
+
+    solutions = parseSolutions(findSolutions(lines))
+    return solutions
+
+# void printSolution (dict<int,bool>)
+def printSolution(solution):
+    for lit, val in solution.iteritems():
+        print "(" + str(lit) + "=" + str(val) + ")",
+
+# void printClauses (list<list<int>>)
+def printClauses(clauses):
+    for clause in clauses:
+        for lit in clause:
+            print lit, 
+        print ""
+
+# bool checkSolution (list<list<int>>, list<map<int,bool>>)
+def checkSolution(clauses, solution):
+    solutionResult = True
+    for clause in clauses:
+        clauseResult = False
+        for lit in clause:
+            absLit = math.fabs(lit)
+            if (lit < 0):
+                clauseResult = clauseResult or (not solution[absLit])
+            else:
+                clauseResult = clauseResult or solution[absLit]
+        solutionResult = solutionResult and clauseResult
+    return solutionResult
+    
+# bool checkSolutions (list<list<int>>, list<map<int,bool>>)
+def checkSolutions (clauses, solutions):
+    allOk = True
+    i = 1
+    for solution in solutions:
+        result = checkSolution(clauses, solution)
+#         print "Solution #" + str(i) + ": " + str(result)
+        allOk = allOk and result
+        i = i + 1
+    return allOk
+
+def main():
+    if (len(sys.argv) != 3):
+        print "USAGE: soln-checker.py [problemfile] [solutionfile]"
+    else:
+        inputFileName = sys.argv[1]
+        outputFileName = sys.argv[2]
+
+        clauses = readProblemFile(inputFileName)
+#        printClauses(clauses)
+        solutions = readSolutionFile(outputFileName)
+#         for solution in solutions:
+#             print "One solution:"
+#             printSolution(solution)
+#             print "\n"
+        print "All solutions passed: "+ str(checkSolutions(clauses, solutions))
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/charm++/state_space_searchengine/3SAT/solvers_convertor.C b/examples/charm++/state_space_searchengine/3SAT/solvers_convertor.C
new file mode 100644 (file)
index 0000000..9202c1c
--- /dev/null
@@ -0,0 +1,27 @@
+#ifdef MINISAT
+#include "searchEngineAPI.h"
+#include "Solver.h"
+
+inline bool convertToSequential(StateBase *_base)
+{
+    SatStateBase* parent = (SatStateBase*)_base;
+    vector< vector<int> > seq_clauses;
+    for(int _i_=0; _i_<parent->clause_size; _i_++)
+    {
+        if(parent->clauses[_i_*MAX_LITS] != 0)
+        {
+            vector<int> unsolvedclaus;
+            for(int _j_=_i_*MAX_LITS; _j_<_i_*MAX_LITS+MAX_LITS && parent->clauses[_j_]! =0; _j_++)
+            {
+                unsolvedclaus.push_back(parent->clauses[_j_]);
+            }
+            seq_clauses.push_back(unsolvedclaus);
+        }
+    }
+
+    signed int *seq_assignment = (signed int*) malloc( sizeof(signed int) *  parent->getVarSize());
+    bool satisfiable = seq_processing(parent->getVarSize(), seq_clauses, seq_assignment);
+    return satisfiable;
+}
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/solvers_convertor.h b/examples/charm++/state_space_searchengine/3SAT/solvers_convertor.h
new file mode 100644 (file)
index 0000000..07a4be6
--- /dev/null
@@ -0,0 +1,4 @@
+#ifndef SOLVERS_CONVERTOR_H_
+#define SOLVERS_CONVERTOR_H_
+bool convertToSequential(StateBase *_base);
+#endif
diff --git a/examples/charm++/state_space_searchengine/3SAT/uf125-01.cnf b/examples/charm++/state_space_searchengine/3SAT/uf125-01.cnf
new file mode 100644 (file)
index 0000000..e9e0b2f
--- /dev/null
@@ -0,0 +1,549 @@
+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 125  538 
+ -26 -105 118 0
+-62 92 80 0
+-65 -84 -25 0
+-80 -37 -9 0
+-91 -8 117 0
+-59 98 -10 0
+58 11 -26 0
+-77 98 -5 0
+-74 -5 22 0
+20 -41 22 0
+30 54 113 0
+111 -107 44 0
+-77 70 -30 0
+-67 -119 84 0
+-103 -95 -75 0
+14 11 123 0
+-34 35 29 0
+10 -124 92 0
+-119 -21 -6 0
+111 -87 51 0
+6 -100 -43 0
+-50 -9 2 0
+-101 96 47 0
+-79 -2 22 0
+-41 -65 92 0
+124 5 27 0
+9 57 -11 0
+-59 111 -66 0
+106 -7 77 0
+-7 -95 99 0
+97 -99 53 0
+23 38 65 0
+-92 -34 102 0
+52 93 3 0
+61 66 -2 0
+-60 11 70 0
+-42 -46 89 0
+-17 -45 46 0
+-44 100 -47 0
+-32 99 81 0
+-1 22 122 0
+30 91 10 0
+28 -89 -67 0
+-64 -124 -49 0
+64 -1 -55 0
+-72 67 87 0
+-115 -85 98 0
+-21 123 106 0
+-37 -81 59 0
+-41 4 -29 0
+-36 95 -37 0
+-5 26 51 0
+-119 46 18 0
+-34 44 116 0
+121 44 -60 0
+120 50 -52 0
+124 51 115 0
+-70 -20 -60 0
+-123 -28 -112 0
+-43 116 34 0
+-60 9 96 0
+-76 -39 -68 0
+80 -33 -115 0
+-82 -118 11 0
+-58 -23 121 0
+-12 59 19 0
+-125 121 98 0
+37 15 -93 0
+9 110 80 0
+24 -110 -83 0
+29 -88 16 0
+-107 70 -57 0
+-15 -48 6 0
+70 -83 -19 0
+85 1 57 0
+124 -48 94 0
+75 77 -108 0
+123 46 -42 0
+36 -97 73 0
+1 -81 -49 0
+64 120 -117 0
+70 -84 -39 0
+-45 -88 114 0
+77 1 -113 0
+-73 -56 65 0
+65 -51 -57 0
+17 -26 -24 0
+-124 -123 76 0
+-4 35 -41 0
+101 7 26 0
+102 -68 63 0
+-98 -15 -45 0
+111 69 -120 0
+102 60 113 0
+113 -28 52 0
+-26 -45 -122 0
+108 50 -9 0
+25 -32 -22 0
+-97 -70 -13 0
+5 -74 92 0
+-111 -113 79 0
+-101 -60 80 0
+-62 112 33 0
+36 102 70 0
+-113 -65 -105 0
+-114 -106 55 0
+98 63 66 0
+-54 -108 14 0
+86 102 122 0
+62 -12 -122 0
+109 79 98 0
+-45 117 122 0
+13 97 -26 0
+46 19 -69 0
+-98 111 -105 0
+86 11 23 0
+-118 -93 -35 0
+32 -91 -51 0
+-25 -37 2 0
+60 51 -37 0
+109 106 -74 0
+-50 31 90 0
+-39 -51 -8 0
+-73 -7 -35 0
+125 -35 39 0
+100 -58 -39 0
+45 -115 107 0
+52 -113 51 0
+-58 -24 41 0
+-81 98 -49 0
+-52 109 -55 0
+41 -75 109 0
+-22 -11 -45 0
+106 -2 -20 0
+-37 50 -90 0
+83 -95 13 0
+-100 63 115 0
+-18 -32 -91 0
+-71 -103 -106 0
+-4 121 63 0
+47 -8 -119 0
+66 41 -44 0
+-102 54 -97 0
+28 90 -50 0
+106 61 117 0
+-79 71 -38 0
+-54 -70 20 0
+38 101 110 0
+82 -70 93 0
+-2 -58 -84 0
+24 54 61 0
+54 3 -59 0
+-63 102 -99 0
+28 88 -69 0
+36 -97 51 0
+-52 -124 88 0
+-28 -53 22 0
+76 -16 125 0
+-25 116 104 0
+-60 114 111 0
+15 59 106 0
+-29 -110 23 0
+-65 79 45 0
+-13 33 40 0
+40 -116 -47 0
+43 -92 -40 0
+25 -122 82 0
+92 51 99 0
+-73 51 -48 0
+-45 -69 94 0
+-73 12 -14 0
+84 -60 -103 0
+60 -73 15 0
+-48 31 103 0
+73 63 76 0
+-88 -102 -55 0
+82 -48 24 0
+24 22 77 0
+-90 -102 -66 0
+74 19 21 0
+-68 -23 -26 0
+-88 79 -36 0
+-116 -37 -20 0
+103 -39 -50 0
+2 -53 -15 0
+-71 20 -97 0
+-85 -105 48 0
+119 81 98 0
+87 2 -85 0
+7 -47 -117 0
+-96 -15 -87 0
+-35 -70 83 0
+-18 -59 5 0
+-36 33 -29 0
+59 -51 -121 0
+-118 -42 -79 0
+59 -17 -9 0
+-65 -117 -8 0
+-96 16 113 0
+-74 -69 82 0
+-9 -111 69 0
+26 124 68 0
+-108 79 33 0
+71 -118 30 0
+89 66 -109 0
+72 -18 89 0
+66 5 27 0
+-51 21 120 0
+-96 82 9 0
+40 102 -66 0
+-1 -93 -89 0
+49 -77 20 0
+-108 10 -56 0
+37 -103 -81 0
+-76 -94 -23 0
+-100 -83 66 0
+-56 114 -88 0
+-10 -29 -87 0
+-13 5 -86 0
+-50 -117 46 0
+-46 65 118 0
+-123 58 -47 0
+-38 -17 -121 0
+-108 95 69 0
+113 -2 -67 0
+-106 32 96 0
+88 -92 75 0
+-86 -116 39 0
+67 -42 -97 0
+-31 92 -108 0
+75 -7 106 0
+73 -60 -107 0
+-65 68 71 0
+-106 -94 60 0
+59 -10 6 0
+-116 -57 39 0
+-112 -49 70 0
+-49 -11 119 0
+-12 94 -114 0
+-110 104 -102 0
+22 -10 -15 0
+70 93 -40 0
+66 -109 -121 0
+-81 115 -78 0
+37 46 -102 0
+-96 -57 -7 0
+101 -61 81 0
+-125 -16 -121 0
+-32 93 58 0
+12 -74 33 0
+-119 41 37 0
+-80 92 -105 0
+-93 58 -120 0
+68 40 -64 0
+-57 26 41 0
+119 43 -66 0
+54 -101 -64 0
+28 38 -23 0
+-69 -85 58 0
+-1 124 -66 0
+-84 -91 31 0
+-43 89 66 0
+-103 -70 82 0
+119 -13 87 0
+77 82 -59 0
+108 -5 73 0
+-16 -35 24 0
+-1 -88 -83 0
+81 84 -46 0
+-83 122 40 0
+-82 47 94 0
+-111 75 -52 0
+67 -22 109 0
+108 -64 14 0
+9 27 -51 0
+69 83 15 0
+-65 -39 -4 0
+-100 -46 -85 0
+13 -53 -6 0
+80 90 -102 0
+-98 -82 -61 0
+42 58 27 0
+-109 -24 -51 0
+10 119 47 0
+-90 -99 -93 0
+-44 76 62 0
+-92 104 113 0
+124 -8 60 0
+-44 -84 35 0
+94 64 29 0
+-41 48 82 0
+31 -119 123 0
+-55 110 -29 0
+-30 78 63 0
+119 -12 -99 0
+-28 -112 26 0
+4 120 46 0
+24 67 17 0
+-31 85 3 0
+-4 17 57 0
+-80 66 -115 0
+-33 54 -73 0
+111 79 -28 0
+53 36 -43 0
+100 -7 -84 0
+34 -63 -24 0
+77 -41 50 0
+16 49 -38 0
+-70 -90 -39 0
+-99 64 5 0
+-20 -123 62 0
+15 -25 -88 0
+-61 -44 11 0
+23 61 45 0
+-121 -2 88 0
+-38 102 20 0
+-13 -55 29 0
+-74 -35 67 0
+90 10 99 0
+-34 27 -3 0
+19 65 -62 0
+-42 52 31 0
+95 100 39 0
+75 23 -36 0
+50 66 -93 0
+-12 -79 -59 0
+-51 -34 24 0
+-86 -74 -24 0
+26 -59 105 0
+-2 -32 77 0
+89 96 -91 0
+120 94 -116 0
+-69 11 43 0
+49 -36 -86 0
+-39 -97 99 0
+-3 30 -27 0
+51 -47 -40 0
+12 -9 -100 0
+82 25 -20 0
+-110 -92 87 0
+15 84 -57 0
+112 103 -30 0
+-115 -31 -104 0
+-74 -41 104 0
+83 67 -123 0
+71 -39 -38 0
+110 -66 -67 0
+-110 81 -116 0
+43 -117 -116 0
+53 -42 14 0
+5 31 76 0
+-7 17 96 0
+34 -16 17 0
+-99 22 52 0
+37 96 53 0
+89 -26 -43 0
+69 76 -92 0
+-101 -58 -14 0
+-52 56 14 0
+115 -56 27 0
+-55 -69 74 0
+47 -52 -93 0
+10 66 50 0
+16 -108 -61 0
+-86 -75 -10 0
+-36 46 59 0
+-2 -64 92 0
+86 -87 122 0
+-16 125 -36 0
+31 -115 71 0
+-31 -13 108 0
+-4 -124 65 0
+27 -54 -102 0
+-77 80 -87 0
+108 -62 -105 0
+-115 -8 -93 0
+97 -100 88 0
+52 -97 109 0
+-115 72 2 0
+66 -41 -95 0
+-1 83 79 0
+58 27 -25 0
+76 114 67 0
+-108 -7 110 0
+-23 -106 111 0
+68 -32 12 0
+-94 114 87 0
+-66 40 123 0
+-108 63 65 0
+-109 -42 111 0
+27 -52 91 0
+100 56 -41 0
+-117 -111 6 0
+-47 93 124 0
+-117 43 60 0
+36 -40 95 0
+-54 -53 113 0
+-61 -105 18 0
+3 16 97 0
+-20 -118 -74 0
+-123 5 -125 0
+24 60 -5 0
+44 90 -97 0
+66 34 -81 0
+68 56 75 0
+-102 -8 48 0
+54 125 113 0
+50 -55 106 0
+88 -57 -45 0
+-1 36 10 0
+119 27 28 0
+-95 -57 2 0
+-99 40 67 0
+90 -24 -115 0
+-89 68 118 0
+119 12 -70 0
+-23 -5 25 0
+79 -33 102 0
+122 117 -24 0
+-95 1 99 0
+-62 -30 87 0
+106 -105 39 0
+41 -38 64 0
+-52 -66 -24 0
+56 -42 -82 0
+46 47 -4 0
+-41 -109 66 0
+110 29 64 0
+-81 97 75 0
+61 103 62 0
+-117 53 -93 0
+82 100 -80 0
+-48 -39 96 0
+-120 42 113 0
+89 -80 13 0
+-72 89 40 0
+41 106 90 0
+-110 72 2 0
+90 -75 5 0
+122 50 -52 0
+94 -110 18 0
+-18 109 5 0
+14 31 110 0
+33 -90 93 0
+77 119 112 0
+-74 -109 118 0
+-115 -10 -45 0
+32 6 -121 0
+35 -54 -86 0
+65 43 -77 0
+60 -118 -76 0
+114 -73 -77 0
+-124 -98 -74 0
+115 -23 76 0
+91 -31 -110 0
+77 69 -26 0
+117 100 -44 0
+24 13 60 0
+-7 24 52 0
+-116 14 71 0
+-50 -108 -90 0
+-42 103 92 0
+72 26 20 0
+-35 49 -45 0
+-1 -122 108 0
+94 -20 -121 0
+50 -11 -83 0
+23 43 111 0
+-63 82 -77 0
+76 -44 79 0
+-71 84 68 0
+47 -66 49 0
+-90 104 -62 0
+102 -83 -66 0
+-11 -16 28 0
+-12 -19 -101 0
+117 6 57 0
+-59 100 116 0
+104 -26 94 0
+29 90 -49 0
+73 65 -15 0
+-40 11 -105 0
+-110 89 -100 0
+84 -39 -80 0
+-32 82 38 0
+-34 -74 49 0
+-122 103 -2 0
+77 -13 -80 0
+-38 -76 -7 0
+106 -110 -81 0
+-52 104 38 0
+-122 57 107 0
+-115 101 22 0
+37 65 89 0
+-43 37 -26 0
+-87 -106 75 0
+-4 -77 -67 0
+121 65 -66 0
+-31 -46 -32 0
+36 7 125 0
+-32 -91 -35 0
+116 -94 66 0
+-22 -75 -81 0
+-56 -122 -11 0
+51 -26 -106 0
+104 -118 74 0
+-2 89 -8 0
+84 43 36 0
+4 60 -125 0
+-113 -72 -16 0
+76 -101 -96 0
+-64 116 33 0
+-32 17 -96 0
+-70 -58 35 0
+59 -3 75 0
+102 -100 -22 0
+64 78 123 0
+-41 -27 -22 0
+-52 -15 -32 0
+54 19 -91 0
+-54 21 64 0
+41 -85 -104 0
+-90 -9 -16 0
+108 42 -112 0
+-101 91 66 0
+-22 30 -94 0
+12 -10 -99 0
+-14 -111 -103 0
+-107 18 61 0
+96 -20 -98 0
+67 -8 11 0
+30 116 71 0
+-90 53 34 0
+-17 34 -27 0
+84 124 -101 0
+37 101 -96 0
+109 41 -66 0
+103 -8 -33 0
+%
+0
+
diff --git a/examples/charm++/state_space_searchengine/3SAT/uf200-055.cnf b/examples/charm++/state_space_searchengine/3SAT/uf200-055.cnf
new file mode 100644 (file)
index 0000000..72844ec
--- /dev/null
@@ -0,0 +1,871 @@
+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 200  860 
+ -56 88 -198 0
+92 76 -73 0
+11 -73 130 0
+61 -29 -12 0
+-50 -26 146 0
+-131 -194 -147 0
+-120 -84 23 0
+-190 -193 -158 0
+7 -56 -130 0
+124 -160 140 0
+130 86 72 0
+23 -134 -147 0
+131 116 -122 0
+-189 42 172 0
+-33 184 -42 0
+-50 183 84 0
+-185 -80 -31 0
+-60 -55 -73 0
+98 132 149 0
+-151 82 192 0
+190 103 27 0
+171 -8 164 0
+159 -199 144 0
+139 -78 17 0
+95 98 -147 0
+-130 -80 -102 0
+40 -123 133 0
+93 -83 69 0
+-122 -52 127 0
+-5 -33 171 0
+152 48 139 0
+-178 44 -14 0
+181 -141 -21 0
+99 98 -186 0
+99 -42 156 0
+129 -145 -122 0
+-159 175 169 0
+-111 -65 -157 0
+65 12 31 0
+-173 135 -109 0
+-3 133 45 0
+50 -160 -17 0
+-35 -43 166 0
+-124 39 -91 0
+-21 -61 62 0
+29 -193 -199 0
+-116 -166 158 0
+-33 18 -133 0
+-77 132 145 0
+94 105 156 0
+-62 -76 20 0
+-51 -157 176 0
+15 -158 -199 0
+88 -97 49 0
+-148 -86 176 0
+-125 -179 -134 0
+-162 -164 82 0
+4 -161 -179 0
+-106 -61 41 0
+36 -63 107 0
+70 91 -3 0
+128 -197 80 0
+31 -138 -187 0
+-154 -45 -19 0
+-16 35 -196 0
+-146 -115 53 0
+-64 45 83 0
+-170 85 155 0
+-115 48 -138 0
+67 -58 171 0
+24 125 130 0
+162 136 -92 0
+62 50 -30 0
+110 121 173 0
+-184 -120 72 0
+170 6 175 0
+147 43 183 0
+183 -150 -111 0
+-137 -75 37 0
+-124 105 -10 0
+46 -29 197 0
+66 -74 120 0
+110 -94 -157 0
+-138 -43 -197 0
+64 76 23 0
+65 -116 110 0
+139 2 112 0
+66 -160 117 0
+-144 117 65 0
+59 155 -93 0
+164 -93 79 0
+111 -93 15 0
+-45 17 24 0
+-183 120 47 0
+182 -165 -156 0
+26 86 197 0
+10 131 25 0
+75 -98 -113 0
+18 118 36 0
+128 22 11 0
+-2 111 -89 0
+8 18 -58 0
+121 -124 -37 0
+-149 176 -91 0
+30 168 153 0
+-44 53 -147 0
+-59 58 174 0
+56 10 -146 0
+-65 -191 -81 0
+87 4 -89 0
+76 87 192 0
+-178 -77 -99 0
+-173 -48 198 0
+-23 -5 31 0
+-24 46 9 0
+51 -160 -139 0
+-85 -160 32 0
+-171 84 72 0
+9 -25 -17 0
+45 151 -22 0
+105 -112 66 0
+199 38 -7 0
+-55 -192 1 0
+-139 169 -26 0
+-131 -53 -103 0
+-59 10 76 0
+-172 51 68 0
+96 137 81 0
+-98 -1 11 0
+-76 87 -71 0
+144 98 186 0
+-49 -194 -89 0
+6 -67 -107 0
+-128 -59 -170 0
+156 58 12 0
+-3 -181 -149 0
+-27 -48 -164 0
+-86 170 -2 0
+-161 -183 23 0
+56 -76 63 0
+119 105 80 0
+37 120 127 0
+-136 -120 -61 0
+-102 72 98 0
+-129 -57 -93 0
+-91 -42 -99 0
+-50 -146 -110 0
+-67 82 -64 0
+-43 120 46 0
+158 -172 104 0
+-44 54 -69 0
+133 74 122 0
+187 116 -149 0
+25 85 -87 0
+117 183 103 0
+-47 77 -119 0
+93 -151 16 0
+82 180 181 0
+198 -54 -108 0
+-15 41 -116 0
+-183 108 25 0
+44 -116 -194 0
+-125 12 -167 0
+128 -40 -51 0
+169 140 15 0
+33 -39 182 0
+101 183 120 0
+81 167 -61 0
+44 198 142 0
+68 2 6 0
+-157 -119 100 0
+144 -77 21 0
+-112 52 29 0
+75 143 -98 0
+83 -104 132 0
+149 143 -137 0
+-87 24 -189 0
+-170 -199 -10 0
+-97 45 51 0
+125 144 -191 0
+74 181 -118 0
+-122 116 -23 0
+68 -192 108 0
+186 87 -123 0
+-123 5 -128 0
+89 -134 -140 0
+6 -65 -84 0
+137 -42 98 0
+122 -105 174 0
+-28 -64 -58 0
+114 65 -52 0
+-22 -76 59 0
+-12 40 -74 0
+-197 5 98 0
+24 75 101 0
+199 -143 142 0
+-44 -18 -88 0
+135 -31 9 0
+40 -119 -98 0
+-32 42 -37 0
+-112 14 55 0
+-5 -28 -154 0
+42 -85 175 0
+-51 -168 -8 0
+-84 -9 16 0
+34 -33 -100 0
+-154 -198 137 0
+52 -147 -173 0
+-116 -46 68 0
+-97 -78 -52 0
+198 -31 -5 0
+-7 -73 -196 0
+32 47 -4 0
+174 88 171 0
+-194 -159 67 0
+104 -187 44 0
+-8 -178 -38 0
+-183 189 185 0
+90 -22 -114 0
+-75 112 -154 0
+181 -121 96 0
+-66 129 -179 0
+41 63 -124 0
+-51 -138 -193 0
+-160 74 22 0
+-22 195 161 0
+118 -84 11 0
+-32 27 153 0
+-127 101 -140 0
+29 -24 11 0
+90 158 20 0
+-132 193 -122 0
+-32 120 -134 0
+-186 -2 -84 0
+62 -149 -173 0
+-98 -89 -66 0
+155 70 134 0
+-183 43 142 0
+-100 -13 -19 0
+-132 200 87 0
+12 169 -174 0
+-19 -40 -182 0
+-173 98 35 0
+-132 113 75 0
+-88 -28 12 0
+59 144 -52 0
+-144 -39 177 0
+-117 163 189 0
+13 -9 116 0
+-100 45 -39 0
+194 -77 -114 0
+-182 -52 -174 0
+49 93 127 0
+-41 -57 -13 0
+168 -43 15 0
+177 -147 110 0
+-25 -173 70 0
+162 180 -138 0
+-93 58 -37 0
+75 -181 -24 0
+122 164 -124 0
+-51 79 88 0
+-166 -39 198 0
+-85 -19 73 0
+-102 198 67 0
+103 9 18 0
+142 91 150 0
+47 176 -65 0
+-59 165 -11 0
+17 -188 132 0
+-138 16 26 0
+-26 183 -157 0
+2 -59 143 0
+59 162 186 0
+-3 -110 -59 0
+-152 131 187 0
+44 111 11 0
+-167 -89 -81 0
+-131 14 145 0
+188 86 -146 0
+18 -172 -70 0
+33 -194 -65 0
+-65 160 -40 0
+129 -199 9 0
+110 -102 -177 0
+194 -165 -169 0
+17 2 -112 0
+34 109 -66 0
+68 182 133 0
+-168 164 149 0
+-141 13 61 0
+-27 -92 31 0
+-43 7 184 0
+-42 148 19 0
+-21 -191 37 0
+-65 -74 -67 0
+-156 -9 34 0
+62 190 15 0
+-82 -139 41 0
+174 -134 -54 0
+-66 168 62 0
+-75 49 -53 0
+-116 -97 188 0
+-24 -65 125 0
+-70 -183 -109 0
+139 32 -107 0
+-81 -128 89 0
+-13 -114 -135 0
+-178 -22 -23 0
+-200 -27 -135 0
+-82 137 -188 0
+-49 141 57 0
+-177 -180 -195 0
+107 -200 -176 0
+-8 -184 -62 0
+-197 118 -104 0
+152 135 -56 0
+69 74 102 0
+-16 -111 79 0
+-120 126 -19 0
+148 37 118 0
+166 -172 138 0
+144 -48 -110 0
+125 -128 -24 0
+38 39 -68 0
+-57 167 -144 0
+-178 183 -135 0
+152 -148 163 0
+-174 -117 -1 0
+140 157 -158 0
+114 70 -143 0
+-20 -21 -143 0
+69 -89 95 0
+-104 -124 -4 0
+-24 60 80 0
+157 180 162 0
+60 56 -26 0
+148 -79 52 0
+-129 -13 124 0
+-56 -141 -105 0
+-28 -79 -150 0
+195 37 41 0
+183 186 130 0
+-35 157 -51 0
+-3 144 109 0
+77 107 108 0
+12 -91 -122 0
+103 -94 -146 0
+-70 -162 129 0
+-89 123 162 0
+-27 -106 146 0
+-20 -143 132 0
+101 -97 136 0
+-19 -199 -25 0
+-166 8 67 0
+-166 -32 -2 0
+153 -185 75 0
+127 27 166 0
+-124 91 93 0
+-93 -4 19 0
+55 96 -56 0
+160 -4 -63 0
+171 156 -98 0
+-156 -119 84 0
+-197 161 -115 0
+10 -187 193 0
+-54 -154 -17 0
+-48 -169 -101 0
+137 156 47 0
+117 56 166 0
+-169 21 43 0
+-173 140 -190 0
+135 104 -156 0
+164 186 -111 0
+-15 -123 25 0
+36 122 -56 0
+-115 55 -81 0
+92 178 41 0
+-3 -176 76 0
+-83 -1 -5 0
+-143 17 -79 0
+139 -9 15 0
+-156 3 35 0
+-85 -52 23 0
+42 -48 -10 0
+3 98 -7 0
+40 34 109 0
+-112 8 24 0
+194 88 126 0
+25 -89 138 0
+26 136 190 0
+133 -56 -118 0
+62 -22 -179 0
+158 -161 -70 0
+-173 2 -5 0
+-3 62 75 0
+-77 26 146 0
+-165 129 78 0
+-124 171 -6 0
+-110 -27 184 0
+-53 -140 -82 0
+-17 8 2 0
+19 -166 196 0
+-142 33 180 0
+-130 135 -60 0
+134 102 136 0
+-191 46 75 0
+60 -28 -42 0
+65 182 44 0
+141 -142 -137 0
+188 -93 -70 0
+-195 -167 11 0
+-46 -2 128 0
+166 190 60 0
+86 -142 -9 0
+157 -184 93 0
+-163 -182 -181 0
+-61 -14 157 0
+-66 80 72 0
+192 -175 15 0
+1 -154 -195 0
+106 -143 -164 0
+-41 -177 145 0
+-80 -31 138 0
+24 -148 -1 0
+48 149 -151 0
+-24 147 -73 0
+118 73 -166 0
+121 -151 -161 0
+85 -126 64 0
+82 12 160 0
+162 77 -147 0
+-23 181 -52 0
+118 162 -73 0
+194 -105 100 0
+69 -71 -74 0
+-29 64 4 0
+154 -120 47 0
+-127 -25 50 0
+173 -96 -174 0
+135 23 -33 0
+-135 80 199 0
+5 9 -16 0
+-139 -140 148 0
+59 -110 146 0
+195 -117 -121 0
+-162 -60 -52 0
+57 2 -114 0
+-195 -191 66 0
+-192 38 113 0
+-36 64 -11 0
+-128 54 -195 0
+-85 -70 193 0
+-125 137 36 0
+-194 70 -52 0
+1 -42 185 0
+-147 -125 -129 0
+-133 -188 -12 0
+170 -111 -89 0
+19 -94 37 0
+-191 1 84 0
+-52 159 -6 0
+-122 -32 97 0
+-87 -127 193 0
+-142 150 -188 0
+-21 -11 -188 0
+-184 37 159 0
+-98 139 90 0
+77 -158 -172 0
+-163 75 53 0
+-138 -74 83 0
+125 -161 -106 0
+141 48 -61 0
+76 -118 90 0
+150 -98 3 0
+-37 -23 158 0
+-87 -160 132 0
+-111 -158 115 0
+16 -117 -138 0
+13 -54 57 0
+89 -191 30 0
+73 39 189 0
+-59 119 56 0
+-21 -74 171 0
+-118 -149 128 0
+181 53 72 0
+39 -171 62 0
+-126 34 189 0
+35 -29 121 0
+80 105 -6 0
+-89 60 -21 0
+184 -108 91 0
+-115 60 -100 0
+150 75 -136 0
+-128 -161 -26 0
+-102 57 164 0
+-42 200 140 0
+198 160 -134 0
+-5 13 -49 0
+62 -10 90 0
+-192 -44 -114 0
+-188 -8 -130 0
+-2 136 -134 0
+-109 -37 9 0
+-86 -39 101 0
+-32 118 87 0
+75 -61 -60 0
+-179 -189 -135 0
+-107 -31 -5 0
+-6 73 -19 0
+150 80 -62 0
+-89 -99 -195 0
+147 -81 171 0
+48 100 -124 0
+33 -20 185 0
+196 -76 -112 0
+-192 -1 -34 0
+-169 -95 18 0
+-32 24 -109 0
+68 -107 143 0
+-84 153 145 0
+-130 -2 57 0
+101 157 -119 0
+128 -99 -37 0
+151 81 -103 0
+87 192 -117 0
+-12 -3 30 0
+-76 148 136 0
+-122 171 111 0
+118 5 165 0
+-192 -94 -194 0
+-80 -187 -198 0
+145 38 -136 0
+92 -153 149 0
+87 29 7 0
+54 -40 107 0
+43 -27 69 0
+-28 -81 68 0
+142 52 -51 0
+92 -140 190 0
+111 44 78 0
+-99 -134 -51 0
+197 -1 67 0
+163 -106 -79 0
+-175 -87 72 0
+2 -96 -107 0
+-103 -12 -132 0
+140 176 106 0
+-33 2 -175 0
+-44 -190 58 0
+178 156 138 0
+83 138 62 0
+118 31 15 0
+93 -70 57 0
+38 -25 62 0
+137 118 172 0
+-124 85 145 0
+25 15 -67 0
+-94 -130 -174 0
+22 -35 -179 0
+99 -66 36 0
+77 63 122 0
+-57 -72 35 0
+27 -4 -2 0
+-155 176 -33 0
+52 157 -27 0
+125 -103 29 0
+66 -180 147 0
+-172 -130 62 0
+172 85 191 0
+-166 -69 5 0
+-158 -80 133 0
+61 192 -35 0
+-65 63 -68 0
+-141 7 82 0
+-179 -176 -167 0
+-13 -125 -2 0
+1 -172 119 0
+173 -44 -72 0
+-38 111 -113 0
+-18 20 98 0
+-106 -15 190 0
+-34 -161 71 0
+161 169 93 0
+139 -47 173 0
+174 -184 33 0
+-136 -73 50 0
+25 -13 -170 0
+145 -125 -134 0
+100 -96 -189 0
+-86 -120 -138 0
+153 127 -178 0
+-12 -76 -169 0
+147 -116 57 0
+22 -53 108 0
+-166 -10 -174 0
+-9 80 -91 0
+-142 94 -18 0
+42 -21 105 0
+111 -123 110 0
+73 99 -44 0
+-10 -50 100 0
+137 25 60 0
+-89 120 153 0
+-98 142 -119 0
+190 -174 -196 0
+-45 -185 -17 0
+187 -117 172 0
+94 52 190 0
+-56 137 151 0
+-128 42 -199 0
+-90 122 -158 0
+54 53 25 0
+192 -68 85 0
+94 43 44 0
+-196 138 68 0
+-9 136 -199 0
+-168 -54 188 0
+-88 -143 -71 0
+-66 -75 -20 0
+179 139 53 0
+88 -66 3 0
+21 -149 59 0
+12 30 -153 0
+60 -67 -8 0
+194 155 -88 0
+-114 -89 -11 0
+-122 196 141 0
+-190 16 -112 0
+76 158 -180 0
+-32 30 -111 0
+65 -190 -1 0
+67 28 -172 0
+-89 -197 192 0
+113 14 47 0
+-48 128 -113 0
+70 -112 178 0
+45 54 -112 0
+-192 -149 115 0
+-73 -60 -67 0
+-2 -199 -90 0
+102 25 49 0
+164 -140 -89 0
+-194 -148 97 0
+161 -3 104 0
+189 123 54 0
+15 138 -35 0
+-98 180 69 0
+134 -49 -172 0
+-74 -117 105 0
+33 132 -149 0
+-96 24 -121 0
+-60 -184 -118 0
+-152 -102 -21 0
+-26 -6 94 0
+-156 -17 -169 0
+89 -199 2 0
+147 -189 71 0
+36 -69 142 0
+-32 -18 79 0
+-162 104 -79 0
+-109 -96 -181 0
+198 -51 99 0
+109 150 83 0
+123 -38 92 0
+-64 125 -143 0
+-124 163 -46 0
+-14 -70 -1 0
+127 47 65 0
+-84 19 108 0
+-15 83 195 0
+-108 149 11 0
+-103 -67 153 0
+18 -105 138 0
+154 -198 52 0
+-132 -187 -154 0
+-175 52 -127 0
+68 106 46 0
+111 -27 129 0
+-81 -63 40 0
+-3 -56 -199 0
+135 -157 -194 0
+41 9 -103 0
+111 -140 139 0
+-81 -68 111 0
+-132 -2 91 0
+73 -93 -28 0
+-64 194 178 0
+78 191 -147 0
+-65 110 1 0
+-11 162 -3 0
+173 164 52 0
+-170 93 200 0
+-155 -137 70 0
+34 -18 9 0
+35 -4 200 0
+197 77 55 0
+55 -48 177 0
+134 150 -172 0
+-102 -84 -143 0
+-150 -154 139 0
+40 187 -120 0
+-178 -90 45 0
+-189 77 188 0
+85 182 122 0
+-163 -42 -193 0
+144 -31 170 0
+-60 102 96 0
+-143 44 -116 0
+169 -89 176 0
+-129 -78 -110 0
+105 -122 131 0
+-81 -45 156 0
+-15 91 54 0
+125 190 146 0
+168 -9 -139 0
+-178 -35 39 0
+-163 -190 67 0
+-129 -179 -106 0
+-39 -33 -118 0
+-45 -101 -5 0
+-100 156 170 0
+161 -26 68 0
+-43 72 -11 0
+-76 92 152 0
+-189 -120 -185 0
+129 -3 -117 0
+176 -101 -6 0
+76 -171 21 0
+-6 -195 166 0
+42 -176 161 0
+-188 -98 66 0
+85 171 106 0
+40 -90 -5 0
+135 -182 -119 0
+-141 181 81 0
+164 194 -147 0
+-35 184 -113 0
+-174 -114 -16 0
+103 108 -173 0
+126 148 91 0
+56 12 -91 0
+144 76 172 0
+-183 -189 -159 0
+-189 70 40 0
+-72 15 195 0
+-60 76 55 0
+-140 21 -171 0
+-157 59 -175 0
+48 45 -12 0
+-135 78 -116 0
+173 101 12 0
+123 -190 -110 0
+79 -58 -46 0
+195 -21 -147 0
+107 -44 30 0
+-159 -145 170 0
+-60 -94 -10 0
+156 -66 -168 0
+102 -114 162 0
+1 26 113 0
+100 -8 30 0
+90 37 96 0
+-10 -162 148 0
+119 -64 179 0
+149 -113 -124 0
+-147 -42 -180 0
+179 -1 195 0
+-156 110 -163 0
+-169 6 188 0
+-46 34 -12 0
+-142 43 -196 0
+80 197 107 0
+75 -26 117 0
+-161 96 10 0
+49 89 129 0
+15 -200 66 0
+116 1 -82 0
+-29 -150 -177 0
+-150 148 200 0
+-54 146 -132 0
+5 21 -190 0
+156 -145 -112 0
+-188 -196 -137 0
+68 90 -72 0
+111 102 -113 0
+32 -88 -140 0
+-131 114 43 0
+-138 77 166 0
+169 -107 -160 0
+-147 -56 -41 0
+20 -27 99 0
+171 98 181 0
+42 185 -138 0
+96 54 61 0
+183 37 71 0
+183 44 36 0
+-148 55 -118 0
+-190 -110 149 0
+-82 12 -89 0
+157 50 15 0
+36 -55 -83 0
+91 83 21 0
+-172 -1 -198 0
+155 -10 -126 0
+21 -108 -42 0
+-73 170 -169 0
+-122 -131 -186 0
+31 110 -197 0
+142 184 135 0
+-59 47 -193 0
+-16 -154 -97 0
+88 -31 68 0
+70 3 -115 0
+-191 172 -129 0
+10 -98 1 0
+129 -14 -36 0
+163 -85 -175 0
+-36 26 -151 0
+95 83 -153 0
+-177 17 89 0
+59 -148 101 0
+39 -135 -182 0
+-161 -200 165 0
+92 45 -139 0
+-35 44 -163 0
+-11 -80 -130 0
+-8 12 37 0
+128 186 -2 0
+148 187 196 0
+-33 -65 -106 0
+-177 -199 -5 0
+8 -117 190 0
+46 -34 200 0
+-198 -73 -82 0
+-55 -192 -176 0
+86 163 91 0
+-75 188 59 0
+165 127 -72 0
+9 125 -49 0
+57 76 136 0
+-103 24 -62 0
+-61 166 120 0
+192 49 -140 0
+31 68 117 0
+-38 -126 -76 0
+-73 44 160 0
+-67 97 16 0
+-200 8 149 0
+132 -102 -75 0
+-48 -18 69 0
+61 -63 55 0
+70 63 188 0
+-185 -48 11 0
+141 -119 -183 0
+159 -14 -179 0
+38 197 32 0
+-182 -87 -90 0
+-173 157 -186 0
+64 30 91 0
+%
+0
+
diff --git a/examples/charm++/state_space_searchengine/BalancedTree/Makefile b/examples/charm++/state_space_searchengine/BalancedTree/Makefile
new file mode 100644 (file)
index 0000000..bed50e3
--- /dev/null
@@ -0,0 +1,34 @@
+
+override OPTS += -I../searchengineLib -L../searchengineLib
+
+include ../Makefile.common
+
+
+all: main  main.nb 
+
+projections: main.prj  main.nb.prj
+
+main: searchEngineAPI.o main.o 
+       $(CHARMC) -language charm++  main.o searchEngineAPI.o -o main -module searchEngine
+
+main.prj:  main.o 
+       $(CHARMC) -language charm++  -tracemode projections main.o searchEngineAPI.o -o main.prj -module searchEngine
+
+main.nb: searchEngineAPI.o main.o 
+       $(CHARMC) -language charm++  main.o searchEngineAPI.o -o main.nb -balance neighbor -module searchEngine
+
+main.nb.prj:  main.o 
+       $(CHARMC) -language charm++  -tracemode projections main.o searchEngineAPI.o -o main.nb.prj -balance neighbor -module searchEngine
+
+main.decl.h: main.ci
+       $(CHARMC)  main.ci
+
+main.o: main.C main.decl.h
+       $(CHARMC) -c  main.C
+
+searchEngineAPI.o: searchEngineAPI.C  
+       $(CHARMC) -c  searchEngineAPI.C
+
+
+clean:
+       rm -f *.decl.h *.def.h conv-host *.o main charmrun main.prj  main.nb.prj  main.nb $(ALL) *~
diff --git a/examples/charm++/state_space_searchengine/BalancedTree/main.C b/examples/charm++/state_space_searchengine/BalancedTree/main.C
new file mode 100644 (file)
index 0000000..cfec83f
--- /dev/null
@@ -0,0 +1,35 @@
+#include "main.decl.h"
+
+#include "searchEngine.h"
+int branchfactor;
+int depth;
+int initial_grainsize;
+int target;
+
+class Main
+{
+public:
+    Main(CkArgMsg* msg )
+    {
+        branchfactor = 2;
+        CkPrintf("main initial_grainsize branchfactor depth\n");
+        if(msg->argc == 5)
+        {
+            initial_grainsize = atoi(msg->argv[1]);
+            branchfactor = atoi(msg->argv[2]);
+            depth = atoi(msg->argv[3]);
+            target = atoi(msg->argv[4]);            
+            delete msg;
+        }else
+        {
+            CkPrintf("Check input parameter\n");
+            delete msg;
+            CkExit();
+        }
+
+        searchEngineProxy.start();
+    }
+
+};
+
+#include "main.def.h"
diff --git a/examples/charm++/state_space_searchengine/BalancedTree/main.ci b/examples/charm++/state_space_searchengine/BalancedTree/main.ci
new file mode 100644 (file)
index 0000000..81a5648
--- /dev/null
@@ -0,0 +1,11 @@
+mainmodule main
+{
+    readonly int branchfactor;
+    readonly int depth;
+    readonly int  initial_grainsize;
+    readonly int target;
+    mainchare Main
+       {
+               entry Main(CkArgMsg *m);
+       }
+}
diff --git a/examples/charm++/state_space_searchengine/BalancedTree/searchEngineAPI.C b/examples/charm++/state_space_searchengine/BalancedTree/searchEngineAPI.C
new file mode 100644 (file)
index 0000000..ccba6de
--- /dev/null
@@ -0,0 +1,68 @@
+#ifndef __SEARCHENGINEAPI__
+#define __SEARCHENGINEAPI__
+
+#include "searchEngine.h"
+
+/*   framework for search engine */
+
+
+extern int branchfactor;
+extern int depth;
+extern int initial_grainsize;
+extern int target;
+
+class BTreeStateBase : public StateBase
+{
+public:
+   int depth;
+   long long index;
+};
+
+void createInitialChildren(Solver *solver)
+{
+    BTreeStateBase *root = (BTreeStateBase*)solver->registerRootState(sizeof(BTreeStateBase), 0, 1);
+    root->index = 0;
+    root->depth = 0;
+    solver->process(root);
+}
+
+inline void createChildren( StateBase *_base , Solver* solver, bool parallel)
+{
+    BTreeStateBase base = *((BTreeStateBase*)_base);
+    long long t = 1;
+
+    for(int i=0; i<target; i++)
+         t = t << 1;
+    for(int childIndex=0; childIndex<branchfactor; childIndex++)
+    {
+        long long thisindex = base.index * branchfactor + childIndex;
+        //CkPrintf(" t = %lld, based index=%lld _basedindex=%lld  thisindex=%lld, depth=%d\n", t, base.index, ((BTreeStateBase*)_base)->index, thisindex, base.depth);
+        if(base.depth == depth-1)
+        {
+            if( t-1 == thisindex)
+                solver->reportSolution();
+        }
+        else{
+            BTreeStateBase *child  = (BTreeStateBase*)solver->registerState(sizeof(BTreeStateBase), childIndex, branchfactor);
+            child->depth = base.depth + 1;
+            child->index = base.index * branchfactor + childIndex; 
+            if(parallel) {
+                solver->process(child);
+            }
+        }
+    }
+}
+
+int parallelLevel()
+{
+    return initial_grainsize;
+}
+
+int searchDepthLimit()
+{
+    return 1;
+}
+
+SE_Register(BTreeStateBase, createInitialChildren, createChildren, parallelLevel, searchDepthLimit);
+
+#endif
diff --git a/examples/charm++/state_space_searchengine/Hamiltonian_SE/Makefile b/examples/charm++/state_space_searchengine/Hamiltonian_SE/Makefile
new file mode 100644 (file)
index 0000000..be27e22
--- /dev/null
@@ -0,0 +1,34 @@
+
+override OPTS += -I../searchengineLib -L../searchengineLib -DVALUE_HEURISTIC #-DUSERSOLVER 
+
+include ../Makefile.common
+
+
+all: main main.nb
+
+projections: main.nb.prj main.prj
+
+main: searchEngineAPI.o main.o 
+       $(CHARMC) -language charm++  main.o searchEngineAPI.o -o main -module searchEngine
+
+main.prj:  main.o 
+       $(CHARMC) -language charm++  -tracemode projections main.o searchEngineAPI.o -o main.prj -module searchEngine
+
+main.nb: searchEngineAPI.o main.o 
+       $(CHARMC) -language charm++  main.o searchEngineAPI.o -o main.nb -balance neighbor -module searchEngine
+
+main.nb.prj:  main.o 
+       $(CHARMC) -language charm++  -tracemode projections main.o searchEngineAPI.o -o main.nb.prj -balance neighbor -module searchEngine
+
+main.decl.h: main.ci
+       $(CHARMC)  main.ci
+
+main.o: main.C main.decl.h
+       $(CHARMC) -c  main.C
+
+searchEngineAPI.o: searchEngineAPI.C  
+       $(CHARMC) -c  searchEngineAPI.C
+
+
+clean:
+       rm -f *.decl.h *.def.h conv-host *.o main main.nb main.nb.prj main.prj charmrun $(ALL) *~
diff --git a/examples/charm++/state_space_searchengine/Hamiltonian_SE/data/alb1000.hcp b/examples/charm++/state_space_searchengine/Hamiltonian_SE/data/alb1000.hcp
new file mode 100644 (file)
index 0000000..7fd87a0
--- /dev/null
@@ -0,0 +1,2006 @@
+NAME : alb1000
+COMMENT : Hamiltonian cycle problem (Erbacci) 
+TYPE : HCP
+DIMENSION : 1000
+EDGE_DATA_FORMAT : EDGE_LIST
+EDGE_DATA_SECTION
+  1000    593
+  1000    456
+  1000    217
+   999    577
+   999    537
+   999    519
+   998    604
+   998    599
+   998    211
+   997    996
+   997    604
+   997    299
+   996    444
+   996    234
+   995    440
+   995    413
+   995    251
+   994    993
+   994    434
+   994    428
+   993    992
+   993    585
+   992    991
+   992     28
+   991    990
+   991    481
+   990    989
+   990    242
+   989    988
+   989      7
+   988    603
+   988      5
+   987    986
+   987    603
+   987     32
+   986    985
+   986    187
+   985    984
+   985     94
+   984    983
+   984      3
+   983    982
+   983     68
+   982    602
+   982     29
+   981    602
+   981    352
+   981     33
+   980    554
+   980    538
+   980     59
+   979    601
+   979    432
+   979    374
+   978    601
+   978    550
+   978    499
+   977    445
+   977    173
+   977     47
+   976    975
+   976    584
+   976    220
+   975    974
+   975    512
+   974    365
+   974    247
+   973    526
+   973    350
+   973    151
+   972    592
+   972    248
+   972    171
+   971    591
+   971    248
+   971     77
+   970    969
+   970    209
+   970    175
+   969    968
+   969    230
+   968    600
+   968    210
+   967    600
+   967    565
+   967    558
+   966    965
+   966    465
+   966    321
+   965    964
+   965    244
+   964    963
+   964    152
+   963    962
+   963    599
+   962    961
+   962     67
+   961    960
+   961    497
+   960    598
+   960    462
+   959    598
+   959    597
+   959    218
+   958    957
+   958    597
+   958     60
+   957    956
+   957    174
+   956    955
+   956      9
+   955    954
+   955    124
+   954    596
+   954    185
+   953    952
+   953    596
+   953    494
+   952    951
+   952    414
+   951    595
+   951    245
+   950    595
+   950    416
+   950    221
+   949    594
+   949    347
+   949    199
+   948    594
+   948    503
+   948    214
+   947    946
+   947    485
+   947    422
+   946    945
+   946    222
+   945    944
+   945     75
+   944    943
+   944    188
+   943    942
+   943    560
+   942    941
+   942    496
+   941    940
+   941    240
+   940    939
+   940    433
+   939    938
+   939    593
+   938    395
+   938    203
+   937    936
+   937    436
+   937    235
+   936    528
+   936    156
+   935    511
+   935    446
+   935     48
+   934    403
+   934    247
+   934    103
+   933    932
+   933    581
+   933    488
+   932    574
+   932    343
+   931    246
+   931    236
+   931     33
+   930    246
+   930    245
+   930     30
+   929    928
+   929    592
+   929    332
+   928    927
+   928    244
+   927    926
+   927    582
+   926    925
+   926    265
+   925    341
+   925    306
+   924    923
+   924    549
+   924     32
+   923    555
+   923    385
+   922    921
+   922    345
+   922     86
+   921    920
+   921    243
+   920    919
+   920     96
+   919    356
+   919     43
+   918    917
+   918    357
+   918     90
+   917    591
+   917    404
+   916    540
+   916    378
+   916     11
+   915    562
+   915    150
+   915      2
+   914    451
+   914     99
+   914     52
+   913    553
+   913    473
+   913      9
+   912    542
+   912    469
+   912     57
+   911    590
+   911    227
+   911      2
+   910    909
+   910    590
+   910     97
+   909    589
+   909    552
+   908    907
+   908    589
+   908    238
+   907    906
+   907    100
+   906    709
+   906    241
+   905    588
+   905    467
+   905     73
+   904    588
+   904    587
+   904     93
+   903    587
+   903    586
+   903    320
+   902    586
+   902    471
+   902      8
+   901    585
+   901    408
+   901    309
+   900    899
+   900    584
+   900    461
+   899    898
+   899    229
+   898    583
+   898    248
+   897    583
+   897    243
+   897    145
+   896    895
+   896    463
+   896    242
+   895    894
+   895    204
+   894    241
+   894    208
+   893    892
+   893    327
+   893     64
+   892    891
+   892    507
+   891    582
+   891    250
+   890    889
+   890    533
+   890    226
+   889    581
+   889    580
+   888    580
+   888    579
+   888      2
+   887    579
+   887    578
+   887    479
+   886    885
+   886    578
+   886    146
+   885    358
+   885    213
+   884    883
+   884    326
+   884    241
+   883    882
+   883    577
+   882    371
+   882    325
+   881    880
+   881    324
+   881    100
+   880    529
+   880    267
+   879    878
+   879    179
+   879    177
+   878    240
+   878    165
+   877    576
+   877    457
+   877    334
+   876    576
+   876    239
+   876     27
+   875    874
+   875    239
+   875    219
+   874    873
+   874    572
+   873    224
+   873    190
+   872    575
+   872    476
+   872     74
+   871    575
+   871    574
+   871    487
+   870    384
+   870    364
+   870    329
+   869    868
+   869    238
+   869    141
+   868    162
+   868     98
+   867    866
+   867    398
+   867     26
+   866    573
+   866     18
+   865    573
+   865    231
+   865     99
+   864    572
+   864    571
+   864      8
+   863    862
+   863    571
+   863     82
+   862    861
+   862    534
+   861    860
+   861     20
+   860    859
+   860    483
+   859    237
+   859     80
+   858    570
+   858    420
+   858    237
+   857    570
+   857    569
+   857     99
+   856    569
+   856    548
+   856     31
+   855    854
+   855    532
+   855     31
+   854    853
+   854    458
+   853    852
+   853     19
+   852    568
+   852    547
+   851    568
+   851    556
+   851    525
+   850    567
+   850    410
+   850    212
+   849    848
+   849    567
+   849    129
+   848    847
+   848    415
+   847    846
+   847     30
+   846    845
+   846    472
+   845    844
+   845     29
+   844    843
+   844     28
+   843    842
+   843    197
+   842    841
+   842     98
+   841    236
+   841    206
+   840    492
+   840    236
+   840     62
+   839    501
+   839    367
+   839    235
+   838    421
+   838    369
+   838     95
+   837    566
+   837    232
+   837    130
+   836    566
+   836    565
+   836    134
+   835    834
+   835    565
+   835     71
+   834    833
+   834    234
+   833    832
+   833    475
+   832    564
+   832    328
+   831    564
+   831    563
+   831     15
+   830    597
+   830    563
+   830    233
+   829    562
+   829    561
+   829    233
+   828    561
+   828    560
+   828    169
+   827    826
+   827    560
+   827    482
+   826    559
+   826     97
+   825    559
+   825    323
+   825    164
+   824    558
+   824    477
+   824    127
+   823    411
+   823    167
+   823     61
+   822    821
+   822    510
+   822    319
+   821    232
+   821    100
+   820    557
+   820    182
+   820    135
+   819    818
+   819    557
+   819    517
+   818    231
+   818    161
+   817    556
+   817    230
+   817    122
+   816    815
+   816    513
+   816    230
+   815    814
+   815     22
+   814    354
+   814    229
+   813    812
+   813    229
+   813    148
+   812    505
+   812    191
+   811    810
+   811    555
+   811    509
+   810    809
+   810    554
+   809    372
+   809     96
+   808    807
+   808    553
+   808    393
+   807    552
+   807      7
+   806    805
+   806    314
+   806    183
+   805    804
+   805    570
+   804    228
+   804    215
+   803    802
+   803    228
+   803     42
+   802    227
+   802    226
+   801    226
+   801    159
+   801      2
+   800    527
+   800     89
+   800     23
+   799    545
+   799    438
+   799    181
+   798    569
+   798    443
+   798    225
+   797    796
+   797    225
+   797     58
+   796    795
+   796    231
+   795    794
+   795     95
+   794    793
+   794    200
+   793    792
+   793    363
+   792    551
+   792     44
+   791    790
+   791    551
+   791    224
+   790    789
+   790    423
+   789    490
+   789    223
+   788    787
+   788    223
+   788     25
+   787    786
+   787     94
+   786    502
+   786    222
+   785     93
+   785     91
+   785     85
+   784    783
+   784    388
+   784     87
+   783    450
+   783      1
+   782    550
+   782    523
+   782    373
+   781    780
+   781    478
+   781    221
+   780    549
+   780     49
+   779    548
+   779    520
+   779    452
+   778    548
+   778    547
+   778    361
+   777    776
+   777    547
+   777    544
+   776    775
+   776    220
+   775    774
+   775    392
+   774     92
+   774     29
+   773    772
+   773    113
+   773     92
+   772    546
+   772      8
+   771    770
+   771    546
+   771      1
+   770    769
+   770     91
+   769    768
+   769    545
+   768    401
+   768    311
+   767    766
+   767    544
+   767     91
+   766    508
+   766    216
+   765    764
+   765    303
+   765    192
+   764    543
+   764     90
+   763    543
+   763    535
+   763     81
+   762    541
+   762    437
+   762    380
+   761    760
+   761    542
+   761    541
+   760     89
+   760     88
+   759    758
+   759    540
+   759     88
+   758    757
+   758     83
+   757    400
+   757    294
+   756    755
+   756    455
+   756    219
+   755    539
+   755     16
+   754    539
+   754    538
+   754    406
+   753    563
+   753    538
+   753    375
+   752    454
+   752    194
+   752     79
+   751    537
+   751    536
+   751    298
+   750    749
+   750    536
+   750     78
+   749    439
+   749    353
+   748    747
+   748    535
+   748      1
+   747    480
+   747    218
+   746    578
+   746    534
+   746     27
+   745    744
+   745    205
+   745    157
+   744    743
+   744     26
+   743    533
+   743    217
+   742    741
+   742    217
+   742    216
+   741    532
+   741      2
+   740    215
+   740     87
+   740     55
+   739    531
+   739    486
+   739    214
+   738    531
+   738    530
+   738     84
+   737    530
+   737    213
+   737     25
+   736    735
+   736    529
+   736    528
+   735    399
+   735    390
+   734    527
+   734    526
+   734    524
+   733    525
+   733    524
+   733    212
+   732    523
+   732    430
+   732     51
+   731    522
+   731     86
+   731     72
+   730    598
+   730    522
+   730    521
+   729    521
+   729    520
+   729    184
+   728    520
+   728    514
+   728     29
+   727    453
+   727    425
+   727     24
+   726    519
+   726    518
+   726     24
+   725    518
+   725     85
+   725     84
+   724    723
+   724     84
+   724      4
+   723    722
+   723    186
+   722    721
+   722     17
+   721    720
+   721    419
+   720    468
+   720     14
+   719    517
+   719    243
+   719     83
+   718    516
+   718    441
+   718     93
+   717    285
+   717    211
+   717     23
+   716    715
+   716    382
+   716    136
+   715    596
+   715    210
+   714    561
+   714    515
+   714      2
+   713    516
+   713    515
+   713    470
+   712    711
+   712    222
+   712    193
+   711    209
+   711    168
+   710    514
+   710    464
+   710      6
+   709    513
+   709    142
+   708    460
+   708    114
+   708     24
+   707    706
+   707    512
+   707    225
+   706    429
+   706    258
+   705    704
+   705    370
+   705     82
+   704    511
+   704    424
+   703    702
+   703    510
+   703    491
+   702    449
+   702     70
+   701    700
+   701     81
+   701     21
+   700    208
+   700     12
+   699    335
+   699    201
+   699     80
+   698    697
+   698    509
+   698     53
+   697    696
+   697    551
+   696    257
+   696     79
+   695    588
+   695     78
+   695     66
+   694    693
+   694    160
+   694     78
+   693    692
+   693     23
+   692    207
+   692     89
+   691    508
+   691    207
+   691     69
+   690    206
+   690     77
+   690     41
+   689    688
+   689    507
+   689    274
+   688    687
+   688    239
+   687     76
+   687      6
+   686    506
+   686     78
+   686     76
+   685    506
+   685    504
+   685    126
+   684    683
+   684    505
+   684    504
+   683     75
+   683     54
+   682    493
+   682    426
+   682      8
+   681     96
+   681     74
+   681      8
+   680    679
+   680    503
+   680    502
+   679    678
+   679    216
+   678    394
+   678      5
+   677    676
+   677      5
+   677      4
+   676    675
+   676    205
+   675    539
+   675     22
+   674    277
+   674    204
+   674     10
+   673    501
+   673    376
+   673    203
+   672    671
+   672    203
+   672     73
+   671    518
+   671    202
+   670    359
+   670    202
+   670    198
+   669    668
+   669     40
+   669     21
+   668    366
+   668    322
+   667    304
+   667    275
+   667     90
+   666    500
+   666    201
+   666    200
+   665    664
+   665    500
+   665    307
+   664    573
+   664    499
+   663    498
+   663    210
+   663    139
+   662    498
+   662     97
+   662     80
+   661    660
+   661    442
+   661      4
+   660    659
+   660     72
+   659    459
+   659    199
+   658    199
+   658    198
+   658      5
+   657    497
+   657    496
+   657    391
+   656    496
+   656    495
+   656    101
+   655    495
+   655    489
+   655    197
+   654    530
+   654    197
+   654    196
+   653    196
+   653     71
+   653     70
+   652    418
+   652    269
+   652     69
+   651    494
+   651    195
+   651     20
+   650    649
+   650    230
+   650    195
+   649    493
+   649    197
+   648    492
+   648    387
+   648    131
+   647    646
+   647    427
+   647    344
+   646    491
+   646    194
+   645     56
+   645     19
+   645     18
+   644    490
+   644    435
+   644    193
+   643    490
+   643    213
+   643     68
+   642    489
+   642    484
+   642     17
+   641    297
+   641     90
+   641     33
+   640    488
+   640    263
+   640    149
+   639    487
+   639    486
+   639     67
+   638    637
+   638    485
+   638    342
+   637    484
+   637    192
+   636    191
+   636     50
+   636     13
+   635    634
+   635    176
+   635     66
+   634    279
+   634    260
+   633    576
+   633    483
+   633    482
+   632    631
+   632    481
+   632     36
+   631    630
+   631     65
+   630    480
+   630    172
+   629    479
+   629    190
+   629     16
+   628    448
+   628     65
+   628     63
+   627    189
+   627    180
+   627      3
+   626    381
+   626    189
+   626     84
+   625    478
+   625    368
+   625    188
+   624    288
+   624    188
+   624    107
+   623    622
+   623    187
+   623    186
+   622    477
+   622    147
+   621    476
+   621    475
+   621    466
+   620    209
+   620    185
+   620     98
+   619    184
+   619    155
+   619     64
+   618    417
+   618    355
+   618     18
+   617    474
+   617     63
+   617     62
+   616    474
+   616    431
+   616     20
+   615    473
+   615    348
+   615    253
+   614    447
+   614    183
+   614     67
+   613    472
+   613    182
+   613     61
+   612    611
+   612    409
+   612     68
+   611    181
+   611     15
+   610    405
+   610    183
+   610     60
+   609    471
+   609    180
+   609    158
+   608    179
+   608    178
+   608      7
+   607    223
+   607    178
+   607    163
+   606    249
+   606     59
+   606     58
+   605    396
+   605    133
+   605     20
+   604    583
+   604    185
+   603    470
+   603    217
+   602    177
+   602    170
+   601    189
+   601    176
+   600    469
+   600    197
+   599    537
+   599     14
+   598    468
+   597    467
+   596    474
+   595    466
+   595    270
+   594    465
+   594    229
+   593    464
+   593     13
+   592    245
+   592     57
+   591    463
+   591    175
+   590    174
+   590     83
+   589    346
+   589     28
+   588    186
+   587    510
+   587      5
+   586    559
+   586    462
+   585    461
+   585    412
+   584    173
+   584    125
+   583    386
+   582    533
+   582    460
+   581    459
+   581    172
+   580    171
+   580     56
+   579    458
+   579    170
+   578    457
+   577    456
+   577    169
+   576    470
+   575    461
+   575    455
+   574    166
+   574    144
+   573    168
+   572    231
+   572    167
+   571    454
+   571    453
+   570     61
+   569     79
+   568     55
+   568      7
+   567    494
+   567     63
+   566    495
+   566    452
+   565    119
+   564    233
+   564     70
+   563     88
+   562    451
+   562    450
+   561    302
+   560    166
+   559     14
+   558    179
+   558     88
+   557    449
+   557    402
+   556    448
+   556    447
+   555    505
+   555    255
+   554    446
+   554     54
+   553    469
+   553    383
+   552    242
+   552     35
+   551    281
+   550    445
+   550     66
+   549    165
+   549     13
+   548     54
+   547     91
+   546    444
+   546    397
+   545    443
+   545    215
+   544    442
+   544    310
+   543    451
+   543    164
+   542    441
+   542    227
+   541    530
+   541    163
+   540    340
+   540     28
+   539    500
+   538    162
+   537     92
+   536    440
+   536    138
+   535    439
+   535    292
+   534    206
+   534    161
+   533    143
+   532    438
+   532     87
+   531    243
+   531    140
+   529    437
+   529    177
+   528    436
+   528    435
+   527    434
+   527    315
+   526    506
+   526    160
+   525    433
+   525    132
+   524    432
+   524    431
+   523    430
+   523     53
+   522    429
+   522    331
+   521    439
+   521    159
+   520    428
+   519    453
+   519    102
+   518    158
+   517    407
+   517    108
+   516    427
+   516    154
+   515    501
+   515    426
+   514    425
+   514    248
+   513    157
+   513     62
+   512    112
+   512     45
+   511    156
+   511    155
+   510    424
+   509    389
+   509    278
+   508    379
+   508     76
+   507    423
+   507    163
+   506     52
+   505     51
+   504     92
+   504     50
+   503    422
+   503    229
+   502    452
+   502     74
+   501    421
+   500     18
+   499    420
+   499    154
+   498    444
+   498    419
+   497     49
+   497     46
+   496     48
+   495    226
+   494    418
+   493    417
+   493     86
+   492    360
+   492    201
+   491    268
+   491    120
+   490     68
+   489    416
+   489    214
+   488    153
+   488     66
+   487    181
+   487    153
+   486    485
+   486     12
+   485    152
+   484    415
+   484    207
+   483    414
+   483     24
+   482    413
+   482    259
+   481     94
+   481     47
+   480    447
+   480    318
+   479    377
+   479      6
+   478    412
+   478     34
+   477    411
+   477     11
+   476    224
+   476    151
+   475    256
+   475    150
+   474    149
+   473    410
+   473    128
+   472    409
+   472    208
+   471    408
+   471     15
+   470    148
+   469    316
+   468    407
+   468     46
+   467    406
+   467     87
+   466    405
+   466    147
+   465    179
+   465    146
+   464    404
+   464    157
+   463    157
+   463    145
+   462    459
+   462    403
+   461    178
+   460     45
+   460     25
+   459     44
+   458    402
+   458     47
+   457    401
+   457    144
+   456     19
+   456      6
+   455    400
+   455     60
+   454    399
+   454    187
+   453     22
+   452    313
+   451    398
+   450    397
+   450     10
+   449    396
+   449     38
+   448    395
+   448    204
+   447     45
+   446    394
+   446     22
+   445    393
+   445     43
+   444    392
+   443    308
+   443     21
+   442     97
+   442     87
+   441    286
+   441    143
+   440    392
+   440    115
+   439    213
+   438    434
+   438    317
+   437    301
+   437      7
+   436     63
+   436     14
+   435    391
+   435    142
+   434     55
+   433    410
+   433    390
+   432    330
+   432    141
+   431    140
+   431     57
+   430    148
+   430    137
+   429    389
+   429     26
+   428    413
+   428    300
+   427    211
+   427     92
+   426    388
+   426    152
+   425    212
+   425    168
+   424    408
+   424     21
+   423    387
+   423     77
+   422    146
+   422     78
+   421    386
+   421    162
+   420    139
+   420     59
+   419    385
+   419     52
+   418    384
+   418    177
+   417    140
+   417     70
+   416     84
+   416     68
+   415     50
+   415     27
+   414    383
+   414     77
+   413    235
+   412    290
+   412     53
+   411    382
+   411     45
+   410    393
+   409    381
+   409     94
+   408    117
+   407    362
+   407    239
+   406    380
+   406    379
+   405    181
+   405      2
+   404    378
+   404     54
+   403    400
+   403     79
+   402    377
+   402     99
+   401    376
+   401    240
+   400    246
+   399    375
+   399    138
+   398    374
+   398    162
+   397    373
+   397     60
+   396     46
+   396     21
+   395    235
+   395      8
+   394    374
+   394     19
+   393    372
+   392     51
+   391    137
+   391     56
+   390    371
+   390    172
+   389    370
+   389     37
+   388     93
+   388     31
+   387    369
+   387    291
+   386    295
+   386     25
+   385     66
+   385     42
+   384    377
+   384    187
+   383    164
+   383    100
+   382     96
+   382     13
+   381    368
+   381     95
+   380    337
+   380    241
+   379    155
+   379     41
+   378     39
+   378     17
+   377    172
+   376    276
+   376    136
+   375    367
+   375     63
+   374    366
+   373    365
+   373    228
+   372    364
+   372     81
+   371    363
+   371    180
+   370    147
+   370     81
+   369    140
+   369     99
+   368     53
+   368      5
+   367    362
+   367     55
+   366    219
+   366    191
+   365    200
+   365    151
+   364    361
+   364      8
+   363    188
+   363    160
+   362    360
+   362    333
+   361    359
+   361    358
+   360    165
+   360    135
+   359    357
+   359     40
+   358    166
+   358     39
+   357    356
+   357     26
+   356    355
+   356    354
+   355    134
+   355     62
+   354    353
+   354      1
+   353     67
+   353     20
+   352    351
+   352    133
+   352    132
+   351    339
+   351     67
+   351     59
+   350    349
+   350    180
+   350     88
+   349    348
+   349    171
+   349     39
+   348    209
+   348    183
+   347    346
+   347    221
+   347    177
+   346    345
+   346     52
+   345    344
+   345     42
+   344    261
+   344    131
+   343    342
+   343    130
+   343     44
+   342    149
+   342     40
+   341    176
+   341     32
+   341     16
+   340    339
+   340    221
+   340    176
+   339    338
+   339     23
+   338    337
+   338    195
+   338      6
+   337    336
+   337    156
+   336    335
+   336    334
+   336    245
+   335    153
+   335    150
+   334    333
+   334    283
+   333    129
+   333      5
+   332    331
+   332    330
+   332    154
+   331    237
+   331    128
+   330    329
+   330     58
+   329    207
+   329     48
+   328    327
+   328    287
+   328    208
+   327     73
+   327      6
+   326    273
+   326    213
+   326     80
+   325    324
+   325    262
+   325    106
+   324     27
+   324     17
+   323    322
+   323    198
+   323     76
+   322    321
+   322     16
+   321    320
+   321     53
+   320    202
+   320    127
+   319    284
+   319     65
+   319     61
+   318    317
+   318    161
+   318      9
+   317    316
+   317    315
+   316    126
+   316     65
+   315    200
+   315      3
+   314    202
+   314     48
+   314     15
+   313    312
+   313    196
+   313     38
+   312    254
+   312    178
+   312    105
+   311    310
+   311    289
+   311    166
+   310    309
+   310     39
+   309    308
+   309     73
+   308    307
+   308     44
+   307    266
+   307     17
+   306    305
+   306    216
+   306    173
+   305    304
+   305    204
+   305    125
+   304    202
+   304     44
+   303    302
+   303    131
+   303    125
+   302    238
+   302    123
+   301    110
+   301     81
+   301     65
+   300    299
+   300    296
+   300    118
+   299    298
+   299     98
+   298    297
+   298    228
+   297    124
+   297     64
+   296    194
+   296     51
+   296      4
+   295    130
+   295    123
+   295      1
+   294    130
+   294     89
+   294     85
+   293    212
+   293     62
+   293     56
+   293     51
+   292    291
+   292    138
+   292    122
+   291     39
+   291     30
+   290    289
+   290    243
+   290     81
+   289    288
+   289    170
+   288    287
+   288     28
+   287    194
+   287    121
+   286    252
+   286    223
+   286    121
+   285    157
+   285    136
+   285    120
+   284    283
+   284    282
+   284    134
+   283    184
+   283      1
+   282    281
+   282    232
+   282    184
+   281    272
+   281     70
+   280    234
+   280    175
+   280    144
+   280    142
+   279     80
+   279     12
+   279     10
+   278    201
+   278    183
+   278    171
+   277    222
+   277    189
+   277    119
+   276    120
+   276    109
+   276     32
+   275    219
+   275    195
+   275     37
+   274     55
+   274     44
+   274     16
+   273    247
+   273     46
+   273     37
+   272    145
+   272    139
+   272    118
+   271    264
+   271    118
+   271     99
+   271     49
+   270    269
+   270    220
+   270     12
+   269     58
+   269     25
+   268    267
+   268    266
+   268     36
+   267    265
+   267    203
+   266    264
+   266    230
+   265    174
+   265    156
+   264    204
+   264     19
+   263    234
+   263    116
+   263     11
+   262    261
+   262    191
+   262    182
+   261    147
+   261    138
+   260    244
+   260    121
+   260      3
+   259    199
+   259    129
+   259    117
+   258    227
+   258    170
+   258    116
+   257    211
+   257    187
+   257     30
+   256    168
+   256    151
+   256     89
+   255    185
+   255    168
+   255    115
+   254    155
+   254    114
+   254    113
+   253    252
+   253    112
+   253     10
+   252    251
+   252    111
+   251    237
+   251      4
+   250    137
+   250     58
+   250     35
+   249    238
+   249    233
+   249     25
+   248    141
+   247    146
+   247     10
+   246    149
+   246     26
+   245     50
+   244    117
+   244     26
+   242     83
+   242     49
+   241    111
+   240     60
+   240      6
+   239     82
+   238     83
+   237    185
+   236    195
+   236     91
+   235    205
+   234     29
+   233    201
+   232    110
+   232     42
+   231     50
+   228    100
+   227    132
+   226    199
+   225    203
+   225     48
+   224    196
+   224    160
+   223    206
+   222     91
+   221    217
+   220     61
+   220     49
+   219      3
+   218    139
+   218    115
+   218     65
+   216     35
+   215    214
+   215     46
+   214    121
+   212     45
+   211    119
+   210    109
+   210     31
+   209      6
+   208    145
+   207     34
+   206    115
+   205    142
+   205     27
+   200     14
+   198     37
+   198     15
+   196     64
+   194     41
+   193    148
+   193    104
+   193     70
+   192    159
+   192    108
+   192     36
+   191    163
+   190    131
+   190    116
+   190      1
+   189    173
+   188      3
+   186    107
+   186      5
+   184     82
+   182    119
+   182    110
+   181    124
+   180    111
+   179     79
+   178    129
+   176     16
+   175     71
+   175     15
+   174    107
+   174     19
+   173    128
+   172     69
+   171    124
+   170     69
+   169    132
+   169     74
+   169     23
+   167    109
+   167    108
+   167    106
+   166    108
+   165    105
+   165     20
+   164     40
+   164     26
+   163     35
+   162     56
+   161    104
+   161     38
+   160     18
+   159     89
+   159      7
+   158    121
+   158     97
+   158      7
+   156    139
+   155     52
+   154    128
+   154     47
+   153    115
+   153    106
+   152    135
+   152     23
+   151     76
+   150    112
+   150     78
+   149     33
+   148    104
+   147     52
+   146     48
+   145     40
+   144    114
+   144     57
+   143    103
+   143     93
+   143     43
+   142     10
+   141     38
+   141     23
+   140     36
+   138     16
+   137     39
+   137     27
+   136     86
+   136     85
+   135    100
+   135     42
+   134     72
+   134     71
+   133    123
+   133    103
+   133     59
+   132    106
+   131     98
+   130     32
+   129     28
+   128    123
+   127     92
+   127     71
+   127     27
+   126    120
+   126    119
+   126     32
+   125     90
+   125     12
+   124     24
+   123     47
+   122    102
+   122     72
+   122     33
+   120     76
+   118     54
+   118      4
+   117     86
+   117     41
+   116     85
+   116     17
+   114    105
+   114     58
+   113     98
+   113     29
+   113      8
+   112     31
+   112     11
+   111    101
+   111     75
+   110     67
+   110      9
+   109     82
+   109     69
+   108      3
+   107     25
+   107     24
+   106     77
+   105     93
+   105     31
+   104     88
+   104     11
+   103     64
+   103     30
+   102     94
+   102     86
+   102     57
+   101     57
+   101     41
+   101      9
+    97     37
+    96     69
+    96     28
+    95     74
+    95     42
+    95     18
+    94     37
+    90     29
+    87     43
+    85     63
+    84      3
+    83     15
+    82     31
+    80      1
+    79     34
+    77     32
+    75     43
+    75     35
+    75     18
+    74     30
+    73     40
+    73     30
+    72     51
+    72     43
+    71      2
+    68     13
+    66     34
+    64     21
+    62     59
+    61     56
+    60      4
+    55     14
+    54     36
+    53     46
+    50     34
+    49     47
+    45     21
+    41     36
+    38     11
+    38      9
+    35     33
+    34      4
+    33     20
+    24     17
+    22     13
+    22     12
+    22     10
+    19     11
+    14     13
+    12      9
+     9      1
+     7      2
+-1
+EOF
diff --git a/examples/charm++/state_space_searchengine/Hamiltonian_SE/data/ham300.hcp b/examples/charm++/state_space_searchengine/Hamiltonian_SE/data/ham300.hcp
new file mode 100644 (file)
index 0000000..73046fc
--- /dev/null
@@ -0,0 +1,18009 @@
+NAME : alb1000\r
+COMMENT : Hamiltonian cycle problem (Erbacci)\r
+TYPE : HCP\r
+DIMENSION : 300\r
+EDGE_DATA_FORMAT : EDGE_LIST\r
+EDGE_DATA_SECTION\r
+212 147\r
+37 10\r
+94 56\r
+170 84\r
+260 150\r
+71 22\r
+240 144\r
+265 212\r
+191 185\r
+208 128\r
+188 117\r
+189 166\r
+60 48\r
+243 221\r
+286 245\r
+147 8\r
+193 5\r
+51 1\r
+210 32\r
+266 97\r
+30 14\r
+141 124\r
+174 126\r
+180 94\r
+97 53\r
+258 189\r
+271 220\r
+76 55\r
+187 32\r
+222 136\r
+252 89\r
+284 73\r
+110 30\r
+299 228\r
+243 197\r
+91 48\r
+206 151\r
+244 51\r
+85 51\r
+171 56\r
+235 178\r
+60 42\r
+95 31\r
+269 24\r
+275 103\r
+220 64\r
+235 60\r
+285 172\r
+233 134\r
+149 41\r
+205 187\r
+63 8\r
+194 73\r
+294 84\r
+179 91\r
+256 4\r
+149 26\r
+104 72\r
+78 77\r
+19 12\r
+269 222\r
+111 100\r
+224 27\r
+116 24\r
+138 48\r
+273 225\r
+233 172\r
+264 22\r
+96 92\r
+249 90\r
+171 83\r
+260 227\r
+133 103\r
+190 84\r
+224 213\r
+142 94\r
+163 77\r
+256 121\r
+280 90\r
+231 148\r
+146 7\r
+173 49\r
+145 137\r
+290 46\r
+276 30\r
+155 145\r
+172 78\r
+22 1\r
+65 13\r
+180 84\r
+278 257\r
+265 104\r
+284 191\r
+232 186\r
+281 27\r
+270 156\r
+266 24\r
+253 50\r
+184 152\r
+297 184\r
+293 73\r
+281 230\r
+288 224\r
+155 12\r
+208 132\r
+295 136\r
+224 47\r
+78 28\r
+197 13\r
+195 120\r
+109 49\r
+219 56\r
+167 166\r
+241 83\r
+215 162\r
+60 28\r
+49 38\r
+218 131\r
+226 3\r
+203 187\r
+224 103\r
+244 211\r
+30 24\r
+87 15\r
+280 70\r
+222 142\r
+229 106\r
+128 124\r
+252 234\r
+211 42\r
+139 81\r
+178 133\r
+210 159\r
+138 55\r
+187 25\r
+297 51\r
+113 8\r
+115 87\r
+158 18\r
+199 138\r
+215 35\r
+213 115\r
+230 84\r
+272 20\r
+273 70\r
+272 188\r
+156 119\r
+242 16\r
+274 169\r
+237 80\r
+223 181\r
+267 23\r
+259 178\r
+122 80\r
+212 54\r
+206 190\r
+218 156\r
+295 24\r
+243 71\r
+86 71\r
+276 258\r
+256 38\r
+275 229\r
+185 159\r
+192 42\r
+235 72\r
+136 65\r
+39 8\r
+84 81\r
+44 29\r
+220 135\r
+222 27\r
+149 64\r
+246 146\r
+299 229\r
+62 61\r
+195 152\r
+256 25\r
+299 21\r
+147 25\r
+280 276\r
+244 1\r
+233 159\r
+89 75\r
+300 80\r
+266 178\r
+108 26\r
+176 25\r
+267 164\r
+76 59\r
+277 153\r
+55 51\r
+229 28\r
+279 171\r
+91 63\r
+135 52\r
+172 98\r
+228 170\r
+256 102\r
+265 235\r
+184 126\r
+283 143\r
+99 77\r
+243 16\r
+166 146\r
+129 48\r
+218 90\r
+239 220\r
+264 187\r
+250 31\r
+127 15\r
+247 80\r
+248 114\r
+176 45\r
+296 85\r
+300 294\r
+263 110\r
+203 145\r
+191 188\r
+219 101\r
+288 215\r
+87 10\r
+132 101\r
+258 93\r
+229 64\r
+289 218\r
+206 195\r
+197 127\r
+205 202\r
+299 36\r
+196 83\r
+220 200\r
+244 66\r
+54 15\r
+278 201\r
+299 139\r
+78 9\r
+200 23\r
+16 5\r
+108 64\r
+201 133\r
+218 104\r
+202 73\r
+245 151\r
+132 37\r
+177 74\r
+142 75\r
+201 60\r
+281 24\r
+289 262\r
+294 249\r
+244 193\r
+137 8\r
+220 9\r
+248 186\r
+181 176\r
+128 96\r
+218 66\r
+263 83\r
+187 68\r
+69 36\r
+154 114\r
+255 254\r
+42 27\r
+217 214\r
+177 23\r
+265 63\r
+235 96\r
+238 114\r
+180 128\r
+147 54\r
+244 65\r
+129 128\r
+169 106\r
+270 208\r
+132 72\r
+227 180\r
+298 263\r
+236 177\r
+61 28\r
+286 209\r
+190 68\r
+151 33\r
+294 255\r
+253 83\r
+246 49\r
+233 109\r
+231 104\r
+238 178\r
+62 46\r
+200 118\r
+125 86\r
+294 80\r
+287 97\r
+205 90\r
+197 90\r
+106 19\r
+264 163\r
+259 258\r
+152 104\r
+257 46\r
+139 71\r
+244 28\r
+276 172\r
+152 4\r
+280 9\r
+100 10\r
+278 219\r
+89 36\r
+140 50\r
+298 170\r
+108 100\r
+27 13\r
+119 73\r
+189 114\r
+110 48\r
+272 30\r
+41 24\r
+247 84\r
+276 83\r
+279 239\r
+246 225\r
+272 193\r
+256 140\r
+183 24\r
+167 9\r
+241 184\r
+229 117\r
+73 35\r
+199 107\r
+223 129\r
+220 157\r
+207 74\r
+205 167\r
+111 41\r
+151 40\r
+279 74\r
+268 221\r
+284 231\r
+113 83\r
+235 75\r
+271 253\r
+222 143\r
+252 126\r
+277 203\r
+201 19\r
+269 202\r
+234 99\r
+133 42\r
+247 25\r
+236 235\r
+163 25\r
+283 95\r
+174 46\r
+209 186\r
+288 30\r
+203 89\r
+280 260\r
+209 91\r
+249 31\r
+135 123\r
+287 207\r
+291 175\r
+208 199\r
+269 189\r
+176 14\r
+221 86\r
+270 217\r
+146 127\r
+260 116\r
+278 142\r
+223 119\r
+249 248\r
+197 185\r
+223 90\r
+247 108\r
+249 22\r
+206 52\r
+174 42\r
+107 97\r
+168 4\r
+220 152\r
+217 133\r
+226 180\r
+173 18\r
+248 135\r
+169 28\r
+263 176\r
+133 132\r
+221 195\r
+265 114\r
+257 232\r
+149 34\r
+277 188\r
+267 54\r
+295 118\r
+231 13\r
+289 265\r
+52 38\r
+188 170\r
+156 16\r
+140 136\r
+217 185\r
+125 106\r
+216 69\r
+278 159\r
+269 215\r
+187 4\r
+232 168\r
+242 91\r
+267 154\r
+119 8\r
+222 51\r
+209 97\r
+276 73\r
+168 101\r
+262 60\r
+57 56\r
+250 81\r
+116 112\r
+252 8\r
+88 58\r
+136 85\r
+150 51\r
+155 61\r
+122 63\r
+286 255\r
+162 139\r
+289 59\r
+276 27\r
+249 47\r
+166 119\r
+273 203\r
+94 13\r
+216 1\r
+293 105\r
+238 79\r
+103 1\r
+264 76\r
+155 40\r
+95 62\r
+269 98\r
+43 25\r
+148 9\r
+95 17\r
+253 143\r
+89 62\r
+171 53\r
+224 66\r
+295 287\r
+212 67\r
+254 68\r
+226 192\r
+265 15\r
+119 20\r
+215 10\r
+113 37\r
+216 126\r
+280 2\r
+113 48\r
+245 83\r
+146 11\r
+156 58\r
+199 50\r
+300 47\r
+235 37\r
+115 74\r
+287 216\r
+180 150\r
+129 63\r
+199 169\r
+200 79\r
+84 73\r
+280 250\r
+291 69\r
+215 51\r
+83 17\r
+198 81\r
+239 46\r
+227 226\r
+90 67\r
+71 20\r
+187 99\r
+215 41\r
+282 68\r
+290 272\r
+196 97\r
+159 35\r
+285 100\r
+134 119\r
+298 63\r
+188 18\r
+224 45\r
+206 147\r
+160 5\r
+224 143\r
+239 7\r
+199 85\r
+171 80\r
+125 30\r
+264 121\r
+31 19\r
+222 94\r
+67 25\r
+185 61\r
+229 99\r
+290 65\r
+251 209\r
+113 70\r
+282 122\r
+176 73\r
+204 58\r
+251 86\r
+90 54\r
+187 138\r
+135 103\r
+273 205\r
+245 27\r
+194 3\r
+125 13\r
+238 1\r
+167 109\r
+220 167\r
+152 26\r
+83 9\r
+156 108\r
+71 10\r
+172 72\r
+74 47\r
+95 68\r
+162 161\r
+143 9\r
+287 57\r
+162 103\r
+273 2\r
+170 99\r
+180 26\r
+132 124\r
+228 217\r
+83 65\r
+294 228\r
+85 68\r
+297 19\r
+286 178\r
+155 41\r
+226 9\r
+219 146\r
+147 21\r
+255 99\r
+173 145\r
+258 43\r
+273 1\r
+261 139\r
+232 93\r
+194 126\r
+87 71\r
+194 35\r
+272 240\r
+163 36\r
+212 131\r
+266 146\r
+266 256\r
+252 216\r
+255 253\r
+296 66\r
+262 254\r
+101 100\r
+178 126\r
+32 27\r
+209 66\r
+104 103\r
+285 99\r
+178 79\r
+114 99\r
+98 21\r
+161 28\r
+254 141\r
+32 13\r
+251 126\r
+179 2\r
+217 69\r
+298 266\r
+188 13\r
+202 19\r
+199 153\r
+210 42\r
+195 117\r
+293 95\r
+205 150\r
+284 211\r
+185 151\r
+222 57\r
+89 22\r
+136 120\r
+76 71\r
+58 3\r
+170 78\r
+91 10\r
+228 215\r
+279 237\r
+291 169\r
+285 243\r
+247 35\r
+265 67\r
+148 102\r
+181 98\r
+240 200\r
+257 99\r
+230 185\r
+230 166\r
+250 211\r
+252 123\r
+178 25\r
+201 63\r
+273 73\r
+194 92\r
+224 129\r
+204 119\r
+164 93\r
+220 68\r
+285 250\r
+200 187\r
+188 162\r
+187 19\r
+64 35\r
+165 96\r
+268 147\r
+261 128\r
+261 220\r
+273 96\r
+227 11\r
+271 156\r
+210 208\r
+283 148\r
+165 83\r
+238 197\r
+278 161\r
+293 45\r
+269 238\r
+268 18\r
+218 37\r
+152 105\r
+179 54\r
+253 102\r
+113 53\r
+104 74\r
+261 194\r
+188 33\r
+72 38\r
+144 1\r
+220 25\r
+263 60\r
+217 36\r
+194 59\r
+199 197\r
+133 123\r
+298 16\r
+291 118\r
+274 25\r
+170 13\r
+21 16\r
+84 23\r
+113 93\r
+67 62\r
+256 78\r
+204 132\r
+76 32\r
+287 167\r
+178 111\r
+188 149\r
+153 87\r
+243 182\r
+74 13\r
+298 12\r
+113 91\r
+232 217\r
+249 118\r
+26 19\r
+248 47\r
+153 105\r
+175 26\r
+270 228\r
+59 43\r
+226 102\r
+227 168\r
+191 87\r
+179 82\r
+102 46\r
+266 138\r
+250 70\r
+233 5\r
+281 225\r
+112 42\r
+288 276\r
+214 69\r
+271 227\r
+255 103\r
+267 153\r
+147 78\r
+107 105\r
+166 103\r
+158 89\r
+286 285\r
+222 88\r
+116 99\r
+288 67\r
+187 129\r
+176 99\r
+246 77\r
+122 66\r
+13 5\r
+287 11\r
+208 190\r
+142 84\r
+228 99\r
+275 132\r
+83 70\r
+99 84\r
+294 47\r
+254 162\r
+263 179\r
+152 124\r
+146 125\r
+282 169\r
+133 127\r
+120 100\r
+280 100\r
+210 41\r
+202 11\r
+232 107\r
+152 44\r
+154 29\r
+257 127\r
+261 121\r
+203 135\r
+226 144\r
+231 89\r
+199 125\r
+221 135\r
+294 288\r
+194 13\r
+218 204\r
+211 162\r
+216 66\r
+121 33\r
+155 5\r
+211 201\r
+250 138\r
+154 106\r
+196 35\r
+287 163\r
+141 34\r
+158 23\r
+224 165\r
+230 83\r
+263 24\r
+283 181\r
+153 53\r
+26 8\r
+294 290\r
+266 133\r
+102 17\r
+114 11\r
+282 6\r
+151 124\r
+287 115\r
+262 123\r
+264 97\r
+250 154\r
+91 66\r
+212 169\r
+267 178\r
+295 246\r
+154 149\r
+161 99\r
+265 16\r
+215 83\r
+191 3\r
+194 192\r
+226 32\r
+242 150\r
+37 30\r
+111 27\r
+270 58\r
+266 201\r
+119 93\r
+209 50\r
+290 263\r
+295 179\r
+241 92\r
+223 57\r
+155 83\r
+194 116\r
+269 259\r
+249 199\r
+198 149\r
+86 75\r
+292 221\r
+238 143\r
+251 136\r
+217 134\r
+170 92\r
+180 166\r
+92 32\r
+186 48\r
+93 57\r
+143 19\r
+181 151\r
+138 116\r
+71 11\r
+271 98\r
+227 174\r
+151 3\r
+32 21\r
+42 29\r
+175 157\r
+269 219\r
+275 190\r
+88 66\r
+247 198\r
+22 18\r
+21 15\r
+245 226\r
+56 21\r
+292 216\r
+229 78\r
+210 167\r
+82 40\r
+127 112\r
+254 203\r
+138 117\r
+161 93\r
+299 133\r
+236 57\r
+30 20\r
+144 34\r
+98 44\r
+193 1\r
+257 203\r
+134 74\r
+145 80\r
+72 34\r
+262 125\r
+289 215\r
+130 122\r
+212 148\r
+64 53\r
+103 5\r
+145 90\r
+247 223\r
+70 2\r
+229 58\r
+117 87\r
+177 134\r
+263 250\r
+246 108\r
+287 14\r
+276 16\r
+205 182\r
+224 84\r
+286 216\r
+267 173\r
+173 104\r
+298 165\r
+79 16\r
+271 64\r
+249 154\r
+285 203\r
+276 226\r
+66 7\r
+261 226\r
+52 18\r
+202 150\r
+75 26\r
+263 12\r
+211 141\r
+294 282\r
+249 132\r
+181 180\r
+195 133\r
+260 46\r
+141 15\r
+215 79\r
+173 65\r
+49 8\r
+195 6\r
+294 21\r
+94 43\r
+275 164\r
+243 49\r
+288 45\r
+229 3\r
+99 27\r
+300 179\r
+297 247\r
+276 156\r
+261 36\r
+286 264\r
+254 69\r
+188 143\r
+114 13\r
+237 130\r
+183 120\r
+232 178\r
+152 65\r
+141 125\r
+247 51\r
+297 162\r
+255 28\r
+278 6\r
+83 33\r
+167 6\r
+216 65\r
+285 143\r
+300 263\r
+191 58\r
+286 219\r
+119 100\r
+288 282\r
+111 38\r
+183 178\r
+202 148\r
+259 241\r
+167 101\r
+263 59\r
+91 2\r
+189 111\r
+95 94\r
+178 119\r
+281 233\r
+140 105\r
+295 137\r
+236 202\r
+257 143\r
+279 40\r
+129 98\r
+275 230\r
+130 19\r
+228 162\r
+192 178\r
+288 245\r
+215 151\r
+167 24\r
+278 163\r
+101 1\r
+271 70\r
+263 28\r
+178 63\r
+59 10\r
+278 271\r
+289 53\r
+281 86\r
+254 59\r
+201 31\r
+238 85\r
+120 67\r
+258 15\r
+280 216\r
+90 43\r
+282 256\r
+210 44\r
+225 198\r
+299 48\r
+203 70\r
+45 22\r
+81 4\r
+184 57\r
+285 10\r
+215 204\r
+282 215\r
+287 155\r
+186 132\r
+265 28\r
+195 20\r
+288 200\r
+267 103\r
+106 4\r
+266 56\r
+104 27\r
+236 181\r
+210 114\r
+111 7\r
+219 150\r
+265 193\r
+24 12\r
+88 39\r
+99 49\r
+164 42\r
+260 99\r
+274 67\r
+247 40\r
+168 127\r
+293 206\r
+30 9\r
+226 167\r
+269 36\r
+260 171\r
+243 80\r
+152 95\r
+186 158\r
+96 27\r
+226 27\r
+220 130\r
+137 132\r
+266 218\r
+153 92\r
+168 5\r
+255 212\r
+179 83\r
+226 181\r
+97 3\r
+186 183\r
+144 21\r
+283 8\r
+126 59\r
+222 198\r
+96 85\r
+165 17\r
+267 16\r
+293 265\r
+56 36\r
+206 98\r
+283 134\r
+255 185\r
+177 142\r
+297 187\r
+232 195\r
+169 158\r
+258 17\r
+217 67\r
+218 96\r
+166 77\r
+223 195\r
+43 38\r
+165 69\r
+26 11\r
+300 66\r
+169 71\r
+291 214\r
+78 65\r
+209 130\r
+247 187\r
+274 94\r
+198 74\r
+284 40\r
+291 232\r
+281 10\r
+271 34\r
+260 252\r
+178 154\r
+118 106\r
+290 163\r
+278 115\r
+287 283\r
+214 170\r
+32 11\r
+151 20\r
+199 149\r
+294 216\r
+239 120\r
+262 68\r
+283 169\r
+229 20\r
+283 124\r
+263 77\r
+214 40\r
+220 211\r
+217 193\r
+295 25\r
+293 91\r
+182 118\r
+113 11\r
+114 52\r
+93 83\r
+246 186\r
+247 124\r
+69 68\r
+217 34\r
+244 74\r
+189 176\r
+224 176\r
+99 67\r
+152 142\r
+269 206\r
+250 74\r
+254 217\r
+85 54\r
+206 61\r
+253 201\r
+260 83\r
+267 214\r
+262 39\r
+171 81\r
+259 210\r
+214 13\r
+138 67\r
+123 72\r
+56 49\r
+122 11\r
+194 112\r
+298 35\r
+90 4\r
+135 99\r
+145 126\r
+144 41\r
+269 109\r
+195 150\r
+234 23\r
+110 94\r
+206 126\r
+56 34\r
+91 16\r
+259 63\r
+288 201\r
+239 165\r
+259 46\r
+140 79\r
+123 101\r
+239 150\r
+96 75\r
+294 285\r
+93 80\r
+237 221\r
+284 102\r
+190 146\r
+206 155\r
+112 49\r
+260 190\r
+258 209\r
+249 88\r
+277 146\r
+176 2\r
+178 41\r
+271 85\r
+17 16\r
+235 166\r
+264 59\r
+182 148\r
+239 182\r
+253 203\r
+148 13\r
+212 156\r
+217 178\r
+85 59\r
+196 4\r
+272 253\r
+236 231\r
+63 2\r
+280 257\r
+281 90\r
+110 88\r
+228 208\r
+216 40\r
+297 173\r
+223 91\r
+188 90\r
+205 92\r
+202 14\r
+169 162\r
+245 227\r
+270 248\r
+221 110\r
+65 60\r
+193 111\r
+31 8\r
+299 203\r
+245 10\r
+268 55\r
+285 254\r
+107 70\r
+216 57\r
+146 77\r
+258 49\r
+189 127\r
+230 96\r
+280 279\r
+160 1\r
+244 163\r
+131 130\r
+260 230\r
+193 66\r
+206 138\r
+194 40\r
+287 285\r
+273 7\r
+29 20\r
+99 34\r
+67 41\r
+143 36\r
+221 87\r
+148 27\r
+299 153\r
+289 282\r
+276 103\r
+73 61\r
+90 49\r
+277 216\r
+202 75\r
+258 9\r
+172 149\r
+292 53\r
+286 113\r
+258 26\r
+263 53\r
+222 101\r
+259 223\r
+273 57\r
+211 92\r
+161 24\r
+181 175\r
+186 97\r
+193 62\r
+153 6\r
+88 3\r
+63 15\r
+268 171\r
+214 66\r
+253 9\r
+140 54\r
+257 26\r
+217 186\r
+156 76\r
+260 199\r
+269 116\r
+218 178\r
+99 94\r
+154 5\r
+51 9\r
+145 24\r
+216 172\r
+154 108\r
+129 27\r
+248 118\r
+112 1\r
+71 29\r
+231 222\r
+54 20\r
+297 20\r
+268 128\r
+283 259\r
+234 204\r
+242 120\r
+261 120\r
+276 134\r
+295 90\r
+206 125\r
+73 71\r
+252 99\r
+199 156\r
+279 243\r
+216 58\r
+254 78\r
+293 157\r
+274 261\r
+37 4\r
+203 189\r
+248 198\r
+122 73\r
+119 83\r
+286 12\r
+152 121\r
+143 75\r
+213 207\r
+235 21\r
+148 65\r
+195 99\r
+200 176\r
+76 13\r
+65 3\r
+61 40\r
+58 31\r
+131 56\r
+20 3\r
+290 67\r
+148 38\r
+215 190\r
+172 151\r
+221 218\r
+186 157\r
+273 189\r
+265 221\r
+248 61\r
+154 67\r
+226 16\r
+271 109\r
+300 52\r
+215 59\r
+151 72\r
+249 240\r
+276 81\r
+243 131\r
+295 185\r
+113 111\r
+124 114\r
+63 23\r
+148 60\r
+163 158\r
+225 31\r
+294 32\r
+215 154\r
+283 205\r
+293 257\r
+159 28\r
+94 8\r
+292 291\r
+291 235\r
+255 87\r
+266 19\r
+67 60\r
+237 87\r
+282 123\r
+290 57\r
+247 41\r
+215 171\r
+169 92\r
+135 74\r
+209 100\r
+177 156\r
+150 29\r
+202 23\r
+209 12\r
+213 149\r
+62 25\r
+181 5\r
+182 19\r
+265 197\r
+130 16\r
+174 122\r
+226 135\r
+82 69\r
+207 182\r
+282 246\r
+177 145\r
+290 251\r
+207 10\r
+275 10\r
+264 74\r
+149 40\r
+241 7\r
+20 19\r
+223 69\r
+244 61\r
+284 283\r
+196 51\r
+213 133\r
+42 23\r
+290 289\r
+196 130\r
+236 96\r
+207 173\r
+285 226\r
+90 89\r
+119 49\r
+206 133\r
+159 117\r
+199 189\r
+266 33\r
+39 30\r
+167 131\r
+213 124\r
+109 16\r
+133 80\r
+260 101\r
+161 125\r
+65 30\r
+296 82\r
+206 47\r
+281 160\r
+161 73\r
+192 1\r
+160 114\r
+109 56\r
+249 125\r
+255 65\r
+154 103\r
+270 90\r
+275 3\r
+224 36\r
+172 11\r
+123 120\r
+231 187\r
+292 92\r
+296 148\r
+270 185\r
+135 44\r
+144 4\r
+279 128\r
+130 37\r
+231 158\r
+58 9\r
+180 13\r
+279 29\r
+264 27\r
+163 86\r
+277 32\r
+107 50\r
+269 182\r
+222 54\r
+262 83\r
+292 185\r
+165 158\r
+154 34\r
+214 14\r
+277 163\r
+291 145\r
+97 28\r
+298 206\r
+161 95\r
+103 62\r
+215 116\r
+298 111\r
+85 42\r
+248 209\r
+210 124\r
+199 66\r
+251 106\r
+209 36\r
+279 2\r
+192 2\r
+87 77\r
+82 22\r
+262 21\r
+244 241\r
+144 53\r
+131 128\r
+256 36\r
+204 169\r
+243 211\r
+245 55\r
+281 242\r
+276 115\r
+272 16\r
+200 51\r
+266 144\r
+51 30\r
+117 81\r
+114 15\r
+269 75\r
+290 234\r
+249 206\r
+93 20\r
+245 143\r
+244 15\r
+244 116\r
+138 20\r
+230 192\r
+210 171\r
+250 157\r
+248 109\r
+142 100\r
+205 20\r
+258 150\r
+65 37\r
+105 3\r
+205 105\r
+287 223\r
+250 232\r
+18 14\r
+299 234\r
+27 12\r
+145 12\r
+286 8\r
+127 88\r
+257 178\r
+169 94\r
+74 21\r
+120 96\r
+277 108\r
+231 62\r
+165 18\r
+297 252\r
+250 227\r
+230 32\r
+233 181\r
+190 9\r
+80 4\r
+180 121\r
+39 31\r
+95 77\r
+292 105\r
+280 160\r
+177 6\r
+258 115\r
+121 71\r
+89 84\r
+203 199\r
+134 6\r
+240 58\r
+216 210\r
+124 61\r
+31 15\r
+220 202\r
+226 199\r
+217 190\r
+265 239\r
+271 215\r
+66 47\r
+262 26\r
+225 148\r
+251 193\r
+152 33\r
+237 21\r
+224 104\r
+158 126\r
+150 136\r
+138 91\r
+188 21\r
+219 152\r
+249 150\r
+107 69\r
+86 43\r
+122 102\r
+219 198\r
+223 220\r
+291 41\r
+247 119\r
+101 69\r
+157 113\r
+288 72\r
+192 138\r
+233 47\r
+199 33\r
+234 24\r
+259 224\r
+268 51\r
+278 273\r
+100 92\r
+211 86\r
+199 89\r
+210 99\r
+133 46\r
+209 135\r
+77 24\r
+247 229\r
+264 18\r
+121 58\r
+157 104\r
+274 211\r
+219 34\r
+246 199\r
+247 137\r
+200 31\r
+268 202\r
+144 123\r
+211 3\r
+216 28\r
+260 19\r
+300 244\r
+66 2\r
+283 75\r
+36 23\r
+255 30\r
+226 59\r
+10 9\r
+250 106\r
+137 14\r
+139 116\r
+214 193\r
+217 165\r
+145 36\r
+242 86\r
+168 139\r
+267 238\r
+244 76\r
+98 50\r
+196 56\r
+84 7\r
+243 189\r
+103 70\r
+143 127\r
+210 196\r
+286 13\r
+276 202\r
+149 56\r
+72 71\r
+185 138\r
+235 164\r
+255 135\r
+134 115\r
+300 200\r
+111 35\r
+260 25\r
+12 4\r
+258 224\r
+272 271\r
+169 128\r
+256 7\r
+275 117\r
+241 54\r
+193 159\r
+164 161\r
+271 27\r
+269 66\r
+130 25\r
+87 84\r
+276 245\r
+118 16\r
+233 10\r
+256 231\r
+155 17\r
+297 21\r
+264 170\r
+275 217\r
+289 103\r
+127 100\r
+154 33\r
+296 35\r
+234 91\r
+279 145\r
+172 170\r
+258 64\r
+242 23\r
+252 59\r
+272 131\r
+296 253\r
+244 174\r
+134 24\r
+280 134\r
+153 54\r
+98 2\r
+291 177\r
+148 30\r
+147 102\r
+148 77\r
+295 84\r
+140 16\r
+203 48\r
+152 7\r
+273 230\r
+251 159\r
+128 109\r
+267 171\r
+214 119\r
+133 20\r
+117 13\r
+243 126\r
+215 95\r
+299 259\r
+202 71\r
+91 31\r
+180 79\r
+185 21\r
+259 233\r
+247 3\r
+181 65\r
+222 135\r
+207 175\r
+251 55\r
+44 32\r
+192 57\r
+243 186\r
+64 34\r
+256 117\r
+251 113\r
+206 70\r
+211 127\r
+290 29\r
+134 104\r
+276 105\r
+144 115\r
+264 263\r
+264 171\r
+270 265\r
+74 51\r
+68 53\r
+82 9\r
+258 178\r
+213 164\r
+289 88\r
+157 123\r
+152 129\r
+258 99\r
+123 53\r
+275 44\r
+188 102\r
+300 201\r
+229 127\r
+238 169\r
+188 148\r
+231 133\r
+168 165\r
+270 160\r
+266 88\r
+201 148\r
+274 38\r
+146 76\r
+269 15\r
+45 36\r
+229 144\r
+253 155\r
+237 139\r
+212 68\r
+195 139\r
+276 163\r
+212 205\r
+237 190\r
+299 77\r
+116 9\r
+77 71\r
+57 9\r
+201 192\r
+144 143\r
+158 157\r
+229 35\r
+172 115\r
+297 45\r
+121 106\r
+211 17\r
+166 76\r
+97 11\r
+184 42\r
+280 8\r
+76 63\r
+196 8\r
+291 236\r
+282 254\r
+55 54\r
+246 71\r
+201 37\r
+155 11\r
+273 107\r
+255 105\r
+179 150\r
+112 33\r
+293 143\r
+205 75\r
+140 98\r
+288 124\r
+239 133\r
+263 203\r
+115 12\r
+151 110\r
+274 119\r
+232 158\r
+219 187\r
+141 137\r
+171 151\r
+223 36\r
+255 170\r
+221 90\r
+175 35\r
+278 200\r
+277 99\r
+132 20\r
+152 113\r
+145 83\r
+217 111\r
+245 107\r
+118 62\r
+201 4\r
+247 112\r
+68 61\r
+176 96\r
+149 37\r
+277 103\r
+184 72\r
+149 69\r
+79 73\r
+155 80\r
+150 32\r
+163 104\r
+204 77\r
+290 50\r
+91 59\r
+293 205\r
+52 51\r
+175 128\r
+50 28\r
+75 74\r
+80 79\r
+119 72\r
+171 62\r
+114 36\r
+52 49\r
+172 128\r
+150 35\r
+239 12\r
+215 86\r
+242 144\r
+168 50\r
+284 106\r
+218 130\r
+103 10\r
+227 68\r
+286 158\r
+297 213\r
+297 87\r
+245 231\r
+103 22\r
+145 95\r
+9 8\r
+145 42\r
+279 216\r
+236 39\r
+235 211\r
+270 15\r
+79 29\r
+138 8\r
+241 164\r
+285 190\r
+211 96\r
+256 34\r
+228 202\r
+254 64\r
+111 1\r
+285 124\r
+248 174\r
+150 60\r
+257 64\r
+246 101\r
+233 71\r
+70 56\r
+260 247\r
+295 241\r
+154 128\r
+204 178\r
+218 198\r
+294 9\r
+285 27\r
+155 131\r
+199 26\r
+236 7\r
+278 179\r
+293 149\r
+163 19\r
+231 5\r
+250 213\r
+195 182\r
+146 15\r
+264 32\r
+50 43\r
+189 11\r
+192 95\r
+101 41\r
+150 61\r
+265 257\r
+194 109\r
+191 64\r
+170 108\r
+300 239\r
+166 116\r
+295 54\r
+152 81\r
+258 103\r
+135 5\r
+277 100\r
+277 250\r
+232 148\r
+266 93\r
+250 191\r
+297 280\r
+245 149\r
+90 28\r
+297 24\r
+201 120\r
+280 65\r
+244 196\r
+156 112\r
+179 140\r
+207 138\r
+246 158\r
+181 64\r
+189 141\r
+274 117\r
+236 33\r
+69 28\r
+232 61\r
+170 40\r
+267 47\r
+292 176\r
+258 166\r
+256 47\r
+269 59\r
+281 124\r
+210 109\r
+162 20\r
+250 59\r
+109 70\r
+297 275\r
+219 196\r
+159 57\r
+298 100\r
+288 152\r
+165 157\r
+63 62\r
+184 11\r
+150 52\r
+192 133\r
+109 72\r
+159 101\r
+278 31\r
+178 96\r
+183 61\r
+271 74\r
+282 218\r
+254 214\r
+245 78\r
+261 154\r
+198 65\r
+273 272\r
+237 5\r
+284 227\r
+212 47\r
+230 228\r
+249 204\r
+139 115\r
+285 47\r
+253 140\r
+257 200\r
+223 207\r
+148 145\r
+272 220\r
+205 125\r
+144 60\r
+278 192\r
+279 49\r
+192 162\r
+240 96\r
+278 83\r
+91 60\r
+224 8\r
+247 170\r
+188 115\r
+261 1\r
+289 164\r
+135 106\r
+196 46\r
+188 54\r
+253 217\r
+254 139\r
+234 42\r
+256 158\r
+171 1\r
+175 104\r
+202 181\r
+116 109\r
+282 142\r
+225 7\r
+256 233\r
+218 43\r
+173 140\r
+89 44\r
+229 13\r
+254 37\r
+278 51\r
+201 57\r
+40 31\r
+298 84\r
+214 173\r
+198 183\r
+179 137\r
+185 25\r
+290 55\r
+262 14\r
+115 112\r
+173 171\r
+203 186\r
+253 14\r
+278 156\r
+153 145\r
+283 142\r
+273 8\r
+262 173\r
+195 116\r
+213 24\r
+115 7\r
+238 18\r
+94 64\r
+155 85\r
+292 116\r
+292 163\r
+267 112\r
+94 35\r
+205 122\r
+280 223\r
+281 280\r
+161 68\r
+235 186\r
+257 51\r
+185 144\r
+152 117\r
+294 126\r
+268 107\r
+259 15\r
+262 255\r
+293 87\r
+300 15\r
+189 17\r
+53 47\r
+63 34\r
+66 27\r
+165 80\r
+206 46\r
+284 108\r
+137 46\r
+300 191\r
+199 17\r
+244 106\r
+219 144\r
+286 30\r
+76 34\r
+188 112\r
+281 181\r
+274 97\r
+200 164\r
+125 104\r
+192 63\r
+270 250\r
+238 181\r
+165 145\r
+280 88\r
+44 43\r
+274 207\r
+187 77\r
+205 164\r
+201 3\r
+202 166\r
+210 102\r
+121 19\r
+188 101\r
+134 38\r
+244 5\r
+92 68\r
+127 111\r
+137 25\r
+284 216\r
+254 244\r
+183 87\r
+281 46\r
+179 139\r
+202 94\r
+121 67\r
+191 106\r
+41 25\r
+269 85\r
+255 251\r
+227 76\r
+113 104\r
+189 35\r
+268 105\r
+211 1\r
+295 256\r
+83 76\r
+256 17\r
+159 70\r
+260 141\r
+178 145\r
+239 50\r
+150 120\r
+203 90\r
+251 72\r
+128 77\r
+101 97\r
+65 8\r
+241 144\r
+285 72\r
+166 155\r
+183 43\r
+231 201\r
+170 63\r
+296 92\r
+230 95\r
+155 98\r
+284 113\r
+196 20\r
+284 281\r
+186 108\r
+220 138\r
+169 77\r
+282 158\r
+146 80\r
+255 109\r
+171 92\r
+240 133\r
+246 140\r
+255 43\r
+219 171\r
+276 31\r
+247 60\r
+157 4\r
+131 55\r
+265 190\r
+271 7\r
+205 185\r
+292 280\r
+160 24\r
+217 171\r
+269 60\r
+195 183\r
+285 165\r
+222 159\r
+232 177\r
+237 18\r
+227 166\r
+228 106\r
+288 57\r
+221 137\r
+74 45\r
+266 2\r
+159 153\r
+155 141\r
+164 61\r
+237 94\r
+281 125\r
+244 154\r
+289 237\r
+220 141\r
+99 2\r
+292 286\r
+103 60\r
+220 131\r
+56 38\r
+270 183\r
+184 52\r
+228 16\r
+53 42\r
+169 121\r
+283 137\r
+297 46\r
+172 75\r
+173 130\r
+123 57\r
+94 79\r
+189 159\r
+278 223\r
+68 50\r
+184 183\r
+190 132\r
+182 71\r
+162 14\r
+280 82\r
+275 71\r
+253 6\r
+125 57\r
+209 54\r
+210 72\r
+184 153\r
+191 151\r
+226 123\r
+265 94\r
+181 87\r
+61 6\r
+147 69\r
+257 4\r
+180 3\r
+118 22\r
+58 18\r
+203 202\r
+211 64\r
+246 172\r
+244 3\r
+117 75\r
+220 37\r
+243 172\r
+144 100\r
+229 187\r
+218 111\r
+269 159\r
+165 123\r
+132 45\r
+244 184\r
+161 64\r
+191 183\r
+266 72\r
+196 144\r
+231 152\r
+232 184\r
+142 56\r
+255 183\r
+249 184\r
+176 139\r
+199 22\r
+285 137\r
+198 10\r
+57 18\r
+279 158\r
+115 15\r
+82 70\r
+117 68\r
+174 159\r
+179 105\r
+88 40\r
+170 139\r
+99 72\r
+279 68\r
+191 165\r
+285 113\r
+210 161\r
+281 64\r
+258 23\r
+279 173\r
+272 108\r
+249 98\r
+249 3\r
+288 16\r
+272 256\r
+217 3\r
+242 168\r
+157 44\r
+162 114\r
+278 80\r
+284 87\r
+246 217\r
+63 50\r
+181 172\r
+205 84\r
+267 123\r
+209 191\r
+112 13\r
+294 222\r
+144 86\r
+249 245\r
+111 11\r
+273 204\r
+162 86\r
+115 42\r
+85 84\r
+205 177\r
+269 37\r
+115 13\r
+272 264\r
+122 81\r
+277 61\r
+268 154\r
+145 26\r
+193 118\r
+211 100\r
+96 43\r
+115 78\r
+202 3\r
+116 38\r
+214 93\r
+296 267\r
+218 181\r
+285 252\r
+298 152\r
+110 53\r
+168 35\r
+105 16\r
+222 63\r
+89 12\r
+177 146\r
+207 17\r
+177 127\r
+143 4\r
+42 7\r
+214 97\r
+288 50\r
+243 19\r
+252 93\r
+299 97\r
+239 229\r
+86 31\r
+255 149\r
+194 138\r
+158 88\r
+211 98\r
+281 262\r
+145 54\r
+252 177\r
+250 65\r
+260 56\r
+193 24\r
+250 214\r
+140 116\r
+271 177\r
+254 104\r
+295 158\r
+139 12\r
+86 50\r
+297 3\r
+226 223\r
+261 115\r
+119 52\r
+240 142\r
+27 24\r
+144 31\r
+120 50\r
+208 66\r
+258 237\r
+284 39\r
+169 64\r
+286 240\r
+213 195\r
+123 97\r
+262 210\r
+87 54\r
+36 3\r
+207 54\r
+138 130\r
+290 138\r
+107 81\r
+268 176\r
+250 130\r
+127 98\r
+235 233\r
+246 164\r
+176 20\r
+200 41\r
+197 68\r
+120 101\r
+277 19\r
+285 63\r
+100 13\r
+148 101\r
+163 49\r
+70 23\r
+106 35\r
+138 22\r
+266 248\r
+228 201\r
+233 198\r
+120 15\r
+269 258\r
+233 223\r
+187 114\r
+123 107\r
+285 173\r
+293 280\r
+249 96\r
+103 94\r
+231 85\r
+92 70\r
+160 26\r
+265 2\r
+297 295\r
+187 150\r
+159 79\r
+205 201\r
+240 214\r
+195 84\r
+248 19\r
+298 269\r
+188 105\r
+264 99\r
+286 269\r
+251 240\r
+239 91\r
+129 5\r
+209 79\r
+285 227\r
+268 254\r
+90 74\r
+281 198\r
+265 30\r
+129 126\r
+114 42\r
+285 239\r
+144 93\r
+176 13\r
+298 91\r
+271 270\r
+201 87\r
+201 76\r
+127 80\r
+276 57\r
+246 220\r
+125 66\r
+264 245\r
+268 27\r
+222 144\r
+198 83\r
+300 260\r
+111 10\r
+290 129\r
+30 25\r
+242 148\r
+209 124\r
+229 120\r
+45 21\r
+300 131\r
+110 21\r
+124 51\r
+159 143\r
+205 8\r
+261 250\r
+299 132\r
+293 204\r
+156 153\r
+229 125\r
+116 26\r
+85 33\r
+194 113\r
+16 13\r
+266 250\r
+291 229\r
+138 66\r
+264 241\r
+97 24\r
+288 258\r
+74 22\r
+270 150\r
+146 18\r
+132 49\r
+176 108\r
+224 49\r
+262 7\r
+269 260\r
+179 111\r
+190 175\r
+214 133\r
+128 25\r
+298 14\r
+231 153\r
+297 182\r
+293 230\r
+265 83\r
+265 115\r
+250 101\r
+185 10\r
+210 81\r
+162 151\r
+126 90\r
+86 30\r
+290 213\r
+90 87\r
+268 136\r
+290 167\r
+88 28\r
+183 13\r
+138 45\r
+284 82\r
+296 74\r
+27 2\r
+194 151\r
+288 51\r
+177 72\r
+271 155\r
+188 68\r
+235 215\r
+218 210\r
+19 4\r
+261 197\r
+169 53\r
+236 105\r
+246 233\r
+189 98\r
+240 18\r
+279 26\r
+212 11\r
+243 46\r
+59 58\r
+258 71\r
+207 42\r
+273 143\r
+196 74\r
+182 44\r
+235 4\r
+231 8\r
+144 37\r
+217 120\r
+214 186\r
+264 134\r
+147 127\r
+160 13\r
+278 247\r
+134 131\r
+253 49\r
+290 247\r
+153 147\r
+228 135\r
+201 105\r
+277 230\r
+212 26\r
+256 177\r
+271 251\r
+195 159\r
+170 162\r
+194 183\r
+300 45\r
+281 217\r
+104 37\r
+102 27\r
+274 77\r
+98 77\r
+264 214\r
+165 6\r
+275 35\r
+108 37\r
+192 103\r
+247 129\r
+244 45\r
+171 131\r
+21 20\r
+252 182\r
+237 45\r
+247 214\r
+172 60\r
+151 81\r
+235 86\r
+227 8\r
+134 66\r
+199 102\r
+115 46\r
+148 26\r
+286 231\r
+276 77\r
+149 117\r
+291 30\r
+296 195\r
+252 211\r
+284 120\r
+179 44\r
+19 10\r
+208 185\r
+69 1\r
+120 75\r
+140 81\r
+273 51\r
+180 108\r
+212 57\r
+222 99\r
+74 52\r
+286 135\r
+174 31\r
+271 242\r
+270 218\r
+90 82\r
+145 34\r
+295 95\r
+26 25\r
+212 98\r
+294 137\r
+131 23\r
+243 164\r
+129 55\r
+196 33\r
+186 21\r
+210 138\r
+189 12\r
+217 176\r
+111 93\r
+248 10\r
+283 256\r
+273 164\r
+233 49\r
+231 132\r
+206 176\r
+202 144\r
+259 86\r
+300 236\r
+233 31\r
+266 73\r
+230 135\r
+244 12\r
+112 20\r
+62 29\r
+234 121\r
+169 69\r
+280 169\r
+281 173\r
+238 6\r
+275 188\r
+40 38\r
+262 155\r
+219 9\r
+215 39\r
+277 158\r
+119 28\r
+282 154\r
+133 95\r
+157 148\r
+191 41\r
+23 20\r
+201 47\r
+239 180\r
+83 57\r
+293 58\r
+273 262\r
+163 76\r
+291 210\r
+61 25\r
+286 277\r
+287 241\r
+288 112\r
+234 227\r
+271 3\r
+253 17\r
+166 41\r
+285 152\r
+234 60\r
+284 212\r
+217 110\r
+262 90\r
+119 50\r
+295 247\r
+192 154\r
+198 95\r
+259 28\r
+300 267\r
+274 33\r
+174 62\r
+115 72\r
+66 12\r
+194 15\r
+235 140\r
+280 35\r
+162 45\r
+146 97\r
+208 62\r
+234 217\r
+129 89\r
+300 243\r
+177 96\r
+78 35\r
+263 254\r
+169 1\r
+292 31\r
+93 37\r
+265 62\r
+297 146\r
+231 120\r
+167 38\r
+282 121\r
+287 180\r
+244 216\r
+56 48\r
+276 34\r
+290 202\r
+290 169\r
+189 137\r
+283 193\r
+259 39\r
+42 34\r
+105 18\r
+126 122\r
+248 115\r
+116 25\r
+233 209\r
+246 239\r
+108 76\r
+293 250\r
+71 4\r
+241 236\r
+190 22\r
+290 184\r
+96 59\r
+289 29\r
+203 163\r
+206 54\r
+47 32\r
+91 32\r
+173 91\r
+238 64\r
+172 112\r
+136 37\r
+238 94\r
+127 32\r
+142 13\r
+253 244\r
+170 83\r
+239 156\r
+200 197\r
+210 96\r
+105 48\r
+159 31\r
+254 173\r
+248 92\r
+273 134\r
+224 21\r
+116 89\r
+24 20\r
+286 125\r
+111 79\r
+58 54\r
+239 131\r
+186 142\r
+183 144\r
+91 89\r
+233 175\r
+231 67\r
+202 43\r
+204 62\r
+181 128\r
+283 274\r
+300 54\r
+196 158\r
+282 40\r
+183 35\r
+197 139\r
+48 21\r
+274 91\r
+214 41\r
+143 106\r
+283 211\r
+132 105\r
+283 161\r
+141 122\r
+298 134\r
+159 93\r
+273 239\r
+300 259\r
+144 79\r
+264 188\r
+112 17\r
+27 4\r
+195 89\r
+151 82\r
+282 4\r
+225 80\r
+153 137\r
+277 202\r
+109 71\r
+294 87\r
+229 111\r
+299 227\r
+164 147\r
+135 30\r
+285 196\r
+288 158\r
+195 94\r
+277 17\r
+196 85\r
+110 69\r
+298 168\r
+58 5\r
+245 214\r
+254 91\r
+216 70\r
+262 165\r
+127 87\r
+50 15\r
+250 245\r
+212 63\r
+118 117\r
+206 143\r
+137 16\r
+300 4\r
+291 93\r
+183 123\r
+286 129\r
+166 117\r
+168 85\r
+256 251\r
+292 17\r
+218 2\r
+163 85\r
+176 144\r
+157 120\r
+290 93\r
+197 177\r
+180 47\r
+253 197\r
+88 13\r
+124 116\r
+106 26\r
+150 48\r
+180 158\r
+232 189\r
+117 116\r
+283 54\r
+164 155\r
+185 178\r
+238 235\r
+142 46\r
+105 56\r
+193 89\r
+111 90\r
+249 143\r
+12 9\r
+261 47\r
+245 84\r
+160 138\r
+171 150\r
+280 263\r
+201 196\r
+172 154\r
+220 42\r
+281 227\r
+223 54\r
+249 75\r
+161 34\r
+270 168\r
+235 24\r
+299 107\r
+37 26\r
+261 28\r
+157 105\r
+97 68\r
+260 72\r
+252 80\r
+299 193\r
+265 68\r
+181 16\r
+174 134\r
+263 50\r
+116 28\r
+199 42\r
+83 16\r
+219 135\r
+107 7\r
+193 76\r
+294 262\r
+261 173\r
+146 81\r
+235 26\r
+263 173\r
+283 233\r
+231 130\r
+242 32\r
+259 18\r
+293 29\r
+256 133\r
+189 151\r
+218 38\r
+242 192\r
+224 43\r
+255 209\r
+157 102\r
+