ruby-minisat 1.14.2 → 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 296d98a29864044819a0e0dd556a152e1aff8a96
+  data.tar.gz: 10a28e85eca2fc741a4dd4f43adaabe248dc1146
+SHA512:
+  metadata.gz: a3990d7912879f13d48445fe48a4435b9c4a8d94245b55de68bdfea4142ec4e434a0a0560eb111b6f228f9280637524f2d7230c1edec94cd1c58d92a0c990cf5
+  data.tar.gz: abf39822777fff19785d307d1c1acd6e016fd48b8f0afb03643daaa38e369a491aaff833cdefed6784b06a231aeab0c8822ab4fcaf931b014e12223065acf9d5

data/.gitignore

@@ -1,24 +1,21 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
 coverage
-rdoc
+doc/
+lib/bundler/man
 pkg
-
-## PROJECT::SPECIFIC
-lib
-*.gemspec
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
 tmp
+*.o
+*.so
+Makefile
+.*.sw*

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in minisat.gemspec
+gemspec

data/LICENSE

@@ -1,5 +1,6 @@
-MiniSat -- Copyright (c) 2003-2005, Niklas Een, Niklas Sorensson
-ruby-minisat -- Copyright (c) 2007,2010 Yusuke Endoh
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+           Copyright (c) 2007-2010  Niklas Sorensson
+ruby-minisat -- Copyright (c) 2007,2010,2013 Yusuke Endoh
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,42 @@
+# Minisat
+
+ruby-minisat is ruby binding for MiniSat, an open-source SAT solver.
+
+## Installation
+
+    $ gem install ruby-minisat
+
+## Usage
+
+A brief example that solves a simple SAT problem:
+
+    # solve (a or b) and (not a or b) and (a or not b)
+
+    require "minisat"
+    solver = MiniSat::Solver.new
+    
+    a = solver.new_var
+    b = solver.new_var
+    
+    solver << [a, b] << [-a, b] << [a, -b]
+    
+    p solver.solve  #=> true (satisfiable)
+    
+    p solver[a]  #=> true
+    p solver[b]  #=> true
+
+For more examples, see the examples directory in the distribution.
+
+## Copyright
+
+ruby-minisat is covered under the MIT License.
+This package includes MiniSat in the directory `minisat` which is also
+distributed under the MIT License.  See `minisat/minisat/LICENSE`.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -1,48 +1 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  jeweler_tasks = Jeweler::Tasks.new do |gem|
-    gem.name = "ruby-minisat"
-    gem.summary = %Q{ruby binding for MiniSat, which is an open-source SAT solver}
-    gem.description = gem.summary
-    gem.email = "mame@tsg.ne.jp"
-    gem.homepage = "http://github.com/mame/ruby-minisat"
-    gem.authors = ["Yusuke Endoh"]
-    gem.extensions = FileList['ext/**/extconf.rb']
-    gem.files.include FileList['ext/**/*', 'minisat/**/*/**']
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-task :test => :check_dependencies
-
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "ruby-minisat #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('ext/**/*.c')
-end
-
-begin
-  require 'rake/extensiontask'
-  require 'rake/extensiontesttask'
-
-  Rake::ExtensionTask.new('minisat', jeweler_tasks.gemspec)
-rescue LoadError
-end
+require "bundler/gem_tasks"

data/examples/shikaku.rb

@@ -122,11 +122,11 @@ def output_field(solution, field)
     line.each_with_index do |c, x|
       ary[y * 2 + 1][x * 2 + 1] = c ? c.to_s.rjust(2) : " ."
 
-      if x == 0 || solution[x - 1][y] != solution[x][y]
+      if x == 0 || solution[y][x - 1] != solution[y][x]
         ary[y * 2 + 1][x * 2] = " |" 
       end
       ary[y * 2 + 1][x * 2 + 2] = " |" if x == w - 1
-      if y == 0 || solution[x][y - 1] != solution[x][y]
+      if y == 0 || solution[y - 1][x] != solution[y][x]
         ary[y * 2][x * 2 + 1] = "--"
       end
       ary[y * 2 + 2][x * 2 + 1] = "--" if y == h - 1

data/ext/minisat/extconf.rb

@@ -1,9 +1,24 @@
 require 'mkmf'
 
 CONFIG["CXX"] ||= "g++"
-MINISAT_DIR = File.join(File.dirname(__FILE__), "../../minisat/MiniSat_v1.14")
 
-minisat_include, _ = dir_config("minisat", MINISAT_DIR, "")
-$objs = ["minisat.o", "minisat-wrap.o", minisat_include + "/Solver.o"]
+system_minisat = have_library("minisat")
+if system_minisat
+  # dirty hack for mkmf
+  with_cflags("-x c++") do
+    system_minisat &&= have_header("minisat/core/Solver.h")
+    false
+  end
+end
+$defs << "-D __STDC_LIMIT_MACROS" << "-D __STDC_FORMAT_MACROS"
 
-create_makefile("minisat") if have_library("stdc++")
+unless system_minisat
+  # use bundled minisat
+  MINISAT_DIR = File.join(File.dirname(__FILE__), "../../minisat/minisat/")
+
+  minisat_include, _ = dir_config("minisat", MINISAT_DIR, "")
+  $objs = ["minisat.o", "minisat-wrap.o", minisat_include + "core/Solver.o"]
+end
+
+raise unless have_library("stdc++")
+create_makefile("minisat")

data/ext/minisat/minisat-wrap.cpp

@@ -29,17 +29,23 @@ THE SOFTWARE.
 ******************************************************************************/
 
 
-#include "Solver.h"
+#ifdef HAVE_MINISAT_CORE_SOLVER_H
+#include "minisat/core/Solver.h"
+#else
+#include "core/Solver.h"
+#endif
 #include "minisat.h"
 
+using namespace Minisat;
+
 /***** variable **************************************************************/
 
 extern "C" int wrap_lit_pos_var(int v) {
-    return index(Lit(v, false));
+    return toInt(mkLit(v, false));
 }
 
 extern "C" int wrap_lit_neg_var(int v) {
-    return index(Lit(v, true));
+    return toInt(mkLit(v, true));
 }
 
 /***** solver ****************************************************************/
@@ -74,8 +80,8 @@ extern "C" int wrap_solver_solve(wrap_solver slv, int *lits, int len) {
     return ((Solver*) slv)->solve(lit_vec) ? 1 : 0;
 }
 
-extern "C" int wrap_solver_simplify_db(wrap_solver slv) {
-    ((Solver*) slv)->simplifyDB();
+extern "C" int wrap_solver_simplify(wrap_solver slv) {
+    ((Solver*) slv)->simplify();
     return ((Solver*) slv)->okay() ? 1 : 0;
 }
 

data/ext/minisat/minisat.c

@@ -339,20 +339,21 @@ static VALUE solver_solve(int argc, VALUE *argv, VALUE rslv)
 
 /*
  *  call-seq:
- *     solver.simplify_db   -> true or false
+ *     solver.simplify    -> true or false
  *
  *  Detects conflicts independent of the assumptions.  This is useful when the
  *  same SAT is solved many times under some different assumptions.
+ *  Solver#simplify_db is deprecated.
  *
  */
-static VALUE solver_simplify_db(VALUE rslv)
+static VALUE solver_simplify(VALUE rslv)
 {
     csolver *cslv;
 
     Data_Get_Struct(rslv, csolver, cslv);
 
     check_model_available(cslv->result, 0);
-    if(!wrap_solver_simplify_db(cslv->solver)) {
+    if(!wrap_solver_simplify(cslv->solver)) {
         cslv->result = UNSATISFIABLE;
         return Qfalse;
     }
@@ -360,6 +361,18 @@ static VALUE solver_simplify_db(VALUE rslv)
     return Qtrue;
 }
 
+/*
+ *  call-seq:
+ *     solver.simplify_db    -> true or false
+ *
+ *  Deprecated. The same as Solver#simplify.
+ *
+ */
+static VALUE solver_simplify_db(VALUE rslv)
+{
+    return solver_simplify(rslv);
+}
+
 /*
  *  call-seq:
  *     solver.var_size   -> integer
@@ -479,6 +492,7 @@ void Init_minisat()
     rb_define_method(rb_cSolver, "<<", solver_add_clause_2, 1);
     rb_define_method(rb_cSolver, "[]", solver_ref_var, 1);
     rb_define_method(rb_cSolver, "solve", solver_solve, -1);
+    rb_define_method(rb_cSolver, "simplify", solver_simplify, 0);
     rb_define_method(rb_cSolver, "simplify_db", solver_simplify_db, 0);
     rb_define_method(rb_cSolver, "var_size", solver_var_size, 0);
     rb_define_method(rb_cSolver, "clause_size", solver_clause_size, 0);

data/ext/minisat/minisat.h

@@ -44,7 +44,7 @@ extern int wrap_solver_new_var(wrap_solver slv);
 extern int wrap_solver_add_clause(wrap_solver slv, int *lits, int len);
 extern int wrap_solver_ref_var(wrap_solver slv, int var);
 extern int wrap_solver_solve(wrap_solver slv, int *lits, int len);
-extern int wrap_solver_simplify_db(wrap_solver slv);
+extern int wrap_solver_simplify(wrap_solver slv);
 extern int wrap_solver_var_size(wrap_solver slv);
 extern int wrap_solver_clause_size(wrap_solver slv);
 

data/minisat/{MiniSat_v1.14 → minisat}/LICENSE

@@ -1,4 +1,5 @@
-MiniSat -- Copyright (c) 2003-2005, Niklas Een, Niklas Sorensson
+MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+           Copyright (c) 2007-2010  Niklas Sorensson
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the

data/minisat/minisat/README

@@ -0,0 +1,24 @@
+================================================================================
+DIRECTORY OVERVIEW:
+
+mtl/            Mini Template Library
+utils/          Generic helper code (I/O, Parsing, CPU-time, etc)
+core/           A core version of the solver
+simp/           An extended solver with simplification capabilities
+README
+LICENSE
+
+================================================================================
+BUILDING: (release version: without assertions, statically linked, etc)
+
+export MROOT=<minisat-dir>              (or setenv in cshell)
+cd { core | simp }
+gmake rs
+cp minisat_static <install-dir>/minisat
+
+================================================================================
+EXAMPLES:
+
+Run minisat with same heuristics as version 2.0:
+
+> minisat <cnf-file> -no-luby -rinc=1.5 -phase-saving=0 -rnd-freq=0.02

data/minisat/minisat/core/Dimacs.h

@@ -0,0 +1,89 @@
+/****************************************************************************************[Dimacs.h]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, 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 Minisat_Dimacs_h
+#define Minisat_Dimacs_h
+
+#include <stdio.h>
+
+#include "utils/ParseUtils.h"
+#include "core/SolverTypes.h"
+
+namespace Minisat {
+
+//=================================================================================================
+// DIMACS Parser:
+
+template<class B, class Solver>
+static void readClause(B& in, Solver& S, vec<Lit>& lits) {
+    int     parsed_lit, var;
+    lits.clear();
+    for (;;){
+        parsed_lit = parseInt(in);
+        if (parsed_lit == 0) break;
+        var = abs(parsed_lit)-1;
+        while (var >= S.nVars()) S.newVar();
+        lits.push( (parsed_lit > 0) ? mkLit(var) : ~mkLit(var) );
+    }
+}
+
+template<class B, class Solver>
+static void parse_DIMACS_main(B& in, Solver& S) {
+    vec<Lit> lits;
+    int vars    = 0;
+    int clauses = 0;
+    int cnt     = 0;
+    for (;;){
+        skipWhitespace(in);
+        if (*in == EOF) break;
+        else if (*in == 'p'){
+            if (eagerMatch(in, "p cnf")){
+                vars    = parseInt(in);
+                clauses = parseInt(in);
+                // SATRACE'06 hack
+                // if (clauses > 4000000)
+                //     S.eliminate(true);
+            }else{
+                printf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
+            }
+        } else if (*in == 'c' || *in == 'p')
+            skipLine(in);
+        else{
+            cnt++;
+            readClause(in, S, lits);
+            S.addClause_(lits); }
+    }
+    if (vars != S.nVars())
+        fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of variables.\n");
+    if (cnt  != clauses)
+        fprintf(stderr, "WARNING! DIMACS header mismatch: wrong number of clauses.\n");
+}
+
+// Inserts problem into solver.
+//
+template<class Solver>
+static void parse_DIMACS(gzFile input_stream, Solver& S) {
+    StreamBuffer in(input_stream);
+    parse_DIMACS_main(in, S); }
+
+//=================================================================================================
+}
+
+#endif

data/minisat/minisat/core/Main.cc

@@ -0,0 +1,192 @@
+/*****************************************************************************************[Main.cc]
+Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
+Copyright (c) 2007-2010, 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 <errno.h>
+
+#include <signal.h>
+#include <zlib.h>
+
+#include "utils/System.h"
+#include "utils/ParseUtils.h"
+#include "utils/Options.h"
+#include "core/Dimacs.h"
+#include "core/Solver.h"
+
+using namespace Minisat;
+
+//=================================================================================================
+
+
+void printStats(Solver& solver)
+{
+    double cpu_time = cpuTime();
+    double mem_used = memUsedPeak();
+    printf("restarts              : %"PRIu64"\n", solver.starts);
+    printf("conflicts             : %-12"PRIu64"   (%.0f /sec)\n", solver.conflicts   , solver.conflicts   /cpu_time);
+    printf("decisions             : %-12"PRIu64"   (%4.2f %% random) (%.0f /sec)\n", solver.decisions, (float)solver.rnd_decisions*100 / (float)solver.decisions, solver.decisions   /cpu_time);
+    printf("propagations          : %-12"PRIu64"   (%.0f /sec)\n", solver.propagations, solver.propagations/cpu_time);
+    printf("conflict literals     : %-12"PRIu64"   (%4.2f %% deleted)\n", solver.tot_literals, (solver.max_literals - solver.tot_literals)*100 / (double)solver.max_literals);
+    if (mem_used != 0) printf("Memory used           : %.2f MB\n", mem_used);
+    printf("CPU time              : %g s\n", cpu_time);
+}
+
+
+static Solver* solver;
+// Terminate by notifying the solver and back out gracefully. This is mainly to have a test-case
+// for this feature of the Solver as it may take longer than an immediate call to '_exit()'.
+static void SIGINT_interrupt(int signum) { solver->interrupt(); }
+
+// Note that '_exit()' rather than 'exit()' has to be used. The reason is that 'exit()' calls
+// destructors and may cause deadlocks if a malloc/free function happens to be running (these
+// functions are guarded by locks for multithreaded use).
+static void SIGINT_exit(int signum) {
+    printf("\n"); printf("*** INTERRUPTED ***\n");
+    if (solver->verbosity > 0){
+        printStats(*solver);
+        printf("\n"); printf("*** INTERRUPTED ***\n"); }
+    _exit(1); }
+
+
+//=================================================================================================
+// Main:
+
+
+int main(int argc, char** argv)
+{
+    try {
+        setUsageHelp("USAGE: %s [options] <input-file> <result-output-file>\n\n  where input may be either in plain or gzipped DIMACS.\n");
+        // printf("This is MiniSat 2.0 beta\n");
+        
+#if defined(__linux__)
+        fpu_control_t oldcw, newcw;
+        _FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw);
+        printf("WARNING: for repeatability, setting FPU to use double precision\n");
+#endif
+        // Extra options:
+        //
+        IntOption    verb   ("MAIN", "verb",   "Verbosity level (0=silent, 1=some, 2=more).", 1, IntRange(0, 2));
+        IntOption    cpu_lim("MAIN", "cpu-lim","Limit on CPU time allowed in seconds.\n", INT32_MAX, IntRange(0, INT32_MAX));
+        IntOption    mem_lim("MAIN", "mem-lim","Limit on memory usage in megabytes.\n", INT32_MAX, IntRange(0, INT32_MAX));
+        
+        parseOptions(argc, argv, true);
+
+        Solver S;
+        double initial_time = cpuTime();
+
+        S.verbosity = verb;
+        
+        solver = &S;
+        // Use signal handlers that forcibly quit until the solver will be able to respond to
+        // interrupts:
+        signal(SIGINT, SIGINT_exit);
+        signal(SIGXCPU,SIGINT_exit);
+
+        // Set limit on CPU-time:
+        if (cpu_lim != INT32_MAX){
+            rlimit rl;
+            getrlimit(RLIMIT_CPU, &rl);
+            if (rl.rlim_max == RLIM_INFINITY || (rlim_t)cpu_lim < rl.rlim_max){
+                rl.rlim_cur = cpu_lim;
+                if (setrlimit(RLIMIT_CPU, &rl) == -1)
+                    printf("WARNING! Could not set resource limit: CPU-time.\n");
+            } }
+
+        // Set limit on virtual memory:
+        if (mem_lim != INT32_MAX){
+            rlim_t new_mem_lim = (rlim_t)mem_lim * 1024*1024;
+            rlimit rl;
+            getrlimit(RLIMIT_AS, &rl);
+            if (rl.rlim_max == RLIM_INFINITY || new_mem_lim < rl.rlim_max){
+                rl.rlim_cur = new_mem_lim;
+                if (setrlimit(RLIMIT_AS, &rl) == -1)
+                    printf("WARNING! Could not set resource limit: Virtual memory.\n");
+            } }
+        
+        if (argc == 1)
+            printf("Reading from standard input... Use '--help' for help.\n");
+        
+        gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb");
+        if (in == NULL)
+            printf("ERROR! Could not open file: %s\n", argc == 1 ? "<stdin>" : argv[1]), exit(1);
+        
+        if (S.verbosity > 0){
+            printf("============================[ Problem Statistics ]=============================\n");
+            printf("|                                                                             |\n"); }
+        
+        parse_DIMACS(in, S);
+        gzclose(in);
+        FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL;
+        
+        if (S.verbosity > 0){
+            printf("|  Number of variables:  %12d                                         |\n", S.nVars());
+            printf("|  Number of clauses:    %12d                                         |\n", S.nClauses()); }
+        
+        double parsed_time = cpuTime();
+        if (S.verbosity > 0){
+            printf("|  Parse time:           %12.2f s                                       |\n", parsed_time - initial_time);
+            printf("|                                                                             |\n"); }
+ 
+        // Change to signal-handlers that will only notify the solver and allow it to terminate
+        // voluntarily:
+        signal(SIGINT, SIGINT_interrupt);
+        signal(SIGXCPU,SIGINT_interrupt);
+       
+        if (!S.simplify()){
+            if (res != NULL) fprintf(res, "UNSAT\n"), fclose(res);
+            if (S.verbosity > 0){
+                printf("===============================================================================\n");
+                printf("Solved by unit propagation\n");
+                printStats(S);
+                printf("\n"); }
+            printf("UNSATISFIABLE\n");
+            exit(20);
+        }
+        
+        vec<Lit> dummy;
+        lbool ret = S.solveLimited(dummy);
+        if (S.verbosity > 0){
+            printStats(S);
+            printf("\n"); }
+        printf(ret == l_True ? "SATISFIABLE\n" : ret == l_False ? "UNSATISFIABLE\n" : "INDETERMINATE\n");
+        if (res != NULL){
+            if (ret == l_True){
+                fprintf(res, "SAT\n");
+                for (int i = 0; i < S.nVars(); i++)
+                    if (S.model[i] != l_Undef)
+                        fprintf(res, "%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1);
+                fprintf(res, " 0\n");
+            }else if (ret == l_False)
+                fprintf(res, "UNSAT\n");
+            else
+                fprintf(res, "INDET\n");
+            fclose(res);
+        }
+        
+#ifdef NDEBUG
+        exit(ret == l_True ? 10 : ret == l_False ? 20 : 0);     // (faster than "return", which will invoke the destructor for 'Solver')
+#else
+        return (ret == l_True ? 10 : ret == l_False ? 20 : 0);
+#endif
+    } catch (OutOfMemoryException&){
+        printf("===============================================================================\n");
+        printf("INDETERMINATE\n");
+        exit(0);
+    }
+}