YuhangQ/cloud-sat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add lstech

Browse Source
This commit is contained in:
ihan-o 2023-04-28 17:15:37 +08:00
parent de434abbfb
commit 8fff1bc11d
110 changed files with 12557 additions and 949 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1121
data/072785fd927ff0fd180ce8b9cc00078f-20180321_140826713_p_cnf_320_1120.cnf Normal file
View File

File diff suppressed because it is too large Load Diff

18
kissat-inc/makefile
View File

@ -1,17 +1,17 @@
all:
$(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build"
$(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build"
kissat:
$(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" kissat
$(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" kissat
tissat:
$(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" tissat
$(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" tissat
clean:
rm -f "/pub/netdisk1/qianyh/Light/kissat-inc"/makefile
-$(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" clean
rm -rf "/pub/netdisk1/qianyh/Light/kissat-inc/build"
rm -f "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc"/makefile
-$(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" clean
rm -rf "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build"
coverage:
$(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" coverage
$(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" coverage
indent:
$(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" indent
$(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" indent
test:
$(MAKE) -C "/pub/netdisk1/qianyh/Light/kissat-inc/build" test
$(MAKE) -C "/home/chenzh/solvers/cloud-nobug/cloud-sat/kissat-inc/build" test
.PHONY: all clean coverage indent kissat test tissat

38
lstech_maple/LICENSE Executable file
View File

@ -0,0 +1,38 @@
/***************************************************************************************
MIT LICENSE
lstech_maple, Relaxed_newTech -- Copyright (c) 2019-2021, Shaowei Cai, Xindi Zhang.
Reference: Shaowei Cai, Xindi Zhang: Deep Cooperation of CDCL and Local Search for SAT.
Xindi Zhang, Shaowei Cai: Relaxed Backtracking with Rephasing.
MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c) 2019, Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters.
MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c) 2018, Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121.
Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
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 "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.
**************************************************************************************************/

215
lstech_maple/Makefile Executable file
View File

@ -0,0 +1,215 @@
###################################################################################################
.PHONY: r d p sh cr cd cp csh lr ld lp lsh config all install install-headers install-lib\
install-bin clean distclean
all: r lr lsh
## Load Previous Configuration ####################################################################
-include config.mk
## Configurable options ###########################################################################
# Directory to store object files, libraries, executables, and dependencies:
BUILD_DIR ?= build
# Include debug-symbols in release builds
MAPLE_RELSYM ?= -g
# Sets of compile flags for different build types
MAPLE_REL ?= -O3 -D NDEBUG
MAPLE_DEB ?= -O0 -D DEBUG
MAPLE_PRF ?= -O3 -D NDEBUG
MAPLE_FPIC ?= -fpic
# GNU Standard Install Prefix
prefix ?= /usr/local
## Write Configuration ###########################################################################
config:
@( echo 'BUILD_DIR?=$(BUILD_DIR)' ; \
echo 'MAPLE_RELSYM?=$(MAPLE_RELSYM)' ; \
echo 'MAPLE_REL?=$(MAPLE_REL)' ; \
echo 'MAPLE_DEB?=$(MAPLE_DEB)' ; \
echo 'MAPLE_PRF?=$(MAPLE_PRF)' ; \
echo 'MAPLE_FPIC?=$(MAPLE_FPIC)' ; \
echo 'prefix?=$(prefix)' ) > config.mk
## Configurable options end #######################################################################
INSTALL ?= install
# GNU Standard Install Variables
exec_prefix ?= $(prefix)
includedir ?= $(prefix)/include
bindir ?= $(exec_prefix)/bin
libdir ?= $(exec_prefix)/lib
datarootdir ?= $(prefix)/share
mandir ?= $(datarootdir)/man
# Target file names
MAPLE = lstech# Name of MiniSat main executable.
MAPLE_CORE = lstech_core# Name of simplified MiniSat executable (only core solver support).
MAPLE_SLIB = lib$(MAPLE).a# Name of MiniSat static library.
MAPLE_DLIB = lib$(MAPLE).so# Name of MiniSat shared library.
# Shared Library Version
SOMAJOR=2
SOMINOR=1
SORELEASE?=.0# Declare empty to leave out from library file name.
MAPLE_CXXFLAGS = -I. -Ilstech/ -D __STDC_LIMIT_MACROS -D __STDC_FORMAT_MACROS -Wall -Wno-parentheses -Wextra -std=c++11
MAPLE_LDFLAGS = -Wall -lz
ECHO=@echo
ifeq ($(VERB),)
VERB=@
else
VERB=
endif
SRCS = $(wildcard lstech/core/*.cc) $(wildcard lstech/simp/*.cc) $(wildcard lstech/utils/*.cc)
HDRS = $(wildcard lstech/mtl/*.h) $(wildcard lstech/core/*.h) $(wildcard lstech/simp/*.h) $(wildcard lstech/utils/*.h)
OBJS = $(filter-out %Main.o, $(SRCS:.cc=.o))
r: $(BUILD_DIR)/release/bin/$(MAPLE)
d: $(BUILD_DIR)/debug/bin/$(MAPLE)
p: $(BUILD_DIR)/profile/bin/$(MAPLE)
sh: $(BUILD_DIR)/dynamic/bin/$(MAPLE)
cr: $(BUILD_DIR)/release/bin/$(MAPLE_CORE)
cd: $(BUILD_DIR)/debug/bin/$(MAPLE_CORE)
cp: $(BUILD_DIR)/profile/bin/$(MAPLE_CORE)
csh: $(BUILD_DIR)/dynamic/bin/$(MAPLE_CORE)
lr: $(BUILD_DIR)/release/lib/$(MAPLE_SLIB)
ld: $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB)
lp: $(BUILD_DIR)/profile/lib/$(MAPLE_SLIB)
lsh: $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE)
## Build-type Compile-flags:
$(BUILD_DIR)/release/%.o: MAPLE_CXXFLAGS +=$(MAPLE_REL) $(MAPLE_RELSYM)
$(BUILD_DIR)/debug/%.o: MAPLE_CXXFLAGS +=$(MAPLE_DEB) -g
$(BUILD_DIR)/profile/%.o: MAPLE_CXXFLAGS +=$(MAPLE_PRF) -pg
$(BUILD_DIR)/dynamic/%.o: MAPLE_CXXFLAGS +=$(MAPLE_REL) $(MAPLE_FPIC)
## Build-type Link-flags:
$(BUILD_DIR)/profile/bin/$(MAPLE): MAPLE_LDFLAGS += -pg
$(BUILD_DIR)/release/bin/$(MAPLE): MAPLE_LDFLAGS += --static $(MAPLE_RELSYM)
$(BUILD_DIR)/profile/bin/$(MAPLE_CORE): MAPLE_LDFLAGS += -pg
$(BUILD_DIR)/release/bin/$(MAPLE_CORE): MAPLE_LDFLAGS += --static $(MAPLE_RELSYM)
## Executable dependencies
$(BUILD_DIR)/release/bin/$(MAPLE): $(BUILD_DIR)/release/lstech/simp/Main.o $(BUILD_DIR)/release/lib/$(MAPLE_SLIB)
$(BUILD_DIR)/debug/bin/$(MAPLE): $(BUILD_DIR)/debug/lstech/simp/Main.o $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB)
$(BUILD_DIR)/profile/bin/$(MAPLE): $(BUILD_DIR)/profile/lstech/simp/Main.o $(BUILD_DIR)/profile/lib/$(MAPLE_SLIB)
# need the main-file be compiled with fpic?
$(BUILD_DIR)/dynamic/bin/$(MAPLE): $(BUILD_DIR)/dynamic/lstech/simp/Main.o $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB)
## Executable dependencies (core-version)
$(BUILD_DIR)/release/bin/$(MAPLE_CORE): $(BUILD_DIR)/release/lstech/core/Main.o $(BUILD_DIR)/release/lib/$(MAPLE_SLIB)
$(BUILD_DIR)/debug/bin/$(MAPLE_CORE): $(BUILD_DIR)/debug/lstech/core/Main.o $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB)
$(BUILD_DIR)/profile/bin/$(MAPLE_CORE): $(BUILD_DIR)/profile/lstech/core/Main.o $(BUILD_DIR)/profile/lib/$(MAPLE_SLIB)
# need the main-file be compiled with fpic?
$(BUILD_DIR)/dynamic/bin/$(MAPLE_CORE): $(BUILD_DIR)/dynamic/lstech/core/Main.o $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB)
## Library dependencies
$(BUILD_DIR)/release/lib/$(MAPLE_SLIB): $(foreach o,$(OBJS),$(BUILD_DIR)/release/$(o))
$(BUILD_DIR)/debug/lib/$(MAPLE_SLIB): $(foreach o,$(OBJS),$(BUILD_DIR)/debug/$(o))
$(BUILD_DIR)/profile/lib/$(MAPLE_SLIB): $(foreach o,$(OBJS),$(BUILD_DIR)/profile/$(o))
$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE)\
$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR)\
$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB): $(foreach o,$(OBJS),$(BUILD_DIR)/dynamic/$(o))
## Compile rules (these should be unified, buit I have not yet found a way which works in GNU Make)
$(BUILD_DIR)/release/%.o: %.cc
$(ECHO) Compiling: $@
$(VERB) mkdir -p $(dir $@)
$(VERB) $(CXX) $(MAPLE_CXXFLAGS) $(CXXFLAGS) -c -o $@ $< -MMD -MF $(BUILD_DIR)/release/$*.d
$(BUILD_DIR)/profile/%.o: %.cc
$(ECHO) Compiling: $@
$(VERB) mkdir -p $(dir $@)
$(VERB) $(CXX) $(MAPLE_CXXFLAGS) $(CXXFLAGS) -c -o $@ $< -MMD -MF $(BUILD_DIR)/profile/$*.d
$(BUILD_DIR)/debug/%.o: %.cc
$(ECHO) Compiling: $@
$(VERB) mkdir -p $(dir $@)
$(VERB) $(CXX) $(MAPLE_CXXFLAGS) $(CXXFLAGS) -c -o $@ $< -MMD -MF $(BUILD_DIR)/debug/$*.d
$(BUILD_DIR)/dynamic/%.o: %.cc
$(ECHO) Compiling: $@
$(VERB) mkdir -p $(dir $@)
$(VERB) $(CXX) $(MAPLE_CXXFLAGS) $(CXXFLAGS) -c -o $@ $< -MMD -MF $(BUILD_DIR)/dynamic/$*.d
## Linking rule
$(BUILD_DIR)/release/bin/$(MAPLE) $(BUILD_DIR)/debug/bin/$(MAPLE) $(BUILD_DIR)/profile/bin/$(MAPLE) $(BUILD_DIR)/dynamic/bin/$(MAPLE)\
$(BUILD_DIR)/release/bin/$(MAPLE_CORE) $(BUILD_DIR)/debug/bin/$(MAPLE_CORE) $(BUILD_DIR)/profile/bin/$(MAPLE_CORE) $(BUILD_DIR)/dynamic/bin/$(MAPLE_CORE):
$(ECHO) Linking Binary: $@
$(VERB) mkdir -p $(dir $@)
$(VERB) $(CXX) $^ $(MAPLE_LDFLAGS) $(LDFLAGS) -o $@
## Static Library rule
%/lib/$(MAPLE_SLIB):
$(ECHO) Linking Static Library: $@
$(VERB) mkdir -p $(dir $@)
$(VERB) $(AR) -rcs $@ $^
## Shared Library rule
$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE)\
$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR)\
$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB):
$(ECHO) Linking Shared Library: $@
$(VERB) mkdir -p $(dir $@)
$(VERB) $(CXX) $(MAPLE_LDFLAGS) $(LDFLAGS) -o $@ -shared -Wl,-soname,$(MAPLE_DLIB).$(SOMAJOR) $^
$(VERB) ln -sf $(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE) $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR)
$(VERB) ln -sf $(MAPLE_DLIB).$(SOMAJOR) $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB)
install: install-headers install-lib install-bin
install-debug: install-headers install-lib-debug
install-headers:
# Create directories
$(INSTALL) -d $(DESTDIR)$(includedir)/lstech
for dir in mtl utils core simp; do \
$(INSTALL) -d $(DESTDIR)$(includedir)/lstech/$$dir ; \
done
# Install headers
for h in $(HDRS) ; do \
$(INSTALL) -m 644 $$h $(DESTDIR)$(includedir)/$$h ; \
done
install-lib-debug: $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB)
$(INSTALL) -d $(DESTDIR)$(libdir)
$(INSTALL) -m 644 $(BUILD_DIR)/debug/lib/$(MAPLE_SLIB) $(DESTDIR)$(libdir)
install-lib: $(BUILD_DIR)/release/lib/$(MAPLE_SLIB) $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE)
$(INSTALL) -d $(DESTDIR)$(libdir)
$(INSTALL) -m 644 $(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE) $(DESTDIR)$(libdir)
ln -sf $(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE) $(DESTDIR)$(libdir)/$(MAPLE_DLIB).$(SOMAJOR)
ln -sf $(MAPLE_DLIB).$(SOMAJOR) $(DESTDIR)$(libdir)/$(MAPLE_DLIB)
$(INSTALL) -m 644 $(BUILD_DIR)/release/lib/$(MAPLE_SLIB) $(DESTDIR)$(libdir)
install-bin: $(BUILD_DIR)/dynamic/bin/$(MAPLE)
$(INSTALL) -d $(DESTDIR)$(bindir)
$(INSTALL) -m 755 $(BUILD_DIR)/dynamic/bin/$(MAPLE) $(DESTDIR)$(bindir)
clean:
rm -rf $(foreach t, release debug profile dynamic, $(foreach o, $(SRCS:.cc=.o), $(BUILD_DIR)/$t/$o)) \
$(foreach t, release debug profile dynamic, $(foreach d, $(SRCS:.cc=.d), $(BUILD_DIR)/$t/$d)) \
$(foreach t, release debug profile dynamic, $(BUILD_DIR)/$t/bin/$(MAPLE_CORE) $(BUILD_DIR)/$t/bin/$(MAPLE)) \
$(foreach t, release debug profile, $(BUILD_DIR)/$t/lib/$(MAPLE_SLIB)) \
$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR).$(SOMINOR)$(SORELEASE)\
$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB).$(SOMAJOR)\
$(BUILD_DIR)/dynamic/lib/$(MAPLE_DLIB) \
$(BUILD_DIR)
distclean: clean
rm -f config.mk
## Include generated dependencies
-include $(foreach s, $(SRCS:.cc=.d), $(BUILD_DIR)/release/$s)
-include $(foreach s, $(SRCS:.cc=.d), $(BUILD_DIR)/debug/$s)
-include $(foreach s, $(SRCS:.cc=.d), $(BUILD_DIR)/profile/$s)
-include $(foreach s, $(SRCS:.cc=.d), $(BUILD_DIR)/dynamic/$s)

32
lstech_maple/README Executable file
View File

@ -0,0 +1,32 @@
How to build:
use the command "./starexec_build"
How to use:
In the "bin" directory,
use the command "./lstech_maple <input_cnf>"
e,g. ./lstech_maple ./simple_v3_c2.cnf
The format of CNF:
the CNF format includes lines of 3-lines:
p-line: start with "p cnf ", followed by the number of variables and clauses.
c-line: comment lines.
clause-line: a clause can be represented by a series of numbers end with 0.
For example:
c simple_v3_c2.cnf
c
p cnf 3 2
1 -3 0
2 3 -1 0
The details can be found in "https://people.sc.fsu.edu/~jburkardt/data/cnf/cnf.html"
The output format:
c-line: comment lines
s-line: show the result of this call, SATISFIABLE UNSATISFIABLE or UNKNOWN.
v-line: show the model if SAT
For example:
c result of simple_v3_c2.cnf
s SATISFIABLE
v 1 -2 3 0

BIN
lstech_maple/bin/lstech_maple Executable file
View File

Binary file not shown.

54
lstech_maple/lstech/.vscode/settings.json vendored Executable file
View File

@ -0,0 +1,54 @@
{
"files.associations": {
"ostream": "cpp",
"iosfwd": "cpp",
"cctype": "cpp",
"clocale": "cpp",
"cmath": "cpp",
"cstdarg": "cpp",
"cstddef": "cpp",
"cstdio": "cpp",
"cstdlib": "cpp",
"ctime": "cpp",
"cwchar": "cpp",
"cwctype": "cpp",
"array": "cpp",
"atomic": "cpp",
"*.tcc": "cpp",
"chrono": "cpp",
"cstdint": "cpp",
"deque": "cpp",
"unordered_map": "cpp",
"unordered_set": "cpp",
"vector": "cpp",
"exception": "cpp",
"algorithm": "cpp",
"functional": "cpp",
"iterator": "cpp",
"map": "cpp",
"memory": "cpp",
"memory_resource": "cpp",
"numeric": "cpp",
"optional": "cpp",
"random": "cpp",
"ratio": "cpp",
"set": "cpp",
"string": "cpp",
"string_view": "cpp",
"system_error": "cpp",
"tuple": "cpp",
"type_traits": "cpp",
"utility": "cpp",
"fstream": "cpp",
"initializer_list": "cpp",
"iostream": "cpp",
"istream": "cpp",
"limits": "cpp",
"new": "cpp",
"sstream": "cpp",
"stdexcept": "cpp",
"streambuf": "cpp",
"cinttypes": "cpp",
"typeinfo": "cpp"
}
}

157
lstech_maple/lstech/core/Dimacs.h Executable file
View File

@ -0,0 +1,157 @@
/****************************************************************************************[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); }
//=================================================================================================
template<class B, class Solver>
static void simple_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;
lits.push( (parsed_lit > 0) ? mkLit(var) : ~mkLit(var) );
}
}
template<class B, class Solver>
static void check_solution_DIMACS_main(B& in, Solver& S) {
vec<Lit> lits;
int vars = 0;
int clauses = 0;
int cnt = 0;
bool ok=true;
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("c PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
}
} else if (*in == 'c' || *in == 'p')
skipLine(in);
else{
cnt++;
int parsed_lit, var;
bool ok=false;
for(;;) {
parsed_lit = parseInt(in);
if (parsed_lit == 0) break; //{printf("\n"); break;}
var = abs(parsed_lit)-1;
// printf("%d ", parsed_lit);
if ((parsed_lit>0 && S.model[var]==l_True) ||
(parsed_lit<0 && S.model[var]==l_False))
ok=true;
}
if (!ok) {
printf("c clause %d is not satisfied\n", cnt);
ok=false;
// break;
}
}
}
if (cnt != clauses)
printf("c WARNING! DIMACS header mismatch: wrong number of clauses.%d %d\n", cnt, clauses);
else if (ok)
printf("c solution checked against the original DIMACS file\n");
}
template<class Solver>
static void check_solution_DIMACS(gzFile input_stream, Solver& S) {
StreamBuffer in(input_stream);
check_solution_DIMACS_main(in, S); }
//=================================================================================================
}
#endif

214
lstech_maple/lstech/core/Main.cc Executable file
View File

@ -0,0 +1,214 @@
/***************************************************************************************[Solver.cc]
MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
Copyright (c) 2007-2010, Niklas Sorensson
Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
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("c restarts : %"PRIu64"\n", solver.starts);
printf("c conflicts : %-12"PRIu64" (%.0f /sec)\n", solver.conflicts , solver.conflicts /cpu_time);
printf("c decisions : %-12"PRIu64" (%4.2f %% random) (%.0f /sec)\n", solver.decisions, (float)solver.rnd_decisions*100 / (float)solver.decisions, solver.decisions /cpu_time);
printf("c propagations : %-12"PRIu64" (%.0f /sec)\n", solver.propagations, solver.propagations/cpu_time);
printf("c 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("c Memory used : %.2f MB\n", mem_used);
printf("c 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("c *** INTERRUPTED ***\n");
if (solver->verbosity > 0){
printStats(*solver);
printf("\n"); printf("c *** 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("c This is COMiniSatPS.\n");
#if defined(__linux__)
fpu_control_t oldcw, newcw;
_FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw);
printf("c 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("c 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("c WARNING! Could not set resource limit: Virtual memory.\n");
} }
if (argc == 1)
printf("c Reading from standard input... Use '--help' for help.\n");
gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb");
if (in == NULL)
printf("c ERROR! Could not open file: %s\n", argc == 1 ? "<stdin>" : argv[1]), exit(1);
if (S.verbosity > 0){
printf("c ============================[ Problem Statistics ]=============================\n");
printf("c | |\n"); }
parse_DIMACS(in, S);
gzclose(in);
FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL;
if (S.verbosity > 0){
printf("c | Number of variables: %12d |\n", S.nVars());
printf("c | Number of clauses: %12d |\n", S.nClauses()); }
double parsed_time = cpuTime();
if (S.verbosity > 0){
printf("c | Parse time: %12.2f s |\n", parsed_time - initial_time);
printf("c | |\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("c ===============================================================================\n");
printf("c Solved by unit propagation\n");
printStats(S);
printf("\n"); }
printf("s UNSATISFIABLE\n");
exit(20);
}
vec<Lit> dummy;
lbool ret = S.solveLimited(dummy);
if (S.verbosity > 0){
printStats(S);
if (ret == l_True) {
in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb");
// check_solution_DIMACS(in, S);
gzclose(in);
}
printf("\n"); }
printf(ret == l_True ? "s SATISFIABLE\n" : ret == l_False ? "s UNSATISFIABLE\n" : "s UNKNOWN\n");
if (ret == l_True){
printf("v ");
for (int i = 0; i < S.nVars(); i++)
if (S.model[i] != l_Undef)
printf("%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1);
printf(" 0\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("c ===============================================================================\n");
printf("s UNKNOWN\n");
exit(0);
}
}

5
lstech_maple/lstech/core/Makefile Executable file
View File

@ -0,0 +1,5 @@
EXEC = glucose
DEPDIR = mtl utils
MROOT = ..
include $(MROOT)/mtl/template.mk

2831
lstech_maple/lstech/core/Solver.cc Executable file
View File

File diff suppressed because it is too large Load Diff

665
lstech_maple/lstech/core/Solver.h Executable file
View File

@ -0,0 +1,665 @@
/***************************************************************************************[Solver.cc]
MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
Copyright (c) 2007-2010, Niklas Sorensson
Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c), Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121.
MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c), Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters.
lstech, Relaxed_newTech -- Copyright (c) 2019-2021, Shaowei Cai, Xindi Zhang
Reference: Shaowei Cai, Xindi Zhang: Deep Cooperation of CDCL and Local Search for SAT.
Xindi Zhang, Shaowei Cai: Relaxed Backtracking with Rephasing.
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_Solver_h
#define Minisat_Solver_h
#define ANTI_EXPLORATION
#define BIN_DRUP
#define GLUCOSE23
//#define INT_QUEUE_AVG
//#define LOOSE_PROP_STAT
#ifdef GLUCOSE23
#define INT_QUEUE_AVG
#define LOOSE_PROP_STAT
#endif
#include "mtl/Vec.h"
#include "mtl/Heap.h"
#include "mtl/Alg.h"
#include "utils/Options.h"
#include "core/SolverTypes.h"
#include "utils/ccnr.h"
// duplicate learnts version
#include <chrono>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <map>
#include <algorithm>
// duplicate learnts version
// Don't change the actual numbers.
#define LOCAL 0
#define TIER2 2
#define CORE 3
namespace Minisat {
//=================================================================================================
// Solver -- the main class:
class Solver {
private:
template<typename T>
class MyQueue {
int max_sz, q_sz;
int ptr;
int64_t sum;
vec<T> q;
public:
MyQueue(int sz) : max_sz(sz), q_sz(0), ptr(0), sum(0) { assert(sz > 0); q.growTo(sz); }
inline bool full () const { return q_sz == max_sz; }
#ifdef INT_QUEUE_AVG
inline T avg () const { assert(full()); return sum / max_sz; }
#else
inline double avg () const { assert(full()); return sum / (double) max_sz; }
#endif
inline void clear() { sum = 0; q_sz = 0; ptr = 0; }
void push(T e) {
if (q_sz < max_sz) q_sz++;
else sum -= q[ptr];
sum += e;
q[ptr++] = e;
if (ptr == max_sz) ptr = 0;
}
};
public:
// Constructor/Destructor:
//
Solver();
virtual ~Solver();
// Problem specification:
//
Var newVar (bool polarity = true, bool dvar = true); // Add a new variable with parameters specifying variable mode.
bool addClause (const vec<Lit>& ps); // Add a clause to the solver.
bool addEmptyClause(); // Add the empty clause, making the solver contradictory.
bool addClause (Lit p); // Add a unit clause to the solver.
bool addClause (Lit p, Lit q); // Add a binary clause to the solver.
bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
bool addClause_( vec<Lit>& ps); // Add a clause to the solver without making superflous internal copy. Will
// change the passed vector 'ps'.
// Parallel support
//
bool importClauses();
vec<Lit> importedClause;
void * issuer; // used as the callback parameter
bool (* cbkImportClause)(void *, int *, vec<Lit> &);
void (* cbkExportClause)(void *, int, vec<Lit> &); // callback for clause learning
// Solving:
//
bool simplify (); // Removes already satisfied clauses.
bool solve (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions.
lbool solveLimited (const vec<Lit>& assumps); // Search for a model that respects a given set of assumptions (With resource constraints).
bool solve (); // Search without assumptions.
bool solve (Lit p); // Search for a model that respects a single assumption.
bool solve (Lit p, Lit q); // Search for a model that respects two assumptions.
bool solve (Lit p, Lit q, Lit r); // Search for a model that respects three assumptions.
bool okay () const; // FALSE means solver is in a conflicting state
void toDimacs (FILE* f, const vec<Lit>& assumps); // Write CNF to file in DIMACS-format.
void toDimacs (const char *file, const vec<Lit>& assumps);
void toDimacs (FILE* f, Clause& c, vec<Var>& map, Var& max);
// Convenience versions of 'toDimacs()':
void toDimacs (const char* file);
void toDimacs (const char* file, Lit p);
void toDimacs (const char* file, Lit p, Lit q);
void toDimacs (const char* file, Lit p, Lit q, Lit r);
// 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 (Var x) const; // The value of a variable in the last model. The last call to solve must have been satisfiable.
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.
int nFreeVars () const;
// Resource contraints:
//
void setConfBudget(int64_t x);
void setPropBudget(int64_t x);
void budgetOff();
void interrupt(); // Trigger a (potentially asynchronous) interruption of the solver.
void clearInterrupt(); // Clear interrupt indicator flag.
// Memory managment:
//
virtual void garbageCollect();
void checkGarbage(double gf);
void checkGarbage();
// 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:
//
FILE* drup_file;
int worker_index;
int worker_number;
int worker_seed;
int verbosity;
double step_size;
double step_size_dec;
double min_step_size;
int timer;
double var_decay;
double clause_decay;
double random_var_freq;
double random_seed;
bool VSIDS;
int ccmin_mode; // Controls conflict clause minimization (0=none, 1=basic, 2=deep).
int phase_saving; // Controls the level of phase saving (0=none, 1=limited, 2=full).
bool rnd_pol; // Use random polarities for branching heuristics.
bool rnd_init_act; // Initialize variable activities with a small random value.
double garbage_frac; // The fraction of wasted memory allowed before a garbage collection is triggered.
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)
int learntsize_adjust_start_confl;
double learntsize_adjust_inc;
// duplicate learnts version
uint32_t min_number_of_learnts_copies;
uint32_t dupl_db_init_size;
uint32_t max_lbd_dup;
std::chrono::microseconds duptime;
// duplicate learnts version
// Statistics: (read-only member variable)
//
uint64_t solves, starts, decisions, rnd_decisions, propagations, conflicts, conflicts_VSIDS;
uint64_t dec_vars, clauses_literals, learnts_literals, max_literals, tot_literals;
uint64_t chrono_backtrack, non_chrono_backtrack;
// duplicate learnts version
uint64_t duplicates_added_conflicts;
uint64_t duplicates_added_tier2;
uint64_t duplicates_added_minimization;
uint64_t dupl_db_size;
// duplicate learnts version
vec<uint32_t> picked;
vec<uint32_t> conflicted;
vec<uint32_t> almost_conflicted;
#ifdef ANTI_EXPLORATION
vec<uint32_t> canceled;
#endif
protected:
// Helper structures:
//
struct VarData { CRef reason; int level; };
static inline VarData mkVarData(CRef cr, int l){ VarData d = {cr, l}; return d; }
struct Watcher {
CRef cref;
Lit blocker;
Watcher(CRef cr, Lit p) : cref(cr), blocker(p) {}
bool operator==(const Watcher& w) const { return cref == w.cref; }
bool operator!=(const Watcher& w) const { return cref != w.cref; }
};
struct WatcherDeleted
{
const ClauseAllocator& ca;
WatcherDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
bool operator()(const Watcher& w) const { return ca[w.cref].mark() == 1; }
};
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) { }
};
struct ConflictData
{
ConflictData() :
nHighestLevel(-1),
bOnlyOneLitFromHighest(false)
{}
int nHighestLevel;
bool bOnlyOneLitFromHighest;
};
// Solver state:
//
bool ok; // If FALSE, the constraints are already unsatisfiable. No part of the solver state may be used!
vec<CRef> clauses; // List of problem clauses.
vec<CRef> learnts_core, // List of learnt clauses.
learnts_tier2,
learnts_local;
double cla_inc; // Amount to bump next clause with.
vec<double> activity_CHB, // A heuristic measurement of the activity of a variable.
activity_VSIDS;
double var_inc; // Amount to bump next variable with.
OccLists<Lit, vec<Watcher>, WatcherDeleted>
watches_bin, // Watches for binary clauses only.
watches; // 'watches[lit]' is a list of constraints watching 'lit' (will go there if literal becomes true).
vec<lbool> assigns; // The current assignments.
vec<char> polarity; // The preferred polarity of each variable.
vec<char> decision; // 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<VarData> vardata; // Stores reason and level for each variable.
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_CHB, // A priority queue of variables ordered with respect to the variable activity.
order_heap_VSIDS;
double progress_estimate;// Set by 'search()'.
bool remove_satisfied; // Indicates whether possibly inefficient linear scan for satisfied clauses should be performed in 'simplify'.
int core_lbd_cut;
float global_lbd_sum;
MyQueue<int> lbd_queue; // For computing moving averages of recent LBD values.
uint64_t next_T2_reduce,
next_L_reduce;
ClauseAllocator ca;
// duplicate learnts version
std::map<int32_t,std::map<uint32_t,std::unordered_map<uint64_t,uint32_t>>> ht;
// duplicate learnts version
int confl_to_chrono;
int chrono;
// 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;
vec<Lit> add_oc;
vec<uint64_t> seen2; // Mostly for efficient LBD computation. 'seen2[i]' will indicate if decision level or variable 'i' has been seen.
uint64_t counter; // Simple counter for marking purpose with 'seen2'.
double max_learnts;
double learntsize_adjust_confl;
int learntsize_adjust_cnt;
// Resource contraints:
//
int64_t conflict_budget; // -1 means no budget.
int64_t propagation_budget; // -1 means no budget.
bool asynch_interrupt;
// Main internal methods:
//
void insertVarOrder (Var x); // Insert a variable in the decision order priority queue.
Lit pickBranchLit (); // Return the next decision variable.
void newDecisionLevel (); // Begins a new decision level.
void uncheckedEnqueue (Lit p, int level = 0, CRef from = CRef_Undef); // Enqueue a literal. Assumes value of literal is undefined.
bool enqueue (Lit p, CRef from = CRef_Undef); // Test if fact 'p' contradicts current state, enqueue otherwise.
CRef propagate (); // Perform unit propagation. Returns possibly conflicting clause.
void cancelUntil (int level); // Backtrack until a certain level.
void analyze (CRef confl, vec<Lit>& out_learnt, int& out_btlevel, int& out_lbd); // (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); // Search for a given number of conflicts.
lbool solve_ (); // Main solve method (assumptions given in 'assumptions').
void reduceDB (); // Reduce the set of learnt clauses.
void reduceDB_Tier2 ();
void removeSatisfied (vec<CRef>& cs); // Shrink 'cs' to contain only non-satisfied clauses.
void safeRemoveSatisfied(vec<CRef>& cs, unsigned valid_mark);
void rebuildOrderHeap ();
bool binResMinimize (vec<Lit>& out_learnt); // Further learnt clause minimization by binary resolution.
// Maintaining Variable/Clause activity:
//
void varDecayActivity (); // Decay all variables with the specified factor. Implemented by increasing the 'bump' value instead.
void varBumpActivity (Var v, double mult); // 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 (CRef cr); // Attach a clause to watcher lists.
void detachClause (CRef cr, bool strict = false); // Detach a clause to watcher lists.
void removeClause (CRef cr); // 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.
void relocAll (ClauseAllocator& to);
// duplicate learnts version
int is_duplicate (std::vector<uint32_t>&c); //returns TRUE if a clause is duplicate
// duplicate learnts version
// Misc:
//
int decisionLevel () const; // Gives the current decisionlevel.
uint32_t abstractLevel (Var x) const; // Used to represent an abstraction of sets of decision levels.
CRef reason (Var x) const;
ConflictData FindConflictLevel(CRef cind);
public:
int level (Var x) const;
protected:
double progressEstimate () const; // DELETE THIS ?? IT'S NOT VERY USEFUL ...
bool withinBudget () const;
template<class V> int computeLBD(const V& c) {
int lbd = 0;
counter++;
for (int i = 0; i < c.size(); i++){
int l = level(var(c[i]));
if (l != 0 && seen2[l] != counter){
seen2[l] = counter;
lbd++; } }
return lbd;
}
#ifdef BIN_DRUP
static int buf_len;
static unsigned char drup_buf[];
static unsigned char* buf_ptr;
static inline void byteDRUP(Lit l){
unsigned int u = 2 * (var(l) + 1) + sign(l);
do{
*buf_ptr++ = u & 0x7f | 0x80; buf_len++;
u = u >> 7;
}while (u);
*(buf_ptr - 1) &= 0x7f; // End marker of this unsigned number.
}
template<class V>
static inline void binDRUP(unsigned char op, const V& c, FILE* drup_file){
assert(op == 'a' || op == 'd');
*buf_ptr++ = op; buf_len++;
for (int i = 0; i < c.size(); i++) byteDRUP(c[i]);
*buf_ptr++ = 0; buf_len++;
if (buf_len > 1048576) binDRUP_flush(drup_file);
}
static inline void binDRUP_strengthen(const Clause& c, Lit l, FILE* drup_file){
*buf_ptr++ = 'a'; buf_len++;
for (int i = 0; i < c.size(); i++)
if (c[i] != l) byteDRUP(c[i]);
*buf_ptr++ = 0; buf_len++;
if (buf_len > 1048576) binDRUP_flush(drup_file);
}
static inline void binDRUP_flush(FILE* drup_file){
// fwrite(drup_buf, sizeof(unsigned char), buf_len, drup_file);
fwrite_unlocked(drup_buf, sizeof(unsigned char), buf_len, drup_file);
buf_ptr = drup_buf; buf_len = 0;
}
#endif
// 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); }
// simplify
//
public:
bool simplifyAll();
void simplifyLearnt(Clause& c);
bool simplifyLearnt_x(vec<CRef>& learnts_x);
bool simplifyLearnt_core();
bool simplifyLearnt_tier2();
int trailRecord;
void litsEnqueue(int cutP, Clause& c);
void cancelUntilTrailRecord();
void simpleUncheckEnqueue(Lit p, CRef from = CRef_Undef);
CRef simplePropagate();
uint64_t nbSimplifyAll;
uint64_t simplified_length_record, original_length_record;
uint64_t s_propagations;
vec<Lit> simp_learnt_clause;
vec<CRef> simp_reason_clause;
void simpleAnalyze(CRef confl, vec<Lit>& out_learnt, vec<CRef>& reason_clause, bool True_confl);
// in redundant
bool removed(CRef cr);
// adjust simplifyAll occasion
long curSimplify;
int nbconfbeforesimplify;
int incSimplify;
private:
// to avoid the init_soln of two LS too near.
int restarts_gap = 300;
int restarts_basic = 300;
// if trail.size() over c*nVars or p*max_trail, call ls.
// float conflict_ratio = 0.4;
// float percent_ratio = 0.9;
// // control ls time total use.
// float up_time_ratio = 0.2;
// control ls memory use per call.
long long ls_mems_num = 50*1000*1000;
// whether the mediation_soln is used as rephase, if not
// bool mediation_used = false;
int switch_heristic_mod = 500;//starts
int last_switch_conflicts;
//informations
// bool lssolver_constructed = false;
CCAnr *lssolver;
int freeze_ls_restart_num = 0;
double ls_used_time = 0;
int ls_call_num = 0;
int ls_best_unsat_num = INT_MAX;
bool solved_by_ls = false;
int max_trail = 0;
bool max_trail_improved = false;
int up_build_num = 0;
double up_build_time = 0.0;
//Phases
// save the recent ls soln and best ls soln, need to call ls once.
char* ls_mediation_soln;
// with the minimum unsat clauses num in LS.
char* ls_best_soln;
// hold the soln with the best trail size.
char* top_trail_soln;
char* tmp_up_build_soln;
//functions
// bool call_ls(bool use_up_build);
bool ccanr_has_constructed = false;
enum build_type{current_UP,top_trail_UP,random_build};
bool call_ls(build_type type);
void load_ls_data();
void build_soln_with_UP();
void rand_based_rephase();
void info_based_rephase();
};
//=================================================================================================
// Implementation of inline methods:
inline CRef Solver::reason(Var x) const { return vardata[x].reason; }
inline int Solver::level (Var x) const { return vardata[x].level; }
inline void Solver::insertVarOrder(Var x) {
// Heap<VarOrderLt>& order_heap = VSIDS ? order_heap_VSIDS : order_heap_CHB;
Heap<VarOrderLt>& order_heap = ((!VSIDS)? order_heap_CHB:order_heap_VSIDS);
if (!order_heap.inHeap(x) && decision[x]) order_heap.insert(x); }
inline void Solver::varDecayActivity() {
var_inc *= (1 / var_decay); }
inline void Solver::varBumpActivity(Var v, double mult) {
if ( (activity_VSIDS[v] += var_inc * mult) > 1e100 ) {
// Rescale:
for (int i = 0; i < nVars(); i++)
activity_VSIDS[i] *= 1e-100;
var_inc *= 1e-100; }
// Update order_heap with respect to new activity:
if (order_heap_VSIDS.inHeap(v)) order_heap_VSIDS.decrease(v); }
inline void Solver::claDecayActivity() { cla_inc *= (1 / clause_decay); }
inline void Solver::claBumpActivity (Clause& c) {
if ( (c.activity() += cla_inc) > 1e20 ) {
// Rescale:
for (int i = 0; i < learnts_local.size(); i++)
ca[learnts_local[i]].activity() *= 1e-20;
cla_inc *= 1e-20; } }
inline void Solver::checkGarbage(void){ return checkGarbage(garbage_frac); }
inline void Solver::checkGarbage(double gf){
if (ca.wasted() > ca.size() * gf)
garbageCollect(); }
// NOTE: enqueue does not set the ok flag! (only public methods do)
inline bool Solver::enqueue (Lit p, CRef from) { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, decisionLevel(), from), true); }
inline bool Solver::addClause (const vec<Lit>& ps) { ps.copyTo(add_tmp); return addClause_(add_tmp); }
inline bool Solver::addEmptyClause () { add_tmp.clear(); return addClause_(add_tmp); }
inline bool Solver::addClause (Lit p) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
inline bool Solver::addClause (Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
inline bool Solver::addClause (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
inline bool Solver::locked (const Clause& c) const {
int i = c.size() != 2 ? 0 : (value(c[0]) == l_True ? 0 : 1);
return value(c[i]) == l_True && reason(var(c[i])) != CRef_Undef && ca.lea(reason(var(c[i]))) == &c;
}
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 assigns[x]; }
inline lbool Solver::value (Lit p) const { return assigns[var(p)] ^ sign(p); }
inline lbool Solver::modelValue (Var x) const { return model[x]; }
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_core.size() + learnts_tier2.size() + learnts_local.size(); }
inline int Solver::nVars () const { return vardata.size(); }
inline int Solver::nFreeVars () const { return (int)dec_vars - (trail_lim.size() == 0 ? trail.size() : trail_lim[0]); }
inline void Solver::setPolarity (Var v, bool b) { polarity[v] = b; }
inline void Solver::setDecisionVar(Var v, bool b)
{
if ( b && !decision[v]) dec_vars++;
else if (!b && decision[v]) dec_vars--;
decision[v] = b;
if (b && !order_heap_CHB.inHeap(v)){
order_heap_CHB.insert(v);
order_heap_VSIDS.insert(v);}
}
inline void Solver::setConfBudget(int64_t x){ conflict_budget = conflicts + x; }
inline void Solver::setPropBudget(int64_t x){ propagation_budget = propagations + x; }
inline void Solver::interrupt(){ asynch_interrupt = true; }
inline void Solver::clearInterrupt(){ asynch_interrupt = false; }
inline void Solver::budgetOff(){ conflict_budget = propagation_budget = -1; }
inline bool Solver::withinBudget() const {
return !asynch_interrupt &&
(conflict_budget < 0 || conflicts < (uint64_t)conflict_budget) &&
(propagation_budget < 0 || propagations < (uint64_t)propagation_budget); }
// FIXME: after the introduction of asynchronous interrruptions the solve-versions that return a
// pure bool do not give a safe interface. Either interrupts must be possible to turn off here, or
// all calls to solve must return an 'lbool'. I'm not yet sure which I prefer.
inline bool Solver::solve () { budgetOff(); assumptions.clear(); return solve_() == l_True; }
inline bool Solver::solve (Lit p) { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_() == l_True; }
inline bool Solver::solve (Lit p, Lit q) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_() == l_True; }
inline bool Solver::solve (Lit p, Lit q, Lit r) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_() == l_True; }
inline bool Solver::solve (const vec<Lit>& assumps){ budgetOff(); assumps.copyTo(assumptions); return solve_() == l_True; }
inline lbool Solver::solveLimited (const vec<Lit>& assumps){ assumps.copyTo(assumptions); return solve_(); }
inline bool Solver::okay () const { return ok; }
inline void Solver::toDimacs (const char* file){ vec<Lit> as; toDimacs(file, as); }
inline void Solver::toDimacs (const char* file, Lit p){ vec<Lit> as; as.push(p); toDimacs(file, as); }
inline void Solver::toDimacs (const char* file, Lit p, Lit q){ vec<Lit> as; as.push(p); as.push(q); toDimacs(file, as); }
inline void Solver::toDimacs (const char* file, Lit p, Lit q, Lit r){ vec<Lit> as; as.push(p); as.push(q); as.push(r); toDimacs(file, as); }
//=================================================================================================
// Debug etc:
//=================================================================================================
}
#endif

BIN
lstech_maple/lstech/core/Solver.or Executable file
View File

Binary file not shown.

465
lstech_maple/lstech/core/SolverTypes.h Executable file
View File

@ -0,0 +1,465 @@
/***********************************************************************************[SolverTypes.h]
MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
Copyright (c) 2007-2010, Niklas Sorensson
Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
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_SolverTypes_h
#define Minisat_SolverTypes_h
#include <assert.h>
#include "mtl/IntTypes.h"
#include "mtl/Alg.h"
#include "mtl/Vec.h"
#include "mtl/Map.h"
#include "mtl/Alloc.h"
#include <iostream>
namespace Minisat {
//=================================================================================================
// 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)
struct Lit {
int x;
// Use this as a constructor:
friend Lit mkLit(Var var, bool sign );
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; } // '<' makes p, ~p adjacent in the ordering.
};
inline Lit mkLit (Var var, bool sign= false) { Lit p; p.x = var + var + (int)sign; return p; }
inline Lit operator ~(Lit p) { Lit q; q.x = p.x ^ 1; return q; }
inline Lit operator ^(Lit p, bool b) { Lit q; q.x = p.x ^ (unsigned int)b; return q; }
inline bool sign (Lit p) { return p.x & 1; }
inline int var (Lit p) { return p.x >> 1; }
// Mapping Literals to and from compact integers suitable for array indexing:
inline int toInt (Var v) { return v; }
inline int toInt (Lit p) { return p.x; }
inline Lit toLit (int i) { Lit p; p.x = i; return p; }
//const Lit lit_Undef = mkLit(var_Undef, false); // }- Useful special constants.
//const Lit lit_Error = mkLit(var_Undef, true ); // }
const Lit lit_Undef = { -2 }; // }- Useful special constants.
const Lit lit_Error = { -1 }; // }
inline int toFormal(Lit p) { return sign(p) ? -var(p) - 1 : var(p) + 1; }
inline std::ostream& operator<<(std::ostream& out, const Lit& val)
{
out << (sign(val) ? -var(val) : var(val)) << std::flush;
return out;
}
//=================================================================================================
// Lifted booleans:
//
// NOTE: this implementation is optimized for the case when comparisons between values are mostly
// between one variable and one constant. Some care had to be taken to make sure that gcc
// does enough constant propagation to produce sensible code, and this appears to be somewhat
// fragile unfortunately.
#define l_True (lbool((uint8_t)0)) // gcc does not do constant propagation if these are real constants.
#define l_False (lbool((uint8_t)1))
#define l_Undef (lbool((uint8_t)2))
class lbool {
uint8_t value;
public:
explicit lbool(uint8_t v) : value(v) { }
lbool() : value(0) { }
explicit lbool(bool x) : value(!x) { }
bool operator == (lbool b) const { return ((b.value&2) & (value&2)) | (!(b.value&2)&(value == b.value)); }
bool operator != (lbool b) const { return !(*this == b); }
lbool operator ^ (bool b) const { return lbool((uint8_t)(value^(uint8_t)b)); }
lbool operator && (lbool b) const {
uint8_t sel = (this->value << 1) | (b.value << 3);
uint8_t v = (0xF7F755F4 >> sel) & 3;
return lbool(v); }
lbool operator || (lbool b) const {
uint8_t sel = (this->value << 1) | (b.value << 3);
uint8_t v = (0xFCFCF400 >> sel) & 3;
return lbool(v); }
friend int toInt (lbool l);
friend lbool toLbool(int v);
};
inline int toInt (lbool l) { return l.value; }
inline lbool toLbool(int v) { return lbool((uint8_t)v); }
//=================================================================================================
// Clause -- a simple class for representing a clause:
class Clause;
typedef RegionAllocator<uint32_t>::Ref CRef;
class Clause {
struct {
unsigned mark : 2;
unsigned learnt : 1;
unsigned has_extra : 1;
unsigned reloced : 1;
unsigned lbd : 26;
unsigned removable : 1;
unsigned size : 32;
//simplify
unsigned simplified : 1;} header;
union { Lit lit; float act; uint32_t abs; uint32_t touched; CRef rel; } data[0];
friend class ClauseAllocator;
// NOTE: This constructor cannot be used directly (doesn't allocate enough memory).
template<class V>
Clause(const V& ps, bool use_extra, bool learnt) {
header.mark = 0;
header.learnt = learnt;
header.has_extra = learnt | use_extra;
header.reloced = 0;
header.size = ps.size();
header.lbd = 0;
header.removable = 1;
//simplify
//
header.simplified = 0;
for (int i = 0; i < ps.size(); i++)
data[i].lit = ps[i];
if (header.has_extra){
if (header.learnt){
data[header.size].act = 0;
data[header.size+1].touched = 0;
}else
calcAbstraction(); }
}
public:
void calcAbstraction() {
assert(header.has_extra);
uint32_t abstraction = 0;
for (int i = 0; i < size(); i++)
abstraction |= 1 << (var(data[i].lit) & 31);
data[header.size].abs = abstraction; }
int size () const { return header.size; }
void shrink (int i) { assert(i <= size()); if (header.has_extra) data[header.size-i] = data[header.size]; header.size -= i; }
void pop () { shrink(1); }
bool learnt () const { return header.learnt; }
bool has_extra () const { return header.has_extra; }
uint32_t mark () const { return header.mark; }
void mark (uint32_t m) { header.mark = m; }
const Lit& last () const { return data[header.size-1].lit; }
bool reloced () const { return header.reloced; }
CRef relocation () const { return data[0].rel; }
void relocate (CRef c) { header.reloced = 1; data[0].rel = c; }
int lbd () const { return header.lbd; }
void set_lbd (int lbd) { header.lbd = lbd; }
bool removable () const { return header.removable; }
void removable (bool b) { header.removable = b; }
// 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; }
Lit operator [] (int i) const { return data[i].lit; }
operator const Lit* (void) const { return (Lit*)data; }
uint32_t& touched () { assert(header.has_extra && header.learnt); return data[header.size+1].touched; }
float& activity () { assert(header.has_extra); return data[header.size].act; }
uint32_t abstraction () const { assert(header.has_extra); return data[header.size].abs; }
Lit subsumes (const Clause& other) const;
void strengthen (Lit p);
// simplify
//
void setSimplified(bool b) { header.simplified = b; }
bool simplified() { return header.simplified; }
};
//=================================================================================================
// ClauseAllocator -- a simple class for allocating memory for clauses:
const CRef CRef_Undef = RegionAllocator<uint32_t>::Ref_Undef;
class ClauseAllocator : public RegionAllocator<uint32_t>
{
static int clauseWord32Size(int size, int extras){
return (sizeof(Clause) + (sizeof(Lit) * (size + extras))) / sizeof(uint32_t); }
public:
bool extra_clause_field;
ClauseAllocator(uint32_t start_cap) : RegionAllocator<uint32_t>(start_cap), extra_clause_field(false){}
ClauseAllocator() : extra_clause_field(false){}
void moveTo(ClauseAllocator& to){
to.extra_clause_field = extra_clause_field;
RegionAllocator<uint32_t>::moveTo(to); }
template<class Lits>
CRef alloc(const Lits& ps, bool learnt = false)
{
assert(sizeof(Lit) == sizeof(uint32_t));
assert(sizeof(float) == sizeof(uint32_t));
int extras = learnt ? 2 : (int)extra_clause_field;
CRef cid = RegionAllocator<uint32_t>::alloc(clauseWord32Size(ps.size(), extras));
new (lea(cid)) Clause(ps, extra_clause_field, learnt);
return cid;
}
// Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
Clause& operator[](Ref r) { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
const Clause& operator[](Ref r) const { return (Clause&)RegionAllocator<uint32_t>::operator[](r); }
Clause* lea (Ref r) { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
const Clause* lea (Ref r) const { return (Clause*)RegionAllocator<uint32_t>::lea(r); }
Ref ael (const Clause* t){ return RegionAllocator<uint32_t>::ael((uint32_t*)t); }
void free(CRef cid)
{
Clause& c = operator[](cid);
int extras = c.learnt() ? 2 : (int)c.has_extra();
RegionAllocator<uint32_t>::free(clauseWord32Size(c.size(), extras));
}
void reloc(CRef& cr, ClauseAllocator& to)
{
Clause& c = operator[](cr);
if (c.reloced()) { cr = c.relocation(); return; }
cr = to.alloc(c, c.learnt());
c.relocate(cr);
// Copy extra data-fields:
// (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
to[cr].mark(c.mark());
if (to[cr].learnt()){
to[cr].touched() = c.touched();
to[cr].activity() = c.activity();
to[cr].set_lbd(c.lbd());
to[cr].removable(c.removable());
// simplify
//
to[cr].setSimplified(c.simplified());
}
else if (to[cr].has_extra()) to[cr].calcAbstraction();
}
};
inline std::ostream& operator<<(std::ostream& out, const Clause& cls)
{
for (int i = 0; i < cls.size(); ++i)
{
out << cls[i] << " ";
}
return out;
}
//=================================================================================================
// OccLists -- a class for maintaining occurence lists with lazy deletion:
template<class Idx, class Vec, class Deleted>
class OccLists
{
vec<Vec> occs;
vec<char> dirty;
vec<Idx> dirties;
Deleted deleted;
public:
OccLists(const Deleted& d) : deleted(d) {}
void init (const Idx& idx){ occs.growTo(toInt(idx)+1); dirty.growTo(toInt(idx)+1, 0); }
// Vec& operator[](const Idx& idx){ return occs[toInt(idx)]; }
Vec& operator[](const Idx& idx){ return occs[toInt(idx)]; }
Vec& lookup (const Idx& idx){ if (dirty[toInt(idx)]) clean(idx); return occs[toInt(idx)]; }
void cleanAll ();
void clean (const Idx& idx);
void smudge (const Idx& idx){
if (dirty[toInt(idx)] == 0){
dirty[toInt(idx)] = 1;
dirties.push(idx);
}
}
void clear(bool free = true){
occs .clear(free);
dirty .clear(free);
dirties.clear(free);
}
};
template<class Idx, class Vec, class Deleted>
void OccLists<Idx,Vec,Deleted>::cleanAll()
{
for (int i = 0; i < dirties.size(); i++)
// Dirties may contain duplicates so check here if a variable is already cleaned:
if (dirty[toInt(dirties[i])])
clean(dirties[i]);
dirties.clear();
}
template<class Idx, class Vec, class Deleted>
void OccLists<Idx,Vec,Deleted>::clean(const Idx& idx)
{
Vec& vec = occs[toInt(idx)];
int i, j;
for (i = j = 0; i < vec.size(); i++)
if (!deleted(vec[i]))
vec[j++] = vec[i];
vec.shrink(i - j);
dirty[toInt(idx)] = 0;
}
//=================================================================================================
// CMap -- a class for mapping clauses to values:
template<class T>
class CMap
{
struct CRefHash {
uint32_t operator()(CRef cr) const { return (uint32_t)cr; } };
typedef Map<CRef, T, CRefHash> HashTable;
HashTable map;
public:
// Size-operations:
void clear () { map.clear(); }
int size () const { return map.elems(); }
// Insert/Remove/Test mapping:
void insert (CRef cr, const T& t){ map.insert(cr, t); }
void growTo (CRef cr, const T& t){ map.insert(cr, t); } // NOTE: for compatibility
void remove (CRef cr) { map.remove(cr); }
bool has (CRef cr, T& t) { return map.peek(cr, t); }
// Vector interface (the clause 'c' must already exist):
const T& operator [] (CRef cr) const { return map[cr]; }
T& operator [] (CRef cr) { return map[cr]; }
// Iteration (not transparent at all at the moment):
int bucket_count() const { return map.bucket_count(); }
const vec<typename HashTable::Pair>& bucket(int i) const { return map.bucket(i); }
// Move contents to other map:
void moveTo(CMap& other){ map.moveTo(other.map); }
// TMP debug:
void debug(){
printf("c --- size = %d, bucket_count = %d\n", size(), map.bucket_count()); }
};
/*_________________________________________________________________________________________________
|
| 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)
//if (other.size() < size() || (!learnt() && !other.learnt() && (extra.abst & ~other.extra.abst) != 0))
assert(!header.learnt); assert(!other.header.learnt);
assert(header.has_extra); assert(other.header.has_extra);
if (other.header.size < header.size || (data[header.size].abs & ~other.data[other.header.size].abs) != 0)
return lit_Error;
Lit ret = lit_Undef;
const Lit* c = (const Lit*)(*this);
const Lit* d = (const Lit*)other;
for (unsigned i = 0; i < header.size; i++) {
// search for c[i] or ~c[i]
for (unsigned j = 0; j < other.header.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

84
lstech_maple/lstech/mtl/Alg.h Executable file
View File

@ -0,0 +1,84 @@
/*******************************************************************************************[Alg.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_Alg_h
#define Minisat_Alg_h
#include "mtl/Vec.h"
namespace Minisat {
//=================================================================================================
// Useful functions on vector-like types:
//=================================================================================================
// Removing and searching for elements:
//
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();
}
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();
}
//=================================================================================================
// Copying vectors with support for nested vector types:
//
// Base case:
template<class T>
static inline void copy(const T& from, T& to)
{
to = from;
}
// Recursive case:
template<class T>
static inline void copy(const vec<T>& from, vec<T>& to, bool append = false)
{
if (!append)
to.clear();
for (int i = 0; i < from.size(); i++){
to.push();
copy(from[i], to.last());
}
}
template<class T>
static inline void append(const vec<T>& from, vec<T>& to){ copy(from, to, true); }
//=================================================================================================
}
#endif

131
lstech_maple/lstech/mtl/Alloc.h Executable file
View File

@ -0,0 +1,131 @@
/*****************************************************************************************[Alloc.h]
Copyright (c) 2008-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_Alloc_h
#define Minisat_Alloc_h
#include "mtl/XAlloc.h"
#include "mtl/Vec.h"
namespace Minisat {
//=================================================================================================
// Simple Region-based memory allocator:
template<class T>
class RegionAllocator
{
T* memory;
uint32_t sz;
uint32_t cap;
uint32_t wasted_;
void capacity(uint32_t min_cap);
public:
// TODO: make this a class for better type-checking?
typedef uint32_t Ref;
enum { Ref_Undef = UINT32_MAX };
enum { Unit_Size = sizeof(uint32_t) };
explicit RegionAllocator(uint32_t start_cap = 1024*1024) : memory(NULL), sz(0), cap(0), wasted_(0){ capacity(start_cap); }
~RegionAllocator()
{
if (memory != NULL)
::free(memory);
}
uint32_t size () const { return sz; }
uint32_t wasted () const { return wasted_; }
Ref alloc (int size);
void free (int size) { wasted_ += size; }
// Deref, Load Effective Address (LEA), Inverse of LEA (AEL):
T& operator[](Ref r) { assert(r >= 0 && r < sz); return memory[r]; }
const T& operator[](Ref r) const { assert(r >= 0 && r < sz); return memory[r]; }
T* lea (Ref r) { assert(r >= 0 && r < sz); return &memory[r]; }
const T* lea (Ref r) const { assert(r >= 0 && r < sz); return &memory[r]; }
Ref ael (const T* t) { assert((void*)t >= (void*)&memory[0] && (void*)t < (void*)&memory[sz-1]);
return (Ref)(t - &memory[0]); }
void moveTo(RegionAllocator& to) {
if (to.memory != NULL) ::free(to.memory);
to.memory = memory;
to.sz = sz;
to.cap = cap;
to.wasted_ = wasted_;
memory = NULL;
sz = cap = wasted_ = 0;
}
};
template<class T>
void RegionAllocator<T>::capacity(uint32_t min_cap)
{
if (cap >= min_cap) return;
uint32_t prev_cap = cap;
while (cap < min_cap){
// NOTE: Multiply by a factor (13/8) without causing overflow, then add 2 and make the
// result even by clearing the least significant bit. The resulting sequence of capacities
// is carefully chosen to hit a maximum capacity that is close to the '2^32-1' limit when
// using 'uint32_t' as indices so that as much as possible of this space can be used.
uint32_t delta = ((cap >> 1) + (cap >> 3) + 2) & ~1;
cap += delta;
if (cap <= prev_cap)
throw OutOfMemoryException();
}
// printf(" .. (%p) cap = %u\n", this, cap);
assert(cap > 0);
memory = (T*)xrealloc(memory, sizeof(T)*cap);
}
template<class T>
typename RegionAllocator<T>::Ref
RegionAllocator<T>::alloc(int size)
{
// printf("ALLOC called (this = %p, size = %d)\n", this, size); fflush(stdout);
assert(size > 0);
capacity(sz + size);
uint32_t prev_sz = sz;
sz += size;
// Handle overflow:
if (sz < prev_sz)
throw OutOfMemoryException();
return prev_sz;
}
//=================================================================================================
}
#endif

148
lstech_maple/lstech/mtl/Heap.h Executable file
View File

@ -0,0 +1,148 @@
/******************************************************************************************[Heap.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_Heap_h
#define Minisat_Heap_h
#include "mtl/Vec.h"
namespace Minisat {
//=================================================================================================
// A heap implementation with support for decrease/increase key.
template<class Comp>
class Heap {
Comp lt; // The heap is a minimum-heap with respect to this comparator
vec<int> heap; // Heap of integers
vec<int> indices; // Each integers position (index) in the 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; }
void percolateUp(int i)
{
int x = heap[i];
int p = parent(i);
while (i != 0 && lt(x, heap[p])){
heap[i] = heap[p];
indices[heap[p]] = i;
i = p;
p = parent(p);
}
heap [i] = x;
indices[x] = i;
}
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;
}
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]); }
void increase (int n) { assert(inHeap(n)); percolateDown(indices[n]); }
// Safe variant of insert/decrease/increase:
void update(int n)
{
if (!inHeap(n))
insert(n);
else {
percolateUp(indices[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;
}
// Rebuild the heap from scratch, using the elements in 'ns':
void build(const vec<int>& ns) {
for (int i = 0; i < heap.size(); i++)
indices[heap[i]] = -1;
heap.clear();
for (int i = 0; i < ns.size(); i++){
indices[ns[i]] = i;
heap.push(ns[i]); }
for (int i = heap.size() / 2 - 1; i >= 0; i--)
percolateDown(i);
}
void clear(bool dealloc = false)
{
for (int i = 0; i < heap.size(); i++)
indices[heap[i]] = -1;
heap.clear(dealloc);
}
};
//=================================================================================================
}
#endif

42
lstech_maple/lstech/mtl/IntTypes.h Executable file
View File

@ -0,0 +1,42 @@
/**************************************************************************************[IntTypes.h]
Copyright (c) 2009-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_IntTypes_h
#define Minisat_IntTypes_h
#ifdef __sun
// Not sure if there are newer versions that support C99 headers. The
// needed features are implemented in the headers below though:
# include <sys/int_types.h>
# include <sys/int_fmtio.h>
# include <sys/int_limits.h>
#else
# include <stdint.h>
# include <inttypes.h>
#endif
#include <limits.h>
//=================================================================================================
#endif

193
lstech_maple/lstech/mtl/Map.h Executable file
View File

@ -0,0 +1,193 @@
/*******************************************************************************************[Map.h]
Copyright (c) 2006-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_Map_h
#define Minisat_Map_h
#include "mtl/IntTypes.h"
#include "mtl/Vec.h"
namespace Minisat {
//=================================================================================================
// 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; } };
static inline uint32_t hash(uint32_t x){ return x; }
static inline uint32_t hash(uint64_t x){ return (uint32_t)x; }
static inline uint32_t hash(int32_t x) { return (uint32_t)x; }
static inline uint32_t hash(int64_t x) { return (uint32_t)x; }
//=================================================================================================
// 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 {
public:
struct Pair { K key; D data; };
private:
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); }
bool checkCap(int new_size) const { return new_size > cap; }
int32_t index (const K& k) const { return hash(k) % cap; }
void _insert (const K& k, const D& d) {
vec<Pair>& ps = table[index(k)];
ps.push(); ps.last().key = k; ps.last().data = d; }
void rehash () {
const vec<Pair>* old = table;
int old_cap = cap;
int newsize = primes[0];
for (int i = 1; newsize <= cap && i < nprimes; i++)
newsize = primes[i];
table = new vec<Pair>[newsize];
cap = newsize;
for (int i = 0; i < old_cap; i++){
for (int j = 0; j < old[i].size(); j++){
_insert(old[i][j].key, old[i][j].data); }}
delete [] old;
// printf(" --- rehashing, old-cap=%d, new-cap=%d\n", cap, newsize);
}
public:
Map () : table(NULL), cap(0), size(0) {}
Map (const H& h, const E& e) : hash(h), equals(e), table(NULL), cap(0), size(0){}
~Map () { delete [] table; }
// PRECONDITION: the key must already exist in the map.
const D& operator [] (const K& k) const
{
assert(size != 0);
const D* res = NULL;
const vec<Pair>& ps = table[index(k)];
for (int i = 0; i < ps.size(); i++)
if (equals(ps[i].key, k))
res = &ps[i].data;
assert(res != NULL);
return *res;
}
// PRECONDITION: the key must already exist in the map.
D& operator [] (const K& k)
{
assert(size != 0);
D* res = NULL;
vec<Pair>& ps = table[index(k)];
for (int i = 0; i < ps.size(); i++)
if (equals(ps[i].key, k))
res = &ps[i].data;
assert(res != NULL);
return *res;
}
// PRECONDITION: the key must *NOT* exist in the map.
void insert (const K& k, const D& d) { if (checkCap(size+1)) rehash(); _insert(k, d); size++; }
bool peek (const K& k, D& d) const {
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;
}
bool has (const K& k) const {
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))
return true;
return false;
}
// PRECONDITION: the key must exist in the map.
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();
size--;
}
void clear () {
cap = size = 0;
delete [] table;
table = NULL;
}
int elems() const { return size; }
int bucket_count() const { return cap; }
// NOTE: the hash and equality objects are not moved by this method:
void moveTo(Map& other){
delete [] other.table;
other.table = table;
other.cap = cap;
other.size = size;
table = NULL;
size = cap = 0;
}
// NOTE: given a bit more time, I could make a more C++-style iterator out of this:
const vec<Pair>& bucket(int i) const { return table[i]; }
};
//=================================================================================================
}
#endif

69
lstech_maple/lstech/mtl/Queue.h Executable file
View File

@ -0,0 +1,69 @@
/*****************************************************************************************[Queue.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_Queue_h
#define Minisat_Queue_h
#include "mtl/Vec.h"
namespace Minisat {
//=================================================================================================
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 (bool dealloc = false) { buf.clear(dealloc); buf.growTo(1); first = end = 0; }
int size () const { return (end >= first) ? end - first : end - first + buf.size(); }
const T& operator [] (int index) const { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
T& operator [] (int index) { assert(index >= 0); assert(index < size()); return buf[(first + index) % buf.size()]; }
T peek () const { 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

98
lstech_maple/lstech/mtl/Sort.h Executable file
View File

@ -0,0 +1,98 @@
/******************************************************************************************[Sort.h]
Copyright (c) 2003-2007, 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_Sort_h
#define Minisat_Sort_h
#include "mtl/Vec.h"
//=================================================================================================
// Some sorting algorithms for vec's
namespace Minisat {
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

130
lstech_maple/lstech/mtl/Vec.h Executable file
View File

@ -0,0 +1,130 @@
/*******************************************************************************************[Vec.h]
Copyright (c) 2003-2007, 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_Vec_h
#define Minisat_Vec_h
#include <assert.h>
#include <new>
#include "mtl/IntTypes.h"
#include "mtl/XAlloc.h"
namespace Minisat {
//=================================================================================================
// 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;
// Don't allow copying (error prone):
vec<T>& operator = (vec<T>& other) { assert(0); return *this; }
vec (vec<T>& other) { assert(0); }
// Helpers for calculating next capacity:
static inline int imax (int x, int y) { int mask = (y-x) >> (sizeof(int)*8-1); return (x&mask) + (y&(~mask)); }
//static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
static inline void nextCap(int& cap){ cap += ((cap >> 1) + 2) & ~1; }
public:
// Constructors:
vec() : data(NULL) , sz(0) , cap(0) { }
explicit 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() { clear(true); }
// Pointer to first element:
operator T* (void) { 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; }
int capacity (void) const { return cap; }
void capacity (int min_cap);
void growTo (int size);
void growTo (int size, const T& pad);
void clear (bool dealloc = false);
// Stack interface:
void push (void) { if (sz == cap) capacity(sz+1); new (&data[sz]) T(); sz++; }
void push (const T& elem) { if (sz == cap) capacity(sz+1); data[sz++] = elem; }
void push_ (const T& elem) { assert(sz < cap); data[sz++] = elem; }
void pop (void) { assert(sz > 0); sz--, data[sz].~T(); }
// NOTE: it seems possible that overflow can happen in the 'sz+1' expression of 'push()', but
// in fact it can not since it requires that 'cap' is equal to INT_MAX. This in turn can not
// happen given the way capacities are calculated (below). Essentially, all capacities are
// even, but INT_MAX is odd.
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++) copy[i] = 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>::capacity(int min_cap) {
if (cap >= min_cap) return;
int add = imax((min_cap - cap + 1) & ~1, ((cap >> 1) + 2) & ~1); // NOTE: grow by approximately 3/2
if (add > INT_MAX - cap || ((data = (T*)::realloc(data, (cap += add) * sizeof(T))) == NULL) && errno == ENOMEM)
throw OutOfMemoryException();
}
template<class T>
void vec<T>::growTo(int size, const T& pad) {
if (sz >= size) return;
capacity(size);
for (int i = sz; i < size; i++) data[i] = pad;
sz = size; }
template<class T>
void vec<T>::growTo(int size) {
if (sz >= size) return;
capacity(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

45
lstech_maple/lstech/mtl/XAlloc.h Executable file
View File

@ -0,0 +1,45 @@
/****************************************************************************************[XAlloc.h]
Copyright (c) 2009-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_XAlloc_h
#define Minisat_XAlloc_h
#include <errno.h>
#include <stdlib.h>
namespace Minisat {
//=================================================================================================
// Simple layer on top of malloc/realloc to catch out-of-memory situtaions and provide some typing:
class OutOfMemoryException{};
static inline void* xrealloc(void *ptr, size_t size)
{
void* mem = realloc(ptr, size);
if (mem == NULL && errno == ENOMEM){
throw OutOfMemoryException();
}else
return mem;
}
//=================================================================================================
}
#endif

6
lstech_maple/lstech/mtl/config.mk Executable file
View File

@ -0,0 +1,6 @@
##
## This file is for system specific configurations. For instance, on
## some systems the path to zlib needs to be added. Example:
##
## CFLAGS += -I/usr/local/include
## LFLAGS += -L/usr/local/lib

107
lstech_maple/lstech/mtl/template.mk Executable file
View File

@ -0,0 +1,107 @@
##
## 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)
PWD = $(shell pwd)
EXEC ?= $(notdir $(PWD))
CSRCS = $(wildcard $(PWD)/*.cc)
DSRCS = $(foreach dir, $(DEPDIR), $(filter-out $(MROOT)/$(dir)/Main.cc, $(wildcard $(MROOT)/$(dir)/*.cc)))
CHDRS = $(wildcard $(PWD)/*.h)
COBJS = $(CSRCS:.cc=.o) $(DSRCS:.cc=.o)
PCOBJS = $(addsuffix p, $(COBJS))
DCOBJS = $(addsuffix d, $(COBJS))
RCOBJS = $(addsuffix r, $(COBJS))
CXX ?= g++
CFLAGS ?= -Wall -Wno-parentheses -std=c++11
LFLAGS ?= -Wall
COPTIMIZE ?= -O3
CFLAGS += -I$(MROOT) -D __STDC_LIMIT_MACROS -D __STDC_FORMAT_MACROS
LFLAGS += -lz
.PHONY : s p d r rs clean
s: $(EXEC)
p: $(EXEC)_profile
d: $(EXEC)_debug
r: $(EXEC)_release
rs: $(EXEC)_static
libs: lib$(LIB)_standard.a
libp: lib$(LIB)_profile.a
libd: lib$(LIB)_debug.a
libr: lib$(LIB)_release.a
## Compile options
%.o: CFLAGS +=$(COPTIMIZE) -g -D DEBUG
%.op: CFLAGS +=$(COPTIMIZE) -pg -g -D NDEBUG
%.od: CFLAGS +=-O0 -g -D DEBUG
%.or: CFLAGS +=$(COPTIMIZE) -g -D NDEBUG
## Link options
$(EXEC): LFLAGS += -g
$(EXEC)_profile: LFLAGS += -g -pg
$(EXEC)_debug: LFLAGS += -g
#$(EXEC)_release: LFLAGS += ...
$(EXEC)_static: LFLAGS += --static
## Dependencies
$(EXEC): $(COBJS)
$(EXEC)_profile: $(PCOBJS)
$(EXEC)_debug: $(DCOBJS)
$(EXEC)_release: $(RCOBJS)
$(EXEC)_static: $(RCOBJS)
lib$(LIB)_standard.a: $(filter-out */Main.o, $(COBJS))
lib$(LIB)_profile.a: $(filter-out */Main.op, $(PCOBJS))
lib$(LIB)_debug.a: $(filter-out */Main.od, $(DCOBJS))
lib$(LIB)_release.a: $(filter-out */Main.or, $(RCOBJS))
## Build rule
%.o %.op %.od %.or: %.cc
@echo Compiling: $(subst $(MROOT)/,,$@)
@$(CXX) $(CFLAGS) -c -o $@ $<
## Linking rules (standard/profile/debug/release)
$(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static:
@echo Linking: "$@ ( $(foreach f,$^,$(subst $(MROOT)/,,$f)) )"
@$(CXX) $^ $(LFLAGS) -o $@
## Library rules (standard/profile/debug/release)
lib$(LIB)_standard.a lib$(LIB)_profile.a lib$(LIB)_release.a lib$(LIB)_debug.a:
@echo Making library: "$@ ( $(foreach f,$^,$(subst $(MROOT)/,,$f)) )"
@$(AR) -rcsv $@ $^
## Library Soft Link rule:
libs libp libd libr:
@echo "Making Soft Link: $^ -> lib$(LIB).a"
@ln -sf $^ lib$(LIB).a
## Clean rule
clean:
@rm -f $(EXEC) $(EXEC)_profile $(EXEC)_debug $(EXEC)_release $(EXEC)_static \
$(COBJS) $(PCOBJS) $(DCOBJS) $(RCOBJS) *.core depend.mk
## Make dependencies
depend.mk: $(CSRCS) $(CHDRS)
@echo Making dependencies
@$(CXX) $(CFLAGS) -I$(MROOT) \
$(CSRCS) -MM | sed 's|\(.*\):|$(PWD)/\1 $(PWD)/\1r $(PWD)/\1d $(PWD)/\1p:|' > depend.mk
@for dir in $(DEPDIR); do \
if [ -r $(MROOT)/$${dir}/depend.mk ]; then \
echo Depends on: $${dir}; \
cat $(MROOT)/$${dir}/depend.mk >> depend.mk; \
fi; \
done
-include $(MROOT)/mtl/config.mk
-include depend.mk

266
lstech_maple/lstech/simp/Main.cc Executable file
View File

@ -0,0 +1,266 @@
/*****************************************************************************************[Main.cc]
Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
Copyright (c) 2007, Niklas Sorensson
Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c), Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121.
MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c), Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters.
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 <sys/resource.h>
#include "utils/System.h"
#include "utils/ParseUtils.h"
#include "utils/Options.h"
#include "core/Dimacs.h"
#include "simp/SimpSolver.h"
using namespace Minisat;
//=================================================================================================
void printStats(Solver& solver)
{
double cpu_time = cpuTime();
double mem_used = memUsedPeak();
printf("c restarts : %"PRIu64"\n", solver.starts);
printf("c duplicate learnts_cnf : %"PRIu64"\n", solver.duplicates_added_conflicts);
printf("c duplicate learnts_min : %"PRIu64"\n", solver.duplicates_added_minimization);
printf("c conflicts : %-12"PRIu64" (%.0f /sec)\n", solver.conflicts , solver.conflicts /cpu_time);
printf("c decisions : %-12"PRIu64" (%4.2f %% random) (%.0f /sec)\n", solver.decisions, (float)solver.rnd_decisions*100 / (float)solver.decisions, solver.decisions /cpu_time);
printf("c propagations : %-12"PRIu64" (%.0f /sec)\n", solver.propagations, solver.propagations/cpu_time);
printf("c conflict literals : %-12"PRIu64" (%4.2f %% deleted)\n", solver.tot_literals, (solver.max_literals - solver.tot_literals)*100 / (double)solver.max_literals);
printf("c backtracks : %-12"PRIu64" (NCB %0.f%% , CB %0.f%%)\n", solver.non_chrono_backtrack + solver.chrono_backtrack, (solver.non_chrono_backtrack * 100) / (double)(solver.non_chrono_backtrack + solver.chrono_backtrack), (solver.chrono_backtrack * 100) / (double)(solver.non_chrono_backtrack + solver.chrono_backtrack));
if (mem_used != 0) printf("c Memory used : %.2f MB\n", mem_used);
printf("c 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("c *** INTERRUPTED ***\n");
if (solver->verbosity > 0){
printStats(*solver);
printf("\n"); printf("c *** 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("c This is MapleLCMDistChronoBT-DL.\n");
#if defined(__linux__)
fpu_control_t oldcw, newcw;
_FPU_GETCW(oldcw); newcw = (oldcw & ~_FPU_EXTENDED) | _FPU_DOUBLE; _FPU_SETCW(newcw);
printf("c 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));
BoolOption pre ("MAIN", "pre", "Completely turn on/off any preprocessing.", true);
StringOption dimacs ("MAIN", "dimacs", "If given, stop after preprocessing and write the result to this file.");
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));
BoolOption drup ("MAIN", "drup", "Generate DRUP UNSAT proof.", false);
StringOption drup_file("MAIN", "drup-file", "DRUP UNSAT proof ouput file.", "");
parseOptions(argc, argv, true);
SimpSolver S;
double initial_time = cpuTime();
if (!pre) S.eliminate(true);
S.parsing = true;
S.verbosity = verb;
S.drup_file = NULL;
if (drup || strlen(drup_file)){
S.drup_file = strlen(drup_file) ? fopen(drup_file, "wb") : stdout;
if (S.drup_file == NULL){
S.drup_file = stdout;
printf("c Error opening %s for write.\n", (const char*) drup_file); }
printf("c DRUP proof generation: %s\n", S.drup_file == stdout ? "stdout" : drup_file);
}
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("c 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("c WARNING! Could not set resource limit: Virtual memory.\n");
} }
if (argc == 1)
printf("c Reading from standard input... Use '--help' for help.\n");
gzFile in = (argc == 1) ? gzdopen(0, "rb") : gzopen(argv[1], "rb");
if (in == NULL)
printf("c ERROR! Could not open file: %s\n", argc == 1 ? "<stdin>" : argv[1]), exit(1);
if (S.verbosity > 0){
printf("c ============================[ Problem Statistics ]=============================\n");
printf("c | |\n"); }
parse_DIMACS(in, S);
gzclose(in);
FILE* res = (argc >= 3) ? fopen(argv[2], "wb") : NULL;
if (S.verbosity > 0){
printf("c | Number of variables: %12d |\n", S.nVars());
printf("c | Number of clauses: %12d |\n", S.nClauses()); }
double parsed_time = cpuTime();
if (S.verbosity > 0)
printf("c | Parse time: %12.2f s |\n", parsed_time - initial_time);
// Change to signal-handlers that will only notify the solver and allow it to terminate
// voluntarily:
signal(SIGINT, SIGINT_interrupt);
signal(SIGXCPU,SIGINT_interrupt);
S.parsing = false;
S.eliminate(true);
double simplified_time = cpuTime();
if (S.verbosity > 0){
printf("c | Simplification time: %12.2f s |\n", simplified_time - parsed_time);
printf("c | |\n"); }
if (!S.okay()){
if (res != NULL) fprintf(res, "UNSAT\n"), fclose(res);
if (S.verbosity > 0){
printf("c ===============================================================================\n");
printf("c Solved by simplification\n");
printStats(S);
printf("\n"); }
printf("s UNSATISFIABLE\n");
if (S.drup_file){
#ifdef BIN_DRUP
fputc('a', S.drup_file); fputc(0, S.drup_file);
#else
fprintf(S.drup_file, "0\n");
#endif
}
if (S.drup_file && S.drup_file != stdout) fclose(S.drup_file);
exit(20);
}
if (dimacs){
if (S.verbosity > 0)
printf("c ==============================[ Writing DIMACS ]===============================\n");
S.toDimacs((const char*)dimacs);
if (S.verbosity > 0)
printStats(S);
exit(0);
}
vec<Lit> dummy;
lbool ret = S.solveLimited(dummy);
if (S.verbosity > 0){
printStats(S);
printf("\n"); }
printf(ret == l_True ? "s SATISFIABLE\n" : ret == l_False ? "s UNSATISFIABLE\n" : "s UNKNOWN\n");
if (ret == l_True){
// check_solution_DIMACS(in, S);
// printf("%d",S.nVars());
printf("v ");
for (int i = 0; i < S.nVars(); i++)
if (S.model[i] != l_Undef)
printf("%s%s%d", (i==0)?"":" ", (S.model[i]==l_True)?"":"-", i+1);
printf(" 0\n");
}
if (S.drup_file && ret == l_False){
#ifdef BIN_DRUP
fputc('a', S.drup_file); fputc(0, S.drup_file);
#else
fprintf(S.drup_file, "0\n");
#endif
}
if (S.drup_file && S.drup_file != stdout) fclose(S.drup_file);
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("c ===============================================================================\n");
printf("c Out of memory\n");
printf("s UNKNOWN\n");
exit(0);
}
}

BIN
lstech_maple/lstech/simp/Main.or Executable file
View File

Binary file not shown.

5
lstech_maple/lstech/simp/Makefile Executable file
View File

@ -0,0 +1,5 @@
EXEC = glucose
DEPDIR = mtl utils core
MROOT = ../
include $(MROOT)/mtl/template.mk

921
lstech_maple/lstech/simp/SimpSolver.cc Executable file
View File

@ -0,0 +1,921 @@
/***************************************************************************************[Solver.cc]
MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
Copyright (c) 2007-2010, Niklas Sorensson
Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c), Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121.
MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c), Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters.
lstech, Relaxed_newTech -- Copyright (c) 2019-2021, Shaowei Cai, Xindi Zhang
Reference: Shaowei Cai, Xindi Zhang: Deep Cooperation of CDCL and Local Search for SAT.
Xindi Zhang, Shaowei Cai: Relaxed Backtracking with Rephasing.
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 "mtl/Sort.h"
#include "simp/SimpSolver.h"
#include "utils/System.h"
using namespace Minisat;
//=================================================================================================
// Options:
static const char* _cat = "SIMP";
static BoolOption opt_use_asymm (_cat, "asymm", "Shrink clauses by asymmetric branching.", false);
static BoolOption opt_use_rcheck (_cat, "rcheck", "Check if a clause is already implied. (costly)", false);
static BoolOption opt_use_elim (_cat, "elim", "Perform variable elimination.", true);
static IntOption opt_grow (_cat, "grow", "Allow a variable elimination step to grow by a number of clauses.", 0);
static IntOption opt_clause_lim (_cat, "cl-lim", "Variables are not eliminated if it produces a resolvent with a length above this limit. -1 means no limit", 20, IntRange(-1, INT32_MAX));
static IntOption opt_subsumption_lim (_cat, "sub-lim", "Do not check if subsumption against a clause larger than this. -1 means no limit.", 1000, IntRange(-1, INT32_MAX));
static DoubleOption opt_simp_garbage_frac(_cat, "simp-gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered during simplification.", 0.5, DoubleRange(0, false, HUGE_VAL, false));
//=================================================================================================
// Constructor/Destructor:
SimpSolver::SimpSolver() :
parsing (false)
, grow (opt_grow)
, clause_lim (opt_clause_lim)
, subsumption_lim (opt_subsumption_lim)
, simp_garbage_frac (opt_simp_garbage_frac)
, use_asymm (opt_use_asymm)
, use_rcheck (opt_use_rcheck)
, use_elim (opt_use_elim)
, merges (0)
, asymm_lits (0)
, eliminated_vars (0)
, elimorder (1)
, use_simplification (true)
, occurs (ClauseDeleted(ca))
, elim_heap (ElimLt(n_occ))
, bwdsub_assigns (0)
, n_touched (0)
{
vec<Lit> dummy(1,lit_Undef);
ca.extra_clause_field = true; // NOTE: must happen before allocating the dummy clause below.
bwdsub_tmpunit = ca.alloc(dummy);
remove_satisfied = false;
}
SimpSolver::~SimpSolver()
{
}
void SimpSolver::varGrowTo(int maxVar) {
for (int v = 0; v < maxVar; v++) {
watches_bin.init(mkLit(v, false));
watches_bin.init(mkLit(v, true ));
watches .init(mkLit(v, false));
watches .init(mkLit(v, true ));
assigns .push(l_Undef);
vardata .push(mkVarData(CRef_Undef, 0));
activity_CHB .push(0);
activity_VSIDS.push(rnd_init_act ? drand(random_seed) * 0.00001 : 0);
picked.push(0);
conflicted.push(0);
almost_conflicted.push(0);
#ifdef ANTI_EXPLORATION
canceled.push(0);
#endif
seen .push(0);
seen2 .push(0);
polarity .push(true);
decision .push();
trail .capacity(v+1);
frozen .push((char)false);
eliminated.push((char)false);
if (use_simplification){
n_occ .push(0);
n_occ .push(0);
occurs .init(v);
touched .push(0);
elim_heap .insert(v);
}
}
int seed = worker_seed;
int index = worker_index;
int number = worker_number;
if (seed != -1) {
int *id;
id = (int *)malloc(sizeof(int) * (maxVar));
for (int i = 0; i < maxVar; i++) id[i] = i;
if (seed) {
unsigned int rseed = seed;
for (int i = 0; i < maxVar; i++) {
int j = rand_r(&rseed) % maxVar;
int x = id[i];
id[i] = id[j];
id[j] = x;
}
}
int block_size = maxVar / number;
int cursor = index * block_size;
for (int v = cursor; v < maxVar; v++) {
setDecisionVar(id[v], true);
}
for (int v = 0; v < cursor; v++) {
setDecisionVar(id[v], true);
}
// printf("c maxVar %d, index:%d number:%d seed:%d\n", maxVar, index, number, seed);
// for (int v = cursor; v < maxVar; v++) {
// printf("%d ", id[v]);
// }
// for (int v = 0; v < cursor; v++) {
// printf("%d ", id[v]);
// }
// puts("");
free(id);
}
else {
for (int v = 0; v < maxVar; v++) {
setDecisionVar(v, true);
}
// printf("c maxVar %d, index:%d number:%d seed:%d\n", maxVar, index, number, seed);
// for (int v = 0; v < maxVar; v++) {
// printf("%d ", v);
// }
// puts("");
}
}
Var SimpSolver::newVar(bool sign, bool dvar) {
Var v = Solver::newVar(sign, dvar);
frozen .push((char)false);
eliminated.push((char)false);
if (use_simplification){
n_occ .push(0);
n_occ .push(0);
occurs .init(v);
touched .push(0);
elim_heap .insert(v);
}
return v; }
lbool SimpSolver::solve_(bool do_simp, bool turn_off_simp)
{
vec<Var> extra_frozen;
lbool result = l_True;
do_simp &= use_simplification;
if (do_simp){
// Assumptions must be temporarily frozen to run variable elimination:
for (int i = 0; i < assumptions.size(); i++){
Var v = var(assumptions[i]);
// If an assumption has been eliminated, remember it.
assert(!isEliminated(v));
if (!frozen[v]){
// Freeze and store.
setFrozen(v, true);
extra_frozen.push(v);
} }
result = lbool(eliminate(turn_off_simp));
}
if (result == l_True)
result = Solver::solve_();
else if (verbosity >= 1)
printf("c ===============================================================================\n");
if (result == l_True)
extendModel();
if (do_simp)
// Unfreeze the assumptions that were frozen:
for (int i = 0; i < extra_frozen.size(); i++)
setFrozen(extra_frozen[i], false);
return result;
}
bool SimpSolver::addClause_(vec<Lit>& ps)
{
#ifndef NDEBUG
for (int i = 0; i < ps.size(); i++)
assert(!isEliminated(var(ps[i])));
#endif
int nclauses = clauses.size();
if (use_rcheck && implied(ps))
return true;
if (!Solver::addClause_(ps))
return false;
if (!parsing && drup_file) {
#ifdef BIN_DRUP
binDRUP('a', ps, drup_file);
#else
for (int i = 0; i < ps.size(); i++)
fprintf(drup_file, "%i ", (var(ps[i]) + 1) * (-2 * sign(ps[i]) + 1));
fprintf(drup_file, "0\n");
#endif
}
if (use_simplification && clauses.size() == nclauses + 1){
CRef cr = clauses.last();
const Clause& c = ca[cr];
// NOTE: the clause is added to the queue immediately and then
// again during 'gatherTouchedClauses()'. If nothing happens
// in between, it will only be checked once. Otherwise, it may
// be checked twice unnecessarily. This is an unfortunate
// consequence of how backward subsumption is used to mimic
// forward subsumption.
subsumption_queue.insert(cr);
for (int i = 0; i < c.size(); i++){
occurs[var(c[i])].push(cr);
n_occ[toInt(c[i])]++;
touched[var(c[i])] = 1;
n_touched++;
if (elim_heap.inHeap(var(c[i])))
elim_heap.increase(var(c[i]));
}
}
return true;
}
void SimpSolver::removeClause(CRef cr)
{
const Clause& c = ca[cr];
if (use_simplification)
for (int i = 0; i < c.size(); i++){
n_occ[toInt(c[i])]--;
updateElimHeap(var(c[i]));
occurs.smudge(var(c[i]));
}
Solver::removeClause(cr);
}
bool SimpSolver::strengthenClause(CRef cr, Lit l)
{
Clause& c = ca[cr];
assert(decisionLevel() == 0);
assert(use_simplification);
// FIX: this is too inefficient but would be nice to have (properly implemented)
// if (!find(subsumption_queue, &c))
subsumption_queue.insert(cr);
if (drup_file){
#ifdef BIN_DRUP
binDRUP_strengthen(c, l, drup_file);
#else
for (int i = 0; i < c.size(); i++)
if (c[i] != l) fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
fprintf(drup_file, "0\n");
#endif
}
if (c.size() == 2){
removeClause(cr);
c.strengthen(l);
}else{
if (drup_file){
#ifdef BIN_DRUP
binDRUP('d', c, drup_file);
#else
fprintf(drup_file, "d ");
for (int i = 0; i < c.size(); i++)
fprintf(drup_file, "%i ", (var(c[i]) + 1) * (-2 * sign(c[i]) + 1));
fprintf(drup_file, "0\n");
#endif
}
detachClause(cr, true);
c.strengthen(l);
attachClause(cr);
remove(occurs[var(l)], cr);
n_occ[toInt(l)]--;
updateElimHeap(var(l));
}
return c.size() == 1 ? enqueue(c[0]) && propagate() == CRef_Undef : true;
}
// Returns FALSE if clause is always satisfied ('out_clause' should not be used).
bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause)
{
merges++;
out_clause.clear();
bool ps_smallest = _ps.size() < _qs.size();
const Clause& ps = ps_smallest ? _qs : _ps;
const Clause& qs = ps_smallest ? _ps : _qs;
for (int i = 0; i < qs.size(); i++){
if (var(qs[i]) != v){
for (int j = 0; j < ps.size(); j++)
if (var(ps[j]) == var(qs[i]))
if (ps[j] == ~qs[i])
return false;
else
goto next;
out_clause.push(qs[i]);
}
next:;
}
for (int i = 0; i < ps.size(); i++)
if (var(ps[i]) != v)
out_clause.push(ps[i]);
return true;
}
// Returns FALSE if clause is always satisfied.
bool SimpSolver::merge(const Clause& _ps, const Clause& _qs, Var v, int& size)
{
merges++;
bool ps_smallest = _ps.size() < _qs.size();
const Clause& ps = ps_smallest ? _qs : _ps;
const Clause& qs = ps_smallest ? _ps : _qs;
const Lit* __ps = (const Lit*)ps;
const Lit* __qs = (const Lit*)qs;
size = ps.size()-1;
for (int i = 0; i < qs.size(); i++){
if (var(__qs[i]) != v){
for (int j = 0; j < ps.size(); j++)
if (var(__ps[j]) == var(__qs[i]))
if (__ps[j] == ~__qs[i])
return false;
else
goto next;
size++;
}
next:;
}
return true;
}
void SimpSolver::gatherTouchedClauses()
{
if (n_touched == 0) return;
int i,j;
for (i = j = 0; i < subsumption_queue.size(); i++)
if (ca[subsumption_queue[i]].mark() == 0)
ca[subsumption_queue[i]].mark(2);
for (i = 0; i < touched.size(); i++)
if (touched[i]){
const vec<CRef>& cs = occurs.lookup(i);
for (j = 0; j < cs.size(); j++)
if (ca[cs[j]].mark() == 0){
subsumption_queue.insert(cs[j]);
ca[cs[j]].mark(2);
}
touched[i] = 0;
}
for (i = 0; i < subsumption_queue.size(); i++)
if (ca[subsumption_queue[i]].mark() == 2)
ca[subsumption_queue[i]].mark(0);
n_touched = 0;
}
bool SimpSolver::implied(const vec<Lit>& c)
{
assert(decisionLevel() == 0);
trail_lim.push(trail.size());
for (int i = 0; i < c.size(); i++)
if (value(c[i]) == l_True){
cancelUntil(0);
return true;
}else if (value(c[i]) != l_False){
assert(value(c[i]) == l_Undef);
uncheckedEnqueue(~c[i]);
}
bool result = propagate() != CRef_Undef;
cancelUntil(0);
return result;
}
// Backward subsumption + backward subsumption resolution
bool SimpSolver::backwardSubsumptionCheck(bool verbose)
{
int cnt = 0;
int subsumed = 0;
int deleted_literals = 0;
assert(decisionLevel() == 0);
while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){
// Empty subsumption queue and return immediately on user-interrupt:
if (asynch_interrupt){
subsumption_queue.clear();
bwdsub_assigns = trail.size();
break; }
// Check top-level assignments by creating a dummy clause and placing it in the queue:
if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){
Lit l = trail[bwdsub_assigns++];
ca[bwdsub_tmpunit][0] = l;
ca[bwdsub_tmpunit].calcAbstraction();
subsumption_queue.insert(bwdsub_tmpunit); }
CRef cr = subsumption_queue.peek(); subsumption_queue.pop();
Clause& c = ca[cr];
if (c.mark()) continue;
if (verbose && verbosity >= 2 && cnt++ % 1000 == 0)
printf("c subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals);
assert(c.size() > 1 || value(c[0]) == l_True); // Unit-clauses should have been propagated before this point.
// Find best variable to scan:
Var best = var(c[0]);
for (int i = 1; i < c.size(); i++)
if (occurs[var(c[i])].size() < occurs[best].size())
best = var(c[i]);
// Search all candidates:
vec<CRef>& _cs = occurs.lookup(best);
CRef* cs = (CRef*)_cs;
for (int j = 0; j < _cs.size(); j++)
if (c.mark())
break;
else if (!ca[cs[j]].mark() && cs[j] != cr && (subsumption_lim == -1 || ca[cs[j]].size() < subsumption_lim)){
Lit l = c.subsumes(ca[cs[j]]);
if (l == lit_Undef)
subsumed++, removeClause(cs[j]);
else if (l != lit_Error){
deleted_literals++;
if (!strengthenClause(cs[j], ~l))
return false;
// Did current candidate get deleted from cs? Then check candidate at index j again:
if (var(l) == best)
j--;
}
}
}
return true;
}
bool SimpSolver::asymm(Var v, CRef cr)
{
Clause& c = ca[cr];
assert(decisionLevel() == 0);
if (c.mark() || satisfied(c)) return true;
trail_lim.push(trail.size());
Lit l = lit_Undef;
for (int i = 0; i < c.size(); i++)
if (var(c[i]) != v){
if (value(c[i]) != l_False)
uncheckedEnqueue(~c[i]);
}else
l = c[i];
if (propagate() != CRef_Undef){
cancelUntil(0);
asymm_lits++;
if (!strengthenClause(cr, l))
return false;
}else
cancelUntil(0);
return true;
}
bool SimpSolver::asymmVar(Var v)
{
assert(use_simplification);
const vec<CRef>& cls = occurs.lookup(v);
if (value(v) != l_Undef || cls.size() == 0)
return true;
for (int i = 0; i < cls.size(); i++)
if (!asymm(v, cls[i]))
return false;
return backwardSubsumptionCheck();
}
static void mkElimClause(vec<uint32_t>& elimclauses, Lit x)
{
elimclauses.push(toInt(x));
elimclauses.push(1);
}
static void mkElimClause(vec<uint32_t>& elimclauses, Var v, Clause& c)
{
int first = elimclauses.size();
int v_pos = -1;
// Copy clause to elimclauses-vector. Remember position where the
// variable 'v' occurs:
for (int i = 0; i < c.size(); i++){
elimclauses.push(toInt(c[i]));
if (var(c[i]) == v)
v_pos = i + first;
}
assert(v_pos != -1);
// Swap the first literal with the 'v' literal, so that the literal
// containing 'v' will occur first in the clause:
uint32_t tmp = elimclauses[v_pos];
elimclauses[v_pos] = elimclauses[first];
elimclauses[first] = tmp;
// Store the length of the clause last:
elimclauses.push(c.size());
}
bool SimpSolver::eliminateVar(Var v)
{
assert(!frozen[v]);
assert(!isEliminated(v));
assert(value(v) == l_Undef);
// Split the occurrences into positive and negative:
//
const vec<CRef>& cls = occurs.lookup(v);
vec<CRef> pos, neg;
for (int i = 0; i < cls.size(); i++)
(find(ca[cls[i]], mkLit(v)) ? pos : neg).push(cls[i]);
// Check wether the increase in number of clauses stays within the allowed ('grow'). Moreover, no
// clause must exceed the limit on the maximal clause size (if it is set):
//
int cnt = 0;
int clause_size = 0;
for (int i = 0; i < pos.size(); i++)
for (int j = 0; j < neg.size(); j++)
if (merge(ca[pos[i]], ca[neg[j]], v, clause_size) &&
(++cnt > cls.size() + grow || (clause_lim != -1 && clause_size > clause_lim)))
return true;
// Delete and store old clauses:
eliminated[v] = true;
setDecisionVar(v, false);
eliminated_vars++;
if (pos.size() > neg.size()){
for (int i = 0; i < neg.size(); i++)
mkElimClause(elimclauses, v, ca[neg[i]]);
mkElimClause(elimclauses, mkLit(v));
}else{
for (int i = 0; i < pos.size(); i++)
mkElimClause(elimclauses, v, ca[pos[i]]);
mkElimClause(elimclauses, ~mkLit(v));
}
// Produce clauses in cross product:
vec<Lit>& resolvent = add_tmp;
for (int i = 0; i < pos.size(); i++)
for (int j = 0; j < neg.size(); j++)
if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent))
return false;
for (int i = 0; i < cls.size(); i++)
removeClause(cls[i]);
// Free occurs list for this variable:
occurs[v].clear(true);
// Free watchers lists for this variable, if possible:
watches_bin[ mkLit(v)].clear(true);
watches_bin[~mkLit(v)].clear(true);
watches[ mkLit(v)].clear(true);
watches[~mkLit(v)].clear(true);
return backwardSubsumptionCheck();
}
bool SimpSolver::substitute(Var v, Lit x)
{
assert(!frozen[v]);
assert(!isEliminated(v));
assert(value(v) == l_Undef);
if (!ok) return false;
eliminated[v] = true;
setDecisionVar(v, false);
const vec<CRef>& cls = occurs.lookup(v);
vec<Lit>& subst_clause = add_tmp;
for (int i = 0; i < cls.size(); i++){
Clause& c = ca[cls[i]];
subst_clause.clear();
for (int j = 0; j < c.size(); j++){
Lit p = c[j];
subst_clause.push(var(p) == v ? x ^ sign(p) : p);
}
if (!addClause_(subst_clause))
return ok = false;
removeClause(cls[i]);
}
return true;
}
void SimpSolver::extendModel()
{
int i, j;
Lit x;
for (i = elimclauses.size()-1; i > 0; i -= j){
for (j = elimclauses[i--]; j > 1; j--, i--)
if (modelValue(toLit(elimclauses[i])) != l_False)
goto next;
x = toLit(elimclauses[i]);
model[var(x)] = lbool(!sign(x));
next:;
}
}
// Almost duplicate of Solver::removeSatisfied. Didn't want to make the base method 'virtual'.
void SimpSolver::removeSatisfied()
{
int i, j;
for (i = j = 0; i < clauses.size(); i++){
const Clause& c = ca[clauses[i]];
if (c.mark() == 0)
if (satisfied(c))
removeClause(clauses[i]);
else
clauses[j++] = clauses[i];
}
clauses.shrink(i - j);
}
// The technique and code are by the courtesy of the GlueMiniSat team. Thank you!
// It helps solving certain types of huge problems tremendously.
bool SimpSolver::eliminate(bool turn_off_elim)
{
bool res = true;
int iter = 0;
int n_cls, n_cls_init, n_vars;
if (nVars() == 0) goto cleanup; // User disabling preprocessing.
// Get an initial number of clauses (more accurately).
if (trail.size() != 0) removeSatisfied();
n_cls_init = nClauses();
res = eliminate_(); // The first, usual variable elimination of MiniSat.
if (!res) goto cleanup;
n_cls = nClauses();
n_vars = nFreeVars();
//printf("c Reduced to %d vars, %d cls (grow=%d)\n", n_vars, n_cls, grow);
if ((double)n_cls / n_vars >= 10 || n_vars < 10000){
//printf("c No iterative elimination performed. (vars=%d, c/v ratio=%.1f)\n", n_vars, (double)n_cls / n_vars);
goto cleanup; }
grow = grow ? grow * 2 : 8;
for (; grow < 10000; grow *= 2){
// Rebuild elimination variable heap.
for (int i = 0; i < clauses.size(); i++){
const Clause& c = ca[clauses[i]];
for (int j = 0; j < c.size(); j++)
if (!elim_heap.inHeap(var(c[j])))
elim_heap.insert(var(c[j]));
else
elim_heap.update(var(c[j])); }
int n_cls_last = nClauses();
int n_vars_last = nFreeVars();
res = eliminate_();
if (!res || n_vars_last == nFreeVars()) break;
iter++;
int n_cls_now = nClauses();
int n_vars_now = nFreeVars();
double cl_inc_rate = (double)n_cls_now / n_cls_last;
double var_dec_rate = (double)n_vars_last / n_vars_now;
//printf("c Reduced to %d vars, %d cls (grow=%d)\n", n_vars_now, n_cls_now, grow);
//printf("c cl_inc_rate=%.3f, var_dec_rate=%.3f\n", cl_inc_rate, var_dec_rate);
if (n_cls_now > n_cls_init || cl_inc_rate > var_dec_rate) break;
}
//printf("c No. effective iterative eliminations: %d\n", iter);
cleanup:
touched .clear(true);
occurs .clear(true);
n_occ .clear(true);
elim_heap.clear(true);
subsumption_queue.clear(true);
use_simplification = false;
remove_satisfied = true;
ca.extra_clause_field = false;
// Force full cleanup (this is safe and desirable since it only happens once):
rebuildOrderHeap();
garbageCollect();
return res;
}
bool SimpSolver::eliminate_()
{
if (!simplify())
return false;
else if (!use_simplification)
return true;
int trail_size_last = trail.size();
// Main simplification loop:
//
while (n_touched > 0 || bwdsub_assigns < trail.size() || elim_heap.size() > 0){
gatherTouchedClauses();
// printf(" ## (time = %6.2f s) BWD-SUB: queue = %d, trail = %d\n", cpuTime(), subsumption_queue.size(), trail.size() - bwdsub_assigns);
if ((subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()) &&
!backwardSubsumptionCheck(true)){
ok = false; goto cleanup; }
// Empty elim_heap and return immediately on user-interrupt:
if (asynch_interrupt){
assert(bwdsub_assigns == trail.size());
assert(subsumption_queue.size() == 0);
assert(n_touched == 0);
elim_heap.clear();
goto cleanup; }
// printf(" ## (time = %6.2f s) ELIM: vars = %d\n", cpuTime(), elim_heap.size());
for (int cnt = 0; !elim_heap.empty(); cnt++){
Var elim = elim_heap.removeMin();
if (asynch_interrupt) break;
if (isEliminated(elim) || value(elim) != l_Undef) continue;
if (verbosity >= 2 && cnt % 100 == 0)
printf("c elimination left: %10d\r", elim_heap.size());
if (use_asymm){
// Temporarily freeze variable. Otherwise, it would immediately end up on the queue again:
bool was_frozen = frozen[elim];
frozen[elim] = true;
if (!asymmVar(elim)){
ok = false; goto cleanup; }
frozen[elim] = was_frozen; }
// At this point, the variable may have been set by assymetric branching, so check it
// again. Also, don't eliminate frozen variables:
if (use_elim && value(elim) == l_Undef && !frozen[elim] && !eliminateVar(elim)){
ok = false; goto cleanup; }
checkGarbage(simp_garbage_frac);
}
assert(subsumption_queue.size() == 0);
}
cleanup:
// To get an accurate number of clauses.
if (trail_size_last != trail.size())
removeSatisfied();
else{
int i,j;
for (i = j = 0; i < clauses.size(); i++)
if (ca[clauses[i]].mark() == 0)
clauses[j++] = clauses[i];
clauses.shrink(i - j);
}
checkGarbage();
if (verbosity >= 1 && elimclauses.size() > 0)
printf("c | Eliminated clauses: %10.2f Mb |\n",
double(elimclauses.size() * sizeof(uint32_t)) / (1024*1024));
return ok;
}
//=================================================================================================
// Garbage Collection methods:
void SimpSolver::relocAll(ClauseAllocator& to)
{
if (!use_simplification) return;
// All occurs lists:
//
occurs.cleanAll();
for (int i = 0; i < nVars(); i++){
vec<CRef>& cs = occurs[i];
for (int j = 0; j < cs.size(); j++)
ca.reloc(cs[j], to);
}
// Subsumption queue:
//
for (int i = 0; i < subsumption_queue.size(); i++)
ca.reloc(subsumption_queue[i], to);
// Temporary clause:
//
ca.reloc(bwdsub_tmpunit, to);
}
void SimpSolver::garbageCollect()
{
// Initialize the next region to a size corresponding to the estimated utilization degree. This
// is not precise but should avoid some unnecessary reallocations for the new region:
ClauseAllocator to(ca.size() - ca.wasted());
to.extra_clause_field = ca.extra_clause_field; // NOTE: this is important to keep (or lose) the extra fields.
relocAll(to);
Solver::relocAll(to);
if (verbosity >= 2)
printf("c | Garbage collection: %12d bytes => %12d bytes |\n",
ca.size()*ClauseAllocator::Unit_Size, to.size()*ClauseAllocator::Unit_Size);
to.moveTo(ca);
}

216
lstech_maple/lstech/simp/SimpSolver.h Executable file
View File

@ -0,0 +1,216 @@
/***************************************************************************************[Solver.cc]
MiniSat -- Copyright (c) 2003-2006, Niklas Een, Niklas Sorensson
Copyright (c) 2007-2010, Niklas Sorensson
Chanseok Oh's MiniSat Patch Series -- Copyright (c) 2015, Chanseok Oh
Maple_LCM, Based on MapleCOMSPS_DRUP -- Copyright (c) 2017, Mao Luo, Chu-Min LI, Fan Xiao: implementing a learnt clause minimisation approach
Reference: M. Luo, C.-M. Li, F. Xiao, F. Manya, and Z. L. , “An effective learnt clause minimization approach for cdcl sat solvers,” in IJCAI-2017, 2017, pp. to–appear.
Maple_LCM_Dist, Based on Maple_LCM -- Copyright (c) 2017, Fan Xiao, Chu-Min LI, Mao Luo: using a new branching heuristic called Distance at the beginning of search
MapleLCMDistChronoBT, based on Maple_LCM_Dist -- Copyright (c), Alexander Nadel, Vadim Ryvchin: "Chronological Backtracking" in SAT-2018, pp. 111-121.
MapleLCMDistChronoBT-DL, based on MapleLCMDistChronoBT -- Copyright (c), Stepan Kochemazov, Oleg Zaikin, Victor Kondratiev, Alexander Semenov: The solver was augmented with heuristic that moves duplicate learnt clauses into the core/tier2 tiers depending on a number of parameters.
lstech, Relaxed_newTech -- Copyright (c) 2019-2021, Shaowei Cai, Xindi Zhang
Reference: Shaowei Cai, Xindi Zhang: Deep Cooperation of CDCL and Local Search for SAT.
Xindi Zhang, Shaowei Cai: Relaxed Backtracking with Rephasing.
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_SimpSolver_h
#define Minisat_SimpSolver_h
#include "mtl/Queue.h"
#include "core/Solver.h"
namespace Minisat {
//=================================================================================================
class SimpSolver : public Solver {
public:
// Constructor/Destructor:
//
SimpSolver();
~SimpSolver();
// Problem specification:
//
void varGrowTo (int maxVar);
Var newVar (bool polarity = true, bool dvar = true);
bool addClause (const vec<Lit>& ps);
bool addEmptyClause(); // Add the empty clause to the solver.
bool addClause (Lit p); // Add a unit clause to the solver.
bool addClause (Lit p, Lit q); // Add a binary clause to the solver.
bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
bool addClause_( vec<Lit>& ps);
bool substitute(Var v, Lit x); // Replace all occurences of v with x (may cause a contradiction).
// Variable mode:
//
void setFrozen (Var v, bool b); // If a variable is frozen it will not be eliminated.
bool isEliminated(Var v) const;
// Solving:
//
bool solve (const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
lbool solveLimited(const vec<Lit>& assumps, bool do_simp = true, bool turn_off_simp = false);
bool solve ( bool do_simp = true, bool turn_off_simp = false);
bool solve (Lit p , bool do_simp = true, bool turn_off_simp = false);
bool solve (Lit p, Lit q, bool do_simp = true, bool turn_off_simp = false);
bool solve (Lit p, Lit q, Lit r, bool do_simp = true, bool turn_off_simp = false);
bool eliminate (bool turn_off_elim = false); // Perform variable elimination based simplification.
bool eliminate_ ();
void removeSatisfied();
// Memory managment:
//
virtual void garbageCollect();
// Generate a (possibly simplified) DIMACS file:
//
#if 0
void toDimacs (const char* file, const vec<Lit>& assumps);
void toDimacs (const char* file);
void toDimacs (const char* file, Lit p);
void toDimacs (const char* file, Lit p, Lit q);
void toDimacs (const char* file, Lit p, Lit q, Lit r);
#endif
// Mode of operation:
//
bool parsing;
int grow; // Allow a variable elimination step to grow by a number of clauses (default to zero).
int clause_lim; // Variables are not eliminated if it produces a resolvent with a length above this limit.
// -1 means no limit.
int subsumption_lim; // Do not check if subsumption against a clause larger than this. -1 means no limit.
double simp_garbage_frac; // A different limit for when to issue a GC during simplification (Also see 'garbage_frac').
bool use_asymm; // Shrink clauses by asymmetric branching.
bool use_rcheck; // Check if a clause is already implied. Prett costly, and subsumes subsumptions :)
bool use_elim; // Perform variable elimination.
// Statistics:
//
int merges;
int asymm_lits;
int eliminated_vars;
protected:
// Helper structures:
//
struct ElimLt {
const vec<int>& n_occ;
explicit ElimLt(const vec<int>& no) : n_occ(no) {}
// TODO: are 64-bit operations here noticably bad on 32-bit platforms? Could use a saturating
// 32-bit implementation instead then, but this will have to do for now.
uint64_t cost (Var x) const { return (uint64_t)n_occ[toInt(mkLit(x))] * (uint64_t)n_occ[toInt(~mkLit(x))]; }
bool operator()(Var x, Var y) const { return cost(x) < cost(y); }
// TODO: investigate this order alternative more.
// bool operator()(Var x, Var y) const {
// int c_x = cost(x);
// int c_y = cost(y);
// return c_x < c_y || c_x == c_y && x < y; }
};
struct ClauseDeleted {
const ClauseAllocator& ca;
explicit ClauseDeleted(const ClauseAllocator& _ca) : ca(_ca) {}
bool operator()(const CRef& cr) const { return ca[cr].mark() == 1; } };
// Solver state:
//
int elimorder;
bool use_simplification;
vec<uint32_t> elimclauses;
vec<char> touched;
OccLists<Var, vec<CRef>, ClauseDeleted>
occurs;
vec<int> n_occ;
Heap<ElimLt> elim_heap;
Queue<CRef> subsumption_queue;
vec<char> frozen;
vec<char> eliminated;
int bwdsub_assigns;
int n_touched;
// Temporaries:
//
CRef bwdsub_tmpunit;
// Main internal methods:
//
lbool solve_ (bool do_simp = true, bool turn_off_simp = false);
bool asymm (Var v, CRef cr);
bool asymmVar (Var v);
void updateElimHeap (Var v);
void gatherTouchedClauses ();
bool merge (const Clause& _ps, const Clause& _qs, Var v, vec<Lit>& out_clause);
bool merge (const Clause& _ps, const Clause& _qs, Var v, int& size);
bool backwardSubsumptionCheck (bool verbose = false);
bool eliminateVar (Var v);
void extendModel ();
void removeClause (CRef cr);
bool strengthenClause (CRef cr, Lit l);
bool implied (const vec<Lit>& c);
void relocAll (ClauseAllocator& to);
};
//=================================================================================================
// Implementation of inline methods:
inline bool SimpSolver::isEliminated (Var v) const { return eliminated[v]; }
inline void SimpSolver::updateElimHeap(Var v) {
assert(use_simplification);
// if (!frozen[v] && !isEliminated(v) && value(v) == l_Undef)
if (elim_heap.inHeap(v) || (!frozen[v] && !isEliminated(v) && value(v) == l_Undef))
elim_heap.update(v); }
inline bool SimpSolver::addClause (const vec<Lit>& ps) { ps.copyTo(add_tmp); return addClause_(add_tmp); }
inline bool SimpSolver::addEmptyClause() { add_tmp.clear(); return addClause_(add_tmp); }
inline bool SimpSolver::addClause (Lit p) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
inline bool SimpSolver::addClause (Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
inline bool SimpSolver::addClause (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
inline void SimpSolver::setFrozen (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } }
inline bool SimpSolver::solve ( bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); return solve_(do_simp, turn_off_simp) == l_True; }
inline bool SimpSolver::solve (Lit p , bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); assumptions.push(p); return solve_(do_simp, turn_off_simp) == l_True; }
inline bool SimpSolver::solve (Lit p, Lit q, bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); return solve_(do_simp, turn_off_simp) == l_True; }
inline bool SimpSolver::solve (Lit p, Lit q, Lit r, bool do_simp, bool turn_off_simp) { budgetOff(); assumptions.clear(); assumptions.push(p); assumptions.push(q); assumptions.push(r); return solve_(do_simp, turn_off_simp) == l_True; }
inline bool SimpSolver::solve (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){
budgetOff(); assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp) == l_True; }
inline lbool SimpSolver::solveLimited (const vec<Lit>& assumps, bool do_simp, bool turn_off_simp){
assumps.copyTo(assumptions); return solve_(do_simp, turn_off_simp); }
//=================================================================================================
}
#endif

BIN
lstech_maple/lstech/simp/SimpSolver.or Executable file
View File

Binary file not shown.

13
lstech_maple/lstech/simp/depend.mk Executable file
View File

@ -0,0 +1,13 @@
/home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.o /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.or /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.od /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.op: \
/home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/SimpSolver.cc \
../mtl/Sort.h ../mtl/Vec.h ../mtl/IntTypes.h ../mtl/XAlloc.h \
../simp/SimpSolver.h ../mtl/Queue.h ../core/Solver.h ../mtl/Heap.h \
../mtl/Alg.h ../utils/Options.h ../utils/ParseUtils.h \
../core/SolverTypes.h ../mtl/Map.h ../mtl/Alloc.h ../utils/ccnr.h \
../utils/System.h
/home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.o /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.or /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.od /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.op: /home/zhangxd/solvers/rdpaper/lstech_maple/lstech/simp/Main.cc \
../utils/System.h ../mtl/IntTypes.h ../utils/ParseUtils.h \
../utils/Options.h ../mtl/Vec.h ../mtl/XAlloc.h ../core/Dimacs.h \
../core/SolverTypes.h ../mtl/Alg.h ../mtl/Map.h ../mtl/Alloc.h \
../simp/SimpSolver.h ../mtl/Queue.h ../core/Solver.h ../mtl/Heap.h \
../utils/ccnr.h

BIN
lstech_maple/lstech/simp/glucose_static Executable file
View File

Binary file not shown.

4
lstech_maple/lstech/utils/Makefile Executable file
View File

@ -0,0 +1,4 @@
EXEC = system_test
DEPDIR = mtl
include $(MROOT)/mtl/template.mk

91
lstech_maple/lstech/utils/Options.cc Executable file
View File

@ -0,0 +1,91 @@
/**************************************************************************************[Options.cc]
Copyright (c) 2008-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 "mtl/Sort.h"
#include "utils/Options.h"
#include "utils/ParseUtils.h"
using namespace Minisat;
void Minisat::parseOptions(int& argc, char** argv, bool strict)
{
int i, j;
for (i = j = 1; i < argc; i++){
const char* str = argv[i];
if (match(str, "--") && match(str, Option::getHelpPrefixString()) && match(str, "help")){
if (*str == '\0')
printUsageAndExit(argc, argv);
else if (match(str, "-verb"))
printUsageAndExit(argc, argv, true);
} else {
bool parsed_ok = false;
for (int k = 0; !parsed_ok && k < Option::getOptionList().size(); k++){
parsed_ok = Option::getOptionList()[k]->parse(argv[i]);
// fprintf(stderr, "checking %d: %s against flag <%s> (%s)\n", i, argv[i], Option::getOptionList()[k]->name, parsed_ok ? "ok" : "skip");
}
if (!parsed_ok)
if (strict && match(argv[i], "-"))
fprintf(stderr, "ERROR! Unknown flag \"%s\". Use '--%shelp' for help.\n", argv[i], Option::getHelpPrefixString()), exit(1);
else
argv[j++] = argv[i];
}
}
argc -= (i - j);
}
void Minisat::setUsageHelp (const char* str){ Option::getUsageString() = str; }
void Minisat::setHelpPrefixStr (const char* str){ Option::getHelpPrefixString() = str; }
void Minisat::printUsageAndExit (int argc, char** argv, bool verbose)
{
const char* usage = Option::getUsageString();
if (usage != NULL)
fprintf(stderr, usage, argv[0]);
sort(Option::getOptionList(), Option::OptionLt());
const char* prev_cat = NULL;
const char* prev_type = NULL;
for (int i = 0; i < Option::getOptionList().size(); i++){
const char* cat = Option::getOptionList()[i]->category;
const char* type = Option::getOptionList()[i]->type_name;
if (cat != prev_cat)
fprintf(stderr, "\n%s OPTIONS:\n\n", cat);
else if (type != prev_type)
fprintf(stderr, "\n");
Option::getOptionList()[i]->help(verbose);
prev_cat = Option::getOptionList()[i]->category;
prev_type = Option::getOptionList()[i]->type_name;
}
fprintf(stderr, "\nHELP OPTIONS:\n\n");
fprintf(stderr, " --%shelp Print help message.\n", Option::getHelpPrefixString());
fprintf(stderr, " --%shelp-verb Print verbose help message.\n", Option::getHelpPrefixString());
fprintf(stderr, "\n");
exit(0);
}

386
lstech_maple/lstech/utils/Options.h Executable file
View File

@ -0,0 +1,386 @@
/***************************************************************************************[Options.h]
Copyright (c) 2008-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_Options_h
#define Minisat_Options_h
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "mtl/IntTypes.h"
#include "mtl/Vec.h"
#include "utils/ParseUtils.h"
namespace Minisat {
//==================================================================================================
// Top-level option parse/help functions:
extern void parseOptions (int& argc, char** argv, bool strict = false);
extern void printUsageAndExit(int argc, char** argv, bool verbose = false);
extern void setUsageHelp (const char* str);
extern void setHelpPrefixStr (const char* str);
//==================================================================================================
// Options is an abstract class that gives the interface for all types options:
class Option
{
protected:
const char* name;
const char* description;
const char* category;
const char* type_name;
static vec<Option*>& getOptionList () { static vec<Option*> options; return options; }
static const char*& getUsageString() { static const char* usage_str; return usage_str; }
static const char*& getHelpPrefixString() { static const char* help_prefix_str = ""; return help_prefix_str; }
struct OptionLt {
bool operator()(const Option* x, const Option* y) {
int test1 = strcmp(x->category, y->category);
return test1 < 0 || test1 == 0 && strcmp(x->type_name, y->type_name) < 0;
}
};
Option(const char* name_,
const char* desc_,
const char* cate_,
const char* type_) :
name (name_)
, description(desc_)
, category (cate_)
, type_name (type_)
{
getOptionList().push(this);
}
public:
virtual ~Option() {}
virtual bool parse (const char* str) = 0;
virtual void help (bool verbose = false) = 0;
friend void parseOptions (int& argc, char** argv, bool strict);
friend void printUsageAndExit (int argc, char** argv, bool verbose);
friend void setUsageHelp (const char* str);
friend void setHelpPrefixStr (const char* str);
};
//==================================================================================================
// Range classes with specialization for floating types:
struct IntRange {
int begin;
int end;
IntRange(int b, int e) : begin(b), end(e) {}
};
struct Int64Range {
int64_t begin;
int64_t end;
Int64Range(int64_t b, int64_t e) : begin(b), end(e) {}
};
struct DoubleRange {
double begin;
double end;
bool begin_inclusive;
bool end_inclusive;
DoubleRange(double b, bool binc, double e, bool einc) : begin(b), end(e), begin_inclusive(binc), end_inclusive(einc) {}
};
//==================================================================================================
// Double options:
class DoubleOption : public Option
{
protected:
DoubleRange range;
double value;
public:
DoubleOption(const char* c, const char* n, const char* d, double def = double(), DoubleRange r = DoubleRange(-HUGE_VAL, false, HUGE_VAL, false))
: Option(n, d, c, "<double>"), range(r), value(def) {
// FIXME: set LC_NUMERIC to "C" to make sure that strtof/strtod parses decimal point correctly.
}
operator double (void) const { return value; }
operator double& (void) { return value; }
DoubleOption& operator=(double x) { value = x; return *this; }
virtual bool parse(const char* str){
const char* span = str;
if (!match(span, "-") || !match(span, name) || !match(span, "="))
return false;
char* end;
double tmp = strtod(span, &end);
if (end == NULL)
return false;
else if (tmp >= range.end && (!range.end_inclusive || tmp != range.end)){
fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
exit(1);
}else if (tmp <= range.begin && (!range.begin_inclusive || tmp != range.begin)){
fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
exit(1); }
value = tmp;
// fprintf(stderr, "READ VALUE: %g\n", value);
return true;
}
virtual void help (bool verbose = false){
fprintf(stderr, " -%-12s = %-8s %c%4.2g .. %4.2g%c (default: %g)\n",
name, type_name,
range.begin_inclusive ? '[' : '(',
range.begin,
range.end,
range.end_inclusive ? ']' : ')',
value);
if (verbose){
fprintf(stderr, "\n %s\n", description);
fprintf(stderr, "\n");
}
}
};
//==================================================================================================
// Int options:
class IntOption : public Option
{
protected:
IntRange range;
int32_t value;
public:
IntOption(const char* c, const char* n, const char* d, int32_t def = int32_t(), IntRange r = IntRange(INT32_MIN, INT32_MAX))
: Option(n, d, c, "<int32>"), range(r), value(def) {}
operator int32_t (void) const { return value; }
operator int32_t& (void) { return value; }
IntOption& operator= (int32_t x) { value = x; return *this; }
virtual bool parse(const char* str){
const char* span = str;
if (!match(span, "-") || !match(span, name) || !match(span, "="))
return false;
char* end;
int32_t tmp = strtol(span, &end, 10);
if (end == NULL)
return false;
else if (tmp > range.end){
fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
exit(1);
}else if (tmp < range.begin){
fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
exit(1); }
value = tmp;
return true;
}
virtual void help (bool verbose = false){
fprintf(stderr, " -%-12s = %-8s [", name, type_name);
if (range.begin == INT32_MIN)
fprintf(stderr, "imin");
else
fprintf(stderr, "%4d", range.begin);
fprintf(stderr, " .. ");
if (range.end == INT32_MAX)
fprintf(stderr, "imax");
else
fprintf(stderr, "%4d", range.end);
fprintf(stderr, "] (default: %d)\n", value);
if (verbose){
fprintf(stderr, "\n %s\n", description);
fprintf(stderr, "\n");
}
}
};
// Leave this out for visual C++ until Microsoft implements C99 and gets support for strtoll.
#ifndef _MSC_VER
class Int64Option : public Option
{
protected:
Int64Range range;
int64_t value;
public:
Int64Option(const char* c, const char* n, const char* d, int64_t def = int64_t(), Int64Range r = Int64Range(INT64_MIN, INT64_MAX))
: Option(n, d, c, "<int64>"), range(r), value(def) {}
operator int64_t (void) const { return value; }
operator int64_t& (void) { return value; }
Int64Option& operator= (int64_t x) { value = x; return *this; }
virtual bool parse(const char* str){
const char* span = str;
if (!match(span, "-") || !match(span, name) || !match(span, "="))
return false;
char* end;
int64_t tmp = strtoll(span, &end, 10);
if (end == NULL)
return false;
else if (tmp > range.end){
fprintf(stderr, "ERROR! value <%s> is too large for option \"%s\".\n", span, name);
exit(1);
}else if (tmp < range.begin){
fprintf(stderr, "ERROR! value <%s> is too small for option \"%s\".\n", span, name);
exit(1); }
value = tmp;
return true;
}
virtual void help (bool verbose = false){
fprintf(stderr, " -%-12s = %-8s [", name, type_name);
if (range.begin == INT64_MIN)
fprintf(stderr, "imin");
else
fprintf(stderr, "%4"PRIi64, range.begin);
fprintf(stderr, " .. ");
if (range.end == INT64_MAX)
fprintf(stderr, "imax");
else
fprintf(stderr, "%4"PRIi64, range.end);
fprintf(stderr, "] (default: %"PRIi64")\n", value);
if (verbose){
fprintf(stderr, "\n %s\n", description);
fprintf(stderr, "\n");
}
}
};
#endif
//==================================================================================================
// String option:
class StringOption : public Option
{
const char* value;
public:
StringOption(const char* c, const char* n, const char* d, const char* def = NULL)
: Option(n, d, c, "<string>"), value(def) {}
operator const char* (void) const { return value; }
operator const char*& (void) { return value; }
StringOption& operator= (const char* x) { value = x; return *this; }
virtual bool parse(const char* str){
const char* span = str;
if (!match(span, "-") || !match(span, name) || !match(span, "="))
return false;
value = span;
return true;
}
virtual void help (bool verbose = false){
fprintf(stderr, " -%-10s = %8s\n", name, type_name);
if (verbose){
fprintf(stderr, "\n %s\n", description);
fprintf(stderr, "\n");
}
}
};
//==================================================================================================
// Bool option:
class BoolOption : public Option
{
bool value;
public:
BoolOption(const char* c, const char* n, const char* d, bool v)
: Option(n, d, c, "<bool>"), value(v) {}
operator bool (void) const { return value; }
operator bool& (void) { return value; }
BoolOption& operator=(bool b) { value = b; return *this; }
virtual bool parse(const char* str){
const char* span = str;
if (match(span, "-")){
bool b = !match(span, "no-");
if (strcmp(span, name) == 0){
value = b;
return true; }
}
return false;
}
virtual void help (bool verbose = false){
fprintf(stderr, " -%s, -no-%s", name, name);
for (uint32_t i = 0; i < 32 - strlen(name)*2; i++)
fprintf(stderr, " ");
fprintf(stderr, " ");
fprintf(stderr, "(default: %s)\n", value ? "on" : "off");
if (verbose){
fprintf(stderr, "\n %s\n", description);
fprintf(stderr, "\n");
}
}
};
//=================================================================================================
}
#endif

BIN
lstech_maple/lstech/utils/Options.or Executable file
View File

Binary file not shown.

122
lstech_maple/lstech/utils/ParseUtils.h Executable file
View File

@ -0,0 +1,122 @@
/************************************************************************************[ParseUtils.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_ParseUtils_h
#define Minisat_ParseUtils_h
#include <stdlib.h>
#include <stdio.h>
#include <zlib.h>
namespace Minisat {
//-------------------------------------------------------------------------------------------------
// A simple buffered character stream class:
static const int buffer_size = 1048576;
class StreamBuffer {
gzFile in;
unsigned char buf[buffer_size];
int pos;
int size;
void assureLookahead() {
if (pos >= size) {
pos = 0;
size = gzread(in, buf, sizeof(buf)); } }
public:
explicit StreamBuffer(gzFile i) : in(i), pos(0), size(0) { assureLookahead(); }
int operator * () const { return (pos >= size) ? EOF : buf[pos]; }
void operator ++ () { pos++; assureLookahead(); }
int position () const { return pos; }
};
//-------------------------------------------------------------------------------------------------
// End-of-file detection functions for StreamBuffer and char*:
static inline bool isEof(StreamBuffer& in) { return *in == EOF; }
static inline bool isEof(const char* in) { return *in == '\0'; }
//-------------------------------------------------------------------------------------------------
// Generic parse functions parametrized over the input-stream type.
template<class B>
static void skipWhitespace(B& in) {
while ((*in >= 9 && *in <= 13) || *in == 32)
++in; }
template<class B>
static void skipLine(B& in) {
for (;;){
if (isEof(in)) return;
if (*in == '\n') { ++in; return; }
++in; } }
template<class B>
static int parseInt(B& in) {
int val = 0;
bool neg = false;
skipWhitespace(in);
if (*in == '-') neg = true, ++in;
else if (*in == '+') ++in;
if (*in < '0' || *in > '9') fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
while (*in >= '0' && *in <= '9')
val = val*10 + (*in - '0'),
++in;
return neg ? -val : val; }
// String matching: in case of a match the input iterator will be advanced the corresponding
// number of characters.
template<class B>
static bool match(B& in, const char* str) {
int i;
for (i = 0; str[i] != '\0'; i++)
if (in[i] != str[i])
return false;
in += i;
return true;
}
// String matching: consumes characters eagerly, but does not require random access iterator.
template<class B>
static bool eagerMatch(B& in, const char* str) {
for (; *str != '\0'; ++str, ++in)
if (*str != *in)
return false;
return true; }
//=================================================================================================
}
#endif

95
lstech_maple/lstech/utils/System.cc Executable file
View File

@ -0,0 +1,95 @@
/***************************************************************************************[System.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 "utils/System.h"
#if defined(__linux__)
#include <stdio.h>
#include <stdlib.h>
using namespace Minisat;
// TODO: split the memory reading functions into two: one for reading high-watermark of RSS, and
// one for reading the current virtual memory size.
static inline int memReadStat(int field)
{
char name[256];
pid_t pid = getpid();
int value;
sprintf(name, "/proc/%d/statm", pid);
FILE* in = fopen(name, "rb");
if (in == NULL) return 0;
for (; field >= 0; field--)
if (fscanf(in, "%d", &value) != 1)
printf("ERROR! Failed to parse memory statistics from \"/proc\".\n"), exit(1);
fclose(in);
return value;
}
static inline int memReadPeak(void)
{
char name[256];
pid_t pid = getpid();
sprintf(name, "/proc/%d/status", pid);
FILE* in = fopen(name, "rb");
if (in == NULL) return 0;
// Find the correct line, beginning with "VmPeak:":
int peak_kb = 0;
while (!feof(in) && fscanf(in, "VmPeak: %d kB", &peak_kb) != 1)
while (!feof(in) && fgetc(in) != '\n')
;
fclose(in);
return peak_kb;
}
double Minisat::memUsed() { return (double)memReadStat(0) * (double)getpagesize() / (1024*1024); }
double Minisat::memUsedPeak() {
double peak = memReadPeak() / 1024;
return peak == 0 ? memUsed() : peak; }
#elif defined(__FreeBSD__)
double Minisat::memUsed(void) {
struct rusage ru;
getrusage(RUSAGE_SELF, &ru);
return (double)ru.ru_maxrss / 1024; }
double MiniSat::memUsedPeak(void) { return memUsed(); }
#elif defined(__APPLE__)
#include <malloc/malloc.h>
double Minisat::memUsed(void) {
malloc_statistics_t t;
malloc_zone_statistics(NULL, &t);
return (double)t.max_size_in_use / (1024*1024); }
double Minisat::memUsedPeak(void) {return memUsed(); }
#else
double Minisat::memUsed() {
return 0; }
#endif

60
lstech_maple/lstech/utils/System.h Executable file
View File

@ -0,0 +1,60 @@
/****************************************************************************************[System.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_System_h
#define Minisat_System_h
#if defined(__linux__)
#include <fpu_control.h>
#endif
#include "mtl/IntTypes.h"
//-------------------------------------------------------------------------------------------------
namespace Minisat {
static inline double cpuTime(void); // CPU-time in seconds.
extern double memUsed(); // Memory in mega bytes (returns 0 for unsupported architectures).
extern double memUsedPeak(); // Peak-memory in mega bytes (returns 0 for unsupported architectures).
}
//-------------------------------------------------------------------------------------------------
// Implementation of inline functions:
#if defined(_MSC_VER) || defined(__MINGW32__)
#include <time.h>
static inline double Minisat::cpuTime(void) { return (double)clock() / CLOCKS_PER_SEC; }
#else
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
static inline double Minisat::cpuTime(void) {
struct rusage ru;
getrusage(RUSAGE_SELF, &ru);
return (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec / 1000000; }
#endif
#endif

BIN
lstech_maple/lstech/utils/System.or Executable file
View File

Binary file not shown.

822
lstech_maple/lstech/utils/ccnr.cc Executable file
View File

@ -0,0 +1,822 @@
#include "ccnr.h"
#include <fstream>
using std::ofstream;
#define pop(stack) stack[--stack ## _fill_pointer]
#define push(item, stack) stack[stack ## _fill_pointer++] = item
#define ccanr_Mersenne_N 624
#define ccanr_Mersenne_M 397
#define ccanr_Mersenne_MATRIX_A 0x9908b0dfUL
#define ccanr_Mersenne_UPPER_MASK 0x80000000UL
#define ccanr_Mersenne_LOWER_MASK 0x7fffffffUL
void ccanr_Mersenne_init_with_seed(ccanr_randgen* randgen, int seed);
int ccanr_Mersenne_next(ccanr_randgen* randgen, int bound);
int ccanr_rand(CCAnr*, int);
int pick_var(CCAnr*);
void init(CCAnr*,char*);
void unit_propagation(CCAnr*);
void preprocess(CCAnr*);
void flip(CCAnr*,int);
void smooth_clause_weights(CCAnr*);
void update_clause_weights(CCAnr*);
void set_clause_weighting(CCAnr*);
void default_initialize(CCAnr* lssolver){
lssolver->formula_len=0;
lssolver->unitclause_queue_beg_pointer=0;
lssolver->unitclause_queue_end_pointer=0;
lssolver->max_tries = 10000;
lssolver->max_flips = 200000000;
lssolver->ave_weight=1;
lssolver->delta_total_weight=0;
lssolver->q_scale=0;
lssolver->q_init=0;
lssolver->mems_left=50000000;
}
void alloc_memory(CCAnr *lssolver){
int var_mem = lssolver->num_vars+2;
int cls_mem = lssolver->num_clauses+2;
lssolver->score_inc_vars = (int*)malloc(sizeof(int)*var_mem);
lssolver->score_inc_flag = (int*)malloc(sizeof(int)*var_mem);
lssolver->var_lit = (lit**)malloc(sizeof(lit*)*var_mem);
lssolver->var_lit_count = (int*)malloc(sizeof(int)*var_mem);
lssolver->clause_lit = (lit**)malloc(sizeof(lit*)*cls_mem);
lssolver->clause_lit_count = (int*)malloc(sizeof(int)*cls_mem);
lssolver->score = (int*)malloc(sizeof(int)*var_mem);
lssolver->time_stamp = (int*)malloc(sizeof(int)*var_mem);
lssolver->fix = (int*)malloc(sizeof(int)*var_mem);
lssolver->cscc = (int*)malloc(sizeof(int)*var_mem);
lssolver->clause_weight = (int*)malloc(sizeof(int)*cls_mem);
lssolver->sat_count = (int*)malloc(sizeof(int)*cls_mem);
lssolver->sat_var = (int*)malloc(sizeof(int)*cls_mem);
lssolver->unsat_stack = (int*)malloc(sizeof(int)*cls_mem);
lssolver->index_in_unsat_stack=(int*)malloc(sizeof(int)*cls_mem);
lssolver->unsatvar_stack = (int*)malloc(sizeof(int)*var_mem);
lssolver->index_in_unsatvar_stack = (int*)malloc(sizeof(int)*var_mem);
lssolver->unsat_app_count = (int*)malloc(sizeof(int)*var_mem);
lssolver->goodvar_stack = (int*)malloc(sizeof(int)*var_mem);
lssolver->already_in_goodvar_stack = (int*)malloc(sizeof(int)*var_mem);
lssolver->unitclause_queue = (lit*)malloc(sizeof(lit)*var_mem);
lssolver->clause_delete = (int*)malloc(sizeof(int)*cls_mem);
lssolver->cur_soln = (char*)malloc(sizeof(int)*var_mem);
lssolver->best_soln = (char*)malloc(sizeof(int)*var_mem);
lssolver->conflict_ct = (int*)malloc(sizeof(int)*var_mem);
lssolver->in_conflict = (int*)malloc(sizeof(int)*var_mem);
for(int i=1;i<=lssolver->num_vars;++i) lssolver->conflict_ct[i]=0;
}
void free_memory(CCAnr *lssolver)
{
int i;
for (i = 0; i < lssolver->num_clauses; i++)
{
free(lssolver->clause_lit[i]);
}
for(i=1; i<=lssolver->num_vars; ++i)
{
free(lssolver->var_lit[i]);
}
free(lssolver->score_inc_vars);
free(lssolver->score_inc_flag);
free(lssolver->var_lit);
free(lssolver->var_lit_count);
free(lssolver->clause_lit);
free(lssolver->clause_lit_count);
free(lssolver->score);
free(lssolver->time_stamp);
free(lssolver->fix);
free(lssolver->cscc);
free(lssolver->clause_weight);
free(lssolver->sat_count);
free(lssolver->sat_var);
free(lssolver->unsat_stack);
free(lssolver->index_in_unsat_stack);
free(lssolver->unsatvar_stack);
free(lssolver->index_in_unsatvar_stack);
free(lssolver->unsat_app_count);
free(lssolver->goodvar_stack);
free(lssolver->already_in_goodvar_stack);
free(lssolver->unitclause_queue);
free(lssolver->clause_delete);
free(lssolver->cur_soln);
free(lssolver->best_soln);
free(lssolver->conflict_ct);
free(lssolver->in_conflict);
}
//pick a var to be flip
int pick_var(CCAnr *lssolver)
{
int i,k,c,v;
int best_var;
lit* clause_c;
/**Greedy Mode**/
/*CCD (configuration changed decreasing) mode, the level with configuation chekcing*/
if(lssolver->goodvar_stack_fill_pointer>0)
{
lssolver->mems_left -= lssolver->goodvar_stack_fill_pointer;
best_var = lssolver->goodvar_stack[0];
for(i=1; i<lssolver->goodvar_stack_fill_pointer; ++i)
{
v=lssolver->goodvar_stack[i];
if(lssolver->score[v]>lssolver->score[best_var]) best_var = v;
else if(lssolver->score[v]==lssolver->score[best_var] && lssolver->time_stamp[v]<lssolver->time_stamp[best_var]) best_var = v;
}
return best_var;
}
/*SD (significant decreasing) mode, the level with aspiration*/
best_var = 0;
for(i=0; i<lssolver->unsatvar_stack_fill_pointer; ++i)
{
if(lssolver->score[lssolver->unsatvar_stack[i]]>lssolver->ave_weight)
{
best_var = lssolver->unsatvar_stack[i];
break;
}
}
for(++i; i<lssolver->unsatvar_stack_fill_pointer; ++i)
{
v=lssolver->unsatvar_stack[i];
if(lssolver->score[v]>lssolver->score[best_var]) best_var = v;
else if(lssolver->score[v]==lssolver->score[best_var] && lssolver->time_stamp[v]<lssolver->time_stamp[best_var]) best_var = v;
}
if(best_var!=0) return best_var;
/**Diversification Mode**/
update_clause_weights(lssolver);
/*focused random walk*/
c = lssolver->unsat_stack[ccanr_rand(lssolver,lssolver->unsat_stack_fill_pointer)];
clause_c = lssolver->clause_lit[c];
best_var = clause_c[0].var_num;
for(k=1; k<lssolver->clause_lit_count[c]; ++k)
{
v=clause_c[k].var_num;
//if(time_stamp[v]<time_stamp[best_var]) best_var = v;
if(lssolver->score[v]>lssolver->score[best_var]) best_var = v;
else if(lssolver->score[v]==lssolver->score[best_var]&&lssolver->time_stamp[v]<lssolver->time_stamp[best_var]) best_var = v;
}
return best_var;
}
//set functions in the algorithm
void settings(CCAnr *lssolver,char *soln)
{
set_clause_weighting(lssolver);
init(lssolver,soln);
}
bool local_search(CCAnr *lssolver)
{
int flipvar;
lssolver->best_cost = lssolver->num_clauses;
for (lssolver->step = 0; lssolver->step<lssolver->max_flips; lssolver->step++)
{
//find a solution
if(lssolver->unsat_stack_fill_pointer < lssolver->best_cost){
lssolver->best_cost = lssolver->unsat_stack_fill_pointer;
for(int i=1;i<=lssolver->num_vars;++i) lssolver->best_soln[i]=lssolver->cur_soln[i];
}
if(lssolver->unsat_stack_fill_pointer==0) return true;
if(lssolver->mems_left<0 && lssolver->step>1000) return false;
flipvar = pick_var(lssolver);
flip(lssolver,flipvar);
lssolver->time_stamp[flipvar] = lssolver->step;
//update conflicts information
for(int i=0;i<lssolver->unsatvar_stack_fill_pointer;++i)
++lssolver->conflict_ct[lssolver->unsatvar_stack[i]];
}
return false;
}
inline void unsat(CCAnr *lssolver, int clause)
{
lssolver->index_in_unsat_stack[clause] = lssolver->unsat_stack_fill_pointer;
push(clause,lssolver->unsat_stack);
//update appreance count of each var in unsat clause and update stack of vars in unsat clauses
int v;
for(lit* p=lssolver->clause_lit[clause]; (v=p->var_num)!=0; p++)
{
lssolver->unsat_app_count[v]++;
if(lssolver->unsat_app_count[v]==1)
{
lssolver->index_in_unsatvar_stack[v] = lssolver->unsatvar_stack_fill_pointer;
push(v,lssolver->unsatvar_stack);
}
}
}
inline void sat(CCAnr *lssolver, int clause)
{
int index,last_unsat_clause;
//since the clause is satisfied, its position can be reused to store the last_unsat_clause
last_unsat_clause = pop(lssolver->unsat_stack);
index = lssolver->index_in_unsat_stack[clause];
lssolver->unsat_stack[index] = last_unsat_clause;
lssolver->index_in_unsat_stack[last_unsat_clause] = index;
//update appreance count of each var in unsat clause and update stack of vars in unsat clauses
int v,last_unsat_var;
for(lit* p=lssolver->clause_lit[clause]; (v=p->var_num)!=0; p++)
{
lssolver->unsat_app_count[v]--;
if(lssolver->unsat_app_count[v]==0)
{
last_unsat_var = pop(lssolver->unsatvar_stack);
index = lssolver->index_in_unsatvar_stack[v];
lssolver->unsatvar_stack[index] = last_unsat_var;
lssolver->index_in_unsatvar_stack[last_unsat_var] = index;
}
}
}
//initiation of the algorithm
void init(CCAnr *lssolver,char *soln)
{
int v,c;
int i,j;
//Initialize edge weights
for (c = 0; c<lssolver->num_clauses; c++)
lssolver->clause_weight[c] = 1;
//init unsat_stack
lssolver->unsat_stack_fill_pointer = 0;
lssolver->unsatvar_stack_fill_pointer = 0;
//init solution
for (v = 1; v <= lssolver->num_vars; v++) {
if(lssolver->fix[v]==0){
if(soln==NULL){
if(ccanr_rand(lssolver,2)==1) lssolver->cur_soln[v] = 1;
else lssolver->cur_soln[v] = 0;
}else{
lssolver->cur_soln[v] = soln[v-1];
}
lssolver->time_stamp[v] = 0;
lssolver->unsat_app_count[v] = 0;
lssolver->cscc[v] = 1;
lssolver->score_inc_flag[v]=0;
}
}
/* figure out sat_count, and init unsat_stack */
for (c=0; c<lssolver->num_clauses; ++c)
{
if(lssolver->clause_delete[c]==1) continue;
lssolver->sat_count[c] = 0;
for(j=0; j<lssolver->clause_lit_count[c]; ++j)
{
if (lssolver->cur_soln[lssolver->clause_lit[c][j].var_num] == lssolver->clause_lit[c][j].sense)
{
lssolver->sat_count[c]++;
lssolver->sat_var[c] = lssolver->clause_lit[c][j].var_num;
}
}
if (lssolver->sat_count[c] == 0)
unsat(lssolver,c);
}
/*figure out var score*/
int lit_count;
for (v=1; v<=lssolver->num_vars; v++)
{
if(lssolver->fix[v]==1)
{
lssolver->score[v] = -10000000;
continue;
}
lssolver->score[v] = 0;
lit_count = lssolver->var_lit_count[v];
for(i=0; i<lit_count; ++i)
{
c = lssolver->var_lit[v][i].clause_num;
if (lssolver->sat_count[c]==0) lssolver->score[v]++;
else if (lssolver->sat_count[c]==1 && lssolver->var_lit[v][i].sense==lssolver->cur_soln[v]) lssolver->score[v]--;
}
}
//init goodvars stack
lssolver->goodvar_stack_fill_pointer = 0;
for (v=1; v<=lssolver->num_vars; v++)
{
if(lssolver->fix[v]==1) continue;
if(lssolver->score[v]>0)// && conf_change[v]==1)
{
lssolver->already_in_goodvar_stack[v] = 1;
push(v,lssolver->goodvar_stack);
}
else lssolver->already_in_goodvar_stack[v] = 0;
}
//setting for the virtual var 0
lssolver->time_stamp[0]=0;
//pscore[0]=0;
}
void flip(CCAnr *lssolver, int flipvar)
{
lssolver->cur_soln[flipvar] = 1 - lssolver->cur_soln[flipvar];
lssolver->score_inc_count=0;
int i;
int v,c;
lit* clause_c;
int org_flipvar_score = lssolver->score[flipvar];
//update related clauses and neighbor vars
lssolver->mems_left-=lssolver->var_lit_count[flipvar];
for(lit *q = lssolver->var_lit[flipvar]; (c=q->clause_num)>=0; q++)
{
clause_c = lssolver->clause_lit[c];
if(lssolver->cur_soln[flipvar] == q->sense)
{
++lssolver->sat_count[c];
if (lssolver->sat_count[c] == 2) //sat_count from 1 to 2
{
lssolver->score[lssolver->sat_var[c]] += lssolver->clause_weight[c];
if(lssolver->score_inc_flag[lssolver->sat_var[c]]!=1)
{
lssolver->score_inc_vars[lssolver->score_inc_count++]=lssolver->sat_var[c];
lssolver->score_inc_flag[lssolver->sat_var[c]]=1;
}
}
else if (lssolver->sat_count[c] == 1) // sat_count from 0 to 1
{
lssolver->sat_var[c] = flipvar;//record the only true lit's var
for(lit* p=clause_c; (v=p->var_num)!=0; p++)
{
lssolver->score[v] -= lssolver->clause_weight[c];
lssolver->cscc[v] = 1;
}
sat(lssolver,c);
}
}
else // cur_soln[flipvar] != cur_lit.sense
{
--lssolver->sat_count[c];
if (lssolver->sat_count[c] == 1) //sat_count from 2 to 1
{
for(lit* p=clause_c; (v=p->var_num)!=0; p++)
{
if(p->sense == lssolver->cur_soln[v] )
{
lssolver->score[v] -= lssolver->clause_weight[c];
lssolver->sat_var[c] = v;
break;
}
}
}
else if (lssolver->sat_count[c] == 0) //sat_count from 1 to 0
{
for(lit* p=clause_c; (v=p->var_num)!=0; p++)
{
lssolver->score[v] += lssolver->clause_weight[c];
lssolver->cscc[v] = 1;
if(lssolver->score_inc_flag[v]!=1)
{
lssolver->score_inc_vars[lssolver->score_inc_count++]=v;
lssolver->score_inc_flag[v]=1;
}
}
unsat(lssolver,c);
}//end else if
}//end else
}
lssolver->score[flipvar] = -org_flipvar_score;
lssolver->cscc[flipvar] = 0;
/*update CCD */
int index;
for(index=lssolver->goodvar_stack_fill_pointer-1; index>=0; index--)
{
v = lssolver->goodvar_stack[index];
if(lssolver->score[v]<=0)
{
lssolver->goodvar_stack[index] = pop(lssolver->goodvar_stack);
lssolver->already_in_goodvar_stack[v] = 0;
}
}
for (i=0; i<lssolver->score_inc_count; ++i)
{
v = lssolver->score_inc_vars[i];
if(lssolver->score[v]>0 && lssolver->cscc[v]==1 && lssolver->already_in_goodvar_stack[v] ==0)
{
push(v,lssolver->goodvar_stack);
lssolver->already_in_goodvar_stack[v] = 1;
}
lssolver->score_inc_flag[v]=0;
}
}
void update_after_build(CCAnr *lssolver){
int i,c,v;
lssolver->avg_clause_len = (double)(lssolver->formula_len+0.0)/lssolver->num_clauses;
//creat var literal arrays
for (v=1; v<=lssolver->num_vars; ++v)
{
lssolver->var_lit[v] = (lit*)malloc(sizeof(lit)*(lssolver->var_lit_count[v]+1));
lssolver->var_lit_count[v] = 0; //reset to 0, for build up the array
}
//scan all clauses to build up var literal arrays
for (c = 0; c < lssolver->num_clauses; ++c)
{
if(lssolver->clause_delete[c]==1)
continue;
for(i=0; i<lssolver->clause_lit_count[c]; ++i)
{
v = lssolver->clause_lit[c][i].var_num;
lssolver->var_lit[v][lssolver->var_lit_count[v]] = lssolver->clause_lit[c][i];
++lssolver->var_lit_count[v];
}
}
for (v=1; v<=lssolver->num_vars; ++v) //set boundary
lssolver->var_lit[v][lssolver->var_lit_count[v]].clause_num=-1;
for (int c = 0; c < lssolver->num_clauses; ++c)
{
if(lssolver->clause_delete[c]==1) {
continue;
}
for(int i=0; i<lssolver->clause_lit_count[c]; ++i)
{
int v = lssolver->clause_lit[c][i].var_num;
if (v > 0 && v <= lssolver->num_vars);
else {
printf("\n222wrong v %d clause id: %d\n", v, c);
for(int ii=0; ii<lssolver->clause_lit_count[c]; ++ii)
printf("%d ", lssolver->clause_lit[c][ii].var_num);
puts("");
}
if (lssolver->var_lit_count[v] >= 0 && lssolver->var_lit_count[v] <= lssolver->num_clauses);
else printf("222wrong var_lit_count[v] %d\n", lssolver->var_lit_count[v]);
}
}
// printf("finish check 2\n");
if(lssolver->unitclause_queue_end_pointer>0) preprocess(lssolver);
}
void smooth_clause_weights(CCAnr *lssolver)
{
int j,c,v;
int new_total_weight=0;
for (v=1; v<=lssolver->num_vars; ++v)
lssolver->score[v] = 0;
//smooth clause score and update score of variables
for (c = 0; c<lssolver->num_clauses; ++c)
{
if (lssolver->clause_delete[c]==1) continue;
lssolver->clause_weight[c] = lssolver->clause_weight[c]*lssolver->p_scale+lssolver->scale_ave;
if(lssolver->clause_weight[c]<1) lssolver->clause_weight[c] = 1;
new_total_weight+=lssolver->clause_weight[c];
//update score of variables in this clause
if (lssolver->sat_count[c]==0)
{
for(j=0; j<lssolver->clause_lit_count[c]; ++j)
{
lssolver->score[lssolver->clause_lit[c][j].var_num] += lssolver->clause_weight[c];
}
}
else if(lssolver->sat_count[c]==1)
lssolver->score[lssolver->sat_var[c]]-=lssolver->clause_weight[c];
}
lssolver->ave_weight=new_total_weight/lssolver->num_clauses;
}
void update_clause_weights(CCAnr *lssolver)
{
int i,v;
lssolver->mems_left -= lssolver->unsat_stack_fill_pointer;
for(i=0; i < lssolver->unsat_stack_fill_pointer; ++i)
lssolver->clause_weight[lssolver->unsat_stack[i]]++;
for(i=0; i<lssolver->unsatvar_stack_fill_pointer; ++i)
{
v = lssolver->unsatvar_stack[i];
lssolver->score[v] += lssolver->unsat_app_count[v];
if(lssolver->score[v]>0 && lssolver->cscc[v]==1 && lssolver->already_in_goodvar_stack[v] ==0)
{
push(v,lssolver->goodvar_stack);
lssolver->already_in_goodvar_stack[v] =1;
}
}
lssolver->delta_total_weight+=lssolver->unsat_stack_fill_pointer;
if(lssolver->delta_total_weight>=lssolver->num_clauses)
{
lssolver->ave_weight+=1;
lssolver->delta_total_weight -= lssolver->num_clauses;
//smooth weights
if(lssolver->ave_weight>lssolver->threshold)
smooth_clause_weights(lssolver);
}
}
void set_clause_weighting(CCAnr *lssolver)
{
lssolver->threshold=300;
lssolver->p_scale=0.3;
if(lssolver->q_init==0)
{
if(lssolver->ratio<=15) lssolver->q_scale=0;
else lssolver->q_scale=0.7;
}
else
{
if(lssolver->q_scale<0.5) //0
lssolver->q_scale = 0.7;
else
lssolver->q_scale = 0;
}
lssolver->scale_ave=(lssolver->threshold+1)*lssolver->q_scale;
lssolver->q_init = 1;
}
//preprocess
void unit_propagation(CCAnr *lssolver)
{
lit uc_lit;
int uc_clause;
int uc_var;
bool uc_sense;
int c;
int i,j;
lit cur;
for(lssolver->unitclause_queue_beg_pointer=0; lssolver->unitclause_queue_beg_pointer < lssolver->unitclause_queue_end_pointer; lssolver->unitclause_queue_beg_pointer++)
{
uc_lit = lssolver->unitclause_queue[lssolver->unitclause_queue_beg_pointer];
uc_var = uc_lit.var_num;
uc_sense = uc_lit.sense;
if(lssolver->fix[uc_var]==1) {if(uc_sense!=lssolver->cur_soln[uc_var])printf("c wants to fix a variable twice, forbid\n");continue;}
lssolver->cur_soln[uc_var] = uc_sense;//fix the variable in unit clause
lssolver->fix[uc_var] = 1;
for(i = 0; i<lssolver->var_lit_count[uc_var]; ++i)
{
cur = lssolver->var_lit[uc_var][i];
c = cur.clause_num;
if(lssolver->clause_delete[c]==1) continue;
if(cur.sense == uc_sense)//then remove the clause from var's var_lit[] array
{
lssolver->clause_delete[c]=1;
lssolver->clause_lit_count[c]=0;
}
else
{
if(lssolver->clause_lit_count[c]==2)
{
if(lssolver->clause_lit[c][0].var_num == uc_var)
{
lssolver->unitclause_queue[lssolver->unitclause_queue_end_pointer++] = lssolver->clause_lit[c][1];
}
else
{
lssolver->unitclause_queue[lssolver->unitclause_queue_end_pointer++] = lssolver->clause_lit[c][0];
}
lssolver->clause_delete[c]=1;
lssolver->clause_lit_count[c]=0;
}
else
{
for(j=0; j<lssolver->clause_lit_count[c]; ++j)
{
if(lssolver->clause_lit[c][j].var_num == uc_var)
{
lssolver->clause_lit[c][j]=lssolver->clause_lit[c][lssolver->clause_lit_count[c]-1];
lssolver->clause_lit_count[c]--;
break;
}
}
}
}
}
}
}
void preprocess(CCAnr *lssolver)
{
int c,v,i;
int delete_clause_count=0;
int fix_var_count=0;
// ofstream fout("test2.txt");
// for (int c = 0; c < lssolver->num_clauses; ++c)
// {
// if(lssolver->clause_delete[c]==1) {
// continue;
// }
// fout << c << ": ";
// for(int i=0; i<lssolver->clause_lit_count[c]; ++i)
// {
// int v = lssolver->clause_lit[c][i].var_num;
// int p = lssolver->clause_lit[c][i].sense;
// fout << (p==1 ? v:-v) << " ";
// }
// fout << std::endl;
// }
// fout.close();
unit_propagation(lssolver);
//rescan all clauses to build up var literal arrays
for (v=1; v<=lssolver->num_vars; ++v)
lssolver->var_lit_count[v] = 0;
lssolver->max_clause_len = 0;
lssolver->min_clause_len = lssolver->num_vars;
int formula_len=0;
for (c = 0; c < lssolver->num_clauses; ++c)
{
if(lssolver->clause_delete[c]==1) {
delete_clause_count++;
continue;
}
for(i=0; i<lssolver->clause_lit_count[c]; ++i)
{
v = lssolver->clause_lit[c][i].var_num;
if (v > 0 && v <= lssolver->num_vars);
else {
printf("\n444wrong v %d clause id: %d\n", v, c);
for(int ii=0; ii<lssolver->clause_lit_count[c]; ++ii)
printf("%d ", lssolver->clause_lit[c][ii].var_num);
puts("");
}
if (lssolver->var_lit_count[v] >= 0 && lssolver->var_lit_count[v] <= lssolver->num_clauses);
else printf("444wrong var_lit_count[v] %d\n", lssolver->var_lit_count[v]);
lssolver->var_lit[v][lssolver->var_lit_count[v]] = lssolver->clause_lit[c][i];
++lssolver->var_lit_count[v];
}
lssolver->clause_lit[c][i].var_num=0; //new clause boundary
lssolver->clause_lit[c][i].clause_num = -1;
//about clause length
formula_len += lssolver->clause_lit_count[c];
if(lssolver->clause_lit_count[c] > lssolver->max_clause_len)
lssolver->max_clause_len = lssolver->clause_lit_count[c];
else if(lssolver->clause_lit_count[c] < lssolver->min_clause_len)
lssolver->min_clause_len = lssolver->clause_lit_count[c];
}
lssolver->avg_clause_len = (double)(formula_len+0.0)/lssolver->num_clauses;
for (v=1; v<=lssolver->num_vars; ++v)
{
if(lssolver->fix[v]==1)
{
fix_var_count++;
}
lssolver->var_lit[v][lssolver->var_lit_count[v]].clause_num=-1;//new var_lit boundary
}
lssolver->fix_var_ct = fix_var_count;
lssolver->del_cls_ct = delete_clause_count;
// printf("c unit propagation fixes %d variables, and deletes %d clauses\n",fix_var_count,delete_clause_count);
}
void ccanr_merseene_init(CCAnr* lssolver, int seed){
ccanr_Mersenne_init_with_seed(&(lssolver->randgen),seed);
}
int ccanr_rand(CCAnr* lssolver,int bound){
return ccanr_Mersenne_next(&(lssolver->randgen),bound);
}
void ccanr_Mersenne_init_with_seed(ccanr_randgen* randgen, int seed){
unsigned int s = ((unsigned int) (seed << 1)) + 1;
randgen->mt[0] = s & 0xffffffffUL;
for(randgen->mti = 1; randgen->mti < ccanr_Mersenne_N; randgen->mti++) {
randgen->mt[randgen->mti] = (1812433253UL * (randgen->mt[randgen->mti - 1] ^ (randgen->mt[randgen->mti - 1] >> 30)) + randgen->mti);
randgen->mt[randgen->mti] &= 0xffffffffUL;
}
}
int ccanr_Mersenne_next31(ccanr_randgen* randgen){
unsigned int y;
static unsigned int mag01[2] = {0x0UL, ccanr_Mersenne_MATRIX_A};
if(randgen->mti >= ccanr_Mersenne_N) {
int kk;
for(kk = 0; kk < ccanr_Mersenne_N - ccanr_Mersenne_M; kk++) {
y = (randgen->mt[kk] & ccanr_Mersenne_UPPER_MASK) | (randgen->mt[kk + 1] & ccanr_Mersenne_LOWER_MASK);
randgen->mt[kk] = randgen->mt[kk + ccanr_Mersenne_M] ^ (y >> 1) ^ mag01[y & 0x1UL];
}
for(; kk < ccanr_Mersenne_N - 1; kk++) {
y = (randgen->mt[kk] & ccanr_Mersenne_UPPER_MASK) | (randgen->mt[kk + 1] & ccanr_Mersenne_LOWER_MASK);
randgen->mt[kk] = randgen->mt[kk + (ccanr_Mersenne_M - ccanr_Mersenne_N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
}
y = (randgen->mt[ccanr_Mersenne_N - 1] & ccanr_Mersenne_UPPER_MASK) | (randgen->mt[0] & ccanr_Mersenne_LOWER_MASK);
randgen->mt[ccanr_Mersenne_N - 1] = randgen->mt[ccanr_Mersenne_M - 1] ^ (y >> 1) ^ mag01[y & 0x1UL];
randgen->mti = 0;
}
y = randgen->mt[randgen->mti++];
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return (int) (y>>1);
}
int ccanr_Mersenne_next(ccanr_randgen* randgen, int bound){
unsigned int value;
do {
value = ccanr_Mersenne_next31(randgen);
} while(value + (unsigned int) bound >= 0x80000000UL);
return (int) (value % bound);
}
void init_CCAnr(CCAnr* lssolver){
int seed = 1;
ccanr_merseene_init(lssolver,seed);
default_initialize(lssolver);
}
void reinit_CCAnr(CCAnr *lssolver){
if (lssolver) free_memory(lssolver);
init_CCAnr(lssolver);
}
void confl_trans(CCAnr* lssolver){
lssolver->in_conflict_sz = 0;
if(lssolver->step==0) return;
for(int i=1;i<=lssolver->num_vars;++i){
lssolver->conflict_ct[i] = lssolver->conflict_ct[i]*100/lssolver->step;
if(lssolver->conflict_ct[i]>0){
lssolver->in_conflict[lssolver->in_conflict_sz++] = i;
}
}
}

129
lstech_maple/lstech/utils/ccnr.h Executable file
View File

@ -0,0 +1,129 @@
#ifndef _CCA_H_
#define _CCA_H_
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>
#include <sys/times.h> //these two h files are for linux
#include <unistd.h>
// mersenne twist
typedef struct ccanr_randgen ccanr_randgen;
struct ccanr_randgen
{
unsigned mt[624];
int mti;
};
// Define a data structure for a literal in the SAT problem.
typedef struct lit lit;
struct lit {
int clause_num; //clause num, begin with 0
int var_num; //variable num, begin with 1
int sense; //is 1 for true literals, 0 for false literals.
};
typedef struct CCAnr CCAnr;
struct CCAnr{
/*parameters of the instance*/
int num_vars; //var index from 1 to num_vars
int num_clauses; //clause index from 0 to num_clauses-1
int max_clause_len;
int min_clause_len;
int formula_len;
double avg_clause_len;
double ratio;
int ave_weight; //significant score(sigscore) needed for aspiration
int delta_total_weight;
int threshold;
float p_scale;//w=w*p+ave_w*q
float q_scale;
int scale_ave;//scale_ave==ave_weight*q_scale
int q_init;
long long mems_left;
//cutoff
int max_tries;
int tries;
int max_flips;
int step;
int* score_inc_vars;
int* score_inc_flag;
int score_inc_count;
/* literal arrays */
lit** var_lit; //var_lit[i][j] means the j'th literal of var i.
int* var_lit_count; //amount of literals of each var
lit** clause_lit; //clause_lit[i][j] means the j'th literal of clause i.
int* clause_lit_count; // amount of literals in each clause
/* Information about the variables. */
int* score;
int* time_stamp;
int* fix;
int* cscc;
/* Information about the clauses */
int* clause_weight;
int* sat_count;
int* sat_var;
//unsat clauses stack
int* unsat_stack; //store the unsat clause number
int unsat_stack_fill_pointer;
int* index_in_unsat_stack;//which position is a clause in the unsat_stack
//variables in unsat clauses
int* unsatvar_stack;
int unsatvar_stack_fill_pointer;
int* index_in_unsatvar_stack;
int* unsat_app_count; //a varible appears in how many unsat clauses
//configuration changed decreasing variables (score>0 and confchange=1)
int* goodvar_stack;
int goodvar_stack_fill_pointer;
int* already_in_goodvar_stack;
//unit clauses preprocess
lit* unitclause_queue;
int unitclause_queue_beg_pointer;
int unitclause_queue_end_pointer;
int* clause_delete;
/* Information about solution */
char* cur_soln; //the current solution, with 1's for True variables, and 0's for False variables
ccanr_randgen randgen;
char* best_soln;
int best_cost;
// confl_trans
int* conflict_ct;
int in_conflict_sz;
int* in_conflict;
// preprocess
int fix_var_ct;
int del_cls_ct;
};
void init_CCAnr(CCAnr*);
void reinit_CCAnr(CCAnr*);
void confl_trans(CCAnr*);
bool local_search(CCAnr*);
int build_instance(CCAnr*,char *filename);
void print_solution(CCAnr*);
int verify_sol(CCAnr*);
void alloc_memory(CCAnr*);
void free_memory(CCAnr*);
void settings(CCAnr*, char*);
void ccanr_merseene_init(CCAnr*, int);
void update_after_build(CCAnr*);
#endif

BIN
lstech_maple/lstech/utils/ccnr.or Executable file
View File

Binary file not shown.

9
lstech_maple/starexec_build Executable file
View File

@ -0,0 +1,9 @@
#!/bin/sh
rm build/*.o build/*.or
rm build/libRelaxed.a
rm build/Relaxed
rm bin/lstech_maple
cd lstech/simp
make clean
make rs
cp glucose_static ../../bin/lstech_maple

BIN
m4ri-20140914/.libs/libm4ri-0.0.20140914.so
View File

Binary file not shown.

BIN
m4ri-20140914/.libs/libm4ri.a
View File

Binary file not shown.

28
m4ri-20140914/Makefile
View File

@ -518,14 +518,14 @@ distuninstallcheck_listfiles = find . -type f -print
am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
| sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
distcleancheck_listfiles = find . -type f -print
ACLOCAL = ${SHELL} /root/cloud-sat/m4ri-20140914/missing aclocal-1.14
ACLOCAL = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing aclocal-1.14
AMTAR = $${TAR-tar}
AM_DEFAULT_VERBOSITY = 1
AR = ar
AUTOCONF = ${SHELL} /root/cloud-sat/m4ri-20140914/missing autoconf
AUTOHEADER = ${SHELL} /root/cloud-sat/m4ri-20140914/missing autoheader
AUTOMAKE = ${SHELL} /root/cloud-sat/m4ri-20140914/missing automake-1.14
AWK = mawk
AUTOCONF = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoconf
AUTOHEADER = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoheader
AUTOMAKE = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing automake-1.14
AWK = gawk
CC = gcc
CCDEPMODE = depmode=gcc3
CFLAGS = -g -O2
@ -560,8 +560,8 @@ LIPO =
LN_S = ln -s
LTLIBOBJS =
M4RI_CPU_L1_CACHE = 32768
M4RI_CPU_L2_CACHE = 1310720
M4RI_CPU_L3_CACHE = 12582912
M4RI_CPU_L2_CACHE = 524288
M4RI_CPU_L3_CACHE = 33554432
M4RI_DEBUG_DUMP = 0
M4RI_DEBUG_MZD = 0
M4RI_HAVE_LIBPNG = 0
@ -570,7 +570,7 @@ M4RI_HAVE_OPENMP = 0
M4RI_HAVE_POSIX_MEMALIGN = 1
M4RI_HAVE_SSE2 = 1
MAINT = #
MAKEINFO = ${SHELL} /root/cloud-sat/m4ri-20140914/missing makeinfo
MAKEINFO = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing makeinfo
MANIFEST_TOOL = :
MKDIR_P = /usr/bin/mkdir -p
NM = /usr/bin/nm -B
@ -591,7 +591,7 @@ PAPI_CFLAGS =
PAPI_LDFLAGS =
PAPI_LIBS =
PATH_SEPARATOR = :
PKG_CONFIG =
PKG_CONFIG = /usr/bin/pkg-config
PKG_CONFIG_LIBDIR =
PKG_CONFIG_PATH =
PNG_CFLAGS =
@ -604,10 +604,10 @@ SHELL = /bin/bash
SIMD_CFLAGS = -mmmx -msse -msse2 -msse3
STRIP = strip
VERSION = 20140914
abs_builddir = /root/cloud-sat/m4ri-20140914
abs_srcdir = /root/cloud-sat/m4ri-20140914
abs_top_builddir = /root/cloud-sat/m4ri-20140914
abs_top_srcdir = /root/cloud-sat/m4ri-20140914
abs_builddir = /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914
abs_srcdir = /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914
abs_top_builddir = /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914
abs_top_srcdir = /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914
ac_ct_AR = ar
ac_ct_CC = gcc
ac_ct_DUMPBIN =
@ -636,7 +636,7 @@ host_vendor = unknown
htmldir = ${docdir}
includedir = ${prefix}/include
infodir = ${datarootdir}/info
install_sh = ${SHELL} /root/cloud-sat/m4ri-20140914/install-sh
install_sh = ${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/install-sh
libdir = ${exec_prefix}/lib
libexecdir = ${exec_prefix}/libexec
localedir = ${datarootdir}/locale

810
m4ri-20140914/config.log
View File

@ -10,11 +10,11 @@ generated by GNU Autoconf 2.69. Invocation command line was
## Platform. ##
## --------- ##
hostname = code-server
hostname = seed7
uname -m = x86_64
uname -r = 5.15.74-1-pve
uname -r = 5.4.0-121-generic
uname -s = Linux
uname -v = #1 SMP PVE 5.15.74-1 (Mon, 14 Nov 2022 20:17:15 +0100)
uname -v = #137-Ubuntu SMP Wed Jun 15 13:33:07 UTC 2022
/usr/bin/uname -p = x86_64
/bin/uname -X = unknown
@ -27,209 +27,206 @@ uname -v = #1 SMP PVE 5.15.74-1 (Mon, 14 Nov 2022 20:17:15 +0100)
/usr/bin/oslevel = unknown
/bin/universe = unknown
PATH: /usr/lib/code-server/lib/vscode/bin/remote-cli
PATH: /usr/local/sbin
PATH: /usr/local/bin
PATH: /usr/sbin
PATH: /usr/bin
PATH: /sbin
PATH: /bin
PATH: /root/.local/bin
PATH: /usr/games
PATH: /usr/local/games
PATH: /snap/bin
## ----------- ##
## Core tests. ##
## ----------- ##
configure:2295: checking build system type
configure:2309: result: x86_64-unknown-linux-gnu
configure:2329: checking host system type
configure:2342: result: x86_64-unknown-linux-gnu
configure:2381: checking for a BSD-compatible install
configure:2449: result: /usr/bin/install -c
configure:2460: checking whether build environment is sane
configure:2515: result: yes
configure:2666: checking for a thread-safe mkdir -p
configure:2705: result: /usr/bin/mkdir -p
configure:2712: checking for gawk
configure:2742: result: no
configure:2712: checking for mawk
configure:2728: found /usr/bin/mawk
configure:2739: result: mawk
configure:2750: checking whether make sets $(MAKE)
configure:2772: result: yes
configure:2801: checking whether make supports nested variables
configure:2818: result: yes
configure:2946: checking whether to enable maintainer-specific portions of Makefiles
configure:2955: result: no
configure:2983: checking for style of include used by make
configure:3011: result: GNU
configure:3082: checking for gcc
configure:3098: found /usr/bin/gcc
configure:3109: result: gcc
configure:3338: checking for C compiler version
configure:3347: gcc --version >&5
gcc (Ubuntu 12.2.0-3ubuntu1) 12.2.0
Copyright (C) 2022 Free Software Foundation, Inc.
configure:2291: checking build system type
configure:2305: result: x86_64-unknown-linux-gnu
configure:2325: checking host system type
configure:2338: result: x86_64-unknown-linux-gnu
configure:2377: checking for a BSD-compatible install
configure:2445: result: /usr/bin/install -c
configure:2456: checking whether build environment is sane
configure:2511: result: yes
configure:2660: checking for a thread-safe mkdir -p
configure:2699: result: /usr/bin/mkdir -p
configure:2706: checking for gawk
configure:2722: found /usr/bin/gawk
configure:2733: result: gawk
configure:2744: checking whether make sets $(MAKE)
configure:2766: result: yes
configure:2795: checking whether make supports nested variables
configure:2812: result: yes
configure:2940: checking whether to enable maintainer-specific portions of Makefiles
configure:2949: result: no
configure:2977: checking for style of include used by make
configure:3005: result: GNU
configure:3076: checking for gcc
configure:3092: found /usr/bin/gcc
configure:3103: result: gcc
configure:3332: checking for C compiler version
configure:3341: gcc --version >&5
gcc (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0
Copyright (C) 2019 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
configure:3358: $? = 0
configure:3347: gcc -v >&5
configure:3352: $? = 0
configure:3341: gcc -v >&5
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/12/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/9/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none:hsa
OFFLOAD_TARGET_DEFAULT=1
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu 12.2.0-3ubuntu1' --with-bugurl=file:///usr/share/doc/gcc-12/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-12 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-12-U8K4Qv/gcc-12-12.2.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-12-U8K4Qv/gcc-12-12.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu 9.4.0-1ubuntu1~20.04.1' --with-bugurl=file:///usr/share/doc/gcc-9/README.Bugs --enable-languages=c,ada,c++,go,brig,d,fortran,objc,obj-c++,gm2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-9 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-9-Av3uEd/gcc-9-9.4.0/debian/tmp-nvptx/usr,hsa --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread model: posix
Supported LTO compression algorithms: zlib zstd
gcc version 12.2.0 (Ubuntu 12.2.0-3ubuntu1)
... rest of stderr output deleted ...
configure:3358: $? = 0
configure:3347: gcc -V >&5
gcc: error: unrecognized command-line option '-V'
gcc version 9.4.0 (Ubuntu 9.4.0-1ubuntu1~20.04.1)
configure:3352: $? = 0
configure:3341: gcc -V >&5
gcc: error: unrecognized command line option '-V'
gcc: fatal error: no input files
compilation terminated.
configure:3358: $? = 1
configure:3347: gcc -qversion >&5
gcc: error: unrecognized command-line option '-qversion'; did you mean '--version'?
configure:3352: $? = 1
configure:3341: gcc -qversion >&5
gcc: error: unrecognized command line option '-qversion'; did you mean '--version'?
gcc: fatal error: no input files
compilation terminated.
configure:3358: $? = 1
configure:3378: checking whether the C compiler works
configure:3400: gcc conftest.c >&5
configure:3404: $? = 0
configure:3452: result: yes
configure:3455: checking for C compiler default output file name
configure:3457: result: a.out
configure:3463: checking for suffix of executables
configure:3470: gcc -o conftest conftest.c >&5
configure:3474: $? = 0
configure:3496: result:
configure:3518: checking whether we are cross compiling
configure:3526: gcc -o conftest conftest.c >&5
configure:3530: $? = 0
configure:3537: ./conftest
configure:3541: $? = 0
configure:3556: result: no
configure:3561: checking for suffix of object files
configure:3583: gcc -c conftest.c >&5
configure:3587: $? = 0
configure:3608: result: o
configure:3612: checking whether we are using the GNU C compiler
configure:3631: gcc -c conftest.c >&5
configure:3631: $? = 0
configure:3640: result: yes
configure:3649: checking whether gcc accepts -g
configure:3669: gcc -c -g conftest.c >&5
configure:3669: $? = 0
configure:3710: result: yes
configure:3727: checking for gcc option to accept ISO C89
configure:3790: gcc -c -g -O2 conftest.c >&5
configure:3790: $? = 0
configure:3803: result: none needed
configure:3828: checking whether gcc understands -c and -o together
configure:3850: gcc -c conftest.c -o conftest2.o
configure:3853: $? = 0
configure:3850: gcc -c conftest.c -o conftest2.o
configure:3853: $? = 0
configure:3865: result: yes
configure:3884: checking dependency style of gcc
configure:3995: result: gcc3
configure:4058: checking how to print strings
configure:4085: result: printf
configure:4106: checking for a sed that does not truncate output
configure:4170: result: /usr/bin/sed
configure:4188: checking for grep that handles long lines and -e
configure:4246: result: /usr/bin/grep
configure:4251: checking for egrep
configure:4313: result: /usr/bin/grep -E
configure:4318: checking for fgrep
configure:4380: result: /usr/bin/grep -F
configure:4415: checking for ld used by gcc
configure:4482: result: /usr/bin/ld
configure:4489: checking if the linker (/usr/bin/ld) is GNU ld
configure:4504: result: yes
configure:4516: checking for BSD- or MS-compatible name lister (nm)
configure:4565: result: /usr/bin/nm -B
configure:4695: checking the name lister (/usr/bin/nm -B) interface
configure:4702: gcc -c -g -O2 conftest.c >&5
configure:4705: /usr/bin/nm -B "conftest.o"
configure:4708: output
configure:3352: $? = 1
configure:3372: checking whether the C compiler works
configure:3394: gcc conftest.c >&5
configure:3398: $? = 0
configure:3446: result: yes
configure:3449: checking for C compiler default output file name
configure:3451: result: a.out
configure:3457: checking for suffix of executables
configure:3464: gcc -o conftest conftest.c >&5
configure:3468: $? = 0
configure:3490: result:
configure:3512: checking whether we are cross compiling
configure:3520: gcc -o conftest conftest.c >&5
configure:3524: $? = 0
configure:3531: ./conftest
configure:3535: $? = 0
configure:3523: result: no
configure:3528: checking for suffix of object files
configure:3550: gcc -c conftest.c >&5
configure:3554: $? = 0
configure:3575: result: o
configure:3579: checking whether we are using the GNU C compiler
configure:3598: gcc -c conftest.c >&5
configure:3598: $? = 0
configure:3607: result: yes
configure:3616: checking whether gcc accepts -g
configure:3636: gcc -c -g conftest.c >&5
configure:3636: $? = 0
configure:3677: result: yes
configure:3694: checking for gcc option to accept ISO C89
configure:3757: gcc -c -g -O2 conftest.c >&5
configure:3757: $? = 0
configure:3770: result: none needed
configure:3795: checking whether gcc understands -c and -o together
configure:3817: gcc -c conftest.c -o conftest2.o
configure:3820: $? = 0
configure:3817: gcc -c conftest.c -o conftest2.o
configure:3820: $? = 0
configure:3832: result: yes
configure:3851: checking dependency style of gcc
configure:3962: result: gcc3
configure:4025: checking how to print strings
configure:4052: result: printf
configure:4073: checking for a sed that does not truncate output
configure:4137: result: /usr/bin/sed
configure:4155: checking for grep that handles long lines and -e
configure:4213: result: /usr/bin/grep
configure:4218: checking for egrep
configure:4280: result: /usr/bin/grep -E
configure:4285: checking for fgrep
configure:4347: result: /usr/bin/grep -F
configure:4382: checking for ld used by gcc
configure:4449: result: /usr/bin/ld
configure:4456: checking if the linker (/usr/bin/ld) is GNU ld
configure:4471: result: yes
configure:4483: checking for BSD- or MS-compatible name lister (nm)
configure:4532: result: /usr/bin/nm -B
configure:4662: checking the name lister (/usr/bin/nm -B) interface
configure:4669: gcc -c -g -O2 conftest.c >&5
configure:4672: /usr/bin/nm -B "conftest.o"
configure:4675: output
0000000000000000 B some_variable
configure:4715: result: BSD nm
configure:4718: checking whether ln -s works
configure:4722: result: yes
configure:4730: checking the maximum length of command line arguments
configure:4861: result: 1572864
configure:4878: checking whether the shell understands some XSI constructs
configure:4888: result: yes
configure:4892: checking whether the shell understands "+="
configure:4898: result: yes
configure:4933: checking how to convert x86_64-unknown-linux-gnu file names to x86_64-unknown-linux-gnu format
configure:4973: result: func_convert_file_noop
configure:4980: checking how to convert x86_64-unknown-linux-gnu file names to toolchain format
configure:5000: result: func_convert_file_noop
configure:5007: checking for /usr/bin/ld option to reload object files
configure:5014: result: -r
configure:5088: checking for objdump
configure:5104: found /usr/bin/objdump
configure:5115: result: objdump
configure:5147: checking how to recognize dependent libraries
configure:5345: result: pass_all
configure:5430: checking for dlltool
configure:5460: result: no
configure:5490: checking how to associate runtime and link libraries
configure:5517: result: printf %s\n
configure:5578: checking for ar
configure:5594: found /usr/bin/ar
configure:5605: result: ar
configure:5642: checking for archiver @FILE support
configure:5659: gcc -c -g -O2 conftest.c >&5
configure:5659: $? = 0
configure:5662: ar cru libconftest.a @conftest.lst >&5
configure:4676: result: BSD nm
configure:4679: checking whether ln -s works
configure:4683: result: yes
configure:4691: checking the maximum length of command line arguments
configure:4822: result: 1572864
configure:4839: checking whether the shell understands some XSI constructs
configure:4848: result: yes
configure:4852: checking whether the shell understands "+="
configure:4856: result: yes
configure:4891: checking how to convert x86_64-unknown-linux-gnu file names to x86_64-unknown-linux-gnu format
configure:4931: result: func_convert_file_noop
configure:4938: checking how to convert x86_64-unknown-linux-gnu file names to toolchain format
configure:4958: result: func_convert_file_noop
configure:4965: checking for /usr/bin/ld option to reload object files
configure:4972: result: -r
configure:5046: checking for objdump
configure:5062: found /usr/bin/objdump
configure:5073: result: objdump
configure:5105: checking how to recognize dependent libraries
configure:5303: result: pass_all
configure:5388: checking for dlltool
configure:5418: result: no
configure:5448: checking how to associate runtime and link libraries
configure:5475: result: printf %s\n
configure:5536: checking for ar
configure:5552: found /usr/bin/ar
configure:5563: result: ar
configure:5600: checking for archiver @FILE support
configure:5617: gcc -c -g -O2 conftest.c >&5
configure:5617: $? = 0
configure:5620: ar cru libconftest.a @conftest.lst >&5
ar: `u' modifier ignored since `D' is the default (see `U')
configure:5665: $? = 0
configure:5670: ar cru libconftest.a @conftest.lst >&5
configure:5623: $? = 0
configure:5628: ar cru libconftest.a @conftest.lst >&5
ar: `u' modifier ignored since `D' is the default (see `U')
ar: conftest.o: No such file or directory
configure:5673: $? = 1
configure:5685: result: @
configure:5743: checking for strip
configure:5759: found /usr/bin/strip
configure:5770: result: strip
configure:5842: checking for ranlib
configure:5858: found /usr/bin/ranlib
configure:5869: result: ranlib
configure:5971: checking command to parse /usr/bin/nm -B output from gcc object
configure:6091: gcc -c -g -O2 conftest.c >&5
configure:6094: $? = 0
configure:6098: /usr/bin/nm -B conftest.o \| sed -n -e 's/^.*[ ]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ ][ ]*\([_A-Za-z][_A-Za-z0-9]*\)$/\1 \2 \2/p' | sed '/ __gnu_lto/d' \> conftest.nm
configure:6101: $? = 0
configure:6167: gcc -o conftest -g -O2 conftest.c conftstm.o >&5
configure:6170: $? = 0
configure:6208: result: ok
configure:6245: checking for sysroot
configure:6275: result: no
configure:6352: gcc -c -g -O2 conftest.c >&5
configure:6355: $? = 0
configure:6544: checking for mt
configure:6560: found /usr/bin/mt
configure:6571: result: mt
configure:6594: checking if mt is a manifest tool
configure:6600: mt '-?'
configure:6608: result: no
configure:7250: checking how to run the C preprocessor
configure:7281: gcc -E conftest.c
configure:7281: $? = 0
configure:7295: gcc -E conftest.c
configure:5631: $? = 1
configure:5630: result: @
configure:5688: checking for strip
configure:5704: found /usr/bin/strip
configure:5715: result: strip
configure:5787: checking for ranlib
configure:5803: found /usr/bin/ranlib
configure:5814: result: ranlib
configure:5916: checking command to parse /usr/bin/nm -B output from gcc object
configure:6036: gcc -c -g -O2 conftest.c >&5
configure:6039: $? = 0
configure:6043: /usr/bin/nm -B conftest.o \| sed -n -e 's/^.*[ ]\([ABCDGIRSTW][ABCDGIRSTW]*\)[ ][ ]*\([_A-Za-z][_A-Za-z0-9]*\)$/\1 \2 \2/p' | sed '/ __gnu_lto/d' \> conftest.nm
configure:6046: $? = 0
configure:6112: gcc -o conftest -g -O2 conftest.c conftstm.o >&5
configure:6115: $? = 0
configure:6153: result: ok
configure:6190: checking for sysroot
configure:6220: result: no
configure:6297: gcc -c -g -O2 conftest.c >&5
configure:6300: $? = 0
configure:6489: checking for mt
configure:6505: found /usr/bin/mt
configure:6516: result: mt
configure:6539: checking if mt is a manifest tool
configure:6545: mt '-?'
configure:6553: result: no
configure:7195: checking how to run the C preprocessor
configure:7226: gcc -E conftest.c
configure:7226: $? = 0
configure:7240: gcc -E conftest.c
conftest.c:11:10: fatal error: ac_nonexistent.h: No such file or directory
11 | #include <ac_nonexistent.h>
| ^~~~~~~~~~~~~~~~~~
compilation terminated.
configure:7295: $? = 1
configure:7240: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "m4ri"
@ -242,15 +239,15 @@ configure: failed program was:
| #define VERSION "20140914"
| /* end confdefs.h. */
| #include <ac_nonexistent.h>
configure:7320: result: gcc -E
configure:7340: gcc -E conftest.c
configure:7340: $? = 0
configure:7354: gcc -E conftest.c
configure:7265: result: gcc -E
configure:7285: gcc -E conftest.c
configure:7285: $? = 0
configure:7299: gcc -E conftest.c
conftest.c:11:10: fatal error: ac_nonexistent.h: No such file or directory
11 | #include <ac_nonexistent.h>
| ^~~~~~~~~~~~~~~~~~
compilation terminated.
configure:7354: $? = 1
configure:7299: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "m4ri"
@ -263,154 +260,154 @@ configure: failed program was:
| #define VERSION "20140914"
| /* end confdefs.h. */
| #include <ac_nonexistent.h>
configure:7383: checking for ANSI C header files
configure:7403: gcc -c -g -O2 conftest.c >&5
configure:7403: $? = 0
configure:7476: gcc -o conftest -g -O2 conftest.c >&5
configure:7476: $? = 0
configure:7476: ./conftest
configure:7476: $? = 0
configure:7487: result: yes
configure:7500: checking for sys/types.h
configure:7500: gcc -c -g -O2 conftest.c >&5
configure:7500: $? = 0
configure:7500: result: yes
configure:7500: checking for sys/stat.h
configure:7500: gcc -c -g -O2 conftest.c >&5
configure:7500: $? = 0
configure:7500: result: yes
configure:7500: checking for stdlib.h
configure:7500: gcc -c -g -O2 conftest.c >&5
configure:7500: $? = 0
configure:7500: result: yes
configure:7500: checking for string.h
configure:7500: gcc -c -g -O2 conftest.c >&5
configure:7500: $? = 0
configure:7500: result: yes
configure:7500: checking for memory.h
configure:7500: gcc -c -g -O2 conftest.c >&5
configure:7500: $? = 0
configure:7500: result: yes
configure:7500: checking for strings.h
configure:7500: gcc -c -g -O2 conftest.c >&5
configure:7500: $? = 0
configure:7500: result: yes
configure:7500: checking for inttypes.h
configure:7500: gcc -c -g -O2 conftest.c >&5
configure:7500: $? = 0
configure:7500: result: yes
configure:7500: checking for stdint.h
configure:7500: gcc -c -g -O2 conftest.c >&5
configure:7500: $? = 0
configure:7500: result: yes
configure:7500: checking for unistd.h
configure:7500: gcc -c -g -O2 conftest.c >&5
configure:7500: $? = 0
configure:7500: result: yes
configure:7514: checking for dlfcn.h
configure:7514: gcc -c -g -O2 conftest.c >&5
configure:7514: $? = 0
configure:7514: result: yes
configure:7720: checking for objdir
configure:7735: result: .libs
configure:8006: checking if gcc supports -fno-rtti -fno-exceptions
configure:8024: gcc -c -g -O2 -fno-rtti -fno-exceptions conftest.c >&5
cc1: warning: command-line option '-fno-rtti' is valid for C++/D/ObjC++ but not for C
configure:8028: $? = 0
configure:8041: result: no
configure:8368: checking for gcc option to produce PIC
configure:8375: result: -fPIC -DPIC
configure:8383: checking if gcc PIC flag -fPIC -DPIC works
configure:8401: gcc -c -g -O2 -fPIC -DPIC -DPIC conftest.c >&5
configure:8405: $? = 0
configure:8418: result: yes
configure:8447: checking if gcc static flag -static works
configure:8475: result: yes
configure:7328: checking for ANSI C header files
configure:7348: gcc -c -g -O2 conftest.c >&5
configure:7348: $? = 0
configure:7421: gcc -o conftest -g -O2 conftest.c >&5
configure:7421: $? = 0
configure:7421: ./conftest
configure:7421: $? = 0
configure:7432: result: yes
configure:7445: checking for sys/types.h
configure:7445: gcc -c -g -O2 conftest.c >&5
configure:7445: $? = 0
configure:7445: result: yes
configure:7445: checking for sys/stat.h
configure:7445: gcc -c -g -O2 conftest.c >&5
configure:7445: $? = 0
configure:7445: result: yes
configure:7445: checking for stdlib.h
configure:7445: gcc -c -g -O2 conftest.c >&5
configure:7445: $? = 0
configure:7445: result: yes
configure:7445: checking for string.h
configure:7445: gcc -c -g -O2 conftest.c >&5
configure:7445: $? = 0
configure:7445: result: yes
configure:7445: checking for memory.h
configure:7445: gcc -c -g -O2 conftest.c >&5
configure:7445: $? = 0
configure:7445: result: yes
configure:7445: checking for strings.h
configure:7445: gcc -c -g -O2 conftest.c >&5
configure:7445: $? = 0
configure:7445: result: yes
configure:7445: checking for inttypes.h
configure:7445: gcc -c -g -O2 conftest.c >&5
configure:7445: $? = 0
configure:7445: result: yes
configure:7445: checking for stdint.h
configure:7445: gcc -c -g -O2 conftest.c >&5
configure:7445: $? = 0
configure:7445: result: yes
configure:7445: checking for unistd.h
configure:7445: gcc -c -g -O2 conftest.c >&5
configure:7445: $? = 0
configure:7445: result: yes
configure:7459: checking for dlfcn.h
configure:7459: gcc -c -g -O2 conftest.c >&5
configure:7459: $? = 0
configure:7459: result: yes
configure:7665: checking for objdir
configure:7680: result: .libs
configure:7951: checking if gcc supports -fno-rtti -fno-exceptions
configure:7969: gcc -c -g -O2 -fno-rtti -fno-exceptions conftest.c >&5
cc1: warning: command line option '-fno-rtti' is valid for C++/D/ObjC++ but not for C
configure:7973: $? = 0
configure:7986: result: no
configure:8313: checking for gcc option to produce PIC
configure:8320: result: -fPIC -DPIC
configure:8328: checking if gcc PIC flag -fPIC -DPIC works
configure:8346: gcc -c -g -O2 -fPIC -DPIC -DPIC conftest.c >&5
configure:8350: $? = 0
configure:8363: result: yes
configure:8392: checking if gcc static flag -static works
configure:8420: result: yes
configure:8435: checking if gcc supports -c -o file.o
configure:8456: gcc -c -g -O2 -o out/conftest2.o conftest.c >&5
configure:8460: $? = 0
configure:8482: result: yes
configure:8490: checking if gcc supports -c -o file.o
configure:8511: gcc -c -g -O2 -o out/conftest2.o conftest.c >&5
configure:8515: $? = 0
configure:8537: result: yes
configure:8545: checking if gcc supports -c -o file.o
configure:8592: result: yes
configure:8625: checking whether the gcc linker (/usr/bin/ld -m elf_x86_64) supports shared libraries
configure:9782: result: yes
configure:9819: checking whether -lc should be explicitly linked in
configure:9827: gcc -c -g -O2 conftest.c >&5
configure:9830: $? = 0
configure:9845: gcc -shared -fPIC -DPIC conftest.o -v -Wl,-soname -Wl,conftest -o conftest 2\>\&1 \| /usr/bin/grep -lc \>/dev/null 2\>\&1
configure:9848: $? = 0
configure:9862: result: no
configure:10022: checking dynamic linker characteristics
configure:10522: gcc -o conftest -g -O2 -Wl,-rpath -Wl,/foo conftest.c >&5
configure:10522: $? = 0
configure:10756: result: GNU/Linux ld.so
configure:10863: checking how to hardcode library paths into programs
configure:10888: result: immediate
configure:11428: checking whether stripping libraries is possible
configure:11433: result: yes
configure:11468: checking if libtool supports shared libraries
configure:11470: result: yes
configure:11473: checking whether to build shared libraries
configure:11494: result: yes
configure:11497: checking whether to build static libraries
configure:11501: result: yes
configure:11544: checking for gcc option to accept ISO C99
configure:11693: gcc -c -g -O2 conftest.c >&5
configure:11693: $? = 0
configure:11706: result: none needed
configure:11750: checking for x86 cpuid 0x00000001 output
configure:11789: gcc -o conftest -g -O2 conftest.c >&5
configure:11789: $? = 0
configure:11789: ./conftest
configure:11789: $? = 0
configure:11799: result: 90675:7100800:7ffafbbf:bfebfbff
configure:11811: checking whether mmx is supported
configure:11823: result: yes
configure:11826: checking whether sse is supported
configure:11838: result: yes
configure:11841: checking whether sse2 is supported
configure:11853: result: yes
configure:11856: checking whether sse3 is supported
configure:11868: result: yes
configure:11871: checking whether ssse3 is supported
configure:11883: result: yes
configure:11890: checking whether C compiler accepts -mmmx
configure:11909: gcc -c -mmmx conftest.c >&5
configure:11909: $? = 0
configure:11919: result: yes
configure:11933: checking whether C compiler accepts -msse
configure:11952: gcc -c -msse conftest.c >&5
configure:11952: $? = 0
configure:11962: result: yes
configure:11976: checking whether C compiler accepts -msse2
configure:11995: gcc -c -msse2 conftest.c >&5
configure:11995: $? = 0
configure:12005: result: yes
configure:12019: checking whether C compiler accepts -msse3
configure:12038: gcc -c -msse3 conftest.c >&5
configure:12038: $? = 0
configure:12048: result: yes
configure:12091: checking mm_malloc.h usability
configure:12091: gcc -c -g -O2 conftest.c >&5
configure:12091: $? = 0
configure:12091: result: yes
configure:12091: checking mm_malloc.h presence
configure:12091: gcc -E conftest.c
configure:12091: $? = 0
configure:12091: result: yes
configure:12091: checking for mm_malloc.h
configure:12091: result: yes
configure:12107: checking for working posix_memalign
configure:12131: gcc -o conftest -g -O2 conftest.c >&5
configure:12131: $? = 0
configure:12131: ./conftest
configure:12131: $? = 0
configure:12141: result: yes
configure:12282: checking for PAPI_start_counters in -lpapi
configure:12307: gcc -o conftest -g -O2 conftest.c -lpapi >&5
/usr/bin/ld: cannot find -lpapi: No such file or directory
configure:8570: checking whether the gcc linker (/usr/bin/ld -m elf_x86_64) supports shared libraries
configure:9727: result: yes
configure:9764: checking whether -lc should be explicitly linked in
configure:9772: gcc -c -g -O2 conftest.c >&5
configure:9775: $? = 0
configure:9790: gcc -shared -fPIC -DPIC conftest.o -v -Wl,-soname -Wl,conftest -o conftest 2\>\&1 \| /usr/bin/grep -lc \>/dev/null 2\>\&1
configure:9793: $? = 0
configure:9807: result: no
configure:9967: checking dynamic linker characteristics
configure:10467: gcc -o conftest -g -O2 -Wl,-rpath -Wl,/foo conftest.c >&5
configure:10467: $? = 0
configure:10701: result: GNU/Linux ld.so
configure:10808: checking how to hardcode library paths into programs
configure:10833: result: immediate
configure:11373: checking whether stripping libraries is possible
configure:11378: result: yes
configure:11413: checking if libtool supports shared libraries
configure:11415: result: yes
configure:11418: checking whether to build shared libraries
configure:11439: result: yes
configure:11442: checking whether to build static libraries
configure:11446: result: yes
configure:8494: checking for gcc option to accept ISO C99
configure:8643: gcc -c -g -O2 conftest.c >&5
configure:8643: $? = 0
configure:8656: result: none needed
configure:8700: checking for x86 cpuid 0x00000001 output
configure:8739: gcc -o conftest -g -O2 conftest.c >&5
configure:8739: $? = 0
configure:8739: ./conftest
configure:8739: $? = 0
configure:8749: result: a00f11:5e800800:7efa320b:178bfbff
configure:8761: checking whether mmx is supported
configure:8773: result: yes
configure:8776: checking whether sse is supported
configure:8788: result: yes
configure:8791: checking whether sse2 is supported
configure:8803: result: yes
configure:8806: checking whether sse3 is supported
configure:8818: result: yes
configure:8821: checking whether ssse3 is supported
configure:8833: result: yes
configure:8840: checking whether C compiler accepts -mmmx
configure:8859: gcc -c -mmmx conftest.c >&5
configure:8859: $? = 0
configure:8869: result: yes
configure:8883: checking whether C compiler accepts -msse
configure:8902: gcc -c -msse conftest.c >&5
configure:8902: $? = 0
configure:8912: result: yes
configure:8926: checking whether C compiler accepts -msse2
configure:8945: gcc -c -msse2 conftest.c >&5
configure:8945: $? = 0
configure:8955: result: yes
configure:8969: checking whether C compiler accepts -msse3
configure:8988: gcc -c -msse3 conftest.c >&5
configure:8988: $? = 0
configure:8998: result: yes
configure:9041: checking mm_malloc.h usability
configure:9041: gcc -c -g -O2 conftest.c >&5
configure:9041: $? = 0
configure:9041: result: yes
configure:9041: checking mm_malloc.h presence
configure:9041: gcc -E conftest.c
configure:9041: $? = 0
configure:9041: result: yes
configure:9041: checking for mm_malloc.h
configure:9041: result: yes
configure:9057: checking for working posix_memalign
configure:9081: gcc -o conftest -g -O2 conftest.c >&5
configure:9081: $? = 0
configure:9081: ./conftest
configure:9081: $? = 0
configure:9091: result: yes
configure:9232: checking for PAPI_start_counters in -lpapi
configure:9257: gcc -o conftest -g -O2 conftest.c -lpapi >&5
/usr/bin/ld: cannot find -lpapi
collect2: error: ld returned 1 exit status
configure:12307: $? = 1
configure:9257: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "m4ri"
@ -457,36 +454,52 @@ configure: failed program was:
| ;
| return 0;
| }
configure:12316: result: no
configure:12486: checking for x86 cpuid 0x0 output
configure:12525: gcc -o conftest -g -O2 conftest.c >&5
configure:12525: $? = 0
configure:12525: ./conftest
configure:12525: $? = 0
configure:12535: result: 20:756e6547:6c65746e:49656e69
configure:12545: checking for the processor vendor
configure:12584: result: Intel
configure:12601: checking for x86 cpuid 0x0 output
configure:12650: result: 20:756e6547:6c65746e:49656e69
configure:12660: checking for the processor vendor
configure:12699: result: Intel
configure:13036: checking the L1 cache size
configure:13040: result: 32768 Bytes
configure:13043: checking the L2 cache size
configure:13047: result: 1310720 Bytes
configure:13050: checking the L3 cache size
configure:13054: result: 12582912 Bytes
configure:13315: checking whether to build with PNG support
configure:13317: result: yes
configure:13375: checking for pkg-config
configure:13408: result: no
configure:13443: checking for PNG
configure:13502: result: no
configure:13513: checking for png_create_write_struct in -lpng
configure:13538: gcc -o conftest -g -O2 conftest.c -lpng >&5
/usr/bin/ld: cannot find -lpng: No such file or directory
configure:9266: result: no
configure:9436: checking for x86 cpuid 0x0 output
configure:9475: gcc -o conftest -g -O2 conftest.c >&5
configure:9475: $? = 0
configure:9475: ./conftest
configure:9475: $? = 0
configure:9485: result: 10:68747541:444d4163:69746e65
configure:9495: checking for the processor vendor
configure:9534: result: AMD
configure:9551: checking for x86 cpuid 0x0 output
configure:9600: result: 10:68747541:444d4163:69746e65
configure:9610: checking for the processor vendor
configure:9649: result: AMD
configure:9986: checking the L1 cache size
configure:9990: result: 32768 Bytes
configure:9993: checking the L2 cache size
configure:9997: result: 524288 Bytes
configure:10000: checking the L3 cache size
configure:10004: result: 33554432 Bytes
configure:10265: checking whether to build with PNG support
configure:10267: result: yes
configure:10325: checking for pkg-config
configure:10343: found /usr/bin/pkg-config
configure:10355: result: /usr/bin/pkg-config
configure:10380: checking pkg-config is at least version 0.9.0
configure:10383: result: yes
configure:10393: checking for PNG
configure:10400: $PKG_CONFIG --exists --print-errors "libpng"
Package libpng was not found in the pkg-config search path.
Perhaps you should add the directory containing `libpng.pc'
to the PKG_CONFIG_PATH environment variable
No package 'libpng' found
configure:10403: $? = 1
configure:10417: $PKG_CONFIG --exists --print-errors "libpng"
Package libpng was not found in the pkg-config search path.
Perhaps you should add the directory containing `libpng.pc'
to the PKG_CONFIG_PATH environment variable
No package 'libpng' found
configure:10420: $? = 1
configure:10434: result: no
No package 'libpng' found
configure:10463: checking for png_create_write_struct in -lpng
configure:10488: gcc -o conftest -g -O2 conftest.c -lpng >&5
/usr/bin/ld: cannot find -lpng
collect2: error: ld returned 1 exit status
configure:13538: $? = 1
configure:10488: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "m4ri"
@ -533,12 +546,12 @@ configure: failed program was:
| ;
| return 0;
| }
configure:13547: result: no
configure:13552: checking for png_create_write_struct in -lpng14
configure:13577: gcc -o conftest -g -O2 conftest.c -lpng14 >&5
/usr/bin/ld: cannot find -lpng14: No such file or directory
configure:10497: result: no
configure:10502: checking for png_create_write_struct in -lpng14
configure:10527: gcc -o conftest -g -O2 conftest.c -lpng14 >&5
/usr/bin/ld: cannot find -lpng14
collect2: error: ld returned 1 exit status
configure:13577: $? = 1
configure:10527: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "m4ri"
@ -585,12 +598,12 @@ configure: failed program was:
| ;
| return 0;
| }
configure:13586: result: no
configure:13591: checking for png_create_write_struct in -lpng12
configure:13616: gcc -o conftest -g -O2 conftest.c -lpng12 >&5
/usr/bin/ld: cannot find -lpng12: No such file or directory
configure:10536: result: no
configure:10541: checking for png_create_write_struct in -lpng12
configure:10566: gcc -o conftest -g -O2 conftest.c -lpng12 >&5
/usr/bin/ld: cannot find -lpng12
collect2: error: ld returned 1 exit status
configure:13616: $? = 1
configure:10566: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "m4ri"
@ -637,12 +650,12 @@ configure: failed program was:
| ;
| return 0;
| }
configure:13625: result: no
configure:13630: checking for png_create_write_struct in -lpng10
configure:13655: gcc -o conftest -g -O2 conftest.c -lpng10 >&5
/usr/bin/ld: cannot find -lpng10: No such file or directory
configure:10575: result: no
configure:10580: checking for png_create_write_struct in -lpng10
configure:10605: gcc -o conftest -g -O2 conftest.c -lpng10 >&5
/usr/bin/ld: cannot find -lpng10
collect2: error: ld returned 1 exit status
configure:13655: $? = 1
configure:10605: $? = 1
configure: failed program was:
| /* confdefs.h */
| #define PACKAGE_NAME "m4ri"
@ -689,13 +702,13 @@ configure: failed program was:
| ;
| return 0;
| }
configure:13664: result: no
configure:13683: WARNING: Can not find a usuable PNG library. Make sure that CPPFLAGS and LDFLAGS are correctly set.
configure:13700: checking whether make sets $(MAKE)
configure:13722: result: yes
configure:13835: checking that generated files are newer than configure
configure:13841: result: done
configure:13868: creating ./config.status
configure:10614: result: no
configure:10633: WARNING: Can not find a usuable PNG library. Make sure that CPPFLAGS and LDFLAGS are correctly set.
configure:10650: checking whether make sets $(MAKE)
configure:10672: result: yes
configure:10785: checking that generated files are newer than configure
configure:10791: result: done
configure:10818: creating ./config.status
## ---------------- ##
## Cache variables. ##
@ -754,9 +767,10 @@ ac_cv_path_EGREP='/usr/bin/grep -E'
ac_cv_path_FGREP='/usr/bin/grep -F'
ac_cv_path_GREP=/usr/bin/grep
ac_cv_path_SED=/usr/bin/sed
ac_cv_path_ac_pt_PKG_CONFIG=/usr/bin/pkg-config
ac_cv_path_install='/usr/bin/install -c'
ac_cv_path_mkdir=/usr/bin/mkdir
ac_cv_prog_AWK=mawk
ac_cv_prog_AWK=gawk
ac_cv_prog_CPP='gcc -E'
ac_cv_prog_ac_ct_AR=ar
ac_cv_prog_ac_ct_CC=gcc
@ -775,10 +789,10 @@ ax_cv_c_flags__mmmx=yes
ax_cv_c_flags__msse2=yes
ax_cv_c_flags__msse3=yes
ax_cv_c_flags__msse=yes
ax_cv_cpu_vendor=Intel
ax_cv_cpu_vendor=AMD
ax_cv_func_posix_memalign_works=yes
ax_cv_gcc_x86_cpuid_0x00000001=90675:7100800:7ffafbbf:bfebfbff
ax_cv_gcc_x86_cpuid_0x0=20:756e6547:6c65746e:49656e69
ax_cv_gcc_x86_cpuid_0x00000001=a00f11:5e800800:7efa320b:178bfbff
ax_cv_gcc_x86_cpuid_0x0=10:68747541:444d4163:69746e65
ax_cv_have_mmx_ext=yes
ax_cv_have_sse2_ext=yes
ax_cv_have_sse3_ext=yes
@ -815,7 +829,7 @@ lt_cv_to_tool_file_cmd=func_convert_file_noop
## Output variables. ##
## ----------------- ##
ACLOCAL='${SHELL} /root/cloud-sat/m4ri-20140914/missing aclocal-1.14'
ACLOCAL='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing aclocal-1.14'
AMDEPBACKSLASH='\'
AMDEP_FALSE='#'
AMDEP_TRUE=''
@ -825,10 +839,10 @@ AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
AM_DEFAULT_VERBOSITY='1'
AM_V='$(V)'
AR='ar'
AUTOCONF='${SHELL} /root/cloud-sat/m4ri-20140914/missing autoconf'
AUTOHEADER='${SHELL} /root/cloud-sat/m4ri-20140914/missing autoheader'
AUTOMAKE='${SHELL} /root/cloud-sat/m4ri-20140914/missing automake-1.14'
AWK='mawk'
AUTOCONF='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoconf'
AUTOHEADER='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoheader'
AUTOMAKE='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing automake-1.14'
AWK='gawk'
CC='gcc'
CCDEPMODE='depmode=gcc3'
CFLAGS='-g -O2'
@ -862,8 +876,8 @@ LIPO=''
LN_S='ln -s'
LTLIBOBJS=''
M4RI_CPU_L1_CACHE='32768'
M4RI_CPU_L2_CACHE='1310720'
M4RI_CPU_L3_CACHE='12582912'
M4RI_CPU_L2_CACHE='524288'
M4RI_CPU_L3_CACHE='33554432'
M4RI_DEBUG_DUMP='0'
M4RI_DEBUG_MZD='0'
M4RI_HAVE_LIBPNG='0'
@ -874,7 +888,7 @@ M4RI_HAVE_SSE2='1'
MAINT='#'
MAINTAINER_MODE_FALSE=''
MAINTAINER_MODE_TRUE='#'
MAKEINFO='${SHELL} /root/cloud-sat/m4ri-20140914/missing makeinfo'
MAKEINFO='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing makeinfo'
MANIFEST_TOOL=':'
MKDIR_P='/usr/bin/mkdir -p'
NM='/usr/bin/nm -B'
@ -895,7 +909,7 @@ PAPI_CFLAGS=''
PAPI_LDFLAGS=''
PAPI_LIBS=''
PATH_SEPARATOR=':'
PKG_CONFIG=''
PKG_CONFIG='/usr/bin/pkg-config'
PKG_CONFIG_LIBDIR=''
PKG_CONFIG_PATH=''
PNG_CFLAGS=''
@ -941,7 +955,7 @@ host_vendor='unknown'
htmldir='${docdir}'
includedir='${prefix}/include'
infodir='${datarootdir}/info'
install_sh='${SHELL} /root/cloud-sat/m4ri-20140914/install-sh'
install_sh='${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/install-sh'
libdir='${exec_prefix}/lib'
libexecdir='${exec_prefix}/libexec'
localedir='${datarootdir}/locale'
@ -1007,13 +1021,13 @@ generated by GNU Autoconf 2.69. Invocation command line was
CONFIG_COMMANDS =
$ ./config.status
on code-server
on seed7
config.status:1117: creating Makefile
config.status:1117: creating testsuite/Makefile
config.status:1117: creating m4ri/m4ri_config.h
config.status:1117: creating m4ri.pc
config.status:1117: creating m4ri/config.h
config.status:1298: m4ri/config.h is unchanged
config.status:1346: executing depfiles commands
config.status:1346: executing libtool commands
config.status:1113: creating Makefile
config.status:1113: creating testsuite/Makefile
config.status:1113: creating m4ri/m4ri_config.h
config.status:1113: creating m4ri.pc
config.status:1113: creating m4ri/config.h
config.status:1294: m4ri/config.h is unchanged
config.status:1342: executing depfiles commands
config.status:1342: executing libtool commands

28
m4ri-20140914/config.status
View File

@ -437,11 +437,11 @@ Copyright (C) 2012 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."
ac_pwd='/root/cloud-sat/m4ri-20140914'
ac_pwd='/home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914'
srcdir='.'
INSTALL='/usr/bin/install -c'
MKDIR_P='/usr/bin/mkdir -p'
AWK='mawk'
AWK='gawk'
test -n "$AWK" || AWK=awk
# The default lists apply if the user does not specify any file.
ac_need_defaults=:
@ -674,8 +674,8 @@ postuninstall_cmds=''
finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
finish_eval=''
hardcode_into_libs='yes'
sys_lib_search_path_spec='/usr/lib/gcc/x86_64-linux-gnu/12 /usr/lib/x86_64-linux-gnu /usr/lib /lib/x86_64-linux-gnu /lib '
sys_lib_dlsearch_path_spec='/lib /usr/lib /usr/lib/x86_64-linux-gnu/libfakeroot /usr/local/lib /usr/local/lib/x86_64-linux-gnu /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu /lib32 /usr/lib32 '
sys_lib_search_path_spec='/usr/lib/gcc/x86_64-linux-gnu/9 /usr/lib/x86_64-linux-gnu /usr/lib /lib/x86_64-linux-gnu /lib '
sys_lib_dlsearch_path_spec='/lib /usr/lib /usr/lib/x86_64-linux-gnu/libfakeroot /usr/local/lib /usr/local/lib/x86_64-linux-gnu /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu '
hardcode_action='immediate'
enable_dlopen='unknown'
enable_dlopen_self='unknown'
@ -827,9 +827,9 @@ S["PNG_LIBS"]=""
S["PNG_CFLAGS"]=""
S["PKG_CONFIG_LIBDIR"]=""
S["PKG_CONFIG_PATH"]=""
S["PKG_CONFIG"]=""
S["M4RI_CPU_L3_CACHE"]="12582912"
S["M4RI_CPU_L2_CACHE"]="1310720"
S["PKG_CONFIG"]="/usr/bin/pkg-config"
S["M4RI_CPU_L3_CACHE"]="33554432"
S["M4RI_CPU_L2_CACHE"]="524288"
S["M4RI_CPU_L1_CACHE"]="32768"
S["PAPI_CFLAGS"]=""
S["PAPI_LDFLAGS"]=""
@ -894,17 +894,17 @@ S["am__tar"]="$${TAR-tar} chof - \"$$tardir\""
S["AMTAR"]="$${TAR-tar}"
S["am__leading_dot"]="."
S["SET_MAKE"]=""
S["AWK"]="mawk"
S["AWK"]="gawk"
S["mkdir_p"]="$(MKDIR_P)"
S["MKDIR_P"]="/usr/bin/mkdir -p"
S["INSTALL_STRIP_PROGRAM"]="$(install_sh) -c -s"
S["STRIP"]="strip"
S["install_sh"]="${SHELL} /root/cloud-sat/m4ri-20140914/install-sh"
S["MAKEINFO"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing makeinfo"
S["AUTOHEADER"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing autoheader"
S["AUTOMAKE"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing automake-1.14"
S["AUTOCONF"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing autoconf"
S["ACLOCAL"]="${SHELL} /root/cloud-sat/m4ri-20140914/missing aclocal-1.14"
S["install_sh"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/install-sh"
S["MAKEINFO"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing makeinfo"
S["AUTOHEADER"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoheader"
S["AUTOMAKE"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing automake-1.14"
S["AUTOCONF"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing autoconf"
S["ACLOCAL"]="${SHELL} /home/chenzh/solvers/cloud-nobug/cloud-sat/m4ri-20140914/missing aclocal-1.14"
S["VERSION"]="20140914"
S["PACKAGE"]="m4ri"
S["CYGPATH_W"]="echo"

6
m4ri-20140914/libtool
View File

@ -2,7 +2,7 @@
# libtool - Provide generalized library-building support services.
# Generated automatically by config.status (m4ri) 20140914
# Libtool was configured on host code-server:
# Libtool was configured on host seed7:
# NOTE: Changes made to this file will be lost: look at ltmain.sh.
#
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
@ -272,10 +272,10 @@ finish_eval=""
hardcode_into_libs=yes
# Compile-time system search path for libraries.
sys_lib_search_path_spec="/usr/lib/gcc/x86_64-linux-gnu/12 /usr/lib/x86_64-linux-gnu /usr/lib /lib/x86_64-linux-gnu /lib "
sys_lib_search_path_spec="/usr/lib/gcc/x86_64-linux-gnu/9 /usr/lib/x86_64-linux-gnu /usr/lib /lib/x86_64-linux-gnu /lib "
# Run-time system search path for libraries.
sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib/x86_64-linux-gnu/libfakeroot /usr/local/lib /usr/local/lib/x86_64-linux-gnu /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu /lib32 /usr/lib32 "
sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib/x86_64-linux-gnu/libfakeroot /usr/local/lib /usr/local/lib/x86_64-linux-gnu /lib/x86_64-linux-gnu /usr/lib/x86_64-linux-gnu "
# Whether dlopen is supported.
dlopen_support=unknown

142
m4ri-20140914/m4ri/.deps/brilliantrussian.Plo
View File

@ -2,14 +2,13 @@ m4ri/brilliantrussian.lo: m4ri/brilliantrussian.c \
/usr/include/stdc-predef.h m4ri/config.h m4ri/brilliantrussian.h \
/usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
@ -20,8 +19,9 @@ m4ri/brilliantrussian.lo: m4ri/brilliantrussian.c \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/string.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/string.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \
/usr/include/strings.h \
@ -49,14 +49,13 @@ m4ri/brilliantrussian.lo: m4ri/brilliantrussian.c \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h \
/usr/include/x86_64-linux-gnu/bits/stdlib.h m4ri/mzd.h m4ri/config.h \
m4ri/m4ri_config.h /usr/include/assert.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -64,110 +63,203 @@ m4ri/brilliantrussian.lo: m4ri/brilliantrussian.c \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h m4ri/misc.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h m4ri/misc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/mzp.h m4ri/xor.h m4ri/xor_template.h m4ri/graycode.h \
m4ri/echelonform.h m4ri/ple_russian.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/brilliantrussian.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/string.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/mzd.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
m4ri/misc.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/mzp.h:
m4ri/xor.h:
m4ri/xor_template.h:
m4ri/graycode.h:
m4ri/echelonform.h:
m4ri/ple_russian.h:

137
m4ri-20140914/m4ri/.deps/debug_dump.Plo
View File

@ -1,14 +1,13 @@
m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \
m4ri/config.h m4ri/mzd.h m4ri/m4ri_config.h /usr/include/assert.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
@ -19,9 +18,10 @@ m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -29,13 +29,13 @@ m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -58,7 +58,6 @@ m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -70,97 +69,185 @@ m4ri/debug_dump.lo: m4ri/debug_dump.c /usr/include/stdc-predef.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/mzp.h m4ri/mzd.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/mzd.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
m4ri/config.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/mzp.h:
m4ri/mzd.h:

147
m4ri-20140914/m4ri/.deps/djb.Plo
View File

@ -1,14 +1,13 @@
m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \
m4ri/mzd.h m4ri/config.h m4ri/m4ri_config.h /usr/include/assert.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
@ -19,9 +18,10 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -29,13 +29,13 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -58,7 +58,6 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -70,7 +69,7 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/io.h m4ri/djb.h m4ri/xor.h m4ri/xor_template.h \
@ -81,103 +80,201 @@ m4ri/djb.lo: m4ri/djb.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/getopt_core.h \
/usr/include/x86_64-linux-gnu/bits/unistd.h \
/usr/include/x86_64-linux-gnu/bits/unistd_ext.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/mzd.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/io.h:
m4ri/djb.h:
m4ri/xor.h:
m4ri/xor_template.h:
/usr/include/unistd.h:
/usr/include/x86_64-linux-gnu/bits/posix_opt.h:
/usr/include/x86_64-linux-gnu/bits/environments.h:
/usr/include/x86_64-linux-gnu/bits/confname.h:
/usr/include/x86_64-linux-gnu/bits/getopt_posix.h:
/usr/include/x86_64-linux-gnu/bits/getopt_core.h:
/usr/include/x86_64-linux-gnu/bits/unistd.h:
/usr/include/x86_64-linux-gnu/bits/unistd_ext.h:

140
m4ri-20140914/m4ri/.deps/echelonform.Plo
View File

@ -1,15 +1,14 @@
m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \
m4ri/config.h m4ri/echelonform.h m4ri/mzd.h m4ri/config.h \
m4ri/m4ri_config.h /usr/include/assert.h /usr/include/features.h \
/usr/include/features-time64.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
@ -20,9 +19,10 @@ m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -30,13 +30,13 @@ m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -59,7 +59,6 @@ m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -71,100 +70,191 @@ m4ri/echelonform.lo: m4ri/echelonform.c /usr/include/stdc-predef.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/brilliantrussian.h m4ri/mzp.h m4ri/ple.h m4ri/triangular.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/echelonform.h:
m4ri/mzd.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/brilliantrussian.h:
m4ri/mzp.h:
m4ri/ple.h:
m4ri/triangular.h:

113
m4ri-20140914/m4ri/.deps/graycode.Plo
View File

@ -1,16 +1,15 @@
m4ri/graycode.lo: m4ri/graycode.c /usr/include/stdc-predef.h \
m4ri/config.h /usr/include/stdio.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
@ -20,14 +19,14 @@ m4ri/graycode.lo: m4ri/graycode.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h m4ri/misc.h \
m4ri/m4ri_config.h /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
m4ri/m4ri_config.h /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h \
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \
@ -48,7 +47,6 @@ m4ri/graycode.lo: m4ri/graycode.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -60,81 +58,152 @@ m4ri/graycode.lo: m4ri/graycode.c /usr/include/stdc-predef.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/graycode.h
/usr/include/stdc-predef.h:
m4ri/config.h:
/usr/include/stdio.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
m4ri/misc.h:
m4ri/m4ri_config.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
/usr/include/assert.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/graycode.h:

138
m4ri-20140914/m4ri/.deps/io.Plo
View File

@ -1,15 +1,14 @@
m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \
m4ri/m4ri_config.h m4ri/io.h m4ri/m4ri_config.h m4ri/mzd.h m4ri/config.h \
/usr/include/assert.h /usr/include/features.h \
/usr/include/features-time64.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
@ -20,9 +19,10 @@ m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -30,13 +30,13 @@ m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -59,7 +59,6 @@ m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -71,98 +70,187 @@ m4ri/io.lo: m4ri/io.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/echelonform.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/m4ri_config.h:
m4ri/io.h:
m4ri/m4ri_config.h:
m4ri/mzd.h:
m4ri/config.h:
/usr/include/assert.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/echelonform.h:

115
m4ri-20140914/m4ri/.deps/misc.Plo
View File

@ -1,16 +1,15 @@
m4ri/misc.lo: m4ri/misc.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/stdio.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
@ -20,13 +19,13 @@ m4ri/misc.lo: m4ri/misc.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h /usr/include/stdlib.h \
/usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h \
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \
@ -47,96 +46,168 @@ m4ri/misc.lo: m4ri/misc.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h \
/usr/include/x86_64-linux-gnu/bits/stdlib.h m4ri/graycode.h m4ri/misc.h \
m4ri/m4ri_config.h /usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
m4ri/m4ri_config.h /usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/assert.h /usr/include/string.h \
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/mmc.h m4ri/misc.h
/usr/include/stdc-predef.h:
m4ri/config.h:
/usr/include/stdio.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/graycode.h:
m4ri/misc.h:
m4ri/m4ri_config.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/assert.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/mmc.h:
m4ri/misc.h:

86
m4ri-20140914/m4ri/.deps/mmc.Plo
View File

@ -1,22 +1,21 @@
m4ri/mmc.lo: m4ri/mmc.c /usr/include/stdc-predef.h m4ri/config.h \
m4ri/mmc.h m4ri/misc.h m4ri/m4ri_config.h m4ri/config.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h \
@ -38,7 +37,6 @@ m4ri/mmc.lo: m4ri/mmc.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -50,70 +48,130 @@ m4ri/mmc.lo: m4ri/mmc.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/mmc.h:
m4ri/misc.h:
m4ri/m4ri_config.h:
m4ri/config.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
/usr/include/assert.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:

142
m4ri-20140914/m4ri/.deps/mp.Plo
View File

@ -1,22 +1,21 @@
m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \
m4ri/misc.h m4ri/m4ri_config.h m4ri/config.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h \
@ -38,7 +37,6 @@ m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -50,7 +48,7 @@ m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/mp.h m4ri/mzd.h \
m4ri/config.h /usr/include/math.h \
@ -60,8 +58,9 @@ m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -69,106 +68,199 @@ m4ri/mp.lo: m4ri/mp.c /usr/include/stdc-predef.h m4ri/m4ri_config.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h m4ri/misc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h m4ri/misc.h \
m4ri/debug_dump.h m4ri/brilliantrussian.h m4ri/mzp.h m4ri/strassen.h \
m4ri/brilliantrussian.h
/usr/include/stdc-predef.h:
m4ri/m4ri_config.h:
m4ri/misc.h:
m4ri/m4ri_config.h:
m4ri/config.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
/usr/include/assert.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/mp.h:
m4ri/mzd.h:
m4ri/config.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
m4ri/misc.h:
m4ri/debug_dump.h:
m4ri/brilliantrussian.h:
m4ri/mzp.h:
m4ri/strassen.h:
m4ri/brilliantrussian.h:

137
m4ri-20140914/m4ri/.deps/mzd.Plo
View File

@ -1,20 +1,19 @@
m4ri/mzd.lo: m4ri/mzd.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/stdlib.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h \
@ -36,7 +35,6 @@ m4ri/mzd.lo: m4ri/mzd.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -54,8 +52,9 @@ m4ri/mzd.lo: m4ri/mzd.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -63,104 +62,192 @@ m4ri/mzd.lo: m4ri/mzd.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h m4ri/misc.h \
m4ri/config.h /usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h m4ri/misc.h \
m4ri/config.h /usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h \
/usr/include/stdint.h /usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/parity.h m4ri/mmc.h
/usr/include/stdc-predef.h:
m4ri/config.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
m4ri/mzd.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
m4ri/misc.h:
m4ri/config.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/parity.h:
m4ri/mmc.h:

137
m4ri-20140914/m4ri/.deps/mzp.Plo
View File

@ -1,15 +1,14 @@
m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \
m4ri/mzp.h m4ri/mzd.h m4ri/config.h m4ri/m4ri_config.h \
/usr/include/assert.h /usr/include/features.h \
/usr/include/features-time64.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
@ -20,9 +19,10 @@ m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -30,13 +30,13 @@ m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -59,7 +59,6 @@ m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -71,97 +70,185 @@ m4ri/mzp.lo: m4ri/mzp.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/mzd.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/mzp.h:
m4ri/mzd.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/mzd.h:

149
m4ri-20140914/m4ri/.deps/ple.Plo
View File

@ -1,16 +1,15 @@
m4ri/ple.lo: m4ri/ple.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/stdio.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
@ -20,23 +19,24 @@ m4ri/ple.lo: m4ri/ple.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h m4ri/mzd.h \
m4ri/m4ri_config.h /usr/include/assert.h /usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -59,7 +59,6 @@ m4ri/ple.lo: m4ri/ple.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -71,104 +70,198 @@ m4ri/ple.lo: m4ri/ple.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/triangular.h m4ri/mzd.h m4ri/parity.h m4ri/ple_russian.h m4ri/mzp.h \
m4ri/strassen.h m4ri/brilliantrussian.h m4ri/ple.h
/usr/include/stdc-predef.h:
m4ri/config.h:
/usr/include/stdio.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
m4ri/mzd.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
m4ri/config.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/triangular.h:
m4ri/mzd.h:
m4ri/parity.h:
m4ri/ple_russian.h:
m4ri/mzp.h:
m4ri/strassen.h:
m4ri/brilliantrussian.h:
m4ri/ple.h:

143
m4ri-20140914/m4ri/.deps/ple_russian.Plo
View File

@ -1,25 +1,24 @@
m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \
m4ri/config.h m4ri/m4ri_config.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h \
@ -41,7 +40,6 @@ m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -54,8 +52,9 @@ m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -63,7 +62,7 @@ m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h m4ri/misc.h \
/usr/include/string.h \
@ -72,104 +71,198 @@ m4ri/ple_russian.lo: m4ri/ple_russian.c /usr/include/stdc-predef.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/mzp.h m4ri/brilliantrussian.h m4ri/graycode.h m4ri/xor.h \
m4ri/xor_template.h m4ri/ple_russian_template.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/ple_russian.h:
m4ri/mzd.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
m4ri/misc.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/mzp.h:
m4ri/brilliantrussian.h:
m4ri/graycode.h:
m4ri/xor.h:
m4ri/xor_template.h:
m4ri/ple_russian_template.h:

142
m4ri-20140914/m4ri/.deps/solve.Plo
View File

@ -1,15 +1,14 @@
m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \
m4ri/solve.h m4ri/mzp.h m4ri/mzd.h m4ri/config.h m4ri/m4ri_config.h \
/usr/include/assert.h /usr/include/features.h \
/usr/include/features-time64.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
@ -20,9 +19,10 @@ m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -30,13 +30,13 @@ m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -59,7 +59,6 @@ m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -71,103 +70,196 @@ m4ri/solve.lo: m4ri/solve.c /usr/include/stdc-predef.h m4ri/config.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/strassen.h m4ri/brilliantrussian.h m4ri/ple.h m4ri/triangular.h \
m4ri/mzp.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/solve.h:
m4ri/mzp.h:
m4ri/mzd.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/strassen.h:
m4ri/brilliantrussian.h:
m4ri/ple.h:
m4ri/triangular.h:
m4ri/mzp.h:

140
m4ri-20140914/m4ri/.deps/strassen.Plo
View File

@ -1,14 +1,13 @@
m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \
m4ri/config.h m4ri/graycode.h m4ri/strassen.h /usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
@ -19,10 +18,11 @@ m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h m4ri/mzd.h m4ri/config.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h m4ri/mzd.h m4ri/config.h \
m4ri/m4ri_config.h /usr/include/assert.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -30,13 +30,13 @@ m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -59,7 +59,6 @@ m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -71,100 +70,191 @@ m4ri/strassen.lo: m4ri/strassen.c /usr/include/stdc-predef.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/brilliantrussian.h m4ri/mzp.h m4ri/parity.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/graycode.h:
m4ri/strassen.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
m4ri/mzd.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/brilliantrussian.h:
m4ri/mzp.h:
m4ri/parity.h:

148
m4ri-20140914/m4ri/.deps/triangular.Plo
View File

@ -1,16 +1,15 @@
m4ri/triangular.lo: m4ri/triangular.c /usr/include/stdc-predef.h \
m4ri/config.h /usr/include/stdio.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
@ -20,23 +19,24 @@ m4ri/triangular.lo: m4ri/triangular.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h m4ri/triangular.h m4ri/mzd.h \
m4ri/config.h m4ri/m4ri_config.h /usr/include/assert.h \
/usr/include/math.h /usr/include/x86_64-linux-gnu/bits/math-vector.h \
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \
/usr/include/x86_64-linux-gnu/bits/floatn.h \
/usr/include/x86_64-linux-gnu/bits/floatn-common.h \
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -59,7 +59,6 @@ m4ri/triangular.lo: m4ri/triangular.c /usr/include/stdc-predef.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -71,103 +70,196 @@ m4ri/triangular.lo: m4ri/triangular.c /usr/include/stdc-predef.h \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/triangular_russian.h m4ri/strassen.h m4ri/brilliantrussian.h \
m4ri/mzp.h m4ri/mzd.h m4ri/parity.h
/usr/include/stdc-predef.h:
m4ri/config.h:
/usr/include/stdio.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
m4ri/triangular.h:
m4ri/mzd.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/triangular_russian.h:
m4ri/strassen.h:
m4ri/brilliantrussian.h:
m4ri/mzp.h:
m4ri/mzd.h:
m4ri/parity.h:

142
m4ri-20140914/m4ri/.deps/triangular_russian.Plo
View File

@ -1,15 +1,14 @@
m4ri/triangular_russian.lo: m4ri/triangular_russian.c \
/usr/include/stdc-predef.h m4ri/config.h m4ri/triangular_russian.h \
m4ri/mzd.h m4ri/config.h m4ri/m4ri_config.h /usr/include/assert.h \
/usr/include/features.h /usr/include/features-time64.h \
/usr/include/features.h /usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/wordsize.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/sys/cdefs.h \
/usr/include/x86_64-linux-gnu/bits/long-double.h \
/usr/include/x86_64-linux-gnu/gnu/stubs.h \
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h /usr/include/math.h \
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h \
/usr/include/x86_64-linux-gnu/bits/types.h \
/usr/include/x86_64-linux-gnu/bits/timesize.h \
/usr/include/x86_64-linux-gnu/bits/typesizes.h \
/usr/include/x86_64-linux-gnu/bits/time64.h \
/usr/include/x86_64-linux-gnu/bits/math-vector.h \
@ -20,9 +19,10 @@ m4ri/triangular_russian.lo: m4ri/triangular_russian.c \
/usr/include/x86_64-linux-gnu/bits/fp-logb.h \
/usr/include/x86_64-linux-gnu/bits/fp-fast.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/mathcalls.h \
/usr/include/x86_64-linux-gnu/bits/mathinline.h /usr/include/stdio.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \
@ -30,13 +30,13 @@ m4ri/triangular_russian.lo: m4ri/triangular_russian.c \
/usr/include/x86_64-linux-gnu/bits/types/FILE.h \
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h \
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h \
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h \
/usr/include/x86_64-linux-gnu/bits/stdio.h \
/usr/include/x86_64-linux-gnu/bits/stdio2.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h \
/usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \
/usr/include/x86_64-linux-gnu/bits/waitstatus.h \
/usr/include/x86_64-linux-gnu/sys/types.h \
@ -59,7 +59,6 @@ m4ri/triangular_russian.lo: m4ri/triangular_russian.c \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h \
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h \
@ -71,103 +70,196 @@ m4ri/triangular_russian.lo: m4ri/triangular_russian.c \
/usr/include/strings.h \
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h \
/usr/include/x86_64-linux-gnu/bits/string_fortified.h \
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h /usr/include/stdint.h \
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h /usr/include/stdint.h \
/usr/include/x86_64-linux-gnu/bits/wchar.h \
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h m4ri/debug_dump.h \
m4ri/graycode.h m4ri/brilliantrussian.h m4ri/mzp.h m4ri/ple_russian.h \
m4ri/xor.h m4ri/xor_template.h
/usr/include/stdc-predef.h:
m4ri/config.h:
m4ri/triangular_russian.h:
m4ri/mzd.h:
m4ri/config.h:
m4ri/m4ri_config.h:
/usr/include/assert.h:
/usr/include/features.h:
/usr/include/features-time64.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/sys/cdefs.h:
/usr/include/x86_64-linux-gnu/bits/wordsize.h:
/usr/include/x86_64-linux-gnu/bits/long-double.h:
/usr/include/x86_64-linux-gnu/gnu/stubs.h:
/usr/include/x86_64-linux-gnu/gnu/stubs-64.h:
/usr/include/math.h:
/usr/include/x86_64-linux-gnu/bits/libc-header-start.h:
/usr/include/x86_64-linux-gnu/bits/types.h:
/usr/include/x86_64-linux-gnu/bits/timesize.h:
/usr/include/x86_64-linux-gnu/bits/typesizes.h:
/usr/include/x86_64-linux-gnu/bits/time64.h:
/usr/include/x86_64-linux-gnu/bits/math-vector.h:
/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h:
/usr/include/x86_64-linux-gnu/bits/floatn.h:
/usr/include/x86_64-linux-gnu/bits/floatn-common.h:
/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h:
/usr/include/x86_64-linux-gnu/bits/fp-logb.h:
/usr/include/x86_64-linux-gnu/bits/fp-fast.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h:
/usr/include/x86_64-linux-gnu/bits/mathcalls.h:
/usr/include/x86_64-linux-gnu/bits/mathinline.h:
/usr/include/stdio.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdarg.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stddef.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdarg.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/FILE.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h:
/usr/include/x86_64-linux-gnu/bits/stdio_lim.h:
/usr/include/x86_64-linux-gnu/bits/stdio2-decl.h:
/usr/include/x86_64-linux-gnu/bits/sys_errlist.h:
/usr/include/x86_64-linux-gnu/bits/stdio.h:
/usr/include/x86_64-linux-gnu/bits/stdio2.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/mm_malloc.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/emmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/xmmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mmintrin.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/mm_malloc.h:
/usr/include/stdlib.h:
/usr/include/x86_64-linux-gnu/bits/waitflags.h:
/usr/include/x86_64-linux-gnu/bits/waitstatus.h:
/usr/include/x86_64-linux-gnu/sys/types.h:
/usr/include/x86_64-linux-gnu/bits/types/clock_t.h:
/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h:
/usr/include/x86_64-linux-gnu/bits/types/time_t.h:
/usr/include/x86_64-linux-gnu/bits/types/timer_t.h:
/usr/include/x86_64-linux-gnu/bits/stdint-intn.h:
/usr/include/endian.h:
/usr/include/x86_64-linux-gnu/bits/endian.h:
/usr/include/x86_64-linux-gnu/bits/endianness.h:
/usr/include/x86_64-linux-gnu/bits/byteswap.h:
/usr/include/x86_64-linux-gnu/bits/uintn-identity.h:
/usr/include/x86_64-linux-gnu/sys/select.h:
/usr/include/x86_64-linux-gnu/bits/select.h:
/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h:
/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h:
/usr/include/x86_64-linux-gnu/bits/select2.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h:
/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h:
/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h:
/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h:
/usr/include/x86_64-linux-gnu/bits/struct_mutex.h:
/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h:
/usr/include/alloca.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-bsearch.h:
/usr/include/x86_64-linux-gnu/bits/stdlib-float.h:
/usr/include/x86_64-linux-gnu/bits/stdlib.h:
m4ri/misc.h:
/usr/include/string.h:
/usr/include/x86_64-linux-gnu/bits/types/locale_t.h:
/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h:
/usr/include/strings.h:
/usr/include/x86_64-linux-gnu/bits/strings_fortified.h:
/usr/include/x86_64-linux-gnu/bits/string_fortified.h:
/usr/lib/gcc/x86_64-linux-gnu/12/include/stdint.h:
/usr/lib/gcc/x86_64-linux-gnu/9/include/stdint.h:
/usr/include/stdint.h:
/usr/include/x86_64-linux-gnu/bits/wchar.h:
/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h:
m4ri/debug_dump.h:
m4ri/graycode.h:
m4ri/brilliantrussian.h:
m4ri/mzp.h:
m4ri/ple_russian.h:
m4ri/xor.h:
m4ri/xor_template.h:

BIN
m4ri-20140914/m4ri/.libs/brilliantrussian.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/debug_dump.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/djb.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/echelonform.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/graycode.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/io.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/misc.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/mmc.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/mp.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/mzd.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/mzp.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/ple.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/ple_russian.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/solve.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/strassen.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/triangular.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/.libs/triangular_russian.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/brilliantrussian.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/debug_dump.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/djb.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/echelonform.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/graycode.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/io.o
View File

Binary file not shown.

4
m4ri-20140914/m4ri/m4ri_config.h
View File

@ -7,8 +7,8 @@
#define __M4RI_HAVE_SSE2 1
#define __M4RI_HAVE_OPENMP 0
#define __M4RI_CPU_L1_CACHE 32768
#define __M4RI_CPU_L2_CACHE 1310720
#define __M4RI_CPU_L3_CACHE 12582912
#define __M4RI_CPU_L2_CACHE 524288
#define __M4RI_CPU_L3_CACHE 33554432
#define __M4RI_DEBUG_DUMP (0 || 0)
#define __M4RI_DEBUG_MZD 0
#define __M4RI_HAVE_LIBPNG 0

BIN
m4ri-20140914/m4ri/misc.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/mmc.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/mp.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/mzd.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/mzp.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/ple.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/ple_russian.o
View File

Binary file not shown.

BIN
m4ri-20140914/m4ri/solve.o
View File

Binary file not shown.

Some files were not shown because too many files have changed in this diff Show More