diff options
Diffstat (limited to 'test/monniaux/picosat-965')
| -rw-r--r-- | test/monniaux/picosat-965/LICENSE | 20 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/Makefile | 11 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/NEWS | 162 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/README | 5 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/VERSION | 1 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/app.c | 1214 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/config.h | 3 | ||||
| -rwxr-xr-x | test/monniaux/picosat-965/configure.sh | 150 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/main.c | 25 | ||||
| -rwxr-xr-x | test/monniaux/picosat-965/mkconfig.sh | 35 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/picogcnf.c | 165 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/picomcs.c | 334 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/picomus.c | 413 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/picosat.c | 8508 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/picosat.h | 660 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/sudoku.sat | 20519 | ||||
| -rw-r--r-- | test/monniaux/picosat-965/version.c | 14 |
17 files changed, 32239 insertions, 0 deletions
diff --git a/test/monniaux/picosat-965/LICENSE b/test/monniaux/picosat-965/LICENSE new file mode 100644 index 00000000..96739de2 --- /dev/null +++ b/test/monniaux/picosat-965/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2006 - 2014, Armin Biere, Johannes Kepler University. + +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. + diff --git a/test/monniaux/picosat-965/Makefile b/test/monniaux/picosat-965/Makefile new file mode 100644 index 00000000..a887c0de --- /dev/null +++ b/test/monniaux/picosat-965/Makefile @@ -0,0 +1,11 @@ +EXECUTE_ARGS=sudoku.sat +ALL_CFLAGS = -DNALARM -DNZIP -DNGETRUSAGE -DNDEBUG +ALL_CCOMPFLAGS += -fbitfields # -fno-if-conversion +TARGET=picosat +ALL_CFILES=picosat.c version.c app.c main.c + +include ../rules.mk + +# FIXME - what were these for? +#K1C_CFLAGS += $(EMBEDDED_CFLAGS) +#K1C_CCOMPFLAGS += $(EMBEDDED_CFLAGS) diff --git a/test/monniaux/picosat-965/NEWS b/test/monniaux/picosat-965/NEWS new file mode 100644 index 00000000..7ad60b53 --- /dev/null +++ b/test/monniaux/picosat-965/NEWS @@ -0,0 +1,162 @@ +news for release 965 since 959 +------------------------------ + +* ADC code works again (spotted by Himanshu Jain) +* include into R projects (with Christoph Muessel) (--rcode) +* fixed 'undefined' + 'ptrdiff_' issues (thanks to Christoph Muessel) +* added 'picosat_set_interrupt' and '-a <alarm>' command line option +* fixed various issues pointed out by Stefan Hengelein: + - fixed incremental usage of 'picosat_adjust' + - added CPP fixes (STATS, NO_BINARY_CLAUSE versus TRACE mix-ups) + - removed redundant explicit set to zero on reset +* fixed various usage bugs with 'picomus' (thanks to Stefan Hengelein) +* removed '-fno-strict-aliasing' (thanks to Jerry James) + +news for release 959 since 953 +------------------------------ + +* fixed header comments + +* fixed minor compilation issues + +* fixed unitialized memory access problem for 'picosat_deref_partial' + and another issue with partial models + +* added 'picosat_add_arg' and 'picosat_add_lits' + +* '--plain' and 'picosat_set_plain' to disable failed literal probing + +* new '#define PICOSAT_REENTRANT_API' in 'picosat.h' + +* added manager so no more global variables + (allows multiple instances, requires manager object) + +news for release 951 since 941 +------------------------------ + +* cleaned up code (based on comments by Donald Knuth) + +* lreduce=O(conflicts^.5) + +* added 'picosat_visits' and 'picosat_decisions' + +* added '--partial' command line option + +* added 'picosat_deref_partial' and 'picosat_save_original_clauses' + +* added 'picomcs' as example for MSS computation + +news for release 941 since 936 +------------------------------ + +* added 'picogcnf' + +* added All-SAT mode ('--all' command line option) + +* statistics include time spent in failed literal preprocessing (probing) + +* 'picosat_failed_context' for 'push & pop' + (and tested failed assumptions for 'push & pop') + +* 'picosat_simplify' for forced garbage collection + +* undefined NFL, defined NADC (= failed literals on, ADC's off) + +* 'picosat_push' and 'picosat_pop' (beta version) + +* fixed some issues related to binary clause handling and + generating list of failed assumptions + +news for release 936 since 935 +------------------------------ + +* simple minimal unsatisfiable core (MUS) extractor 'picomus' + (example for using 'picosat_mus_assumptions' and 'picosat_coreclause') + +* added 'picosat_mus_assumptions' + +* added 'picosat_{set_}propagations' + +* new 'int' return value for 'picosat_enable_trace_generation' to + check for trace code being compiled + +news for release 935 since 926 +------------------------------ + +* added 'picosat_failed_assumptions' (plural) + +* new '-A <failedlits>' command line option + +* fixed failed assumption issues + +* added 'picosat_remove_learned' + +* added 'picosat_reset_{phases,scores}' + +* added 'picosat_set_less_important_lit' + +* added 'picosat_res' + +news for release 926 since 846 +------------------------------ + +* random initial phase (API of 'picosat_set_default_phase' changed) + +* fixed accumulative failed assumption (multiple times) + +* fixed missing original clause in core generation with assumptions + +* fixed debugging code for memory allocation + +* shared library in addition to static library + +* removed potential UNKNOWN result without decision limit + +* added picosat_set_more_important_lit + +* added picosat_coreclause + +* propagation of binary clauses until completion + +* fixed API usage 'assume;sat;sat' + +* literals move to front (LMTF) during traversal of visited clauses + +* switched from inner/outer to Luby style restart scheduling + +* less agressive reduce schedule + +* replaced watched literals with head and tail pointers + +* add 'picosat_failed_assumption', which allows to avoid tracing and core + generation, if one is only interested in assumptions in the core + +* fixed a BUG in the generic iterator code of clauses + (should rarely happen unless you use a very sophisticated malloc lib) + +news for release 846 since 632 +------------------------------ + +* cleaned up assumption handling (actually removed buggy optimization) + +* incremental core generation + +* experimental 'all different constraint' handling as in our FMCAD'08 paper + +* new API calls: + + - picosat_add_ado_lit (add all different object literal) + - picosat_deref_top_level (deref top level assignment) + - picosat_changed (check whether extension was possible) + - picosat_measure_all_calls (per default do not measure adding time) + - picosat_set_prefix (set prefix for messages) + +* 64 bit port (and compilation options) + +* optional NVSIDS visualization code + +* resource controlled failed literal implementation + +* disconnect long clauses satisfied at lower decision level + +* controlling restarts diff --git a/test/monniaux/picosat-965/README b/test/monniaux/picosat-965/README new file mode 100644 index 00000000..05b84396 --- /dev/null +++ b/test/monniaux/picosat-965/README @@ -0,0 +1,5 @@ +These are the sources of the PicoSAT solver. +The preprocessor is not included. +To compile run './configure.sh && make'. +The API is document in 'picosat.h'. +See also 'NEWS' and 'LICENSE'. diff --git a/test/monniaux/picosat-965/VERSION b/test/monniaux/picosat-965/VERSION new file mode 100644 index 00000000..aa5bea4e --- /dev/null +++ b/test/monniaux/picosat-965/VERSION @@ -0,0 +1 @@ +965 diff --git a/test/monniaux/picosat-965/app.c b/test/monniaux/picosat-965/app.c new file mode 100644 index 00000000..64ebdbd0 --- /dev/null +++ b/test/monniaux/picosat-965/app.c @@ -0,0 +1,1214 @@ +#include "picosat.h" + +#include <assert.h> +#include <ctype.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#define GUNZIP "gunzip -c %s" +#define BUNZIP2 "bzcat %s" +#define GZIP "gzip -c -f > %s" + +#ifndef NZIP +FILE * popen (const char *, const char*); +int pclose (FILE *); +#endif + +static PicoSAT * picosat; + +static int lineno; +static FILE *input; +static int inputid; +static FILE *output; +static int verbose; +static int sargc; +static char ** sargv; +static char buffer[100]; +static char *bhead = buffer; +static const char *eob = buffer + 80; +static FILE * incremental_rup_file; +static signed char * sol; + +extern void picosat_enter (PicoSAT *); +extern void picosat_leave (PicoSAT *); + +static int +next (void) +{ + int res = getc (input); + if (res == '\n') + lineno++; + + return res; +} + +static const char * +parse (PicoSAT * picosat, int force) +{ + int ch, sign, lit, vars, clauses; + + lineno = 1; + /* DM inputid = fileno (input); */ + +SKIP_COMMENTS: + ch = next (); + if (ch == 'c') + { + while ((ch = next ()) != EOF && ch != '\n') + ; + goto SKIP_COMMENTS; + } + + if (isspace (ch)) + goto SKIP_COMMENTS; + + if (ch != 'p') +INVALID_HEADER: + return "missing or invalid 'p cnf <variables> <clauses>' header"; + + if (!isspace (next ())) + goto INVALID_HEADER; + + while (isspace (ch = next ())) + ; + + if (ch != 'c' || next () != 'n' || next () != 'f' || !isspace (next ())) + goto INVALID_HEADER; + + while (isspace (ch = next ())) + ; + + if (!isdigit (ch)) + goto INVALID_HEADER; + + vars = ch - '0'; + while (isdigit (ch = next ())) + vars = 10 * vars + (ch - '0'); + + if (!isspace (ch)) + goto INVALID_HEADER; + + while (isspace (ch = next ())) + ; + + if (!isdigit (ch)) + goto INVALID_HEADER; + + clauses = ch - '0'; + while (isdigit (ch = next ())) + clauses = 10 * clauses + (ch - '0'); + + if (!isspace (ch) && ch != '\n' ) + goto INVALID_HEADER; + + if (verbose) + { + fprintf (output, "c parsed header 'p cnf %d %d'\n", vars, clauses); + fflush (output); + } + + picosat_adjust (picosat, vars); + + if (incremental_rup_file) + picosat_set_incremental_rup_file (picosat, incremental_rup_file, vars, clauses); + + lit = 0; +READ_LITERAL: + ch = next (); + + if (ch == 'c') + { + while ((ch = next ()) != EOF && ch != '\n') + ; + goto READ_LITERAL; + } + + if (ch == EOF) + { + if (lit) + return "trailing 0 missing"; + + if (clauses && !force) + return "clause missing"; + + return 0; + } + + if (isspace (ch)) + goto READ_LITERAL; + + sign = 1; + if (ch == '-') + { + sign = -1; + ch = next (); + } + + if (!isdigit (ch)) + return "expected number"; + + lit = ch - '0'; + while (isdigit (ch = next ())) + lit = 10 * lit + (ch - '0'); + + if (!clauses && !force) + return "too many clauses"; + + if (lit) + { + if (lit > vars && !force) + return "maximal variable index exceeded"; + + lit *= sign; + } + else + clauses--; + + picosat_add (picosat, lit); + + goto READ_LITERAL; +} + +static void +bflush (void) +{ + *bhead = 0; + fputs (buffer, output); + fputc ('\n', output); + bhead = buffer; +} + +static void +printi (int i) +{ + char *next; + int l; + +REENTER: + if (bhead == buffer) + *bhead++ = 'v'; + + l = sprintf (bhead, " %d", i); + next = bhead + l; + + if (next >= eob) + { + bflush (); + goto REENTER; + } + else + bhead = next; +} + +static void +printa (PicoSAT * picosat, int partial) +{ + int max_idx = picosat_variables (picosat), i, lit, val; + + assert (bhead == buffer); + + for (i = 1; i <= max_idx; i++) + { + if (partial) + { + val = picosat_deref_partial (picosat, i); + if (!val) + continue; + } + else + val = picosat_deref (picosat, i); + lit = (val > 0) ? i : -i; + printi (lit); + } + + printi (0); + if (bhead > buffer) + bflush (); +} + +static void +blocksol (PicoSAT * picosat) +{ + int max_idx = picosat_variables (picosat), i; + + if (!sol) + { + sol = malloc (max_idx + 1); + memset (sol, 0, max_idx + 1); + } + + for (i = 1; i <= max_idx; i++) + sol[i] = (picosat_deref (picosat, i) > 0) ? 1 : -1; + + for (i = 1; i <= max_idx; i++) + picosat_add (picosat, (sol[i] < 0) ? i : -i); + + picosat_add (picosat, 0); +} + +static int +has_suffix (const char *str, const char *suffix) +{ + const char *tmp = strstr (str, suffix); + if (!tmp) + return 0; + + return str + strlen (str) - strlen (suffix) == tmp; +} + +static void +write_core_variables (PicoSAT * picosat, FILE * file) +{ + int i, max_idx = picosat_variables (picosat), count = 0; + for (i = 1; i <= max_idx; i++) + if (picosat_corelit (picosat, i)) + { + fprintf (file, "%d\n", i); + count++; + } + + if (verbose) + fprintf (output, "c found and wrote %d core variables\n", count); +} + +static int +next_assumption (int start) +{ + char * arg, c; + int res; + res = start + 1; + while (res < sargc) + { + arg = sargv[res++]; + if (!strcmp (arg, "-a")) + { + assert (res < sargc); + break; + } + + if (arg[0] == '-') { + c = arg[1]; + if (c == 'l' || c == 'i' || c == 's' || c == 'o' || c == 't' || + c == 'T' || c == 'r' || c == 'R' || c == 'c' || c == 'V' || + c == 'U' || c == 'A') res++; + } + } + if (res >= sargc) res = 0; + return res; +} + +static void +write_failed_assumptions (PicoSAT * picosat, FILE * file) +{ + int i, lit, count = 0; +#ifndef NDEBUG + int max_idx = picosat_variables (picosat); +#endif + i = 0; + while ((i = next_assumption (i))) { + lit = atoi (sargv[i]); + if (!picosat_failed_assumption (picosat, lit)) continue; + fprintf (file, "%d\n", lit); + count++; + } + if (verbose) + fprintf (output, "c found and wrote %d failed assumptions\n", count); +#ifndef NDEBUG + for (i = 1; i <= max_idx; i++) + if (picosat_failed_assumption (picosat, i)) + count--; +#endif + assert (!count); +} + +static void +write_to_file (PicoSAT * picosat, + const char *name, + const char *type, + void (*writer) (PicoSAT *, FILE *)) +{ + int pclose_file, zipped = has_suffix (name, ".gz"); + FILE *file; + char *cmd; + + if (zipped) + { +#ifdef NZIP + file = NULL; +#else + cmd = malloc (strlen (GZIP) + strlen (name)); + sprintf (cmd, GZIP, name); + file = popen (cmd, "w"); + free (cmd); + pclose_file = 1; +#endif + } + else + { + file = fopen (name, "w"); + pclose_file = 0; + } + + if (file) + { + if (verbose) + fprintf (output, + "c\nc writing %s%s to '%s'\n", + zipped ? "gzipped " : "", type, name); + + writer (picosat, file); + +#ifndef NZIP + if (pclose_file) + pclose (file); + else +#endif + fclose (file); + } + else + fprintf (output, "*** picosat: can not write to '%s'\n", name); +} + +static int catched; + +static void (*sig_int_handler); +static void (*sig_segv_handler); +static void (*sig_abrt_handler); +static void (*sig_term_handler); +#ifndef NALLSIGNALS +static void (*sig_kill_handler); +static void (*sig_xcpu_handler); +static void (*sig_xfsz_handler); +#endif + +static void +resetsighandlers (void) +{ + (void) signal (SIGINT, sig_int_handler); + (void) signal (SIGSEGV, sig_segv_handler); + (void) signal (SIGABRT, sig_abrt_handler); + (void) signal (SIGTERM, sig_term_handler); +#ifndef NALLSIGNALS + (void) signal (SIGKILL, sig_kill_handler); + (void) signal (SIGXCPU, sig_xcpu_handler); + (void) signal (SIGXFSZ, sig_xfsz_handler); +#endif +} + +static int time_limit_in_seconds; +static void (*sig_alarm_handler); +static int ought_to_be_interrupted, interrupt_notified; + +static void +alarm_triggered (int sig) +{ + (void) sig; + assert (sig == SIGALRM); + assert (time_limit_in_seconds); + assert (!ought_to_be_interrupted); + ought_to_be_interrupted = 1; + assert (!interrupt_notified); +} + +static int +interrupt_call_back (void * dummy) +{ + (void) dummy; + if (!ought_to_be_interrupted) + return 0; + if (!interrupt_notified) + { + if (verbose) + { + picosat_message (picosat, 1, ""); + picosat_message (picosat, 1, + "*** TIME LIMIT OF %d SECONDS REACHED ***", + time_limit_in_seconds); + picosat_message (picosat, 1, ""); + } + interrupt_notified = 1; + } + return 1; +} + +static void +setalarm () +{ +#ifndef NALARM + assert (time_limit_in_seconds > 0); + sig_alarm_handler = signal (SIGALRM, alarm_triggered); + alarm (time_limit_in_seconds); + assert (picosat); + picosat_set_interrupt (picosat, 0, interrupt_call_back); +#endif +} + +static void +resetalarm () +{ + assert (time_limit_in_seconds > 0); + (void) signal (SIGALRM, sig_term_handler); +} + +static void +message (int sig) +{ + picosat_message (picosat, 1, ""); + picosat_message (picosat, 1, "*** CAUGHT SIGNAL %d ***", sig); + picosat_message (picosat, 1, ""); +} + +static void +catch (int sig) +{ + if (!catched) + { + message (sig); + catched = 1; + picosat_stats (picosat); + message (sig); + } + + resetsighandlers (); + raise (sig); +} + +static void +setsighandlers (void) +{ + sig_int_handler = signal (SIGINT, catch); + sig_segv_handler = signal (SIGSEGV, catch); + sig_abrt_handler = signal (SIGABRT, catch); + sig_term_handler = signal (SIGTERM, catch); +#ifndef NALLSIGNALS + sig_kill_handler = signal (SIGKILL, catch); + sig_xcpu_handler = signal (SIGXCPU, catch); + sig_xfsz_handler = signal (SIGXFSZ, catch); +#endif +} + +#define USAGE \ +"usage: picosat [ <option> ... ] [ <input> ]\n" \ +"\n" \ +"where <option> is one of the following\n" \ +"\n" \ +" -h print this command line option summary and exit\n" \ +" --version print version and exit\n" \ +" --config print build configuration and exit\n" \ +"\n" \ +" -v enable verbose output\n" \ +" -f ignore invalid header\n" \ +" -n do not print satisfying assignment\n" \ +" -p print formula in DIMACS format and exit\n" \ +" --plain disable preprocessing (failed literal probing)\n" \ +" -a <lit> start with an assumption\n" \ +" -l <limit> set decision limit (no limit per default)\n" \ +" -L <limit> set time limit in seconds (no limit per default)\n" \ +" -P <limit> set propagation limit (no limit per default)\n" \ +" -i [0-3] [0-3]=[FALSE,TRUE,JWH,RAND] initial phase (default 2=JWH)\n" \ +" -s <seed> set random number generator seed (default 0)\n" \ +" -o <output> set output file (<stdout> per default)\n" \ +" -t <trace> generate compact proof trace file\n" \ +" -T <trace> generate extended proof trace file\n" \ +" -r <trace> generate reverse unit propagation proof file\n" \ +" -R <trace> generate reverse unit propagation proof file incrementally\n" \ +" -c <core> generate clausal core file in DIMACS format\n" \ +" -V <core> generate file listing core variables\n" \ +" -U <core> generate file listing used variables\n" \ +" -A <core> generate file listing failed assumptions\n" \ +"\n" \ +" --all enumerate all solutions\n" \ +" --partial generate and print only partial assignment\n" \ +"\n" \ +"and <input> is an optional input file in DIMACS format.\n" + +int +picosat_main (int argc, char **argv) +{ + int res, done, err, print_satisfying_assignment, force, print_formula; + const char *compact_trace_name, *extended_trace_name, * rup_trace_name; + int assumption, assumptions, defaultphase, allsat, partial, plain; + const char * clausal_core_name, * variable_core_name; + const char *input_name, *output_name; + const char * failed_assumptions_name; + int close_input, pclose_input; + long long propagation_limit; + int i, decision_limit; + double start_time; + long long sols; + unsigned seed; + FILE *file; + int trace; + + start_time = picosat_time_stamp (); + + sargc = argc; + sargv = argv; + + clausal_core_name = 0; + variable_core_name = 0; + failed_assumptions_name = 0; + output_name = 0; + compact_trace_name = 0; + extended_trace_name = 0; + rup_trace_name = 0; + incremental_rup_file = 0; + close_input = 0; + pclose_input = 0; + input_name = "<stdin>"; + input = stdin; + output = stdout; + verbose = 0; + done = err = 0; + decision_limit = -1; + propagation_limit = -1; + defaultphase = 2; + assumptions = 0; + force = 0; + allsat = 0; + partial = 0; + trace = 0; + plain = 0; + seed = 0; + sols= 0; + + picosat = 0; + + print_satisfying_assignment = 1; + print_formula = 0; + + for (i = 1; !done && !err && i < argc; i++) + { + if (!strcmp (argv[i], "-h")) + { + fputs (USAGE, output); + done = 1; + } + else if (!strcmp (argv[i], "--version")) + { + fprintf (output, "%s\n", picosat_version ()); + done = 1; + } + else if (!strcmp (argv[i], "--config")) + { + fprintf (output, "%s\n", picosat_config ()); + done = 1; + } + else if (!strcmp (argv[i], "-v")) + { + verbose++; + } + else if (!strcmp (argv[i], "--plain")) + { + plain = 1; + } + else if (!strcmp (argv[i], "-f")) + { + force = 1; + } + else if (!strcmp (argv[i], "-n")) + { + print_satisfying_assignment = 0; + } + else if (!strcmp (argv[i], "--partial")) + { + partial = 1; + } + else if (!strcmp (argv[i], "-p")) + { + print_formula = 1; + } + else if (!strcmp (argv[i], "-l")) + { + if (++i == argc) + { + fprintf (output, "*** picosat: argument to '-l' missing\n"); + err = 1; + } + else + decision_limit = atoi (argv[i]); + } + else if (!strcmp (argv[i], "-L")) + { + if (++i == argc) + { + fprintf (output, "*** picosat: argument to '-L' missing\n"); + err = 1; + } + else + { + time_limit_in_seconds = atoi (argv[i]); + if (time_limit_in_seconds <= 0) + { + fprintf (output, "*** picosat: invalid '-L' argument\n"); + err = 1; + } + } + } + else if (!strcmp (argv[i], "-P")) + { + if (++i == argc) + { + fprintf (output, "*** picosat: argument to '-P' missing\n"); + err = 1; + } + else + propagation_limit = atol /* DM */ (argv[i]); + } + else if (!strcmp (argv[i], "-i")) + { + if (++i == argc) + { + fprintf (output, "*** picosat: argument to '-i' missing\n"); + err = 1; + } + else if (!argv[i][1] && ('0' <= argv[i][0] && argv[i][0] <= '3')) + { + defaultphase = argv[i][0] - '0'; + } + else + { + fprintf (output, "*** picosat: invalid argument to '-i'\n"); + err = 1; + } + } + else if (!strcmp (argv[i], "-a")) + { + if (++i == argc) + { + fprintf (output, "*** picosat: argument to '-a' missing\n"); + err = 1; + } + else if (!atoi (argv[i])) + { + fprintf (output, "*** picosat: argument to '-a' zero\n"); + err = 1; + } + else + { + /* Handle assumptions further down + */ + assumptions++; + } + } + else if (!strcmp (argv[i], "--all")) + { + allsat = 1; + } + else if (!strcmp (argv[i], "-s")) + { + if (++i == argc) + { + fprintf (output, "*** picosat: argument to '-s' missing\n"); + err = 1; + } + else + seed = atoi (argv[i]); + } + else if (!strcmp (argv[i], "-o")) + { + if (output_name) + { + fprintf (output, + "*** picosat: " + "multiple output files '%s' and '%s'\n", + output_name, argv[i]); + err = 1; + } + else if (++i == argc) + { + fprintf (output, "*** picosat: argument ot '-o' missing\n"); + err = 1; + } + else if (!(file = fopen (argv[i], "w"))) + { + fprintf (output, + "*** picosat: " + "can not write output file '%s'\n", argv[i]); + err = 1; + } + else + { + output_name = argv[i]; + output = file; + } + } + else if (!strcmp (argv[i], "-t")) + { + if (compact_trace_name) + { + fprintf (output, + "*** picosat: " + "multiple compact trace files '%s' and '%s'\n", + compact_trace_name, argv[i]); + err = 1; + } + else if (++i == argc) + { + fprintf (output, "*** picosat: argument ot '-t' missing\n"); + err = 1; + } + else + { + compact_trace_name = argv[i]; + trace = 1; + } + } + else if (!strcmp (argv[i], "-T")) + { + if (extended_trace_name) + { + fprintf (output, + "*** picosat: " + "multiple extended trace files '%s' and '%s'\n", + extended_trace_name, argv[i]); + err = 1; + } + else if (++i == argc) + { + fprintf (output, "*** picosat: argument ot '-T' missing\n"); + err = 1; + } + else + { + extended_trace_name = argv[i]; + trace = 1; + } + } + else if (!strcmp (argv[i], "-r")) + { + if (rup_trace_name) + { + fprintf (output, + "*** picosat: " + "multiple RUP trace files '%s' and '%s'\n", + rup_trace_name, argv[i]); + err = 1; + } + else if (++i == argc) + { + fprintf (output, "*** picosat: argument ot '-r' missing\n"); + err = 1; + } + else + { + rup_trace_name = argv[i]; + trace = 1; + } + } + else if (!strcmp (argv[i], "-R")) + { + if (rup_trace_name) + { + fprintf (output, + "*** picosat: " + "multiple RUP trace files '%s' and '%s'\n", + rup_trace_name, argv[i]); + err = 1; + } + else if (++i == argc) + { + fprintf (output, "*** picosat: argument ot '-R' missing\n"); + err = 1; + } + else if (!(file = fopen (argv[i], "w"))) + { + fprintf (output, + "*** picosat: can not write to '%s'\n", argv[i]); + err = 1; + } + else + { + rup_trace_name = argv[i]; + incremental_rup_file = file; + } + } + else if (!strcmp (argv[i], "-c")) + { + if (clausal_core_name) + { + fprintf (output, + "*** picosat: " + "multiple clausal core files '%s' and '%s'\n", + clausal_core_name, argv[i]); + err = 1; + } + else if (++i == argc) + { + fprintf (output, "*** picosat: argument ot '-c' missing\n"); + err = 1; + } + else + { + clausal_core_name = argv[i]; + trace = 1; + } + } + else if (!strcmp (argv[i], "-V")) + { + if (variable_core_name) + { + fprintf (output, + "*** picosat: " + "multiple variable core files '%s' and '%s'\n", + variable_core_name, argv[i]); + err = 1; + } + else if (++i == argc) + { + fprintf (output, "*** picosat: argument ot '-V' missing\n"); + err = 1; + } + else + { + variable_core_name = argv[i]; + trace = 1; + } + } + else if (!strcmp (argv[i], "-A")) + { + if (failed_assumptions_name) + { + fprintf (output, + "*** picosat: " + "multiple failed assumptions files '%s' and '%s'\n", + failed_assumptions_name, argv[i]); + err = 1; + } + else if (++i == argc) + { + fprintf (output, "*** picosat: argument ot '-A' missing\n"); + err = 1; + } + else + failed_assumptions_name = argv[i]; + } + else if (argv[i][0] == '-') + { + fprintf (output, + "*** picosat: " + "unknown command line option '%s' (try '-h')\n", argv[i]); + err = 1; + } + else if (close_input || pclose_input) + { + fprintf (output, + "*** picosat: " + "multiple input files '%s' and '%s'\n", + input_name, argv[i]); + err = 1; + } + else if (has_suffix (argv[i], ".gz")) + { +#ifdef NZIP + file=NULL; + err=1; +#else + char *cmd = malloc (strlen (GUNZIP) + strlen (argv[i])); + sprintf (cmd, GUNZIP, argv[i]); + if ((file = popen (cmd, "r"))) + { + input_name = argv[i]; + pclose_input = 1; + input = file; + } + else + { + fprintf (output, + "*** picosat: " + "can not read compressed input file '%s'\n", argv[i]); + err = 1; + } + free (cmd); +#endif + } + else if (has_suffix (argv[i], ".bz2")) + { +#ifdef NZIP + file=NULL; + err=1; +#else + char *cmd = malloc (strlen (BUNZIP2) + strlen (argv[i])); + sprintf (cmd, BUNZIP2, argv[i]); + if ((file = popen (cmd, "r"))) + { + input_name = argv[i]; + pclose_input = 1; + input = file; + } + else + { + fprintf (output, + "*** picosat: " + "can not read compressed input file '%s'\n", argv[i]); + err = 1; + } + free (cmd); +#endif + } + else if (!(file = fopen (argv[i], "r"))) /* TODO .gz ? */ + { + fprintf (output, + "*** picosat: can not read input file '%s'\n", argv[i]); + err = 1; + } + else + { + input_name = argv[i]; + close_input = 1; + input = file; + } + } + + if (allsat && partial) + { + fprintf (output, + "*** picosat: can not combine '--all' and '--partial'"); + err = 1; + } + + res = PICOSAT_UNKNOWN; + + if (!done && !err) + { + const char *err_msg; + + if (verbose) + { + fprintf (output, + "c PicoSAT SAT Solver Version %s\n", + picosat_version ()); + + fprintf (output, "c %s\n", picosat_copyright ()); + fprintf (output, "c %s\n", picosat_config ()); + } + + picosat = picosat_init (); + + if (verbose) + setsighandlers (); + + if (time_limit_in_seconds) + setalarm (); + + picosat_enter (picosat); + + if (output_name) + picosat_set_output (picosat, output); + + picosat_set_verbosity (picosat, verbose); + picosat_set_plain (picosat, plain); + + if (verbose) fputs ("c\n", output); + + if (trace) + { + if (verbose) + fprintf (output, "c tracing proof\n"); + picosat_enable_trace_generation (picosat); + } + + if (defaultphase) + { + if (verbose) + fprintf (output, "c using %d as default phase\n", defaultphase); + picosat_set_global_default_phase (picosat, defaultphase); + } + + if (propagation_limit >= 0) + { + if (verbose) + fprintf (output, "c propagation limit of %lld propagations\n", + propagation_limit); + picosat_set_propagation_limit (picosat, + (unsigned long long) propagation_limit); + } + + if (partial) + { + if (verbose) + fprintf (output, + "c saving original clauses for partial assignment\n"); + + picosat_save_original_clauses (picosat); + } + + if (verbose) + fprintf (output, "c\nc parsing %s\n", input_name); + + if (verbose) + fflush (output); + + if ((err_msg = parse (picosat, force))) + { + fprintf (output, "%s:%d: %s\n", input_name, lineno, err_msg); + err = 1; + } + else + { +NEXT_SOLUTION: + if (assumptions) + { + i = 0; + while ((i = next_assumption (i))) + { + assert (i < argc); + assumption = atoi (argv[i]); + assert (assumption); + + picosat_assume (picosat, assumption); + + if (verbose) + fprintf (output, "c assumption %d\n", assumption); + } + } + + if (print_formula) + { + picosat_print (picosat, output); + } + else + { + if (verbose) + fprintf (output, + "c initialized %u variables\n" + "c found %u non trivial clauses\n", + picosat_variables (picosat), + picosat_added_original_clauses (picosat)); + + picosat_set_seed (picosat, seed); + if (verbose) + fprintf (output, + "c\nc random number generator seed %u\n", + seed); + + res = picosat_sat (picosat, decision_limit); + + if (res == PICOSAT_UNSATISFIABLE) + { + + if (allsat) + fprintf (output, "s SOLUTIONS %lld\n", sols); + else + fputs ("s UNSATISFIABLE\n", output); + + fflush (output); + + if (compact_trace_name) + write_to_file (picosat, + compact_trace_name, + "compact trace", + picosat_write_compact_trace); + + if (extended_trace_name) + write_to_file (picosat, + extended_trace_name, + "extended trace", + picosat_write_extended_trace); + + if (!incremental_rup_file && rup_trace_name) + write_to_file (picosat, + rup_trace_name, + "rup trace", + picosat_write_rup_trace); + + if (clausal_core_name) + write_to_file (picosat, + clausal_core_name, + "clausal core", + picosat_write_clausal_core); + + if (variable_core_name) + write_to_file (picosat, + variable_core_name, + "variable core", + write_core_variables); + + if (failed_assumptions_name) + write_to_file (picosat, + failed_assumptions_name, + "failed assumptions", + write_failed_assumptions); + } + else if (res == PICOSAT_SATISFIABLE) + { + if (allsat) + { + sols++; + if (verbose) + fprintf (output, "c\nc solution %lld\nc\n", sols); + } + + if (!allsat || print_satisfying_assignment) + fputs ("s SATISFIABLE\n", output); + + if (!allsat || verbose || print_satisfying_assignment) + fflush (output); + + if (print_satisfying_assignment) + printa (picosat, partial); + + if (allsat) + { + blocksol (picosat); + goto NEXT_SOLUTION; + } + } + else + { + fputs ("s UNKNOWN\n", output); + + if (allsat && verbose) + fprintf (output, + "c\nc limit reached after %lld solutions\n", + sols); + fflush (output); + } + } + } + + if (!err && verbose) + { + fputs ("c\n", output); + picosat_stats (picosat); + fprintf (output, + "c %.1f seconds total run time\n", + picosat_time_stamp () - start_time); + } + + if (sol) + { + free (sol); + sol = 0; + } + + picosat_leave (picosat); + + if (time_limit_in_seconds) + resetalarm (); + + if (verbose) + resetsighandlers (); + + picosat_reset (picosat); + } + + if (incremental_rup_file) + fclose (incremental_rup_file); + + if (close_input) + fclose (input); + +#ifndef NZIP + if (pclose_input) + pclose (input); +#endif + + if (output_name) + fclose (output); + + return res; +} diff --git a/test/monniaux/picosat-965/config.h b/test/monniaux/picosat-965/config.h new file mode 100644 index 00000000..36ffc6b6 --- /dev/null +++ b/test/monniaux/picosat-965/config.h @@ -0,0 +1,3 @@ +#define PICOSAT_CC "../../../ccomp" +#define PICOSAT_CFLAGS "-fall -Wall -fno-unprototyped -O3 -DNALARM -DNZIP -DNGETRUSAGE" +#define PICOSAT_VERSION "965" diff --git a/test/monniaux/picosat-965/configure.sh b/test/monniaux/picosat-965/configure.sh new file mode 100755 index 00000000..a82cfe87 --- /dev/null +++ b/test/monniaux/picosat-965/configure.sh @@ -0,0 +1,150 @@ +#!/bin/sh + +satcompetition=no + +log=no +debug=no +stats=undefined +trace=undefined +static=yes +shared=no +thirtytwobit=no +static=no +rcode=no + +while [ $# -gt 0 ] +do + case $1 in + -g|--debug) debug=yes;; + -O|--optimize) debug=no;; + -l|--log) log=yes;; + -s|--stats) stats=yes;; + -t|--trace) trace=yes;; + --no-stats) stats=no;; + --no-trace) trace=no;; + --no-rcode) rcode=no;; + --rcode) rcode=yes;; + -32|--32|-m32) thirtytwobit=yes;; + -static|--static) static=yes;; + -shared|--shared) shared=yes;; + *) cat <<EOF +usage: ./configure.sh [<option> ...] + +where <option> is one of the following: + + -g|--debug include debugging code and symbols + -O|--optimize optimized compilation (default) + -l|--log add low level logging code (default with '-g') + -s|--stats more expensive statististcs (default with '-g') + -t|--trace trace generation (more memory, default with '-g') + --no-stats disable expensive stats + --no-trace enable trace generation + -32|--32|-m32 compile for 32 bit machine even on 64 bit host + -rcode|--no-rcode enable/disable compatibility for used in R exension + -static|--static produce static binary + -shared|--shared produce shared library +EOF +exit 1 +;; + esac +shift +done + +echo "version ... `cat VERSION`" + +if [ $satcompetition = yes ] +then + debug=no + stats=no + trace=no + thirtytwobit=yes + static=yes + shared=no +fi + +echo "debug ... $debug" +echo "log ... $log" + +[ $stats = undefined ] && stats=$debug +echo "stats ... $stats" + +[ $trace = undefined ] && trace=$debug +echo "trace ... $trace" + +echo "static ... $static" + +echo "shared ... $shared" + +[ "X$CC" = X ] && CC=gcc + +if [ X"$CFLAGS" = X ] +then + case X"$CC" in + *wine*|*mingw*) CFLAGS="-DNGETRUSAGE -DNALLSIGNALS";; + *);; + esac + [ $log = yes ] && CFLAGS="$CFLAGS -DLOGGING" + [ $stats = yes ] && CFLAGS="$CFLAGS -DSTATS" + [ $trace = yes ] && CFLAGS="$CFLAGS -DTRACE" + [ $static = yes ] && CFLAGS="$CFLAGS -static" + [ $rcode = yes ] && CFLAGS="$CFLAGS -DRCODE" + case X"$CC" in + X*gcc*) + CFLAGS="$CFLAGS -Wall -Wextra" + [ $thirtytwobit = yes ] && CFLAGS="$CFLAGS -m32" + if [ $debug = yes ] + then + CFLAGS="$CFLAGS -g3 -ggdb" + else + CFLAGS="$CFLAGS -DNDEBUG -O3" + fi + ;; + *) + if [ $debug = yes ] + then + CFLAGS="$CFLAGS -g" + else + CFLAGS="$CFLAGS -O" + fi + ;; + esac +fi + +if [ $rcode = yes ] +then + for rdoth in /usr/share/R/include/R.h $RINC undefined + do + [ -f $rdoth ] && break + done + if [ $rdoth = undefined ] + then + echo "R.h ... not found (add '-I' manually or 'RHEADER=... ./configure')" + else + RINC="-I`dirname $rdoth`" + CFLAGS="$CFLAGS $RINC" + echo "R.h ... added '$RINC' include directive" + fi + TARGETS="libpicosat.a" +else + TARGETS="picosat picomcs picomus picogcnf libpicosat.a" +fi + +if [ $shared = yes ] +then + TARGETS="$TARGETS libpicosat.so" + CFLAGS="$CFLAGS -fPIC" +fi +echo "targets ... $TARGETS" + +echo "cc ... $CC" + +echo "cflags ... $CFLAGS" + +printf "makefile ..." +rm -f makefile +sed \ + -e "s,@CC@,$CC," \ + -e "s,@CFLAGS@,$CFLAGS," \ + -e "s,@TARGETS@,$TARGETS," \ +makefile.in > makefile +echo " done" diff --git a/test/monniaux/picosat-965/main.c b/test/monniaux/picosat-965/main.c new file mode 100644 index 00000000..13d7b0e5 --- /dev/null +++ b/test/monniaux/picosat-965/main.c @@ -0,0 +1,25 @@ +#define VERIMAG_MEASUREMENTS +#ifdef VERIMAG_MEASUREMENTS +#include "../clock.h" +#endif + +int picosat_main (int, char **); + +int +main (int argc, char **argv) +{ + +#ifdef VERIMAG_MEASUREMENTS + clock_prepare(); + clock_start(); +#endif + + int ret= picosat_main (argc, argv); + +#ifdef VERIMAG_MEASUREMENTS + clock_stop(); + print_total_clock(); +#endif + + return ret; +} diff --git a/test/monniaux/picosat-965/mkconfig.sh b/test/monniaux/picosat-965/mkconfig.sh new file mode 100755 index 00000000..621210b9 --- /dev/null +++ b/test/monniaux/picosat-965/mkconfig.sh @@ -0,0 +1,35 @@ +#!/bin/sh + +die () { + echo "*** mkconfig.sh: $*" 1>&2 + exit 1 +} + +[ -f makefile ] || die "can not find 'makefile'" + +sed \ + -e '/^C[A-Z]*=/!d' \ + -e 's,^,#define PICOSAT_,' \ + -e 's,= *, ",' \ + -e 's,$,",' \ + makefile + +id="" +if [ -d .git -a -f .git/HEAD ] +then + head="`awk 'NF == 1' .git/HEAD`" + if [ x"$head" = x ] + then + head="`awk '{print $2}' .git/HEAD`" + if [ ! x"$head" = x -a -f ".git/$head" ] + then + id=" `cat .git/$head`" + fi + else + id=" $head" + fi +fi + +echo "#define PICOSAT_VERSION \"`cat VERSION`$id\"" + +exit 0 diff --git a/test/monniaux/picosat-965/picogcnf.c b/test/monniaux/picosat-965/picogcnf.c new file mode 100644 index 00000000..4d91bfae --- /dev/null +++ b/test/monniaux/picosat-965/picogcnf.c @@ -0,0 +1,165 @@ +/**************************************************************************** +Copyright (c) 2011-2012, Armin Biere, Johannes Kepler University. + +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 "picosat.h" + +#include <stdio.h> +#include <assert.h> +#include <stdarg.h> +#include <ctype.h> +#include <limits.h> + +#if 1 +#define LOG(ARGS...) do { } while (0) +#else +#define LOG(ARGS...) do { printf (##ARGS); } while (0) +#endif + +static int reductions, ngroups; + +static PicoSAT * ps; + +static void die (const char * fmt, ...) { + va_list ap; + fprintf (stderr, "*** picogcnf: "); + va_start (ap, fmt); + vfprintf (stderr, fmt, ap); + va_end (ap); + fputc ('\n', stderr); + exit (1); +} + +static void msg (const char * fmt, ...) { + va_list ap; + printf ("c [picogcnf] %.2f seconds: ", picosat_time_stamp ()); + va_start (ap, fmt); + vprintf (fmt, ap); + va_end (ap); + fputc ('\n', stdout); + fflush (stdout); +} + +static double percent (double a, double b) { return b?100.0*a/b:0.0; } + +static void callback (void * dummy, const int * mus) { + int remaining; + const int * p; + (void) dummy; + remaining = 0; + for (p = mus; *p; p++) remaining++; + assert (remaining <= ngroups); + msg ("<%d> reduction to %d out of %d (%.0f%%)", + ++reductions, remaining, ngroups, percent (remaining, ngroups)); +} + +int main (int argc, char ** argv) { + int ch, nvars, sclauses, nclauses, sign, lit, group, res; + const int * mus, * p; + FILE * file; + if (argc != 2) die ("usage: picogcnf <gcnf-file>"); + if (!(file = fopen (argv[1], "r"))) die ("can not read '%s'", argv[1]); + ps = picosat_init (); +HEADER: + ch = getc (file); + if (ch == 'c') { + while ((ch = getc (file)) != '\n') + if (ch == EOF) die ("unexpected EOF"); + goto HEADER; + } + if (ch != 'p' || + getc (file) != ' ' || + fscanf (file, "gcnf %d %d %d", &nvars, &sclauses, &ngroups) != 3) + die ("invalid header"); + nclauses = lit = 0; + group = INT_MAX; + LOG ("p gcnf %d %d %d\n", nvars, sclauses, ngroups); +LIT: + ch = getc (file); + if (ch == EOF) { + if (lit) die ("zero missing"); + if (nclauses < sclauses) die ("clauses missing"); + goto DONE; + } + if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') goto LIT; + if (lit) { + if (ch == '-') { + sign = -1; + ch = getc (file); + } else sign = 1; + lit = ch - '0'; + while (isdigit (ch = getc (file))) + lit = 10 * lit + ch - '0'; + if (lit > nvars) die ("maximum variable exceeded"); + lit *= sign; + if (lit) { + LOG ("%d ", lit); + } else { + LOG ("0\n"); + group = INT_MAX; + nclauses++; + } + picosat_add (ps, lit); + } else if (ch == '{') { + if (nclauses == sclauses) die ("too many clauses"); + if (group < INT_MAX) die ("multiple groups per clause"); +GROUP: + ch = getc (file); + if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') goto GROUP; + if (!isdigit (ch)) die ("group does not start with digit"); + group = ch - '0'; + while (isdigit (ch = getc (file))) + group = 10 * group + (ch - '0'); + if (group > ngroups) die ("maximal group exceeded"); + while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') + ch = getc (file); + if (ch != '}') die ("expected '}'"); + LOG ("{%d} ", group); + if (group) picosat_add (ps, -(nvars + group)); + lit = INT_MAX; + } else die ("expected '{'"); + goto LIT; +DONE: + fclose (file); + for (lit = nvars + 1; lit <= nvars + ngroups; lit++) picosat_assume (ps, lit); + res = picosat_sat (ps, -1); + msg ("first call to SAT solver returned"); + if (res == 10) printf ("s SATISFIABLE\n"); + else if (res == 20) printf ("s UNSATISFIABLE\n"); + else printf ("s UNKNOWN\n"); + fflush (stdout); + if (res == 20) { + mus = picosat_mus_assumptions (ps, 0, callback, 1); + assert (mus); + printf ("v"); + for (p = mus; (lit = *p); p++) { + assert (nvars + 1 <= lit && lit <= nvars + ngroups); + printf (" %d", lit - nvars); + } + printf (" 0\n"); + fflush (stdout); + } + msg ("max memory %.1f MB", + picosat_max_bytes_allocated (ps) / (double)(1<<20)); + picosat_reset (ps); + msg ("%d reductions", reductions); + return res; +} diff --git a/test/monniaux/picosat-965/picomcs.c b/test/monniaux/picosat-965/picomcs.c new file mode 100644 index 00000000..3acf7bd7 --- /dev/null +++ b/test/monniaux/picosat-965/picomcs.c @@ -0,0 +1,334 @@ +#include <assert.h> +#include <stdlib.h> +#include <stdio.h> +#include <stdarg.h> +#include <ctype.h> +#include <string.h> +#include <unistd.h> + +#include "picosat.h" + +typedef struct Clause { int cid, * lits; struct Clause * next; } Clause; +typedef struct MCS { int mid, * clauses; struct MCS * next; } MCS; + +static int nvars; +static char * marked; + +static Clause * first_clause, * last_clause; +static int nclauses, first_cid, last_cid; + +static MCS * first_mcs, * last_mcs; +static int nmcs; + +static int * stk, szstk, nstk; + +static int verbose, join, noprint; + +static int lineno = 1, close_input; +static const char * input_name; +static FILE * input; + +static PicoSAT * ps; + +static void release_clauses (void) { + Clause * p, * next; + for (p = first_clause; p; p = next) { + next = p->next; + free (p->lits); + free (p); + } +} + +static void release_mss (void) { + MCS * p, * next; + for (p = first_mcs; p; p = next) { + next = p->next; + free (p->clauses); + free (p); + } +} + +static void release (void) { + release_clauses (); + release_mss (); + free (marked); + free (stk); +} + +static void push_stack (int n) { + if (nstk == szstk) + stk = realloc (stk, (szstk = szstk ? 2*szstk : 1) * sizeof *stk); + stk[nstk++] = n; +} + +static void push_clause (void) { + Clause * clause; + size_t bytes; + clause = malloc (sizeof *clause); + clause->cid = ++nclauses; + clause->next = 0; + push_stack (0); + bytes = nstk * sizeof *clause->lits; + clause->lits = malloc (bytes); + memcpy (clause->lits, stk, bytes); + if (last_clause) last_clause->next = clause; + else first_clause = clause; + last_clause = clause; + nstk = 0; +} + +static void push_mcs (void) { + MCS * mcs; + size_t bytes; + mcs = malloc (sizeof *mcs); + mcs->mid = ++nmcs; + mcs->next = 0; + push_stack (0); + bytes = nstk * sizeof *mcs->clauses; + mcs->clauses = malloc (bytes); + memcpy (mcs->clauses, stk, bytes); + if (last_mcs) last_mcs->next = mcs; + else first_mcs = mcs; + last_mcs = mcs; + nstk = 0; +} + +static int nextch (void) { + int res = getc (input); + if (res == '\n') lineno++; + return res; +} + +static void msg (int level, const char * fmt, ...) { + va_list ap; + if (level > verbose) return; + printf ("c [picomcs] "); + va_start (ap, fmt); + vprintf (fmt, ap); + va_end (ap); + fputc ('\n', stdout); + fflush (stdout); +} + +static const char * parse (void) { + int ch, expclauses, lit, sign; + size_t bytes; + msg (1, "parsing %s", input_name); +COMMENTS: + ch = nextch (); + if (ch == 'c') { + while ((ch = nextch ()) != '\n') + if (ch == EOF) return "out of file in comment"; + goto COMMENTS; + } + if (ch != 'p') +INVALID_HEADER: + return "invalid header"; + ungetc (ch, input); + if (fscanf (input, "p cnf %d %d", &nvars, &expclauses) != 2) + goto INVALID_HEADER; + msg (1, "found 'p cnf %d %d' header", nvars, expclauses); + bytes = (1 + nvars + expclauses) * sizeof *marked; + marked = malloc (bytes); + memset (marked, 0, bytes); +LIT: + ch = nextch (); + if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') goto LIT; + if (ch == EOF) { + assert (nclauses <= expclauses); + if (nclauses < expclauses) return "clauses missing"; + return 0; + } + if (ch == '-') { + ch = nextch (); + if (!isdigit (ch)) return "expected digit after '-'"; + if (ch == '0') return "expected positive digit after '-'"; + sign = -1; + } else if (!isdigit (ch)) return "expected '-' or digit"; + else sign = 1; + lit = ch - '0'; + while (isdigit (ch = nextch ())) + lit = 10*lit + (ch - '0'); + if (lit) { + if (lit > nvars) return "maximum variable index exceeded"; + if (nclauses == expclauses) return "too many clauses"; + push_stack (sign * lit); + } else { + assert (nclauses < expclauses); + push_clause (); + } + goto LIT; +} + +#ifndef NDEBUG +static void dump_clause (Clause * c) { + int * p, lit; + for (p = c->lits; (lit = *p); p++) + printf ("%d ", lit); + printf ("0\n"); +} + +void dump (void) { + Clause * p; + printf ("p cnf %d %d\n", nvars, nclauses); + for (p = first_clause; p; p = p->next) + dump_clause (p); +} +#endif + +static int clause2selvar (Clause * c) { + int res = c->cid + nvars; + assert (first_cid <= res && res <= last_cid); + return res; +} + +static void encode_clause (Clause * c) { + int * p, lit; + if (verbose >= 2) { + printf ("c [picomcs] encode clause %d :", c->cid); + printf (" %d", -clause2selvar (c)); + for (p = c->lits; (lit = *p); p++) printf (" %d", lit); + fputc ('\n', stdout), fflush (stdout); + } + picosat_add (ps, -clause2selvar (c)); + for (p = c->lits; (lit = *p); p++) picosat_add (ps, lit); + picosat_add (ps, 0); +} + +static void encode (void) { + Clause * p; + first_cid = nvars + 1; + last_cid = nvars + nclauses; + msg (2, "selector variables range %d to %d", first_cid, last_cid); + for (p = first_clause; p; p = p->next) + encode_clause (p); + msg (1, "encoded %d clauses", nclauses); +} + +static void camcs (void) { + int cid, i; + const int * mcs, * p; + msg (1, "starting to compute all minimal correcting sets"); + while ((mcs = picosat_next_minimal_correcting_subset_of_assumptions (ps))) { + for (p = mcs; (cid = *p); p++) + push_stack (cid); + if (verbose >= 2) { + printf ("c [picomcs] mcs %d :", nmcs); + for (i = 0; i < nstk; i++) printf (" %d", stk[i] - nvars); + fputc ('\n', stdout); + fflush (stdout); + } else if (verbose && isatty (1)) { + printf ("\rc [picomcs] mcs %d", nmcs); + fflush (stdout); + } + push_mcs (); + } + if (verbose && isatty (1)) fputc ('\r', stdout); + msg (1, "found %d minimal correcting sets", nmcs); +} + +static void cumcscb (void * state, int nmcs, int nhumus) { + int * ptr = state; + *ptr = nmcs; + ptr[0] = nmcs, ptr[1] = nhumus; + if (!verbose || (!isatty (1) && verbose == 1)) return; + if (verbose == 1) fputc ('\r', stdout); + printf ("c [picomcs] mcs %d humus %d", nmcs, nhumus); + if (verbose >= 2) fputc ('\n', stdout); + fflush (stdout); +} + +static void cumcs (void) { + int stats[2], count, cid; + const int * humus, * p; + stats[0] = stats[1] = 0; + humus = picosat_humus (ps, cumcscb, stats); + if (isatty (1) && verbose == 1) fputc ('\n', stdout); + count = 0; + for (p = humus; (cid = *p); p++) { + if (marked[cid]) continue; + marked[cid] = 1; + count++; + } + assert (count == stats[1]); + msg (1, + "computed union of minimal correcting sets of size %d with %d mcs", + stats[1], stats[0]); +} + +static void +print_umcs (void) { + int cid; + printf ("v"); + for (cid = first_cid; cid <= last_cid; cid++) + if (marked[cid]) + printf (" %d", cid - nvars); + printf (" 0\n"); +} + +static void +print_mcs (MCS * mcs) +{ + const int * p; + int cid; + printf ("v"); + for (p = mcs->clauses; (cid = *p); p++) + printf (" %d", cid - nvars); + printf (" 0\n"); +} + +static void +print_all_mcs (void) +{ + MCS * p; + for (p = first_mcs; p; p = p->next) + print_mcs (p); +} + +int main (int argc, char ** argv) { + const char * perr; + int i, res; + for (i = 1; i < argc; i++) { + if (!strcmp (argv[i], "-h")) { + printf ("usage: picomcs [-h][-v][-j][-n][<input>]\n"); + exit (0); + } + else if (!strcmp (argv[i], "-v")) verbose++; + else if (!strcmp (argv[i], "-j")) join = 1; + else if (!strcmp (argv[i], "-n")) noprint = 1; + else if (argv[i][0] == '-') { + fprintf (stderr, "*** picomcs: invalid option '%s'\n", argv[i]); + exit (1); + } else if (input_name) { + fprintf (stderr, "*** picomcs: two input files specified\n"); + exit (1); + } else if (!(input = fopen ((input_name = argv[i]), "r"))) { + fprintf (stderr, "*** picomcs: can not read '%s'\n", argv[i]); + exit (1); + } else close_input = 1; + } + if (!input_name) input_name = "<stdin>", input = stdin; + if ((perr = parse ())) { + fprintf (stderr, "%s:%d: parse error: %s\n", input_name, lineno, perr); + exit (1); + } + if (close_input) fclose (input); + ps = picosat_init (); + picosat_set_prefix (ps, "c [picosat] "); + encode (); + for (i = first_cid; i <= last_cid; i++) + picosat_set_default_phase_lit (ps, i, 1); + for (i = first_cid; i <= last_cid; i++) picosat_assume (ps, i); + res = picosat_sat (ps, -1); + if (res == 10) printf ("s SATISFIABLE\n"); + else printf ("s UNSATISFIABLE\n"); + fflush (stdout); + if (join) cumcs (); else camcs (); + if (verbose) picosat_stats (ps); + picosat_reset (ps); + if (!noprint) { + if (join) print_umcs (); else print_all_mcs (); + } + release (); + return res; +} diff --git a/test/monniaux/picosat-965/picomus.c b/test/monniaux/picosat-965/picomus.c new file mode 100644 index 00000000..0f559ded --- /dev/null +++ b/test/monniaux/picosat-965/picomus.c @@ -0,0 +1,413 @@ +/**************************************************************************** +Copyright (c) 2011-2014, Armin Biere, Johannes Kepler University. + +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 "picosat.h" + +#include <stdio.h> +#include <assert.h> +#include <string.h> +#include <stdarg.h> +#include <ctype.h> + +#define MAXNONREDROUNDS 3 +#define MINCOREROUNDS 5 +#define MAXCOREROUNDS 100 + +typedef struct Cls { int lit, red, * lits; } Cls; + +static int verbose, nowitness; +static int fclose_input, pclose_input, close_output; +static FILE * input_file, * output_file; +static const char * input_name, * output_name; +static int lineno = 1; +static int nvars, nclauses; +static Cls * clauses; +static int * lits, nlits, szlits; +static double start; +static int reductions; + +static PicoSAT * ps; + +static int next (void) { + int res = fgetc (input_file); + if (res == '\n') lineno++; + return res; +} + +static void msg (int level, const char * fmt, ...) { + va_list ap; + if (verbose < level) return; + fputs ("c [picomus] ", stdout); + va_start (ap, fmt); + vfprintf (stdout, fmt, ap); + va_end (ap); + fputc ('\n', stdout); + fflush (stdout); +} + +static void warn (const char * fmt, ...) { + va_list ap; + if (verbose < 0) return; + fputs ("c [picomus] WARNING: ", stdout); + va_start (ap, fmt); + vfprintf (stdout, fmt, ap); + va_end (ap); + fputc ('\n', stdout); + fflush (stdout); +} + +static const char * parse (void) { + int ch, n, lit, sign, i; + Cls * c; +HEADER: + ch = next (); + if (ch == 'c') { + while ((ch = next ()) != '\n') + if (ch == EOF) return "EOF after 'c'"; + goto HEADER; + } + if (ch == '\r') goto HEADER; + if (ch != 'p') return "expected 'c' or 'p'"; + if (fscanf (input_file, " cnf %d %d", &nvars, &nclauses) != 2) + return "invalid header"; + msg (1, "p cnf %d %d", nvars, nclauses); + clauses = calloc (nclauses, sizeof *clauses); + lit = n = 0; +LIT: + ch = next (); + if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r') goto LIT; + if (ch == 'c') { + while ((ch = next ()) != '\n') + if (ch == EOF) return "EOF after 'c'"; + goto LIT; + } + if (ch == EOF) { + if (lit) return "zero missing"; + if (n < nclauses) return "clauses missing"; + return 0; + } + if (n == nclauses) return "too many clauses"; + if (ch == '-') { + sign = -1; + ch = next (); + if (!isdigit (ch)) return "expected digit after '-'"; + } else sign = 1; + if (!isdigit (ch)) return "expected digit"; + lit = ch - '0'; + while (isdigit (ch = next ())) + lit = 10 * lit + (ch - '0'); + if (lit > nvars) return "maximum variable index exceeded"; + if (lit) { + lit *= sign; + if (nlits == szlits) { + szlits = szlits ? 2 * szlits : 1; + lits = realloc (lits, szlits * sizeof *lits); + } + lits[nlits++] = lit; + } else { + c = clauses + n++; + c->lits = malloc ((nlits + 1) * sizeof *c->lits); + for (i = 0; i < nlits; i++) + c->lits[i] = lits[i]; + c->lits[i] = 0; + nlits = 0; + } + goto LIT; +} + +static void die (const char * fmt, ...) { + va_list ap; + fputs ("*** picomus: ", stdout); + va_start (ap, fmt); + vfprintf (stdout, fmt, ap); + va_end (ap); + fputc ('\n', stdout); + fflush (stdout); + exit (1); +} + +static double percent (double a, double b) { return b?100.0*a/b:0.0; } + +static void callback (void * dummy, const int * mus) { + int remaining; + const int * p; + (void) dummy; + if (verbose <= 0) return; + remaining = 0; + for (p = mus; *p; p++) remaining++; + assert (remaining <= nclauses); + reductions++; + msg (1, "reduction %d to %d = %.0f%% out of %d after %.1f sec", + reductions, + remaining, percent (remaining, nclauses), nclauses, + picosat_time_stamp () - start); +} + +static const char * USAGE = +"picomus [-h][-v][-q] [ <input> [ <output> ] ]\n" +"\n" +" -h print this command line option summary\n" +" -v increase verbosity level (default 0 = no messages)\n" +" -q be quiet (no warnings nor messages)\n" +"\n" +"This tool is a SAT solver that uses the PicoSAT library to\n" +"generate a 'minimal unsatisfiable core' also known as 'minimal\n" +"unsatisfiable set' (MUS) of a CNF in DIMACS format.\n" +"\n" +"Both file arguments can be \"-\" and then denote <stdin> and\n" +"<stdout> respectively. If no input file is given <stdin> is used.\n" +"If no output file is specified the MUS is computed and only printed\n" +"to <stdout> in the format of the SAT competition 2011 MUS track.\n" +"\n" +"Note, that the 's ...' lines and in case the instance is satisfiable\n" +"also the 'v ...' lines for the satisfying assignment are always\n" +"printed to <stdout> (or not printed at all with '-q').\n" +"\n" +"If '-n' is specified satisfying assignment and MUS printing\n" +"on <stdout> (using the 'v ...' format) is suppressed.\n" +"The 's ...' line is still printed unless '-q' is specified.\n" +"If <output> is specified an MUS is written to this file,\n" +"even if '-n' or '-q' is used.\n" +"\n" +#ifndef TRACE +"WARNING: PicosSAT is compiled without trace support.\n" +"\n" +"This typically slows down this MUS extractor, since\n" +"it only relies on clause selector variables and\n" +"can not make use of core extraction. To enable\n" +"trace generation use './configure.sh --trace' or\n" +"'./configure.sh -O --trace' when building PicoSAT.\n" +#else +"Since trace generation code is included, this binary\n" +"uses also core extraction in addition to clause selector\n" +"variables.\n" +#endif +; + +int main (int argc, char ** argv) { + int i, * p, n, oldn, red, nonred, res, round, printed, len; + const char * err; + const int * q; + char * cmd; + Cls * c; +#ifndef NDEBUG + int tmp; +#endif + start = picosat_time_stamp (); + for (i = 1; i < argc; i++) { + if (!strcmp (argv[i], "-h")) { + fputs (USAGE, stdout); + exit (0); + } else if (!strcmp (argv[i], "-v")) { + if (verbose < 0) die ("'-v' option after '-q'"); + verbose++; + } else if (!strcmp (argv[i], "-q")) { + if (verbose < 0) die ("two '-q' options"); + if (verbose > 0) die ("'-q' option after '-v'"); + verbose = -1; + } else if (!strcmp (argv[i], "-n")) nowitness = 1; + else if (argv[i][0] == '-' && argv[i][1]) + die ("invalid command line option '%s'", argv[i]); + else if (output_name) die ("too many arguments"); + else if (!input_name) input_name = argv[i]; + else output_name = argv[i]; + } + if (!output_name) warn ("no output file given"); + if (input_name && strcmp (input_name, "-")) { + len = strlen (input_name); + if (len >= 3 && !strcmp (input_name + len - 3, ".gz")) { +#ifdef NZIP + input_file=NULL; +#else + cmd = malloc (len + 20); + sprintf (cmd, "gunzip -c %s 2>/dev/null", input_name); + input_file = popen (cmd, "r"); + pclose_input = 1; + free (cmd); +#endif + } else input_file = fopen (input_name, "r"), fclose_input = 1; + if (!input_file) die ("can not read '%s'", input_name); + } else input_file = stdin, input_name = "-"; + if ((err = parse ())) { + fprintf (stdout, "%s:%d: %s\n", input_name, lineno, err); + fflush (stdout); + exit (1); + } + if (fclose_input) fclose (input_file); +#ifndef NZIP + if (pclose_input) pclose (input_file); +#endif + ps = picosat_init (); + picosat_set_prefix (ps, "c [picosat] "); + picosat_set_output (ps, stdout); + if (verbose > 1) picosat_set_verbosity (ps, verbose - 1); + printed = 0; + if (!picosat_enable_trace_generation (ps)) + warn ("PicoSAT compiled without trace generation"), + warn ("core extraction disabled"); + else { + n = nclauses; + nonred = 0; + for (round = 1; round <= MAXCOREROUNDS; round++) { + if (verbose > 1) + msg (1, "starting core extraction round %d", round); + picosat_set_seed (ps, round); + for (i = 0; i < nclauses; i++) { + c = clauses + i; + if (c->red) { + picosat_add (ps, 1); + picosat_add (ps, -1); + } else { + for (p = c->lits; *p; p++) + picosat_add (ps, *p); + } +#ifndef NDEBUG + tmp = +#endif + picosat_add (ps, 0); + assert (tmp == i); + } + res = picosat_sat (ps, -1); + if (res == 10) { assert (round == 1); goto SAT; } + assert (res == 20); + if (!printed) { + assert (round == 1); + printed = 1; + if (verbose >= 0) + printf ("s UNSATISFIABLE\n"), + fflush (stdout); + } + for (i = 0; i < nclauses; i++) { + c = clauses + i; + if (c->red) { assert (!picosat_coreclause (ps, i)); continue; } + if (picosat_coreclause (ps, i)) continue; + c->red = 1; + } + oldn = n; + n = 0; + for (i = 0; i < nclauses; i++) if (!clauses[i].red) n++; + msg (1, "extracted core %d of size %d = %0.f%% out of %d after %.1f sec", + round, n, percent (n, nclauses), nclauses, + picosat_time_stamp () - start); + assert (oldn >= n); + picosat_reset (ps); + ps = picosat_init (); + picosat_set_prefix (ps, "c [picosat] "); + picosat_set_output (ps, stdout); + if (round >= MINCOREROUNDS) { + red = oldn - n; + if (red < 10 && (100*red + 99)/oldn < 2) { + nonred++; + if (nonred > MAXNONREDROUNDS) break; + } + } + if (round < MAXCOREROUNDS) picosat_enable_trace_generation (ps); + } + } + for (i = 0; i < nclauses; i++) { + c = clauses + i; + if (c->red) { + picosat_add (ps, 1); + picosat_add (ps, -1); +#ifndef NDEBUG + tmp = +#endif + picosat_add (ps, 0); + assert (tmp == i); + continue; + } + c->lit = nvars + i + 1; + picosat_add (ps, -c->lit); + for (p = c->lits; *p; p++) + (void) picosat_add (ps, *p); +#ifndef NDEBUG + tmp = +#endif + picosat_add (ps, 0); + assert (tmp == i); + } + for (i = 0; i < nclauses; i++) { + c = clauses + i; + if (c->red) continue; + picosat_assume (ps, c->lit); + } + res = picosat_sat (ps, -1); + if (res == 20) { + if (!printed && verbose >= 0) + printf ("s UNSATISFIABLE\n"), fflush (stdout); + for (i = 0; i < nclauses; i++) clauses[i].red = 1; + q = picosat_mus_assumptions (ps, 0, callback, 1); + while ((i = *q++)) { + i -= nvars + 1; + assert (0 <= i && i < nclauses); + clauses[i].red = 0; + } + } else { +SAT: + assert (res == 10); + if (!printed && verbose >= 0) + printf ("s SATISFIABLE\n"), fflush (stdout); + if (!nowitness && verbose >= 0) { + for (i = 1; i <= nvars; i++) + printf ("v %d\n", ((picosat_deref (ps, i) < 0) ? -1 : 1) * i); + printf ("v 0\n"); + } + } + if (verbose > 0) picosat_stats (ps); + picosat_reset (ps); + n = 0; + for (i = 0; i < nclauses; i++) if (!clauses[i].red) n++; + red = nclauses - n; + msg (1, "found %d redundant clauses %.0f%%", red, percent (red, nclauses)); + if (res == 20) + msg (0, "computed MUS of size %d out of %d (%.0f%%)", + n, nclauses, percent (n, nclauses)); + if (output_name && strcmp (output_name, "-")) { + output_file = fopen (output_name, "w"); + if (!output_file) die ("can not write '%s'", output_name); + close_output = 1; + } else if (output_name && !strcmp (output_name, "-")) output_file = stdout; + if (output_file) { + fprintf (output_file, "p cnf %d %d\n", nvars, n); + for (i = 0; i < nclauses; i++) + if (!clauses[i].red) { + for (p = clauses[i].lits; *p; p++) fprintf (output_file, "%d ", *p); + fprintf (output_file, "0\n"); + } + if (close_output) fclose (output_file); + } + if (res == 20) { + if (!nowitness && verbose >= 0) { + for (i = 0; i < nclauses; i++) + if (!clauses[i].red) printf ("v %d\n", i+1); + printf ("v 0\n"); + } + } + msg (1, "%s %d irredundant clauses %.0f%%", + output_file ? "printed" : "computed", n, percent (n, nclauses)); + for (i = 0; i < nclauses; i++) free (clauses[i].lits); + free (clauses); + free (lits); + msg (1, "%d reductions in %.1f seconds", + reductions, picosat_time_stamp () - start); + return res; +} diff --git a/test/monniaux/picosat-965/picosat.c b/test/monniaux/picosat-965/picosat.c new file mode 100644 index 00000000..21442f44 --- /dev/null +++ b/test/monniaux/picosat-965/picosat.c @@ -0,0 +1,8508 @@ +/**************************************************************************** +Copyright (c) 2006 - 2015, Armin Biere, Johannes Kepler University. + +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 <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <assert.h> +#include <limits.h> +#include <ctype.h> +#include <stdarg.h> +#include <stdint.h> + +#include "picosat.h" + +#define INLINE inline + +/* By default code for 'all different constraints' is disabled, since 'NADC' + * is defined. + */ +#define NADC + +/* By default we enable failed literals, since 'NFL' is undefined. + * +#define NFL + */ + +/* By default we 'detach satisfied (large) clauses', e.g. NDSC undefined. + * +#define NDSC + */ + +/* Do not use luby restart schedule instead of inner/outer. + * +#define NLUBY + */ + +/* Enabling this define, will use gnuplot to visualize how the scores evolve. + * +#define VISCORES + */ + +#ifdef VISCORES +// #define WRITEGIF /* ... to generate a video */ +#endif + +#ifdef VISCORES +#ifndef WRITEGIF +#include <unistd.h> /* for 'usleep' */ +#endif +#endif + +#ifdef RCODE +#include <R.h> +#endif + +#define MINRESTART 100 /* minimum restart interval */ +#define MAXRESTART 1000000 /* maximum restart interval */ +#define RDECIDE 1000 /* interval of random decisions */ +#define FRESTART 110 /* restart increase factor in percent */ +#define FREDUCE 110 /* reduce increase factor in percent */ +#define FREDADJ 121 /* reduce increase adjustment factor */ +#define MAXCILS 10 /* maximal number of unrecycled internals */ +#define FFLIPPED 10000 /* flipped reduce factor */ +#define FFLIPPEDPREC 10000000/* flipped reduce factor precision */ +#define INTERRUPTLIM 1024 /* check interrupt after that many decisions */ + +#ifndef TRACE +#define NO_BINARY_CLAUSES /* store binary clauses more compactly */ +#endif + +/* For debugging purposes you may want to define 'LOGGING', which actually + * can be enforced by using './configure.sh --log'. + */ +#ifdef LOGGING +#define LOG(code) do { code; } while (0) +#else +#define LOG(code) do { } while (0) +#endif +#define NOLOG(code) do { } while (0) /* log exception */ +#define ONLYLOG(code) do { code; } while (0) /* force logging */ + +#define FALSE ((Val)-1) +#define UNDEF ((Val)0) +#define TRUE ((Val)1) + +#define COMPACT_TRACECHECK_TRACE_FMT 0 +#define EXTENDED_TRACECHECK_TRACE_FMT 1 +#define RUP_TRACE_FMT 2 + +#define NEWN(p,n) do { (p) = new (ps, sizeof (*(p)) * (n)); } while (0) +#define CLRN(p,n) do { memset ((p), 0, sizeof (*(p)) * (n)); } while (0) +#define CLR(p) CLRN(p,1) +#define DELETEN(p,n) \ + do { delete (ps, p, sizeof (*(p)) * (n)); (p) = 0; } while (0) + +#define RESIZEN(p,old_num,new_num) \ + do { \ + size_t old_size = sizeof (*(p)) * (old_num); \ + size_t new_size = sizeof (*(p)) * (new_num); \ + (p) = resize (ps, (p), old_size, new_size) ; \ + } while (0) + +#define ENLARGE(start,head,end) \ + do { \ + unsigned old_num = (ptrdiff_t)((end) - (start)); \ + size_t new_num = old_num ? (2 * old_num) : 1; \ + unsigned count = (head) - (start); \ + assert ((start) <= (end)); \ + RESIZEN((start),old_num,new_num); \ + (head) = (start) + count; \ + (end) = (start) + new_num; \ + } while (0) + +#define NOTLIT(l) (ps->lits + (1 ^ ((l) - ps->lits))) + +#define LIT2IDX(l) ((ptrdiff_t)((l) - ps->lits) / 2) +#define LIT2IMPLS(l) (ps->impls + (ptrdiff_t)((l) - ps->lits)) +#define LIT2INT(l) ((int)(LIT2SGN(l) * LIT2IDX(l))) +#define LIT2SGN(l) (((ptrdiff_t)((l) - ps->lits) & 1) ? -1 : 1) +#define LIT2VAR(l) (ps->vars + LIT2IDX(l)) +#define LIT2HTPS(l) (ps->htps + (ptrdiff_t)((l) - ps->lits)) +#define LIT2JWH(l) (ps->jwh + ((l) - ps->lits)) + +#ifndef NDSC +#define LIT2DHTPS(l) (ps->dhtps + (ptrdiff_t)((l) - ps->lits)) +#endif + +#ifdef NO_BINARY_CLAUSES +typedef uintptr_t Wrd; +#define ISLITREASON(C) (1&(Wrd)C) +#define LIT2REASON(L) \ + (assert (L->val==TRUE), ((Cls*)(1 + (2*(L - ps->lits))))) +#define REASON2LIT(C) ((Lit*)(ps->lits + ((Wrd)C)/2)) +#endif + +#define ENDOFCLS(c) ((void*)((Lit**)(c)->lits + (c)->size)) + +#define SOC ((ps->oclauses == ps->ohead) ? ps->lclauses : ps->oclauses) +#define EOC (ps->lhead) +#define NXC(p) (((p) + 1 == ps->ohead) ? ps->lclauses : (p) + 1) + +#define OIDX2IDX(idx) (2 * ((idx) + 1)) +#define LIDX2IDX(idx) (2 * (idx) + 1) + +#define ISLIDX(idx) ((idx)&1) + +#define IDX2OIDX(idx) (assert(!ISLIDX(idx)), (idx)/2 - 1) +#define IDX2LIDX(idx) (assert(ISLIDX(idx)), (idx)/2) + +#define EXPORTIDX(idx) \ + ((ISLIDX(idx) ? (IDX2LIDX (idx) + (ps->ohead - ps->oclauses)) : IDX2OIDX(idx)) + 1) + +#define IDX2CLS(i) \ + (assert(i), (ISLIDX(i) ? ps->lclauses : ps->oclauses)[(i)/2 - !ISLIDX(i)]) + +#define IDX2ZHN(i) (assert(i), (ISLIDX(i) ? ps->zhains[(i)/2] : 0)) + +#define CLS2TRD(c) (((Trd*)(c)) - 1) +#define CLS2IDX(c) ((((Trd*)(c)) - 1)->idx) + +#define CLS2ACT(c) \ + ((Act*)((assert((c)->learned)),assert((c)->size>2),ENDOFCLS(c))) + +#define VAR2LIT(v) (ps->lits + 2 * ((v) - ps->vars)) +#define VAR2RNK(v) (ps->rnks + ((v) - ps->vars)) + +#define RNK2LIT(r) (ps->lits + 2 * ((r) - ps->rnks)) +#define RNK2VAR(r) (ps->vars + ((r) - ps->rnks)) + +#define BLK_FILL_BYTES 8 +#define SIZE_OF_BLK (sizeof (Blk) - BLK_FILL_BYTES) + +#define PTR2BLK(void_ptr) \ + ((void_ptr) ? (Blk*)(((char*)(void_ptr)) - SIZE_OF_BLK) : 0) + +#define AVERAGE(a,b) ((b) ? (((double)a) / (double)(b)) : 0.0) +#define PERCENT(a,b) (100.0 * AVERAGE(a,b)) + +#ifndef RCODE +#define ABORT(msg) \ + do { \ + fputs ("*** picosat: " msg "\n", stderr); \ + abort (); \ + } while (0) +#else +#define ABORT(msg) \ + do { \ + Rf_error (msg); \ + } while (0) +#endif + +#define ABORTIF(cond,msg) \ + do { \ + if (!(cond)) break; \ + ABORT (msg); \ + } while (0) + +#define ZEROFLT (0x00000000u) +#define EPSFLT (0x00000001u) +#define INFFLT (0xffffffffu) + +#define FLTCARRY (1u << 25) +#define FLTMSB (1u << 24) +#define FLTMAXMANTISSA (FLTMSB - 1) + +#define FLTMANTISSA(d) ((d) & FLTMAXMANTISSA) +#define FLTEXPONENT(d) ((int)((d) >> 24) - 128) + +#define FLTMINEXPONENT (-128) +#define FLTMAXEXPONENT (127) + +#define CMPSWAPFLT(a,b) \ + do { \ + Flt tmp; \ + if (((a) < (b))) \ + { \ + tmp = (a); \ + (a) = (b); \ + (b) = tmp; \ + } \ + } while (0) + +#define UNPACKFLT(u,m,e) \ + do { \ + (m) = FLTMANTISSA(u); \ + (e) = FLTEXPONENT(u); \ + (m) |= FLTMSB; \ + } while (0) + +#define INSERTION_SORT_LIMIT 10 + +#define SORTING_SWAP(T,p,q) \ +do { \ + T tmp = *(q); \ + *(q) = *(p); \ + *(p) = tmp; \ +} while (0) + +#define SORTING_CMP_SWAP(T,cmp,p,q) \ +do { \ + if ((cmp) (ps, *(p), *(q)) > 0) \ + SORTING_SWAP (T, p, q); \ +} while(0) + +#define QUICKSORT_PARTITION(T,cmp,a,l,r) \ +do { \ + T pivot; \ + int j; \ + i = (l) - 1; /* result in 'i' */ \ + j = (r); \ + pivot = (a)[j]; \ + for (;;) \ + { \ + while ((cmp) (ps, (a)[++i], pivot) < 0) \ + ; \ + while ((cmp) (ps, pivot, (a)[--j]) < 0) \ + if (j == (l)) \ + break; \ + if (i >= j) \ + break; \ + SORTING_SWAP (T, (a) + i, (a) + j); \ + } \ + SORTING_SWAP (T, (a) + i, (a) + (r)); \ +} while(0) + +#define QUICKSORT(T,cmp,a,n) \ +do { \ + int l = 0, r = (n) - 1, m, ll, rr, i; \ + assert (ps->ihead == ps->indices); \ + if (r - l <= INSERTION_SORT_LIMIT) \ + break; \ + for (;;) \ + { \ + m = (l + r) / 2; \ + SORTING_SWAP (T, (a) + m, (a) + r - 1); \ + SORTING_CMP_SWAP (T, cmp, (a) + l, (a) + r - 1); \ + SORTING_CMP_SWAP (T, cmp, (a) + l, (a) + r); \ + SORTING_CMP_SWAP (T, cmp, (a) + r - 1, (a) + r); \ + QUICKSORT_PARTITION (T, cmp, (a), l + 1, r - 1); \ + if (i - l < r - i) \ + { \ + ll = i + 1; \ + rr = r; \ + r = i - 1; \ + } \ + else \ + { \ + ll = l; \ + rr = i - 1; \ + l = i + 1; \ + } \ + if (r - l > INSERTION_SORT_LIMIT) \ + { \ + assert (rr - ll > INSERTION_SORT_LIMIT); \ + if (ps->ihead == ps->eoi) \ + ENLARGE (ps->indices, ps->ihead, ps->eoi); \ + *ps->ihead++ = ll; \ + if (ps->ihead == ps->eoi) \ + ENLARGE (ps->indices, ps->ihead, ps->eoi); \ + *ps->ihead++ = rr; \ + } \ + else if (rr - ll > INSERTION_SORT_LIMIT) \ + { \ + l = ll; \ + r = rr; \ + } \ + else if (ps->ihead > ps->indices) \ + { \ + r = *--ps->ihead; \ + l = *--ps->ihead; \ + } \ + else \ + break; \ + } \ +} while (0) + +#define INSERTION_SORT(T,cmp,a,n) \ +do { \ + T pivot; \ + int l = 0, r = (n) - 1, i, j; \ + for (i = r; i > l; i--) \ + SORTING_CMP_SWAP (T, cmp, (a) + i - 1, (a) + i); \ + for (i = l + 2; i <= r; i++) \ + { \ + j = i; \ + pivot = (a)[i]; \ + while ((cmp) (ps, pivot, (a)[j - 1]) < 0) \ + { \ + (a)[j] = (a)[j - 1]; \ + j--; \ + } \ + (a)[j] = pivot; \ + } \ +} while (0) + +#ifdef NDEBUG +#define CHECK_SORTED(cmp,a,n) do { } while(0) +#else +#define CHECK_SORTED(cmp,a,n) \ +do { \ + int i; \ + for (i = 0; i < (n) - 1; i++) \ + assert ((cmp) (ps, (a)[i], (a)[i + 1]) <= 0); \ +} while(0) +#endif + +#define SORT(T,cmp,a,n) \ +do { \ + T * aa = (a); \ + int nn = (n); \ + QUICKSORT (T, cmp, aa, nn); \ + INSERTION_SORT (T, cmp, aa, nn); \ + assert (ps->ihead == ps->indices); \ + CHECK_SORTED (cmp, aa, nn); \ +} while (0) + +#define WRDSZ (sizeof (long) * 8) + +#ifdef RCODE +#define fprintf(...) do { } while (0) +#define vfprintf(...) do { } while (0) +#define fputs(...) do { } while (0) +#define fputc(...) do { } while (0) +#endif + +typedef unsigned Flt; /* 32 bit deterministic soft float */ +typedef Flt Act; /* clause and variable activity */ +typedef struct Blk Blk; /* allocated memory block */ +typedef struct Cls Cls; /* clause */ +typedef struct Lit Lit; /* literal */ +typedef struct Rnk Rnk; /* variable to score mapping */ +typedef signed char Val; /* TRUE, UNDEF, FALSE */ +typedef struct Var Var; /* variable */ +#ifdef TRACE +typedef struct Trd Trd; /* trace data for clauses */ +typedef struct Zhn Zhn; /* compressed chain (=zain) data */ +typedef unsigned char Znt; /* compressed antecedent data */ +#endif + +#ifdef NO_BINARY_CLAUSES +typedef struct Ltk Ltk; + +struct Ltk +{ + Lit ** start; + unsigned count : WRDSZ == 32 ? 27 : 32; + unsigned ldsize : WRDSZ == 32 ? 5 : 32; +}; +#endif + +struct Lit +{ + Val val; +}; + +struct Var +{ + unsigned mark : 1; /*bit 1*/ + unsigned resolved : 1; /*bit 2*/ + unsigned phase : 1; /*bit 3*/ + unsigned assigned : 1; /*bit 4*/ + unsigned used : 1; /*bit 5*/ + unsigned failed : 1; /*bit 6*/ + unsigned internal : 1; /*bit 7*/ + unsigned usedefphase : 1; /*bit 8*/ + unsigned defphase : 1; /*bit 9*/ + unsigned msspos : 1; /*bit 10*/ + unsigned mssneg : 1; /*bit 11*/ + unsigned humuspos : 1; /*bit 12*/ + unsigned humusneg : 1; /*bit 13*/ + unsigned partial : 1; /*bit 14*/ +#ifdef TRACE + unsigned core : 1; /*bit 15*/ +#endif + unsigned level; + Cls *reason; +#ifndef NADC + Lit ** inado; + Lit ** ado; + Lit *** adotabpos; +#endif +}; + +struct Rnk +{ + Act score; + unsigned pos : 30; /* 0 iff not on heap */ + unsigned moreimportant : 1; + unsigned lessimportant : 1; +}; + +struct Cls +{ + unsigned size; + + unsigned collect:1; /* bit 1 */ + unsigned learned:1; /* bit 2 */ + unsigned locked:1; /* bit 3 */ + unsigned used:1; /* bit 4 */ +#ifndef NDEBUG + unsigned connected:1; /* bit 5 */ +#endif +#ifdef TRACE + unsigned collected:1; /* bit 6 */ + unsigned core:1; /* bit 7 */ +#endif + +#define LDMAXGLUE 25 /* 32 - 7 */ +#define MAXGLUE ((1<<LDMAXGLUE)-1) + + unsigned glue:LDMAXGLUE; + + Cls *next[2]; + Lit *lits[2]; +}; + +#ifdef TRACE +struct Zhn +{ + unsigned ref:31; + unsigned core:1; + Znt * liz; + Znt znt[0]; +}; + +struct Trd +{ + unsigned idx; + Cls cls[0]; +}; +#endif + +struct Blk +{ +#ifndef NDEBUG + union + { + size_t size; /* this is what we really use */ + void *as_two_ptrs[2]; /* 2 * sizeof (void*) alignment of data */ + } + header; +#endif + char data[BLK_FILL_BYTES]; +}; + +enum State +{ + RESET = 0, + READY = 1, + SAT = 2, + UNSAT = 3, + UNKNOWN = 4, +}; + +enum Phase +{ + POSPHASE, + NEGPHASE, + JWLPHASE, + RNDPHASE, +}; + +struct PicoSAT +{ + enum State state; + enum Phase defaultphase; + int last_sat_call_result; + + FILE *out; + char * prefix; + int verbosity; + int plain; + unsigned LEVEL; + unsigned max_var; + unsigned size_vars; + + Lit *lits; + Var *vars; + Rnk *rnks; + Flt *jwh; + Cls **htps; +#ifndef NDSC + Cls **dhtps; +#endif +#ifdef NO_BINARY_CLAUSES + Ltk *impls; + Cls impl, cimpl; + int implvalid, cimplvalid; +#else + Cls **impls; +#endif + Lit **trail, **thead, **eot, **ttail, ** ttail2; +#ifndef NADC + Lit **ttailado; +#endif + unsigned adecidelevel; + Lit **als, **alshead, **alstail, **eoals; + Lit **CLS, **clshead, **eocls; + int *rils, *rilshead, *eorils; + int *cils, *cilshead, *eocils; + int *fals, *falshead, *eofals; + int *mass, szmass; + int *mssass, szmssass; + int *mcsass, nmcsass, szmcsass; + int *humus, szhumus; + Lit *failed_assumption; + int extracted_all_failed_assumptions; + Rnk **heap, **hhead, **eoh; + Cls **oclauses, **ohead, **eoo; /* original clauses */ + Cls **lclauses, **lhead, ** EOL; /* learned clauses */ + int * soclauses, * sohead, * eoso; /* saved original clauses */ + int saveorig; + int partial; +#ifdef TRACE + int trace; + Zhn **zhains, **zhead, **eoz; + int ocore; +#endif + FILE * rup; + int rupstarted; + int rupvariables; + int rupclauses; + Cls *mtcls; + Cls *conflict; + Lit **added, **ahead, **eoa; + Var **marked, **mhead, **eom; + Var **dfs, **dhead, **eod; + Cls **resolved, **rhead, **eor; + unsigned char *levels, *levelshead, *eolevels; + unsigned *dused, *dusedhead, *eodused; + unsigned char *buffer, *bhead, *eob; + Act vinc, lscore, ilvinc, ifvinc; +#ifdef VISCORES + Act fvinc, nvinc; +#endif + Act cinc, lcinc, ilcinc, fcinc; + unsigned srng; + size_t current_bytes; + size_t max_bytes; + size_t recycled; + double seconds, flseconds; + double entered; + unsigned nentered; + int measurealltimeinlib; + char *rline[2]; + int szrline, RCOUNT; + double levelsum; + unsigned iterations; + int reports; + int lastrheader; + unsigned calls; + unsigned decisions; + unsigned restarts; + unsigned simps; + unsigned fsimplify; + unsigned isimplify; + unsigned reductions; + unsigned lreduce; + unsigned lreduceadjustcnt; + unsigned lreduceadjustinc; + unsigned lastreduceconflicts; + unsigned llocked; /* locked large learned clauses */ + unsigned lrestart; +#ifdef NLUBY + unsigned drestart; + unsigned ddrestart; +#else + unsigned lubycnt; + unsigned lubymaxdelta; + int waslubymaxdelta; +#endif + unsigned long long lsimplify; + unsigned long long propagations; + unsigned long long lpropagations; + unsigned fixed; /* top level assignments */ +#ifndef NFL + unsigned failedlits; + unsigned ifailedlits; + unsigned efailedlits; + unsigned flcalls; +#ifdef STATS + unsigned flrounds; + unsigned long long flprops; + unsigned long long floopsed, fltried, flskipped; +#endif + unsigned long long fllimit; + int simplifying; + Lit ** saved; + unsigned saved_size; +#endif + unsigned conflicts; + unsigned contexts; + unsigned internals; + unsigned noclauses; /* current number large original clauses */ + unsigned nlclauses; /* current number large learned clauses */ + unsigned olits; /* current literals in large original clauses */ + unsigned llits; /* current literals in large learned clauses */ + unsigned oadded; /* added original clauses */ + unsigned ladded; /* added learned clauses */ + unsigned loadded; /* added original large clauses */ + unsigned lladded; /* added learned large clauses */ + unsigned addedclauses; /* oadded + ladded */ + unsigned vused; /* used variables */ + unsigned llitsadded; /* added learned literals */ + unsigned long long visits; +#ifdef STATS + unsigned loused; /* used large original clauses */ + unsigned llused; /* used large learned clauses */ + unsigned long long bvisits; + unsigned long long tvisits; + unsigned long long lvisits; + unsigned long long othertrue; + unsigned long long othertrue2; + unsigned long long othertruel; + unsigned long long othertrue2u; + unsigned long long othertruelu; + unsigned long long ltraversals; + unsigned long long traversals; +#ifdef TRACE + unsigned long long antecedents; +#endif + unsigned uips; + unsigned znts; + unsigned assumptions; + unsigned rdecisions; + unsigned sdecisions; + size_t srecycled; + size_t rrecycled; + unsigned long long derefs; +#endif + unsigned minimizedllits; + unsigned nonminimizedllits; +#ifndef NADC + Lit *** ados, *** hados, *** eados; + Lit *** adotab; + unsigned nadotab; + unsigned szadotab; + Cls * adoconflict; + unsigned adoconflicts; + unsigned adoconflictlimit; + int addingtoado; + int adodisabled; +#endif + unsigned long long flips; +#ifdef STATS + unsigned long long FORCED; + unsigned long long assignments; + unsigned inclreduces; + unsigned staticphasedecisions; + unsigned skippedrestarts; +#endif + int * indices, * ihead, *eoi; + unsigned sdflips; + + unsigned long long saved_flips; + unsigned saved_max_var; + unsigned min_flipped; + + void * emgr; + picosat_malloc enew; + picosat_realloc eresize; + picosat_free edelete; + + struct { + void * state; + int (*function) (void *); + } interrupt; + +#ifdef VISCORES + FILE * fviscores; +#endif +}; + +typedef PicoSAT PS; + +static INLINE Flt +packflt (unsigned m, int e) +{ + Flt res; + assert (m < FLTMSB); + assert (FLTMINEXPONENT <= e); + assert (e <= FLTMAXEXPONENT); + res = m | ((unsigned)(e + 128) << 24); + return res; +} + +static Flt +base2flt (unsigned m, int e) +{ + if (!m) + return ZEROFLT; + + if (m < FLTMSB) + { + do + { + if (e <= FLTMINEXPONENT) + return EPSFLT; + + e--; + m <<= 1; + + } + while (m < FLTMSB); + } + else + { + while (m >= FLTCARRY) + { + if (e >= FLTMAXEXPONENT) + return INFFLT; + + e++; + m >>= 1; + } + } + + m &= ~FLTMSB; + return packflt (m, e); +} + +static Flt +addflt (Flt a, Flt b) +{ + unsigned ma, mb, delta; + int ea, eb; + + CMPSWAPFLT (a, b); + if (!b) + return a; + + UNPACKFLT (a, ma, ea); + UNPACKFLT (b, mb, eb); + + assert (ea >= eb); + delta = ea - eb; + if (delta < 32) mb >>= delta; else mb = 0; + if (!mb) + return a; + + ma += mb; + if (ma & FLTCARRY) + { + if (ea == FLTMAXEXPONENT) + return INFFLT; + + ea++; + ma >>= 1; + } + + assert (ma < FLTCARRY); + ma &= FLTMAXMANTISSA; + + return packflt (ma, ea); +} + +static Flt +mulflt (Flt a, Flt b) +{ + unsigned ma, mb; + unsigned long long accu; + int ea, eb; + + CMPSWAPFLT (a, b); + if (!b) + return ZEROFLT; + + UNPACKFLT (a, ma, ea); + UNPACKFLT (b, mb, eb); + + ea += eb; + ea += 24; + if (ea > FLTMAXEXPONENT) + return INFFLT; + + if (ea < FLTMINEXPONENT) + return EPSFLT; + + accu = ma; + accu *= mb; + accu >>= 24; + + if (accu >= FLTCARRY) + { + if (ea == FLTMAXEXPONENT) + return INFFLT; + + ea++; + accu >>= 1; + + if (accu >= FLTCARRY) + return INFFLT; + } + + assert (accu < FLTCARRY); + assert (accu & FLTMSB); + + ma = accu; + ma &= ~FLTMSB; + + return packflt (ma, ea); +} + +static Flt +ascii2flt (const char *str) +{ + Flt ten = base2flt (10, 0); + Flt onetenth = base2flt (26843546, -28); + Flt res = ZEROFLT, tmp, base; + const char *p = str; + int ch; + + ch = *p++; + + if (ch != '.') + { + if (!isdigit (ch)) + return INFFLT; /* better abort ? */ + + res = base2flt (ch - '0', 0); + + while ((ch = *p++)) + { + if (ch == '.') + break; + + if (!isdigit (ch)) + return INFFLT; /* better abort? */ + + res = mulflt (res, ten); + tmp = base2flt (ch - '0', 0); + res = addflt (res, tmp); + } + } + + if (ch == '.') + { + ch = *p++; + if (!isdigit (ch)) + return INFFLT; /* better abort ? */ + + base = onetenth; + tmp = mulflt (base2flt (ch - '0', 0), base); + res = addflt (res, tmp); + + while ((ch = *p++)) + { + if (!isdigit (ch)) + return INFFLT; /* better abort? */ + + base = mulflt (base, onetenth); + tmp = mulflt (base2flt (ch - '0', 0), base); + res = addflt (res, tmp); + } + } + + return res; +} + +#if defined(VISCORES) + +static double +flt2double (Flt f) +{ + double res; + unsigned m; + int e, i; + + UNPACKFLT (f, m, e); + res = m; + + if (e < 0) + { + for (i = e; i < 0; i++) + res *= 0.5; + } + else + { + for (i = 0; i < e; i++) + res *= 2.0; + } + + return res; +} + +#endif + +static INLINE int +log2flt (Flt a) +{ + return FLTEXPONENT (a) + 24; +} + +static INLINE int +cmpflt (Flt a, Flt b) +{ + if (a < b) + return -1; + + if (a > b) + return 1; + + return 0; +} + +static void * +new (PS * ps, size_t size) +{ + size_t bytes; + Blk *b; + + if (!size) + return 0; + + bytes = size + SIZE_OF_BLK; + + if (ps->enew) + b = ps->enew (ps->emgr, bytes); + else + b = malloc (bytes); + + ABORTIF (!b, "out of memory in 'new'"); +#ifndef NDEBUG + b->header.size = size; +#endif + ps->current_bytes += size; + if (ps->current_bytes > ps->max_bytes) + ps->max_bytes = ps->current_bytes; + return b->data; +} + +static void +delete (PS * ps, void *void_ptr, size_t size) +{ + size_t bytes; + Blk *b; + + if (!void_ptr) + { + assert (!size); + return; + } + + assert (size); + b = PTR2BLK (void_ptr); + + assert (size <= ps->current_bytes); + ps->current_bytes -= size; + + assert (b->header.size == size); + + bytes = size + SIZE_OF_BLK; + if (ps->edelete) + ps->edelete (ps->emgr, b, bytes); + else + free (b); +} + +static void * +resize (PS * ps, void *void_ptr, size_t old_size, size_t new_size) +{ + size_t old_bytes, new_bytes; + Blk *b; + + b = PTR2BLK (void_ptr); + + assert (old_size <= ps->current_bytes); + ps->current_bytes -= old_size; + + if ((old_bytes = old_size)) + { + assert (old_size && b && b->header.size == old_size); + old_bytes += SIZE_OF_BLK; + } + else + assert (!b); + + if ((new_bytes = new_size)) + new_bytes += SIZE_OF_BLK; + + if (ps->eresize) + b = ps->eresize (ps->emgr, b, old_bytes, new_bytes); + else + b = realloc (b, new_bytes); + + if (!new_size) + { + assert (!b); + return 0; + } + + ABORTIF (!b, "out of memory in 'resize'"); +#ifndef NDEBUG + b->header.size = new_size; +#endif + + ps->current_bytes += new_size; + if (ps->current_bytes > ps->max_bytes) + ps->max_bytes = ps->current_bytes; + + return b->data; +} + +static INLINE unsigned +int2unsigned (int l) +{ + return (l < 0) ? 1 + 2 * -l : 2 * l; +} + +static INLINE Lit * +int2lit (PS * ps, int l) +{ + return ps->lits + int2unsigned (l); +} + +static INLINE Lit ** +end_of_lits (Cls * c) +{ + return (Lit**)c->lits + c->size; +} + +#if !defined(NDEBUG) || defined(LOGGING) + +static void +dumplits (PS * ps, Lit ** l, Lit ** end) +{ + int first; + Lit ** p; + + if (l == end) + { + /* empty clause */ + } + else if (l + 1 == end) + { + fprintf (ps->out, "%d ", LIT2INT (l[0])); + } + else + { + assert (l + 2 <= end); + first = (abs (LIT2INT (l[0])) > abs (LIT2INT (l[1]))); + fprintf (ps->out, "%d ", LIT2INT (l[first])); + fprintf (ps->out, "%d ", LIT2INT (l[!first])); + for (p = l + 2; p < end; p++) + fprintf (ps->out, "%d ", LIT2INT (*p)); + } + + fputc ('0', ps->out); +} + +static void +dumpcls (PS * ps, Cls * c) +{ + Lit **end; + + if (c) + { + end = end_of_lits (c); + dumplits (ps, c->lits, end); +#ifdef TRACE + if (ps->trace) + fprintf (ps->out, " clause(%u)", CLS2IDX (c)); +#endif + } + else + fputs ("DECISION", ps->out); +} + +static void +dumpclsnl (PS * ps, Cls * c) +{ + dumpcls (ps, c); + fputc ('\n', ps->out); +} + +void +dumpcnf (PS * ps) +{ + Cls **p, *c; + + for (p = SOC; p != EOC; p = NXC (p)) + { + c = *p; + + if (!c) + continue; + +#ifdef TRACE + if (c->collected) + continue; +#endif + + dumpclsnl (ps, *p); + } +} + +#endif + +static INLINE void +delete_prefix (PS * ps) +{ + if (!ps->prefix) + return; + + delete (ps, ps->prefix, strlen (ps->prefix) + 1); + ps->prefix = 0; +} + +static void +new_prefix (PS * ps, const char * str) +{ + delete_prefix (ps); + assert (str); + ps->prefix = new (ps, strlen (str) + 1); + strcpy (ps->prefix, str); +} + +static PS * +init (void * pmgr, + picosat_malloc pnew, picosat_realloc presize, picosat_free pdelete) +{ + PS * ps; + +#if 0 + int count = 3 - !pnew - !presize - !pdelete; + + ABORTIF (count && !pnew, "API usage: missing 'picosat_set_new'"); + ABORTIF (count && !presize, "API usage: missing 'picosat_set_resize'"); + ABORTIF (count && !pdelete, "API usage: missing 'picosat_set_delete'"); +#endif + + ps = pnew ? pnew (pmgr, sizeof *ps) : malloc (sizeof *ps); + ABORTIF (!ps, "failed to allocate memory for PicoSAT manager"); + memset (ps, 0, sizeof *ps); + + ps->emgr = pmgr; + ps->enew = pnew; + ps->eresize = presize; + ps->edelete = pdelete; + + ps->size_vars = 1; + ps->state = RESET; + ps->defaultphase = JWLPHASE; +#ifdef TRACE + ps->ocore = -1; +#endif + ps->lastrheader = -2; +#ifndef NADC + ps->adoconflictlimit = UINT_MAX; +#endif + ps->min_flipped = UINT_MAX; + + NEWN (ps->lits, 2 * ps->size_vars); + NEWN (ps->jwh, 2 * ps->size_vars); + NEWN (ps->htps, 2 * ps->size_vars); +#ifndef NDSC + NEWN (ps->dhtps, 2 * ps->size_vars); +#endif + NEWN (ps->impls, 2 * ps->size_vars); + NEWN (ps->vars, ps->size_vars); + NEWN (ps->rnks, ps->size_vars); + + /* because '0' pos denotes not on heap + */ + ENLARGE (ps->heap, ps->hhead, ps->eoh); + ps->hhead = ps->heap + 1; + + ps->vinc = base2flt (1, 0); /* initial var activity */ + ps->ifvinc = ascii2flt ("1.05"); /* var score rescore factor */ +#ifdef VISCORES + ps->fvinc = ascii2flt ("0.9523809"); /* 1/f = 1/1.05 */ + ps->nvinc = ascii2flt ("0.0476191"); /* 1 - 1/f = 1 - 1/1.05 */ +#endif + ps->lscore = base2flt (1, 90); /* var activity rescore limit */ + ps->ilvinc = base2flt (1, -90); /* inverse of 'lscore' */ + + ps->cinc = base2flt (1, 0); /* initial clause activity */ + ps->fcinc = ascii2flt ("1.001"); /* cls activity rescore factor */ + ps->lcinc = base2flt (1, 90); /* cls activity rescore limit */ + ps->ilcinc = base2flt (1, -90); /* inverse of 'ilcinc' */ + + ps->lreduceadjustcnt = ps->lreduceadjustinc = 100; + ps->lpropagations = ~0ull; + +#ifndef RCODE + ps->out = stdout; +#else + ps->out = 0; +#endif + new_prefix (ps, "c "); + ps->verbosity = 0; + ps->plain = 0; + +#ifdef NO_BINARY_CLAUSES + memset (&ps->impl, 0, sizeof (ps->impl)); + ps->impl.size = 2; + + memset (&ps->cimpl, 0, sizeof (ps->impl)); + ps->cimpl.size = 2; +#endif + +#ifdef VISCORES + ps->fviscores = popen ( + "/usr/bin/gnuplot -background black" + " -xrm 'gnuplot*textColor:white'" + " -xrm 'gnuplot*borderColor:white'" + " -xrm 'gnuplot*axisColor:white'" + , "w"); + fprintf (ps->fviscores, "unset key\n"); + // fprintf (ps->fviscores, "set log y\n"); + fflush (ps->fviscores); + system ("rm -rf /tmp/picosat-viscores"); + system ("mkdir /tmp/picosat-viscores"); + system ("mkdir /tmp/picosat-viscores/data"); +#ifdef WRITEGIF + system ("mkdir /tmp/picosat-viscores/gif"); + fprintf (ps->fviscores, + "set terminal gif giant animate opt size 1024,768 x000000 xffffff" + "\n"); + + fprintf (ps->fviscores, + "set output \"/tmp/picosat-viscores/gif/animated.gif\"\n"); +#endif +#endif + ps->defaultphase = JWLPHASE; + ps->state = READY; + ps->last_sat_call_result = 0; + + return ps; +} + +static size_t +bytes_clause (PS * ps, unsigned size, unsigned learned) +{ + size_t res; + + res = sizeof (Cls); + res += size * sizeof (Lit *); + res -= 2 * sizeof (Lit *); + + if (learned && size > 2) + res += sizeof (Act); /* add activity */ + +#ifdef TRACE + if (ps->trace) + res += sizeof (Trd); /* add trace data */ +#else + (void) ps; +#endif + + return res; +} + +static Cls * +new_clause (PS * ps, unsigned size, unsigned learned) +{ + size_t bytes; + void * tmp; +#ifdef TRACE + Trd *trd; +#endif + Cls *res; + + bytes = bytes_clause (ps, size, learned); + tmp = new (ps, bytes); + +#ifdef TRACE + if (ps->trace) + { + trd = tmp; + + if (learned) + trd->idx = LIDX2IDX (ps->lhead - ps->lclauses); + else + trd->idx = OIDX2IDX (ps->ohead - ps->oclauses); + + res = trd->cls; + } + else +#endif + res = tmp; + + res->size = size; + res->learned = learned; + + res->collect = 0; +#ifndef NDEBUG + res->connected = 0; +#endif + res->locked = 0; + res->used = 0; +#ifdef TRACE + res->core = 0; + res->collected = 0; +#endif + + if (learned && size > 2) + { + Act * p = CLS2ACT (res); + *p = ps->cinc; + } + + return res; +} + +static void +delete_clause (PS * ps, Cls * c) +{ + size_t bytes; +#ifdef TRACE + Trd *trd; +#endif + + bytes = bytes_clause (ps, c->size, c->learned); + +#ifdef TRACE + if (ps->trace) + { + trd = CLS2TRD (c); + delete (ps, trd, bytes); + } + else +#endif + delete (ps, c, bytes); +} + +static void +delete_clauses (PS * ps) +{ + Cls **p; + for (p = SOC; p != EOC; p = NXC (p)) + if (*p) + delete_clause (ps, *p); + + DELETEN (ps->oclauses, ps->eoo - ps->oclauses); + DELETEN (ps->lclauses, ps->EOL - ps->lclauses); + + ps->ohead = ps->eoo = ps->lhead = ps->EOL = 0; +} + +#ifdef TRACE + +static void +delete_zhain (PS * ps, Zhn * zhain) +{ + const Znt *p, *znt; + + assert (zhain); + + znt = zhain->znt; + for (p = znt; *p; p++) + ; + + delete (ps, zhain, sizeof (Zhn) + (p - znt) + 1); +} + +static void +delete_zhains (PS * ps) +{ + Zhn **p, *z; + for (p = ps->zhains; p < ps->zhead; p++) + if ((z = *p)) + delete_zhain (ps, z); + + DELETEN (ps->zhains, ps->eoz - ps->zhains); + ps->eoz = ps->zhead = 0; +} + +#endif + +#ifdef NO_BINARY_CLAUSES +static void +lrelease (PS * ps, Ltk * stk) +{ + if (stk->start) + DELETEN (stk->start, (1 << (stk->ldsize))); + memset (stk, 0, sizeof (*stk)); +} +#endif + +#ifndef NADC + +static INLINE unsigned +llength (Lit ** a) +{ + Lit ** p; + for (p = a; *p; p++) + ; + return p - a; +} + +static INLINE void +resetadoconflict (PS * ps) +{ + assert (ps->adoconflict); + delete_clause (ps, ps->adoconflict); + ps->adoconflict = 0; +} + +static INLINE void +reset_ados (PS * ps) +{ + Lit *** p; + + for (p = ps->ados; p < ps->hados; p++) + DELETEN (*p, llength (*p) + 1); + + DELETEN (ps->ados, ps->eados - ps->ados); + ps->hados = ps->eados = 0; + + DELETEN (ps->adotab, ps->szadotab); + ps->szadotab = ps->nadotab = 0; + + if (ps->adoconflict) + resetadoconflict (ps); + + ps->adoconflicts = 0; + ps->adoconflictlimit = UINT_MAX; + ps->adodisabled = 0; +} + +#endif + +static void +reset (PS * ps) +{ + ABORTIF (!ps || + ps->state == RESET, "API usage: reset without initialization"); + + delete_clauses (ps); +#ifdef TRACE + delete_zhains (ps); +#endif +#ifdef NO_BINARY_CLAUSES + { + unsigned i; + for (i = 2; i <= 2 * ps->max_var + 1; i++) + lrelease (ps, ps->impls + i); + } +#endif +#ifndef NADC + reset_ados (ps); +#endif +#ifndef NFL + DELETEN (ps->saved, ps->saved_size); +#endif + DELETEN (ps->htps, 2 * ps->size_vars); +#ifndef NDSC + DELETEN (ps->dhtps, 2 * ps->size_vars); +#endif + DELETEN (ps->impls, 2 * ps->size_vars); + DELETEN (ps->lits, 2 * ps->size_vars); + DELETEN (ps->jwh, 2 * ps->size_vars); + DELETEN (ps->vars, ps->size_vars); + DELETEN (ps->rnks, ps->size_vars); + DELETEN (ps->trail, ps->eot - ps->trail); + DELETEN (ps->heap, ps->eoh - ps->heap); + DELETEN (ps->als, ps->eoals - ps->als); + DELETEN (ps->CLS, ps->eocls - ps->CLS); + DELETEN (ps->rils, ps->eorils - ps->rils); + DELETEN (ps->cils, ps->eocils - ps->cils); + DELETEN (ps->fals, ps->eofals - ps->fals); + DELETEN (ps->mass, ps->szmass); + DELETEN (ps->mssass, ps->szmssass); + DELETEN (ps->mcsass, ps->szmcsass); + DELETEN (ps->humus, ps->szhumus); + DELETEN (ps->added, ps->eoa - ps->added); + DELETEN (ps->marked, ps->eom - ps->marked); + DELETEN (ps->dfs, ps->eod - ps->dfs); + DELETEN (ps->resolved, ps->eor - ps->resolved); + DELETEN (ps->levels, ps->eolevels - ps->levels); + DELETEN (ps->dused, ps->eodused - ps->dused); + DELETEN (ps->buffer, ps->eob - ps->buffer); + DELETEN (ps->indices, ps->eoi - ps->indices); + DELETEN (ps->soclauses, ps->eoso - ps->soclauses); + delete_prefix (ps); + delete (ps, ps->rline[0], ps->szrline); + delete (ps, ps->rline[1], ps->szrline); + assert (getenv ("LEAK") || !ps->current_bytes); /* found leak if failing */ +#ifdef VISCORES + pclose (ps->fviscores); +#endif + if (ps->edelete) + ps->edelete (ps->emgr, ps, sizeof *ps); + else + free (ps); +} + +inline static void +tpush (PS * ps, Lit * lit) +{ + assert (ps->lits < lit && lit <= ps->lits + 2* ps->max_var + 1); + if (ps->thead == ps->eot) + { + unsigned ttail2count = ps->ttail2 - ps->trail; + unsigned ttailcount = ps->ttail - ps->trail; +#ifndef NADC + unsigned ttailadocount = ps->ttailado - ps->trail; +#endif + ENLARGE (ps->trail, ps->thead, ps->eot); + ps->ttail = ps->trail + ttailcount; + ps->ttail2 = ps->trail + ttail2count; +#ifndef NADC + ps->ttailado = ps->trail + ttailadocount; +#endif + } + + *ps->thead++ = lit; +} + +static INLINE void +assign_reason (PS * ps, Var * v, Cls * reason) +{ +#if defined(NO_BINARY_CLAUSES) && !defined(NDEBUG) + assert (reason != &ps->impl); +#else + (void) ps; +#endif + v->reason = reason; +} + +static void +assign_phase (PS * ps, Lit * lit) +{ + unsigned new_phase, idx; + Var * v = LIT2VAR (lit); + +#ifndef NFL + /* In 'simplifying' mode we only need to keep 'min_flipped' up to date if + * we force assignments on the top level. The other assignments will be + * undone and thus we can keep the old saved value of the phase. + */ + if (!ps->LEVEL || !ps->simplifying) +#endif + { + new_phase = (LIT2SGN (lit) > 0); + + if (v->assigned) + { + ps->sdflips -= ps->sdflips/FFLIPPED; + + if (new_phase != v->phase) + { + assert (FFLIPPEDPREC >= FFLIPPED); + ps->sdflips += FFLIPPEDPREC / FFLIPPED; + ps->flips++; + + idx = LIT2IDX (lit); + if (idx < ps->min_flipped) + ps->min_flipped = idx; + + NOLOG (fprintf (ps->out, + "%sflipped %d\n", + ps->prefix, LIT2INT (lit))); + } + } + + v->phase = new_phase; + v->assigned = 1; + } + + lit->val = TRUE; + NOTLIT (lit)->val = FALSE; +} + +inline static void +assign (PS * ps, Lit * lit, Cls * reason) +{ + Var * v = LIT2VAR (lit); + assert (lit->val == UNDEF); +#ifdef STATS + ps->assignments++; +#endif + v->level = ps->LEVEL; + assign_phase (ps, lit); + assign_reason (ps, v, reason); + tpush (ps, lit); +} + +inline static int +cmp_added (PS * ps, Lit * k, Lit * l) +{ + Val a = k->val, b = l->val; + Var *u, *v; + int res; + + if (a == UNDEF && b != UNDEF) + return -1; + + if (a != UNDEF && b == UNDEF) + return 1; + + u = LIT2VAR (k); + v = LIT2VAR (l); + + if (a != UNDEF) + { + assert (b != UNDEF); + res = v->level - u->level; + if (res) + return res; /* larger level first */ + } + + res = cmpflt (VAR2RNK (u)->score, VAR2RNK (v)->score); + if (res) + return res; /* smaller activity first */ + + return u - v; /* smaller index first */ +} + +static INLINE void +sorttwolits (Lit ** v) +{ + Lit * a = v[0], * b = v[1]; + + assert (a != b); + + if (a < b) + return; + + v[0] = b; + v[1] = a; +} + +inline static void +sortlits (PS * ps, Lit ** v, unsigned size) +{ + if (size == 2) + sorttwolits (v); /* same order with and with out 'NO_BINARY_CLAUSES' */ + else + SORT (Lit *, cmp_added, v, size); +} + +#ifdef NO_BINARY_CLAUSES +static INLINE Cls * +setimpl (PS * ps, Lit * a, Lit * b) +{ + assert (!ps->implvalid); + assert (ps->impl.size == 2); + + ps->impl.lits[0] = a; + ps->impl.lits[1] = b; + + sorttwolits (ps->impl.lits); + ps->implvalid = 1; + + return &ps->impl; +} + +static INLINE void +resetimpl (PS * ps) +{ + ps->implvalid = 0; +} + +static Cls * +setcimpl (PS * ps, Lit * a, Lit * b) +{ + assert (!ps->cimplvalid); + assert (ps->cimpl.size == 2); + + ps->cimpl.lits[0] = a; + ps->cimpl.lits[1] = b; + + sorttwolits (ps->cimpl.lits); + ps->cimplvalid = 1; + + return &ps->cimpl; +} + +static INLINE void +resetcimpl (PS * ps) +{ + assert (ps->cimplvalid); + ps->cimplvalid = 0; +} + +#endif + +static INLINE int +cmp_ptr (PS * ps, void *l, void *k) +{ + (void) ps; + return ((char*)l) - (char*)k; /* arbitrarily already reverse */ +} + +static int +cmp_rnk (Rnk * r, Rnk * s) +{ + if (!r->moreimportant && s->moreimportant) + return -1; + + if (r->moreimportant && !s->moreimportant) + return 1; + + if (!r->lessimportant && s->lessimportant) + return 1; + + if (r->lessimportant && !s->lessimportant) + return -1; + + if (r->score < s->score) + return -1; + + if (r->score > s->score) + return 1; + + return -cmp_ptr (0, r, s); +} + +static void +hup (PS * ps, Rnk * v) +{ + int upos, vpos; + Rnk *u; + +#ifndef NFL + assert (!ps->simplifying); +#endif + + vpos = v->pos; + + assert (0 < vpos); + assert (vpos < ps->hhead - ps->heap); + assert (ps->heap[vpos] == v); + + while (vpos > 1) + { + upos = vpos / 2; + + u = ps->heap[upos]; + + if (cmp_rnk (u, v) > 0) + break; + + ps->heap[vpos] = u; + u->pos = vpos; + + vpos = upos; + } + + ps->heap[vpos] = v; + v->pos = vpos; +} + +static Cls *add_simplified_clause (PS *, int); + +inline static void +add_antecedent (PS * ps, Cls * c) +{ + assert (c); + +#ifdef NO_BINARY_CLAUSES + if (ISLITREASON (c)) + return; + + if (c == &ps->impl) + return; +#elif defined(STATS) && defined(TRACE) + ps->antecedents++; +#endif + if (ps->rhead == ps->eor) + ENLARGE (ps->resolved, ps->rhead, ps->eor); + + assert (ps->rhead < ps->eor); + *ps->rhead++ = c; +} + +#ifdef TRACE + +#ifdef NO_BINARY_CLAUSES +#error "can not combine TRACE and NO_BINARY_CLAUSES" +#endif + +#endif /* TRACE */ + +static INLINE void +add_lit (PS * ps, Lit * lit) +{ + assert (lit); + + if (ps->ahead == ps->eoa) + ENLARGE (ps->added, ps->ahead, ps->eoa); + + *ps->ahead++ = lit; +} + +static INLINE void +push_var_as_marked (PS * ps, Var * v) +{ + if (ps->mhead == ps->eom) + ENLARGE (ps->marked, ps->mhead, ps->eom); + + *ps->mhead++ = v; +} + +static INLINE void +mark_var (PS * ps, Var * v) +{ + assert (!v->mark); + v->mark = 1; + push_var_as_marked (ps, v); +} + +#ifdef NO_BINARY_CLAUSES + +static Cls * +impl2reason (PS * ps, Lit * lit) +{ + Lit * other; + Cls * res; + other = ps->impl.lits[0]; + if (lit == other) + other = ps->impl.lits[1]; + assert (other->val == FALSE); + res = LIT2REASON (NOTLIT (other)); + resetimpl (ps); + return res; +} + +#endif + +/* Whenever we have a top level derived unit we really should derive a unit + * clause otherwise the resolutions in 'add_simplified_clause' become + * incorrect. + */ +static Cls * +resolve_top_level_unit (PS * ps, Lit * lit, Cls * reason) +{ + unsigned count_resolved; + Lit **p, **eol, *other; + Var *u, *v; + + assert (ps->rhead == ps->resolved); + assert (ps->ahead == ps->added); + + add_lit (ps, lit); + add_antecedent (ps, reason); + count_resolved = 1; + v = LIT2VAR (lit); + + eol = end_of_lits (reason); + for (p = reason->lits; p < eol; p++) + { + other = *p; + u = LIT2VAR (other); + if (u == v) + continue; + + add_antecedent (ps, u->reason); + count_resolved++; + } + + /* Some of the literals could be assumptions. If at least one + * variable is not an assumption, we should resolve. + */ + if (count_resolved >= 2) + { +#ifdef NO_BINARY_CLAUSES + if (reason == &ps->impl) + resetimpl (ps); +#endif + reason = add_simplified_clause (ps, 1); +#ifdef NO_BINARY_CLAUSES + if (reason->size == 2) + { + assert (reason == &ps->impl); + reason = impl2reason (ps, lit); + } +#endif + assign_reason (ps, v, reason); + } + else + { + ps->ahead = ps->added; + ps->rhead = ps->resolved; + } + + return reason; +} + +static void +fixvar (PS * ps, Var * v) +{ + Rnk * r; + + assert (VAR2LIT (v) != UNDEF); + assert (!v->level); + + ps->fixed++; + + r = VAR2RNK (v); + r->score = INFFLT; + +#ifndef NFL + if (ps->simplifying) + return; +#endif + + if (!r->pos) + return; + + hup (ps, r); +} + +static INLINE void +use_var (PS * ps, Var * v) +{ + if (v->used) + return; + + v->used = 1; + ps->vused++; +} + +static void +assign_forced (PS * ps, Lit * lit, Cls * reason) +{ + Var *v; + + assert (reason); + assert (lit->val == UNDEF); + +#ifdef STATS + ps->FORCED++; +#endif + assign (ps, lit, reason); + +#ifdef NO_BINARY_CLAUSES + assert (reason != &ps->impl); + if (ISLITREASON (reason)) + { + reason = setimpl (ps, lit, NOTLIT (REASON2LIT (reason))); + assert (reason); + } +#endif + LOG ( fprintf (ps->out, + "%sassign %d at level %d by ", + ps->prefix, LIT2INT (lit), ps->LEVEL); + dumpclsnl (ps, reason)); + + v = LIT2VAR (lit); + if (!ps->LEVEL) + use_var (ps, v); + + if (!ps->LEVEL && reason->size > 1) + { + reason = resolve_top_level_unit (ps, lit, reason); + assert (reason); + } + +#ifdef NO_BINARY_CLAUSES + if (ISLITREASON (reason) || reason == &ps->impl) + { + /* DO NOTHING */ + } + else +#endif + { + assert (!reason->locked); + reason->locked = 1; + if (reason->learned && reason->size > 2) + ps->llocked++; + } + +#ifdef NO_BINARY_CLAUSES + if (reason == &ps->impl) + resetimpl (ps); +#endif + + if (!ps->LEVEL) + fixvar (ps, v); +} + +#ifdef NO_BINARY_CLAUSES + +static void +lpush (PS * ps, Lit * lit, Cls * c) +{ + int pos = (c->lits[0] == lit); + Ltk * s = LIT2IMPLS (lit); + unsigned oldsize, newsize; + + assert (c->size == 2); + + if (!s->start) + { + assert (!s->count); + assert (!s->ldsize); + NEWN (s->start, 1); + } + else + { + oldsize = (1 << (s->ldsize)); + assert (s->count <= oldsize); + if (s->count == oldsize) + { + newsize = 2 * oldsize; + RESIZEN (s->start, oldsize, newsize); + s->ldsize++; + } + } + + s->start[s->count++] = c->lits[pos]; +} + +#endif + +static void +connect_head_tail (PS * ps, Lit * lit, Cls * c) +{ + Cls ** s; + assert (c->size >= 1); + if (c->size == 2) + { +#ifdef NO_BINARY_CLAUSES + lpush (ps, lit, c); + return; +#else + s = LIT2IMPLS (lit); +#endif + } + else + s = LIT2HTPS (lit); + + if (c->lits[0] != lit) + { + assert (c->size >= 2); + assert (c->lits[1] == lit); + c->next[1] = *s; + } + else + c->next[0] = *s; + + *s = c; +} + +#ifdef TRACE +static void +zpush (PS * ps, Zhn * zhain) +{ + assert (ps->trace); + + if (ps->zhead == ps->eoz) + ENLARGE (ps->zhains, ps->zhead, ps->eoz); + + *ps->zhead++ = zhain; +} + +static INLINE int +cmp_resolved (PS * ps, Cls * c, Cls * d) +{ +#ifndef NDEBUG + assert (ps->trace); +#else + (void) ps; +#endif + return CLS2IDX (c) - CLS2IDX (d); +} + +static INLINE void +bpushc (PS * ps, unsigned char ch) +{ + if (ps->bhead == ps->eob) + ENLARGE (ps->buffer, ps->bhead, ps->eob); + + *ps->bhead++ = ch; +} + +static INLINE void +bpushu (PS * ps, unsigned u) +{ + while (u & ~0x7f) + { + bpushc (ps, u | 0x80); + u >>= 7; + } + + bpushc (ps, u); +} + +static INLINE void +bpushd (PS * ps, unsigned prev, unsigned this) +{ + unsigned delta; + assert (prev < this); + delta = this - prev; + bpushu (ps, delta); +} + +static void +add_zhain (PS * ps) +{ + unsigned prev, this, count, rcount; + Cls **p, *c; + Zhn *res; + + assert (ps->trace); + assert (ps->bhead == ps->buffer); + assert (ps->rhead > ps->resolved); + + rcount = ps->rhead - ps->resolved; + SORT (Cls *, cmp_resolved, ps->resolved, rcount); + + prev = 0; + for (p = ps->resolved; p < ps->rhead; p++) + { + c = *p; + this = CLS2TRD (c)->idx; + bpushd (ps, prev, this); + prev = this; + } + bpushc (ps, 0); + + count = ps->bhead - ps->buffer; + + res = new (ps, sizeof (Zhn) + count); + res->core = 0; + res->ref = 0; + memcpy (res->znt, ps->buffer, count); + + ps->bhead = ps->buffer; +#ifdef STATS + ps->znts += count - 1; +#endif + zpush (ps, res); +} + +#endif + +static void +add_resolved (PS * ps, int learned) +{ +#if defined(STATS) || defined(TRACE) + Cls **p, *c; + + for (p = ps->resolved; p < ps->rhead; p++) + { + c = *p; + if (c->used) + continue; + + c->used = 1; + + if (c->size <= 2) + continue; + +#ifdef STATS + if (c->learned) + ps->llused++; + else + ps->loused++; +#endif + } +#endif + +#ifdef TRACE + if (learned && ps->trace) + add_zhain (ps); +#else + (void) learned; +#endif + ps->rhead = ps->resolved; +} + +static void +incjwh (PS * ps, Cls * c) +{ + Lit **p, *lit, ** eol; + Flt * f, inc, sum; + unsigned size = 0; + Var * v; + Val val; + + eol = end_of_lits (c); + + for (p = c->lits; p < eol; p++) + { + lit = *p; + val = lit->val; + + if (val && ps->LEVEL > 0) + { + v = LIT2VAR (lit); + if (v->level > 0) + val = UNDEF; + } + + if (val == TRUE) + return; + + if (val != FALSE) + size++; + } + + inc = base2flt (1, -size); + + for (p = c->lits; p < eol; p++) + { + lit = *p; + f = LIT2JWH (lit); + sum = addflt (*f, inc); + *f = sum; + } +} + +static void +write_rup_header (PS * ps, FILE * file) +{ + char line[80]; + int i; + + sprintf (line, "%%RUPD32 %u %u", ps->rupvariables, ps->rupclauses); + + fputs (line, file); + for (i = 255 - strlen (line); i >= 0; i--) + fputc (' ', file); + + fputc ('\n', file); + fflush (file); +} + +static Cls * +add_simplified_clause (PS * ps, int learned) +{ + unsigned num_true, num_undef, num_false, size, count_resolved; + Lit **p, **q, *lit, ** end; + unsigned litlevel, glue; + Cls *res, * reason; + int reentered; + Val val; + Var *v; +#if !defined(NDEBUG) && defined(TRACE) + unsigned idx; +#endif + + reentered = 0; + +REENTER: + + size = ps->ahead - ps->added; + + add_resolved (ps, learned); + + if (learned) + { + ps->ladded++; + ps->llitsadded += size; + if (size > 2) + { + ps->lladded++; + ps->nlclauses++; + ps->llits += size; + } + } + else + { + ps->oadded++; + if (size > 2) + { + ps->loadded++; + ps->noclauses++; + ps->olits += size; + } + } + + ps->addedclauses++; + assert (ps->addedclauses == ps->ladded + ps->oadded); + +#ifdef NO_BINARY_CLAUSES + if (size == 2) + res = setimpl (ps, ps->added[0], ps->added[1]); + else +#endif + { + sortlits (ps, ps->added, size); + + if (learned) + { + if (ps->lhead == ps->EOL) + { + ENLARGE (ps->lclauses, ps->lhead, ps->EOL); + + /* A very difficult to find bug, which only occurs if the + * learned clauses stack is immediately allocated before the + * original clauses stack without padding. In this case, we + * have 'SOC == EOC', which terminates all loops using the + * idiom 'for (p = SOC; p != EOC; p = NXC(p))' immediately. + * Unfortunately this occurred in 'fix_clause_lits' after + * using a recent version of the memory allocator of 'Google' + * perftools in the context of one large benchmark for + * our SMT solver 'Boolector'. + */ + if (ps->EOL == ps->oclauses) + ENLARGE (ps->lclauses, ps->lhead, ps->EOL); + } + +#if !defined(NDEBUG) && defined(TRACE) + idx = LIDX2IDX (ps->lhead - ps->lclauses); +#endif + } + else + { + if (ps->ohead == ps->eoo) + { + ENLARGE (ps->oclauses, ps->ohead, ps->eoo); + if (ps->EOL == ps->oclauses) + ENLARGE (ps->oclauses, ps->ohead, ps->eoo); /* ditto */ + } + +#if !defined(NDEBUG) && defined(TRACE) + idx = OIDX2IDX (ps->ohead - ps->oclauses); +#endif + } + + assert (ps->EOL != ps->oclauses); /* ditto */ + + res = new_clause (ps, size, learned); + + glue = 0; + + if (learned) + { + assert (ps->dusedhead == ps->dused); + + for (p = ps->added; p < ps->ahead; p++) + { + lit = *p; + if (lit->val) + { + litlevel = LIT2VAR (lit)->level; + assert (litlevel <= ps->LEVEL); + while (ps->levels + litlevel >= ps->levelshead) + { + if (ps->levelshead >= ps->eolevels) + ENLARGE (ps->levels, ps->levelshead, ps->eolevels); + assert (ps->levelshead < ps->eolevels); + *ps->levelshead++ = 0; + } + if (!ps->levels[litlevel]) + { + if (ps->dusedhead >= ps->eodused) + ENLARGE (ps->dused, ps->dusedhead, ps->eodused); + assert (ps->dusedhead < ps->eodused); + *ps->dusedhead++ = litlevel; + ps->levels[litlevel] = 1; + glue++; + } + } + else + glue++; + } + + while (ps->dusedhead > ps->dused) + { + litlevel = *--ps->dusedhead; + assert (ps->levels + litlevel < ps->levelshead); + assert (ps->levels[litlevel]); + ps->levels[litlevel] = 0; + } + } + + assert (glue <= MAXGLUE); + res->glue = glue; + +#if !defined(NDEBUG) && defined(TRACE) + if (ps->trace) + assert (CLS2IDX (res) == idx); +#endif + if (learned) + *ps->lhead++ = res; + else + *ps->ohead++ = res; + +#if !defined(NDEBUG) && defined(TRACE) + if (ps->trace && learned) + assert (ps->zhead - ps->zhains == ps->lhead - ps->lclauses); +#endif + assert (ps->lhead != ps->oclauses); /* ditto */ + } + + if (learned && ps->rup) + { + if (!ps->rupstarted) + { + write_rup_header (ps, ps->rup); + ps->rupstarted = 1; + } + } + + num_true = num_undef = num_false = 0; + + q = res->lits; + for (p = ps->added; p < ps->ahead; p++) + { + lit = *p; + *q++ = lit; + + if (learned && ps->rup) + fprintf (ps->rup, "%d ", LIT2INT (lit)); + + val = lit->val; + + num_true += (val == TRUE); + num_undef += (val == UNDEF); + num_false += (val == FALSE); + } + assert (num_false + num_true + num_undef == size); + + if (learned && ps->rup) + fputs ("0\n", ps->rup); + + ps->ahead = ps->added; /* reset */ + + if (!reentered) // TODO merge + if (size > 0) + { + assert (size <= 2 || !reentered); // TODO remove + connect_head_tail (ps, res->lits[0], res); + if (size > 1) + connect_head_tail (ps, res->lits[1], res); + } + + if (size == 0) + { + if (!ps->mtcls) + ps->mtcls = res; + } + +#ifdef NO_BINARY_CLAUSES + if (size != 2) +#endif +#ifndef NDEBUG + res->connected = 1; +#endif + + LOG ( fprintf (ps->out, "%s%s ", ps->prefix, learned ? "learned" : "original"); + dumpclsnl (ps, res)); + + /* Shrink clause by resolving it against top level assignments. + */ + if (!ps->LEVEL && num_false > 0) + { + assert (ps->ahead == ps->added); + assert (ps->rhead == ps->resolved); + + count_resolved = 1; + add_antecedent (ps, res); + + end = end_of_lits (res); + for (p = res->lits; p < end; p++) + { + lit = *p; + v = LIT2VAR (lit); + use_var (ps, v); + + if (lit->val == FALSE) + { + add_antecedent (ps, v->reason); + count_resolved++; + } + else + add_lit (ps, lit); + } + + assert (count_resolved >= 2); + + learned = 1; +#ifdef NO_BINARY_CLAUSES + if (res == &ps->impl) + resetimpl (ps); +#endif + reentered = 1; + goto REENTER; /* and return simplified clause */ + } + + if (!num_true && num_undef == 1) /* unit clause */ + { + lit = 0; + for (p = res->lits; p < res->lits + size; p++) + { + if ((*p)->val == UNDEF) + lit = *p; + + v = LIT2VAR (*p); + use_var (ps, v); + } + assert (lit); + + reason = res; +#ifdef NO_BINARY_CLAUSES + if (size == 2) + { + Lit * other = res->lits[0]; + if (other == lit) + other = res->lits[1]; + + assert (other->val == FALSE); + reason = LIT2REASON (NOTLIT (other)); + } +#endif + assign_forced (ps, lit, reason); + num_true++; + } + + if (num_false == size && !ps->conflict) + { +#ifdef NO_BINARY_CLAUSES + if (res == &ps->impl) + ps->conflict = setcimpl (ps, res->lits[0], res->lits[1]); + else +#endif + ps->conflict = res; + } + + if (!learned && !num_true && num_undef) + incjwh (ps, res); + +#ifdef NO_BINARY_CLAUSES + if (res == &ps->impl) + resetimpl (ps); +#endif + return res; +} + +static int +trivial_clause (PS * ps) +{ + Lit **p, **q, *prev; + Var *v; + + SORT (Lit *, cmp_ptr, ps->added, ps->ahead - ps->added); + + prev = 0; + q = ps->added; + for (p = q; p < ps->ahead; p++) + { + Lit *this = *p; + + v = LIT2VAR (this); + + if (prev == this) /* skip repeated literals */ + continue; + + /* Top level satisfied ? + */ + if (this->val == TRUE && !v->level) + return 1; + + if (prev == NOTLIT (this))/* found pair of dual literals */ + return 1; + + *q++ = prev = this; + } + + ps->ahead = q; /* shrink */ + + return 0; +} + +static void +simplify_and_add_original_clause (PS * ps) +{ +#ifdef NO_BINARY_CLAUSES + Cls * c; +#endif + if (trivial_clause (ps)) + { + ps->ahead = ps->added; + + if (ps->ohead == ps->eoo) + ENLARGE (ps->oclauses, ps->ohead, ps->eoo); + + *ps->ohead++ = 0; + + ps->addedclauses++; + ps->oadded++; + } + else + { + if (ps->CLS != ps->clshead) + add_lit (ps, NOTLIT (ps->clshead[-1])); + +#ifdef NO_BINARY_CLAUSES + c = +#endif + add_simplified_clause (ps, 0); +#ifdef NO_BINARY_CLAUSES + if (c == &ps->impl) assert (!ps->implvalid); +#endif + } +} + +#ifndef NADC + +static void +add_ado (PS * ps) +{ + unsigned len = ps->ahead - ps->added; + Lit ** ado, ** p, ** q, *lit; + Var * v, * u; + +#ifdef TRACE + assert (!ps->trace); +#endif + + ABORTIF (ps->ados < ps->hados && llength (ps->ados[0]) != len, + "internal: non matching all different constraint object lengths"); + + if (ps->hados == ps->eados) + ENLARGE (ps->ados, ps->hados, ps->eados); + + NEWN (ado, len + 1); + *ps->hados++ = ado; + + p = ps->added; + q = ado; + u = 0; + while (p < ps->ahead) + { + lit = *p++; + v = LIT2VAR (lit); + ABORTIF (v->inado, + "internal: variable in multiple all different objects"); + v->inado = ado; + if (!u && !lit->val) + u = v; + *q++ = lit; + } + + assert (q == ado + len); + *q++ = 0; + + /* TODO simply do a conflict test as in propado */ + + ABORTIF (!u, + "internal: " + "adding fully instantiated all different object not implemented yet"); + + assert (u); + assert (u->inado == ado); + assert (!u->ado); + u->ado = ado; + + ps->ahead = ps->added; +} + +#endif + +static void +hdown (PS * ps, Rnk * r) +{ + unsigned end, rpos, cpos, opos; + Rnk *child, *other; + + assert (r->pos > 0); + assert (ps->heap[r->pos] == r); + + end = ps->hhead - ps->heap; + rpos = r->pos; + + for (;;) + { + cpos = 2 * rpos; + if (cpos >= end) + break; + + opos = cpos + 1; + child = ps->heap[cpos]; + + if (cmp_rnk (r, child) < 0) + { + if (opos < end) + { + other = ps->heap[opos]; + + if (cmp_rnk (child, other) < 0) + { + child = other; + cpos = opos; + } + } + } + else if (opos < end) + { + child = ps->heap[opos]; + + if (cmp_rnk (r, child) >= 0) + break; + + cpos = opos; + } + else + break; + + ps->heap[rpos] = child; + child->pos = rpos; + rpos = cpos; + } + + r->pos = rpos; + ps->heap[rpos] = r; +} + +static Rnk * +htop (PS * ps) +{ + assert (ps->hhead > ps->heap + 1); + return ps->heap[1]; +} + +static Rnk * +hpop (PS * ps) +{ + Rnk *res, *last; + unsigned end; + + assert (ps->hhead > ps->heap + 1); + + res = ps->heap[1]; + res->pos = 0; + + end = --ps->hhead - ps->heap; + if (end == 1) + return res; + + last = ps->heap[end]; + + ps->heap[last->pos = 1] = last; + hdown (ps, last); + + return res; +} + +inline static void +hpush (PS * ps, Rnk * r) +{ + assert (!r->pos); + + if (ps->hhead == ps->eoh) + ENLARGE (ps->heap, ps->hhead, ps->eoh); + + r->pos = ps->hhead++ - ps->heap; + ps->heap[r->pos] = r; + hup (ps, r); +} + +static INLINE void +fix_trail_lits (PS * ps, long delta) +{ + Lit **p; + for (p = ps->trail; p < ps->thead; p++) + *p += delta; +} + +#ifdef NO_BINARY_CLAUSES +static void +fix_impl_lits (PS * ps, long delta) +{ + Ltk * s; + Lit ** p; + + for (s = ps->impls + 2; s <= ps->impls + 2 * ps->max_var + 1; s++) + for (p = s->start; p < s->start + s->count; p++) + *p += delta; +} +#endif + +static void +fix_clause_lits (PS * ps, long delta) +{ + Cls **p, *clause; + Lit **q, *lit, **eol; + + for (p = SOC; p != EOC; p = NXC (p)) + { + clause = *p; + if (!clause) + continue; + + q = clause->lits; + eol = end_of_lits (clause); + while (q < eol) + { + assert (q - clause->lits <= (int) clause->size); + lit = *q; + lit += delta; + *q++ = lit; + } + } +} + +static INLINE void +fix_added_lits (PS * ps, long delta) +{ + Lit **p; + for (p = ps->added; p < ps->ahead; p++) + *p += delta; +} + +static INLINE void +fix_assumed_lits (PS * ps, long delta) +{ + Lit **p; + for (p = ps->als; p < ps->alshead; p++) + *p += delta; +} + +static INLINE void +fix_cls_lits (PS * ps, long delta) +{ + Lit **p; + for (p = ps->CLS; p < ps->clshead; p++) + *p += delta; +} + +static INLINE void +fix_heap_rnks (PS * ps, long delta) +{ + Rnk **p; + + for (p = ps->heap + 1; p < ps->hhead; p++) + *p += delta; +} + +#ifndef NADC + +static INLINE void +fix_ado (long delta, Lit ** ado) +{ + Lit ** p; + for (p = ado; *p; p++) + *p += delta; +} + +static INLINE void +fix_ados (PS * ps, long delta) +{ + Lit *** p; + + for (p = ps->ados; p < ps->hados; p++) + fix_ado (delta, *p); +} + +#endif + +static void +enlarge (PS * ps, unsigned new_size_vars) +{ + long rnks_delta, lits_delta; + Lit *old_lits = ps->lits; + Rnk *old_rnks = ps->rnks; + + RESIZEN (ps->lits, 2 * ps->size_vars, 2 * new_size_vars); + RESIZEN (ps->jwh, 2 * ps->size_vars, 2 * new_size_vars); + RESIZEN (ps->htps, 2 * ps->size_vars, 2 * new_size_vars); +#ifndef NDSC + RESIZEN (ps->dhtps, 2 * ps->size_vars, 2 * new_size_vars); +#endif + RESIZEN (ps->impls, 2 * ps->size_vars, 2 * new_size_vars); + RESIZEN (ps->vars, ps->size_vars, new_size_vars); + RESIZEN (ps->rnks, ps->size_vars, new_size_vars); + + if ((lits_delta = ps->lits - old_lits)) + { + fix_trail_lits (ps, lits_delta); + fix_clause_lits (ps, lits_delta); + fix_added_lits (ps, lits_delta); + fix_assumed_lits (ps, lits_delta); + fix_cls_lits (ps, lits_delta); +#ifdef NO_BINARY_CLAUSES + fix_impl_lits (ps, lits_delta); +#endif +#ifndef NADC + fix_ados (ps, lits_delta); +#endif + } + + if ((rnks_delta = ps->rnks - old_rnks)) + { + fix_heap_rnks (ps, rnks_delta); + } + + assert (ps->mhead == ps->marked); + + ps->size_vars = new_size_vars; +} + +static void +unassign (PS * ps, Lit * lit) +{ + Cls *reason; + Var *v; + Rnk *r; + + assert (lit->val == TRUE); + + LOG ( fprintf (ps->out, "%sunassign %d\n", ps->prefix, LIT2INT (lit))); + + v = LIT2VAR (lit); + reason = v->reason; + +#ifdef NO_BINARY_CLAUSES + assert (reason != &ps->impl); + if (ISLITREASON (reason)) + { + /* DO NOTHING */ + } + else +#endif + if (reason) + { + assert (reason->locked); + reason->locked = 0; + if (reason->learned && reason->size > 2) + { + assert (ps->llocked > 0); + ps->llocked--; + } + } + + lit->val = UNDEF; + NOTLIT (lit)->val = UNDEF; + + r = VAR2RNK (v); + if (!r->pos) + hpush (ps, r); + +#ifndef NDSC + { + Cls * p, * next, ** q; + + q = LIT2DHTPS (lit); + p = *q; + *q = 0; + + while (p) + { + Lit * other = p->lits[0]; + + if (other == lit) + { + other = p->lits[1]; + q = p->next + 1; + } + else + { + assert (p->lits[1] == lit); + q = p->next; + } + + next = *q; + *q = *LIT2HTPS (other); + *LIT2HTPS (other) = p; + p = next; + } + } +#endif + +#ifndef NADC + if (v->adotabpos) + { + assert (ps->nadotab); + assert (*v->adotabpos == v->ado); + + *v->adotabpos = 0; + v->adotabpos = 0; + + ps->nadotab--; + } +#endif +} + +static Cls * +var2reason (PS * ps, Var * var) +{ + Cls * res = var->reason; +#ifdef NO_BINARY_CLAUSES + Lit * this, * other; + if (ISLITREASON (res)) + { + this = VAR2LIT (var); + if (this->val == FALSE) + this = NOTLIT (this); + + other = REASON2LIT (res); + assert (other->val == TRUE); + assert (this->val == TRUE); + res = setimpl (ps, NOTLIT (other), this); + } +#else + (void) ps; +#endif + return res; +} + +static INLINE void +mark_clause_to_be_collected (Cls * c) +{ + assert (!c->collect); + c->collect = 1; +} + +static void +undo (PS * ps, unsigned new_level) +{ + Lit *lit; + Var *v; + + while (ps->thead > ps->trail) + { + lit = *--ps->thead; + v = LIT2VAR (lit); + if (v->level == new_level) + { + ps->thead++; /* fix pre decrement */ + break; + } + + unassign (ps, lit); + } + + ps->LEVEL = new_level; + ps->ttail = ps->thead; + ps->ttail2 = ps->thead; +#ifndef NADC + ps->ttailado = ps->thead; +#endif + +#ifdef NO_BINARY_CLAUSES + if (ps->conflict == &ps->cimpl) + resetcimpl (ps); +#endif +#ifndef NADC + if (ps->conflict && ps->conflict == ps->adoconflict) + resetadoconflict (ps); +#endif + ps->conflict = ps->mtcls; + if (ps->LEVEL < ps->adecidelevel) + { + assert (ps->als < ps->alshead); + ps->adecidelevel = 0; + ps->alstail = ps->als; + } + LOG ( fprintf (ps->out, "%sback to level %u\n", ps->prefix, ps->LEVEL)); +} + +#ifndef NDEBUG + +static int +clause_satisfied (Cls * c) +{ + Lit **p, **eol, *lit; + + eol = end_of_lits (c); + for (p = c->lits; p < eol; p++) + { + lit = *p; + if (lit->val == TRUE) + return 1; + } + + return 0; +} + +static void +original_clauses_satisfied (PS * ps) +{ + Cls **p, *c; + + for (p = ps->oclauses; p < ps->ohead; p++) + { + c = *p; + + if (!c) + continue; + + if (c->learned) + continue; + + assert (clause_satisfied (c)); + } +} + +static void +assumptions_satisfied (PS * ps) +{ + Lit *lit, ** p; + + for (p = ps->als; p < ps->alshead; p++) + { + lit = *p; + assert (lit->val == TRUE); + } +} + +#endif + +static void +sflush (PS * ps) +{ +#ifdef HAS_FLOAT + double now = picosat_time_stamp (); + double delta = now - ps->entered; + delta = (delta < 0) ? 0 : delta; + ps->seconds += delta; + ps->entered = now; +#endif +} + +static double +mb (PS * ps) +{ + return ps->current_bytes / (double) (1 << 20); +} + +static INLINE double +avglevel (PS * ps) +{ + return ps->decisions ? ps->levelsum / ps->decisions : 0.0; +} + +static void +rheader (PS * ps) +{ + assert (ps->lastrheader <= ps->reports); + + if (ps->lastrheader == ps->reports) + return; + + ps->lastrheader = ps->reports; + + fprintf (ps->out, "%s\n", ps->prefix); + fprintf (ps->out, "%s %s\n", ps->prefix, ps->rline[0]); + fprintf (ps->out, "%s %s\n", ps->prefix, ps->rline[1]); + fprintf (ps->out, "%s\n", ps->prefix); +} + +static unsigned +dynamic_flips_per_assignment_per_mille (PS * ps) +{ + assert (FFLIPPEDPREC >= 1000); + return ps->sdflips / (FFLIPPEDPREC / 1000); +} + +#ifdef NLUBY + +static int +high_agility (PS * ps) +{ + return dynamic_flips_per_assignment_per_mille (ps) >= 200; +} + +static int +very_high_agility (PS * ps) +{ + return dynamic_flips_per_assignment_per_mille (ps) >= 250; +} + +#else + +static int +medium_agility (PS * ps) +{ + return dynamic_flips_per_assignment_per_mille (ps) >= 230; +} + +#endif + +static void +relemdata (PS * ps) +{ + char *p; + int x; + + if (ps->reports < 0) + { + /* strip trailing white space + */ + for (x = 0; x <= 1; x++) + { + p = ps->rline[x] + strlen (ps->rline[x]); + while (p-- > ps->rline[x]) + { + if (*p != ' ') + break; + + *p = 0; + } + } + + rheader (ps); + } + else + fputc ('\n', ps->out); + + ps->RCOUNT = 0; +} + +static void +relemhead (PS * ps, const char * name, int fp, double val) +{ + int x, y, len, size; + const char *fmt; + unsigned tmp, e; + + if (ps->reports < 0) + { + x = ps->RCOUNT & 1; + y = (ps->RCOUNT / 2) * 12 + x * 6; + + if (ps->RCOUNT == 1) + sprintf (ps->rline[1], "%6s", ""); + + len = strlen (name); + while (ps->szrline <= len + y + 1) + { + size = ps->szrline ? 2 * ps->szrline : 128; + ps->rline[0] = resize (ps, ps->rline[0], ps->szrline, size); + ps->rline[1] = resize (ps, ps->rline[1], ps->szrline, size); + ps->szrline = size; + } + + fmt = (len <= 6) ? "%6s%10s" : "%-10s%4s"; + sprintf (ps->rline[x] + y, fmt, name, ""); + } + else if (val < 0) + { + assert (fp); + + if (val > -100 && (tmp = val * 10.0 - 0.5) > -1000.0) + { + fprintf (ps->out, "-%4.1f ", -tmp / 10.0); + } + else + { + tmp = -val / 10.0 + 0.5; + e = 1; + while (tmp >= 100) + { + tmp /= 10; + e++; + } + + fprintf (ps->out, "-%2ue%u ", tmp, e); + } + } + else + { + if (fp && val < 1000 && (tmp = val * 10.0 + 0.5) < 10000) + { + fprintf (ps->out, "%5.1f ", tmp / 10.0); + } + else if (!fp && (tmp = val) < 100000) + { + fprintf (ps->out, "%5u ", tmp); + } + else + { + tmp = val / 10.0 + 0.5; + e = 1; + + while (tmp >= 1000) + { + tmp /= 10; + e++; + } + + fprintf (ps->out, "%3ue%u ", tmp, e); + } + } + + ps->RCOUNT++; +} + +inline static void +relem (PS * ps, const char *name, int fp, double val) +{ + if (name) + relemhead (ps, name, fp, val); + else + relemdata (ps); +} + +static unsigned +reduce_limit_on_lclauses (PS * ps) +{ + unsigned res = ps->lreduce; + res += ps->llocked; + return res; +} + +static void +report (PS * ps, int replevel, char type) +{ + int rounds; + +#ifdef RCODE + (void) type; +#endif + + if (ps->verbosity < replevel) + return; + + sflush (ps); + + if (!ps->reports) + ps->reports = -1; + + for (rounds = (ps->reports < 0) ? 2 : 1; rounds; rounds--) + { + if (ps->reports >= 0) + fprintf (ps->out, "%s%c ", ps->prefix, type); +#ifdef DMONNIAUX_DISABLE + + relem (ps, "seconds", 1, ps->seconds); + relem (ps, "level", 1, avglevel (ps)); + assert (ps->fixed <= ps->max_var); + relem (ps, "variables", 0, ps->max_var - ps->fixed); + relem (ps, "used", 1, PERCENT (ps->vused, ps->max_var)); + relem (ps, "original", 0, ps->noclauses); + relem (ps, "conflicts", 0, ps->conflicts); + // relem (ps, "decisions", 0, ps->decisions); + // relem (ps, "conf/dec", 1, PERCENT(ps->conflicts,ps->decisions)); + // relem (ps, "limit", 0, reduce_limit_on_lclauses (ps)); + relem (ps, "learned", 0, ps->nlclauses); + // relem (ps, "limit", 1, PERCENT (ps->nlclauses, reduce_limit_on_lclauses (ps))); + relem (ps, "limit", 0, ps->lreduce); +#ifdef STATS + relem (ps, "learning", 1, PERCENT (ps->llused, ps->lladded)); +#endif + relem (ps, "agility", 1, dynamic_flips_per_assignment_per_mille (ps) / 10.0); + // relem (ps, "original", 0, ps->noclauses); + relem (ps, "MB", 1, mb (ps)); + // relem (ps, "lladded", 0, ps->lladded); + // relem (ps, "llused", 0, ps->llused); + + relem (ps, 0, 0, 0); +#endif + + ps->reports++; + } + + /* Adapt this to the number of rows in your terminal. + */ + #define ROWS 25 + + if (INT_MOD(ps->reports, (ROWS - 3)) == (ROWS - 4)) + rheader (ps); + + fflush (ps->out); +} + +static int +bcp_queue_is_empty (PS * ps) +{ + if (ps->ttail != ps->thead) + return 0; + + if (ps->ttail2 != ps->thead) + return 0; + +#ifndef NADC + if (ps->ttailado != ps->thead) + return 0; +#endif + + return 1; +} + +static int +satisfied (PS * ps) +{ + assert (!ps->mtcls); + assert (!ps->failed_assumption); + if (ps->alstail < ps->alshead) + return 0; + assert (!ps->conflict); + assert (bcp_queue_is_empty (ps)); + return ps->thead == ps->trail + ps->max_var; /* all assigned */ +} + +static void +vrescore (PS * ps) +{ + Rnk *p, *eor = ps->rnks + ps->max_var; + for (p = ps->rnks + 1; p <= eor; p++) + if (p->score != INFFLT) + p->score = mulflt (p->score, ps->ilvinc); + ps->vinc = mulflt (ps->vinc, ps->ilvinc);; +#ifdef VISCORES + ps->nvinc = mulflt (ps->nvinc, ps->lscore);; +#endif +} + +static void +inc_score (PS * ps, Var * v) +{ + Flt score; + Rnk *r; + +#ifndef NFL + if (ps->simplifying) + return; +#endif + + if (!v->level) + return; + + if (v->internal) + return; + + r = VAR2RNK (v); + score = r->score; + + assert (score != INFFLT); + + score = addflt (score, ps->vinc); + assert (score < INFFLT); + r->score = score; + if (r->pos > 0) + hup (ps, r); + + if (score > ps->lscore) + vrescore (ps); +} + +static void +inc_activity (PS * ps, Cls * c) +{ + Act *p; + + if (!c->learned) + return; + + if (c->size <= 2) + return; + + p = CLS2ACT (c); + *p = addflt (*p, ps->cinc); +} + +static INLINE unsigned +hashlevel (unsigned l) +{ + return 1u << (l & 31); +} + +static INLINE void +push (PS * ps, Var * v) +{ + if (ps->dhead == ps->eod) + ENLARGE (ps->dfs, ps->dhead, ps->eod); + + *ps->dhead++ = v; +} + +static INLINE Var * +pop (PS * ps) +{ + assert (ps->dfs < ps->dhead); + return *--ps->dhead; +} + +static void +analyze (PS * ps) +{ + unsigned open, minlevel, siglevels, l, old, i, orig; + Lit *this, *other, **p, **q, **eol; + Var *v, *u, **m, *start, *uip; + Cls *c; + + assert (ps->conflict); + + assert (ps->ahead == ps->added); + assert (ps->mhead == ps->marked); + assert (ps->rhead == ps->resolved); + + /* First, search for First UIP variable and mark all resolved variables. + * At the same time determine the minimum decision level involved. + * Increase activities of resolved variables. + */ + q = ps->thead; + open = 0; + minlevel = ps->LEVEL; + siglevels = 0; + uip = 0; + + c = ps->conflict; + + for (;;) + { + add_antecedent (ps, c); + inc_activity (ps, c); + eol = end_of_lits (c); + for (p = c->lits; p < eol; p++) + { + other = *p; + + if (other->val == TRUE) + continue; + + assert (other->val == FALSE); + + u = LIT2VAR (other); + if (u->mark) + continue; + + u->mark = 1; + inc_score (ps, u); + use_var (ps, u); + + if (u->level == ps->LEVEL) + { + open++; + } + else + { + push_var_as_marked (ps, u); + + if (u->level) + { + /* The statistics counter 'nonminimizedllits' sums up the + * number of literals that would be added if only the + * 'first UIP' scheme for learned clauses would be used + * and no clause minimization. + */ + ps->nonminimizedllits++; + + if (u->level < minlevel) + minlevel = u->level; + + siglevels |= hashlevel (u->level); + } + else + { + assert (!u->level); + assert (u->reason); + } + } + } + + do + { + if (q == ps->trail) + { + uip = 0; + goto DONE_FIRST_UIP; + } + + this = *--q; + uip = LIT2VAR (this); + } + while (!uip->mark); + + uip->mark = 0; + + c = var2reason (ps, uip); +#ifdef NO_BINARY_CLAUSES + if (c == &ps->impl) + resetimpl (ps); +#endif + open--; + if ((!open && ps->LEVEL) || !c) + break; + + assert (c); + } + +DONE_FIRST_UIP: + + if (uip) + { + assert (ps->LEVEL); + this = VAR2LIT (uip); + this += (this->val == TRUE); + ps->nonminimizedllits++; + ps->minimizedllits++; + add_lit (ps, this); +#ifdef STATS + if (uip->reason) + ps->uips++; +#endif + } + else + assert (!ps->LEVEL); + + /* Second, try to mark more intermediate variables, with the goal to + * minimize the conflict clause. This is a DFS from already marked + * variables backward through the implication graph. It tries to reach + * other marked variables. If the search reaches an unmarked decision + * variable or a variable assigned below the minimum level of variables in + * the first uip learned clause or a level on which no variable has been + * marked, then the variable from which the DFS is started is not + * redundant. Otherwise the start variable is redundant and will + * eventually be removed from the learned clause in step 4. We initially + * implemented BFS, but then profiling revelead that this step is a bottle + * neck for certain incremental applications. After switching to DFS this + * hot spot went away. + */ + orig = ps->mhead - ps->marked; + for (i = 0; i < orig; i++) + { + start = ps->marked[i]; + + assert (start->mark); + assert (start != uip); + assert (start->level < ps->LEVEL); + + if (!start->reason) + continue; + + old = ps->mhead - ps->marked; + assert (ps->dhead == ps->dfs); + push (ps, start); + + while (ps->dhead > ps->dfs) + { + u = pop (ps); + assert (u->mark); + + c = var2reason (ps, u); +#ifdef NO_BINARY_CLAUSES + if (c == &ps->impl) + resetimpl (ps); +#endif + if (!c || + ((l = u->level) && + (l < minlevel || ((hashlevel (l) & ~siglevels))))) + { + while (ps->mhead > ps->marked + old) /* reset all marked */ + (*--ps->mhead)->mark = 0; + + ps->dhead = ps->dfs; /* and DFS stack */ + break; + } + + eol = end_of_lits (c); + for (p = c->lits; p < eol; p++) + { + v = LIT2VAR (*p); + if (v->mark) + continue; + + mark_var (ps, v); + push (ps, v); + } + } + } + + for (m = ps->marked; m < ps->mhead; m++) + { + v = *m; + + assert (v->mark); + assert (!v->resolved); + + use_var (ps, v); + + c = var2reason (ps, v); + if (!c) + continue; + +#ifdef NO_BINARY_CLAUSES + if (c == &ps->impl) + resetimpl (ps); +#endif + eol = end_of_lits (c); + for (p = c->lits; p < eol; p++) + { + other = *p; + + u = LIT2VAR (other); + if (!u->level) + continue; + + if (!u->mark) /* 'MARKTEST' */ + break; + } + + if (p != eol) + continue; + + add_antecedent (ps, c); + v->resolved = 1; + } + + for (m = ps->marked; m < ps->mhead; m++) + { + v = *m; + + assert (v->mark); + v->mark = 0; + + if (v->resolved) + { + v->resolved = 0; + continue; + } + + this = VAR2LIT (v); + if (this->val == TRUE) + this++; /* actually NOTLIT */ + + add_lit (ps, this); + ps->minimizedllits++; + } + + assert (ps->ahead <= ps->eoa); + assert (ps->rhead <= ps->eor); + + ps->mhead = ps->marked; +} + +static void +fanalyze (PS * ps) +{ + Lit ** eol, ** p, * lit; + Cls * c, * reason; + Var * v, * u; + int next; + +#ifndef RCODE + double start = picosat_time_stamp (); +#endif + + assert (ps->failed_assumption); + assert (ps->failed_assumption->val == FALSE); + + v = LIT2VAR (ps->failed_assumption); + reason = var2reason (ps, v); + if (!reason) return; +#ifdef NO_BINARY_CLAUSES + if (reason == &ps->impl) + resetimpl (ps); +#endif + + eol = end_of_lits (reason); + for (p = reason->lits; p != eol; p++) + { + lit = *p; + u = LIT2VAR (lit); + if (u == v) continue; + if (u->reason) break; + } + if (p == eol) return; + + assert (ps->ahead == ps->added); + assert (ps->mhead == ps->marked); + assert (ps->rhead == ps->resolved); + + next = 0; + mark_var (ps, v); + add_lit (ps, NOTLIT (ps->failed_assumption)); + + do + { + v = ps->marked[next++]; + use_var (ps, v); + if (v->reason) + { + reason = var2reason (ps, v); +#ifdef NO_BINARY_CLAUSES + if (reason == &ps->impl) + resetimpl (ps); +#endif + add_antecedent (ps, reason); + eol = end_of_lits (reason); + for (p = reason->lits; p != eol; p++) + { + lit = *p; + u = LIT2VAR (lit); + if (u == v) continue; + if (u->mark) continue; + mark_var (ps, u); + } + } + else + { + lit = VAR2LIT (v); + if (lit->val == TRUE) lit = NOTLIT (lit); + add_lit (ps, lit); + } + } + while (ps->marked + next < ps->mhead); + + c = add_simplified_clause (ps, 1); + v = LIT2VAR (ps->failed_assumption); + reason = v->reason; +#ifdef NO_BINARY_CLAUSES + if (!ISLITREASON (reason)) +#endif + { + assert (reason->locked); + reason->locked = 0; + if (reason->learned && reason->size > 2) + { + assert (ps->llocked > 0); + ps->llocked--; + } + } + +#ifdef NO_BINARY_CLAUSES + if (c == &ps->impl) + { + c = impl2reason (ps, NOTLIT (ps->failed_assumption)); + } + else +#endif + { + assert (c->learned); + assert (!c->locked); + c->locked = 1; + if (c->size > 2) + { + ps->llocked++; + assert (ps->llocked > 0); + } + } + + v->reason = c; + + while (ps->mhead > ps->marked) + (*--ps->mhead)->mark = 0; + + if (ps->verbosity) + fprintf (ps->out, "%sfanalyze took %.1f seconds\n", + ps->prefix, picosat_time_stamp () - start); +} + +/* Propagate assignment of 'this' to 'FALSE' by visiting all binary clauses in + * which 'this' occurs. + */ +inline static void +prop2 (PS * ps, Lit * this) +{ +#ifdef NO_BINARY_CLAUSES + Lit ** l, ** start; + Ltk * lstk; +#else + Cls * c, ** p; + Cls * next; +#endif + Lit * other; + Val tmp; + + assert (this->val == FALSE); + +#ifdef NO_BINARY_CLAUSES + lstk = LIT2IMPLS (this); + start = lstk->start; + l = start + lstk->count; + while (l != start) + { + /* The counter 'visits' is the number of clauses that are + * visited during propagations of assignments. + */ + ps->visits++; +#ifdef STATS + ps->bvisits++; +#endif + other = *--l; + tmp = other->val; + + if (tmp == TRUE) + { +#ifdef STATS + ps->othertrue++; + ps->othertrue2++; + if (LIT2VAR (other)->level < ps->LEVEL) + ps->othertrue2u++; +#endif + continue; + } + + if (tmp != FALSE) + { + assign_forced (ps, other, LIT2REASON (NOTLIT(this))); + continue; + } + + if (ps->conflict == &ps->cimpl) + resetcimpl (ps); + ps->conflict = setcimpl (ps, this, other); + } +#else + /* Traverse all binary clauses with 'this'. Head/Tail pointers for binary + * clauses do not have to be modified here. + */ + p = LIT2IMPLS (this); + for (c = *p; c; c = next) + { + ps->visits++; +#ifdef STATS + ps->bvisits++; +#endif + assert (!c->collect); +#ifdef TRACE + assert (!c->collected); +#endif + assert (c->size == 2); + + other = c->lits[0]; + if (other == this) + { + next = c->next[0]; + other = c->lits[1]; + } + else + next = c->next[1]; + + tmp = other->val; + + if (tmp == TRUE) + { +#ifdef STATS + ps->othertrue++; + ps->othertrue2++; + if (LIT2VAR (other)->level < ps->LEVEL) + ps->othertrue2u++; +#endif + continue; + } + + if (tmp == FALSE) + ps->conflict = c; + else + assign_forced (ps, other, c); /* unit clause */ + } +#endif /* !defined(NO_BINARY_CLAUSES) */ +} + +#ifndef NDSC +static int +should_disconnect_head_tail (PS * ps, Lit * lit) +{ + unsigned litlevel; + Var * v; + + assert (lit->val == TRUE); + + v = LIT2VAR (lit); + litlevel = v->level; + + if (!litlevel) + return 1; + +#ifndef NFL + if (ps->simplifying) + return 0; +#endif + + return litlevel < ps->LEVEL; +} +#endif + +inline static void +propl (PS * ps, Lit * this) +{ + Lit **l, *other, *prev, *new_lit, **eol; + Cls *next, **htp_ptr, **new_htp_ptr; + Cls *c; +#ifdef STATS + unsigned size; +#endif + + htp_ptr = LIT2HTPS (this); + assert (this->val == FALSE); + + /* Traverse all non binary clauses with 'this'. Head/Tail pointers are + * updated as well. + */ + for (c = *htp_ptr; c; c = next) + { + ps->visits++; +#ifdef STATS + size = c->size; + assert (size >= 3); + ps->traversals++; /* other is dereferenced at least */ + + if (size == 3) + ps->tvisits++; + else if (size >= 4) + { + ps->lvisits++; + ps->ltraversals++; + } +#endif +#ifdef TRACE + assert (!c->collected); +#endif + assert (c->size > 0); + + other = c->lits[0]; + if (other != this) + { + assert (c->size != 1); + c->lits[0] = this; + c->lits[1] = other; + next = c->next[1]; + c->next[1] = c->next[0]; + c->next[0] = next; + } + else if (c->size == 1) /* With assumptions we need to + * traverse unit clauses as well. + */ + { + assert (!ps->conflict); + ps->conflict = c; + break; + } + else + { + assert (other == this && c->size > 1); + other = c->lits[1]; + next = c->next[0]; + } + assert (other == c->lits[1]); + assert (this == c->lits[0]); + assert (next == c->next[0]); + assert (!c->collect); + + if (other->val == TRUE) + { +#ifdef STATS + ps->othertrue++; + ps->othertruel++; +#endif +#ifndef NDSC + if (should_disconnect_head_tail (ps, other)) + { + new_htp_ptr = LIT2DHTPS (other); + c->next[0] = *new_htp_ptr; + *new_htp_ptr = c; +#ifdef STATS + ps->othertruelu++; +#endif + *htp_ptr = next; + continue; + } +#endif + htp_ptr = c->next; + continue; + } + + l = c->lits + 1; + eol = (Lit**) c->lits + c->size; + prev = this; + + while (++l != eol) + { +#ifdef STATS + if (size >= 3) + { + ps->traversals++; + if (size > 3) + ps->ltraversals++; + } +#endif + new_lit = *l; + *l = prev; + prev = new_lit; + if (new_lit->val != FALSE) break; + } + + if (l == eol) + { + while (l > c->lits + 2) + { + new_lit = *--l; + *l = prev; + prev = new_lit; + } + assert (c->lits[0] == this); + + assert (other == c->lits[1]); + if (other->val == FALSE) /* found conflict */ + { + assert (!ps->conflict); + ps->conflict = c; + return; + } + + assign_forced (ps, other, c); /* unit clause */ + htp_ptr = c->next; + } + else + { + assert (new_lit->val == TRUE || new_lit->val == UNDEF); + c->lits[0] = new_lit; + // *l = this; + new_htp_ptr = LIT2HTPS (new_lit); + c->next[0] = *new_htp_ptr; + *new_htp_ptr = c; + *htp_ptr = next; + } + } +} + +#ifndef NADC + +static unsigned primes[] = { 996293, 330643, 753947, 500873 }; + +#define PRIMES ((sizeof primes)/sizeof *primes) + +static unsigned +hash_ado (PS * ps, Lit ** ado, unsigned salt) +{ + unsigned i, res, tmp; + Lit ** p, * lit; + + assert (salt < PRIMES); + + i = salt; + res = 0; + + for (p = ado; (lit = *p); p++) + { + assert (lit->val); + + tmp = res >> 31; + res <<= 1; + + if (lit->val > 0) + res |= 1; + + assert (i < PRIMES); + res *= primes[i++]; + if (i == PRIMES) + i = 0; + + res += tmp; + } + + return res & (ps->szadotab - 1); +} + +static unsigned +cmp_ado (Lit ** a, Lit ** b) +{ + Lit ** p, ** q, * l, * k; + int res; + + for (p = a, q = b; (l = *p); p++, q++) + { + k = *q; + assert (k); + if ((res = (l->val - k->val))) + return res; + } + + assert (!*q); + + return 0; +} + +static Lit *** +find_ado (PS * ps, Lit ** ado) +{ + Lit *** res, ** other; + unsigned pos, delta; + + pos = hash_ado (ps, ado, 0); + assert (pos < ps->szadotab); + res = ps->adotab + pos; + + other = *res; + if (!other || !cmp_ado (other, ado)) + return res; + + delta = hash_ado (ps, ado, 1); + if (!(delta & 1)) + delta++; + + assert (delta & 1); + assert (delta < ps->szadotab); + + for (;;) + { + pos += delta; + if (pos >= ps->szadotab) + pos -= ps->szadotab; + + assert (pos < ps->szadotab); + res = ps->adotab + pos; + other = *res; + if (!other || !cmp_ado (other, ado)) + return res; + } +} + +static void +enlarge_adotab (PS * ps) +{ + /* TODO make this generic */ + + ABORTIF (ps->szadotab, + "internal: all different objects table needs larger initial size"); + assert (!ps->nadotab); + ps->szadotab = 10000; + NEWN (ps->adotab, ps->szadotab); + CLRN (ps->adotab, ps->szadotab); +} + +static int +propado (PS * ps, Var * v) +{ + Lit ** p, ** q, *** adotabpos, **ado, * lit; + Var * u; + + if (ps->LEVEL && ps->adodisabled) + return 1; + + assert (!ps->conflict); + assert (!ps->adoconflict); + assert (VAR2LIT (v)->val != UNDEF); + assert (!v->adotabpos); + + if (!v->ado) + return 1; + + assert (v->inado); + + for (p = v->ado; (lit = *p); p++) + if (lit->val == UNDEF) + { + u = LIT2VAR (lit); + assert (!u->ado); + u->ado = v->ado; + v->ado = 0; + + return 1; + } + + if (4 * ps->nadotab >= 3 * ps->szadotab) /* at least 75% filled */ + enlarge_adotab (ps); + + adotabpos = find_ado (ps, v->ado); + ado = *adotabpos; + + if (!ado) + { + ps->nadotab++; + v->adotabpos = adotabpos; + *adotabpos = v->ado; + return 1; + } + + assert (ado != v->ado); + + ps->adoconflict = new_clause (ps, 2 * llength (ado), 1); + q = ps->adoconflict->lits; + + for (p = ado; (lit = *p); p++) + *q++ = lit->val == FALSE ? lit : NOTLIT (lit); + + for (p = v->ado; (lit = *p); p++) + *q++ = lit->val == FALSE ? lit : NOTLIT (lit); + + assert (q == ENDOFCLS (ps->adoconflict)); + ps->conflict = ps->adoconflict; + ps->adoconflicts++; + return 0; +} + +#endif + +static void +bcp (PS * ps) +{ + int props = 0; + assert (!ps->conflict); + + if (ps->mtcls) + return; + + for (;;) + { + if (ps->ttail2 < ps->thead) /* prioritize implications */ + { + props++; + prop2 (ps, NOTLIT (*ps->ttail2++)); + } + else if (ps->ttail < ps->thead) /* unit clauses or clauses with length > 2 */ + { + if (ps->conflict) break; + propl (ps, NOTLIT (*ps->ttail++)); + if (ps->conflict) break; + } +#ifndef NADC + else if (ps->ttailado < ps->thead) + { + if (ps->conflict) break; + propado (ps, LIT2VAR (*ps->ttailado++)); + if (ps->conflict) break; + } +#endif + else + break; /* all assignments propagated, so break */ + } + + ps->propagations += props; +} + +static unsigned +drive (PS * ps) +{ + unsigned res, vlevel; + Lit **p; + Var *v; + + res = 0; + for (p = ps->added; p < ps->ahead; p++) + { + v = LIT2VAR (*p); + vlevel = v->level; + assert (vlevel <= ps->LEVEL); + if (vlevel < ps->LEVEL && vlevel > res) + res = vlevel; + } + + return res; +} + +#ifdef VISCORES + +static void +viscores (PS * ps) +{ + Rnk *p, *eor = ps->rnks + ps->max_var; + char name[100], cmd[200]; + FILE * data; + Flt s; + int i; + + for (p = ps->rnks + 1; p <= ps->eor; p++) + { + s = p->score; + if (s == INFFLT) + continue; + s = mulflt (s, ps->nvinc); + assert (flt2double (s) <= 1.0); + } + + sprintf (name, "/tmp/picosat-viscores/data/%08u", ps->conflicts); + sprintf (cmd, "sort -n|nl>%s", name); + + data = popen (cmd, "w"); + for (p = ps->rnks + 1; p <= ps->eor; p++) + { + s = p->score; + if (s == INFFLT) + continue; + s = mulflt (s, ps->nvinc); + fprintf (data, "%lf %d\n", 100.0 * flt2double (s), (int)(p - ps->rnks)); + } + fflush (data); + pclose (data); + + for (i = 0; i < 8; i++) + { + sprintf (cmd, "awk '$3%%8==%d' %s>%s.%d", i, name, name, i); + system (cmd); + } + + fprintf (ps->fviscores, "set title \"%u\"\n", ps->conflicts); + fprintf (ps->fviscores, "plot [0:%u] 0, 100 * (1 - 1/1.1), 100", ps->max_var); + + for (i = 0; i < 8; i++) + fprintf (ps->fviscores, + ", \"%s.%d\" using 1:2:3 with labels tc lt %d", + name, i, i + 1); + + fputc ('\n', ps->fviscores); + fflush (ps->fviscores); +#ifndef WRITEGIF + usleep (50000); /* refresh rate of 20 Hz */ +#endif +} + +#endif + +static void +crescore (PS * ps) +{ + Cls **p, *c; + Act *a; + Flt factor; + int l = log2flt (ps->cinc); + assert (l > 0); + factor = base2flt (1, -l); + + for (p = ps->lclauses; p != ps->lhead; p++) + { + c = *p; + + if (!c) + continue; + +#ifdef TRACE + if (c->collected) + continue; +#endif + assert (c->learned); + + if (c->size <= 2) + continue; + + a = CLS2ACT (c); + *a = mulflt (*a, factor); + } + + ps->cinc = mulflt (ps->cinc, factor); +} + +static void +inc_vinc (PS * ps) +{ +#ifdef VISCORES + ps->nvinc = mulflt (ps->nvinc, ps->fvinc); +#endif + ps->vinc = mulflt (ps->vinc, ps->ifvinc); +} + +inline static void +inc_max_var (PS * ps) +{ + Lit *lit; + Rnk *r; + Var *v; + + assert (ps->max_var < ps->size_vars); + + if (ps->max_var + 1 == ps->size_vars) + enlarge (ps, ps->size_vars + 2*(ps->size_vars + 3) / 4); /* +25% */ + + ps->max_var++; /* new index of variable */ + assert (ps->max_var); /* no unsigned overflow */ + + assert (ps->max_var < ps->size_vars); + + lit = ps->lits + 2 * ps->max_var; + lit[0].val = lit[1].val = UNDEF; + + memset (ps->htps + 2 * ps->max_var, 0, 2 * sizeof *ps->htps); +#ifndef NDSC + memset (ps->dhtps + 2 * ps->max_var, 0, 2 * sizeof *ps->dhtps); +#endif + memset (ps->impls + 2 * ps->max_var, 0, 2 * sizeof *ps->impls); + memset (ps->jwh + 2 * ps->max_var, 0, 2 * sizeof *ps->jwh); + + v = ps->vars + ps->max_var; /* initialize variable components */ + CLR (v); + + r = ps->rnks + ps->max_var; /* initialize rank */ + CLR (r); + + hpush (ps, r); +} + +static void +force (PS * ps, Cls * c) +{ + Lit ** p, ** eol, * lit, * forced; + Cls * reason; + + forced = 0; + reason = c; + + eol = end_of_lits (c); + for (p = c->lits; p < eol; p++) + { + lit = *p; + if (lit->val == UNDEF) + { + assert (!forced); + forced = lit; +#ifdef NO_BINARY_CLAUSES + if (c == &ps->impl) + reason = LIT2REASON (NOTLIT (p[p == c->lits ? 1 : -1])); +#endif + } + else + assert (lit->val == FALSE); + } + +#ifdef NO_BINARY_CLAUSES + if (c == &ps->impl) + resetimpl (ps); +#endif + if (!forced) + return; + + assign_forced (ps, forced, reason); +} + +static INLINE void +inc_lreduce (PS * ps) +{ +#ifdef STATS + ps->inclreduces++; +#endif + ps->lreduce *= FREDUCE; + ps->lreduce /= 100; + report (ps, 1, '+'); +} + +static void +backtrack (PS * ps) +{ + unsigned new_level; + Cls * c; + + ps->conflicts++; + LOG ( fprintf (ps->out, "%sconflict ", ps->prefix); dumpclsnl (ps, ps->conflict)); + + analyze (ps); + new_level = drive (ps); + // TODO: why not? assert (new_level != 1 || (ps->ahead - ps->added) == 2); + c = add_simplified_clause (ps, 1); + undo (ps, new_level); + force (ps, c); + + if ( +#ifndef NFL + !ps->simplifying && +#endif + !--ps->lreduceadjustcnt) + { + /* With FREDUCE==110 and FREDADJ=121 we stir 'lreduce' to be + * proportional to 'sqrt(conflicts)'. In earlier version we actually + * used 'FREDADJ=150', which results in 'lreduce' to approximate + * 'conflicts^(log(1.1)/log(1.5))' which is close to the fourth root + * of 'conflicts', since log(1.1)/log(1.5)=0.235 (as observed by + * Donald Knuth). The square root is the same we get by a Glucose + * style increase, which simply adds a constant at every reduction. + * This would be way simpler to implement but for now we keep the more + * complicated code using the adjust increments and counters. + */ + ps->lreduceadjustinc *= FREDADJ; ps->lreduceadjustinc /= 100; ps->lreduceadjustcnt + = ps->lreduceadjustinc; + inc_lreduce (ps); + } + + if (ps->verbosity >= 4 && !(INT_MOD(ps->conflicts, 1000))) + report (ps, 4, 'C'); +} + +static void +inc_cinc (PS * ps) +{ + ps->cinc = mulflt (ps->cinc, ps->fcinc); + if (ps->lcinc < ps->cinc) + crescore (ps); +} + +static void +incincs (PS * ps) +{ + inc_vinc (ps); + inc_cinc (ps); +#ifdef VISCORES + viscores (ps); +#endif +} + +static void +disconnect_clause (PS * ps, Cls * c) +{ + assert (c->connected); + + if (c->size > 2) + { + if (c->learned) + { + assert (ps->nlclauses > 0); + ps->nlclauses--; + + assert (ps->llits >= c->size); + ps->llits -= c->size; + } + else + { + assert (ps->noclauses > 0); + ps->noclauses--; + + assert (ps->olits >= c->size); + ps->olits -= c->size; + } + } + +#ifndef NDEBUG + c->connected = 0; +#endif +} + +static int +clause_is_toplevel_satisfied (PS * ps, Cls * c) +{ + Lit *lit, **p, **eol = end_of_lits (c); + Var *v; + + for (p = c->lits; p < eol; p++) + { + lit = *p; + if (lit->val == TRUE) + { + v = LIT2VAR (lit); + if (!v->level) + return 1; + } + } + + return 0; +} + +static int +collect_clause (PS * ps, Cls * c) +{ + assert (c->collect); + c->collect = 0; + +#ifdef TRACE + assert (!c->collected); + c->collected = 1; +#endif + disconnect_clause (ps, c); + +#ifdef TRACE + if (ps->trace && (!c->learned || c->used)) + return 0; +#endif + delete_clause (ps, c); + + return 1; +} + +static size_t +collect_clauses (PS * ps) +{ + Cls *c, **p, **q, * next; + Lit * lit, * eol; + size_t res; + int i; + + res = ps->current_bytes; + + eol = ps->lits + 2 * ps->max_var + 1; + for (lit = ps->lits + 2; lit <= eol; lit++) + { + for (i = 0; i <= 1; i++) + { + if (i) + { +#ifdef NO_BINARY_CLAUSES + Ltk * lstk = LIT2IMPLS (lit); + Lit ** r, ** s; + r = lstk->start; + if (lit->val != TRUE || LIT2VAR (lit)->level) + for (s = r; s < lstk->start + lstk->count; s++) + { + Lit * other = *s; + Var *v = LIT2VAR (other); + if (v->level || + other->val != TRUE) + *r++ = other; + } + lstk->count = r - lstk->start; + continue; +#else + p = LIT2IMPLS (lit); +#endif + } + else + p = LIT2HTPS (lit); + + for (c = *p; c; c = next) + { + q = c->next; + if (c->lits[0] != lit) + q++; + + next = *q; + if (c->collect) + *p = next; + else + p = q; + } + } + } + +#ifndef NDSC + for (lit = ps->lits + 2; lit <= eol; lit++) + { + p = LIT2DHTPS (lit); + while ((c = *p)) + { + Lit * other = c->lits[0]; + if (other == lit) + { + q = c->next + 1; + } + else + { + assert (c->lits[1] == lit); + q = c->next; + } + + if (c->collect) + *p = *q; + else + p = q; + } + } +#endif + + for (p = SOC; p != EOC; p = NXC (p)) + { + c = *p; + + if (!c) + continue; + + if (!c->collect) + continue; + + if (collect_clause (ps, c)) + *p = 0; + } + +#ifdef TRACE + if (!ps->trace) +#endif + { + q = ps->oclauses; + for (p = q; p < ps->ohead; p++) + if ((c = *p)) + *q++ = c; + ps->ohead = q; + + q = ps->lclauses; + for (p = q; p < ps->lhead; p++) + if ((c = *p)) + *q++ = c; + ps->lhead = q; + } + + assert (ps->current_bytes <= res); + res -= ps->current_bytes; + ps->recycled += res; + + LOG ( fprintf (ps->out, "%scollected %ld bytes\n", ps->prefix, (long)res)); + + return res; +} + +static INLINE int +need_to_reduce (PS * ps) +{ + return ps->nlclauses >= reduce_limit_on_lclauses (ps); +} + +#ifdef NLUBY + +static void +inc_drestart (PS * ps) +{ + ps->drestart *= FRESTART; + ps->drestart /= 100; + + if (ps->drestart >= MAXRESTART) + ps->drestart = MAXRESTART; +} + +static void +inc_ddrestart (PS * ps) +{ + ps->ddrestart *= FRESTART; + ps->ddrestart /= 100; + + if (ps->ddrestart >= MAXRESTART) + ps->ddrestart = MAXRESTART; +} + +#else + +static unsigned +luby (unsigned i) +{ + unsigned k; + for (k = 1; k < 32; k++) + if (i == (1u << k) - 1) + return 1u << (k - 1); + + for (k = 1;; k++) + if ((1u << (k - 1)) <= i && i < (1u << k) - 1) + return luby (i - (1u << (k-1)) + 1); +} + +#endif + +#ifndef NLUBY +static void +inc_lrestart (PS * ps, int skip) +{ + unsigned delta; + + delta = 100 * luby (++ps->lubycnt); + ps->lrestart = ps->conflicts + delta; + + if (ps->waslubymaxdelta) + report (ps, 1, skip ? 'N' : 'R'); + else + report (ps, 2, skip ? 'n' : 'r'); + + if (delta > ps->lubymaxdelta) + { + ps->lubymaxdelta = delta; + ps->waslubymaxdelta = 1; + } + else + ps->waslubymaxdelta = 0; +} +#endif + +static void +init_restart (PS * ps) +{ +#ifdef NLUBY + /* TODO: why is it better in incremental usage to have smaller initial + * outer restart interval? + */ + ps->ddrestart = ps->calls > 1 ? MINRESTART : 1000; + ps->drestart = MINRESTART; + ps->lrestart = ps->conflicts + ps->drestart; +#else + ps->lubycnt = 0; + ps->lubymaxdelta = 0; + ps->waslubymaxdelta = 0; + inc_lrestart (ps, 0); +#endif +} + +static void +restart (PS * ps) +{ + int skip; +#ifdef NLUBY + char kind; + int outer; + + inc_drestart (ps); + outer = (ps->drestart >= ps->ddrestart); + + if (outer) + skip = very_high_agility (ps); + else + skip = high_agility (ps); +#else + skip = medium_agility (ps); +#endif + +#ifdef STATS + if (skip) + ps->skippedrestarts++; +#endif + + assert (ps->conflicts >= ps->lrestart); + + if (!skip) + { + ps->restarts++; + assert (ps->LEVEL > 1); + LOG ( fprintf (ps->out, "%srestart %u\n", ps->prefix, ps->restarts)); + undo (ps, 0); + } + +#ifdef NLUBY + if (outer) + { + kind = skip ? 'N' : 'R'; + inc_ddrestart (ps); + ps->drestart = MINRESTART; + } + else if (skip) + { + kind = 'n'; + } + else + { + kind = 'r'; + } + + assert (ps->drestart <= MAXRESTART); + ps->lrestart = ps->conflicts + ps->drestart; + assert (ps->lrestart > ps->conflicts); + + report (outer ? 1 : 2, kind); +#else + inc_lrestart (ps, skip); +#endif +} + +inline static void +assign_decision (PS * ps, Lit * lit) +{ + assert (!ps->conflict); + + ps->LEVEL++; + + LOG ( fprintf (ps->out, "%snew level %u\n", ps->prefix, ps->LEVEL)); + LOG ( fprintf (ps->out, + "%sassign %d at level %d <= DECISION\n", + ps->prefix, LIT2INT (lit), ps->LEVEL)); + + assign (ps, lit, 0); +} + +#ifndef NFL + +static INLINE int +lit_has_binary_clauses (PS * ps, Lit * lit) +{ +#ifdef NO_BINARY_CLAUSES + Ltk* lstk = LIT2IMPLS (lit); + return lstk->count != 0; +#else + return *LIT2IMPLS (lit) != 0; +#endif +} + +static void +flbcp (PS * ps) +{ +#ifdef STATS + unsigned long long propagaions_before_bcp = ps->propagations; +#endif + bcp (ps); +#ifdef STATS + ps->flprops += ps->propagations - propagaions_before_bcp; +#endif +} + +inline static INLINE int +cmp_inverse_rnk (PS * ps, Rnk * a, Rnk * b) +{ + (void) ps; + return -cmp_rnk (a, b); +} + +inline static Flt +rnk2jwh (PS * ps, Rnk * r) +{ + Flt res, sum, pjwh, njwh; + Lit * plit, * nlit; + + plit = RNK2LIT (r); + nlit = plit + 1; + + pjwh = *LIT2JWH (plit); + njwh = *LIT2JWH (nlit); + + res = mulflt (pjwh, njwh); + + sum = addflt (pjwh, njwh); + sum = mulflt (sum, base2flt (1, -10)); + res = addflt (res, sum); + + return res; +} + +static int +cmp_inverse_jwh_rnk (PS * ps, Rnk * r, Rnk * s) +{ + Flt a = rnk2jwh (ps, r); + Flt b = rnk2jwh (ps, s); + int res = cmpflt (a, b); + + if (res) + return -res; + + return cmp_inverse_rnk (ps, r, s); +} + +static void +faillits (PS * ps) +{ + unsigned i, j, old_trail_count, common, saved_count; + unsigned new_saved_size, oldladded = ps->ladded; + unsigned long long limit, delta; + Lit * lit, * other, * pivot; + Rnk * r, ** p, ** q; + int new_trail_count; + double started; + + if (ps->plain) + return; + + if (ps->heap + 1 >= ps->hhead) + return; + + if (ps->propagations < ps->fllimit) + return; + + sflush (ps); + started = ps->seconds; + + ps->flcalls++; +#ifdef STATSA + ps->flrounds++; +#endif + delta = ps->propagations/10; + if (delta >= 100*1000*1000) delta = 100*1000*1000; + else if (delta <= 100*1000) delta = 100*1000; + + limit = ps->propagations + delta; + ps->fllimit = ps->propagations; + + assert (!ps->LEVEL); + assert (ps->simplifying); + + if (ps->flcalls <= 1) + SORT (Rnk *, cmp_inverse_jwh_rnk, ps->heap + 1, ps->hhead - (ps->heap + 1)); + else + SORT (Rnk *, cmp_inverse_rnk, ps->heap + 1, ps->hhead - (ps->heap + 1)); + + i = 1; /* NOTE: heap starts at position '1' */ + + while (ps->propagations < limit) + { + if (ps->heap + i == ps->hhead) + { + if (ps->ladded == oldladded) + break; + + i = 1; +#ifdef STATS + ps->flrounds++; +#endif + oldladded = ps->ladded; + } + + assert (ps->heap + i < ps->hhead); + + r = ps->heap[i++]; + lit = RNK2LIT (r); + + if (lit->val) + continue; + + if (!lit_has_binary_clauses (ps, NOTLIT (lit))) + { +#ifdef STATS + ps->flskipped++; +#endif + continue; + } + +#ifdef STATS + ps->fltried++; +#endif + LOG ( fprintf (ps->out, "%strying %d as failed literal\n", + ps->prefix, LIT2INT (lit))); + + assign_decision (ps, lit); + old_trail_count = ps->thead - ps->trail; + flbcp (ps); + + if (ps->conflict) + { +EXPLICITLY_FAILED_LITERAL: + LOG ( fprintf (ps->out, "%sfound explicitly failed literal %d\n", + ps->prefix, LIT2INT (lit))); + + ps->failedlits++; + ps->efailedlits++; + + backtrack (ps); + flbcp (ps); + + if (!ps->conflict) + continue; + +CONTRADICTION: + assert (!ps->LEVEL); + backtrack (ps); + assert (ps->mtcls); + + goto RETURN; + } + + if (ps->propagations >= limit) + { + undo (ps, 0); + break; + } + + lit = NOTLIT (lit); + + if (!lit_has_binary_clauses (ps, NOTLIT (lit))) + { +#ifdef STATS + ps->flskipped++; +#endif + undo (ps, 0); + continue; + } + +#ifdef STATS + ps->fltried++; +#endif + LOG ( fprintf (ps->out, "%strying %d as failed literals\n", + ps->prefix, LIT2INT (lit))); + + new_trail_count = ps->thead - ps->trail; + saved_count = new_trail_count - old_trail_count; + + if (saved_count > ps->saved_size) + { + new_saved_size = ps->saved_size ? 2 * ps->saved_size : 1; + while (saved_count > new_saved_size) + new_saved_size *= 2; + + RESIZEN (ps->saved, ps->saved_size, new_saved_size); + ps->saved_size = new_saved_size; + } + + for (j = 0; j < saved_count; j++) + ps->saved[j] = ps->trail[old_trail_count + j]; + + undo (ps, 0); + + assign_decision (ps, lit); + flbcp (ps); + + if (ps->conflict) + goto EXPLICITLY_FAILED_LITERAL; + + pivot = (ps->thead - ps->trail <= new_trail_count) ? lit : NOTLIT (lit); + + common = 0; + for (j = 0; j < saved_count; j++) + if ((other = ps->saved[j])->val == TRUE) + ps->saved[common++] = other; + + undo (ps, 0); + + LOG (if (common) + fprintf (ps->out, + "%sfound %d literals implied by %d and %d\n", + ps->prefix, common, + LIT2INT (NOTLIT (lit)), LIT2INT (lit))); + +#if 1 // set to zero to disable 'lifting' + for (j = 0; + j < common + /* TODO: For some Velev benchmarks, extracting the common implicit + * failed literals took quite some time. This needs to be fixed by + * a dedicated analyzer. Up to then we bound the number of + * propagations in this loop as well. + */ + && ps->propagations < limit + delta + ; j++) + { + other = ps->saved[j]; + + if (other->val == TRUE) + continue; + + assert (!other->val); + + LOG ( fprintf (ps->out, + "%sforcing %d as forced implicitly failed literal\n", + ps->prefix, LIT2INT (other))); + + assert (pivot != NOTLIT (other)); + assert (pivot != other); + + assign_decision (ps, NOTLIT (other)); + flbcp (ps); + + assert (ps->LEVEL == 1); + + if (ps->conflict) + { + backtrack (ps); + assert (!ps->LEVEL); + } + else + { + assign_decision (ps, pivot); + flbcp (ps); + + backtrack (ps); + + if (ps->LEVEL) + { + assert (ps->LEVEL == 1); + + flbcp (ps); + + if (ps->conflict) + { + backtrack (ps); + assert (!ps->LEVEL); + } + else + { + assign_decision (ps, NOTLIT (pivot)); + flbcp (ps); + backtrack (ps); + + if (ps->LEVEL) + { + assert (ps->LEVEL == 1); + flbcp (ps); + + if (!ps->conflict) + { +#ifdef STATS + ps->floopsed++; +#endif + undo (ps, 0); + continue; + } + + backtrack (ps); + } + + assert (!ps->LEVEL); + } + + assert (!ps->LEVEL); + } + } + assert (!ps->LEVEL); + flbcp (ps); + + ps->failedlits++; + ps->ifailedlits++; + + if (ps->conflict) + goto CONTRADICTION; + } +#endif + } + + ps->fllimit += 9 * (ps->propagations - ps->fllimit); /* 10% for failed literals */ + +RETURN: + + /* First flush top level assigned literals. Those are prohibited from + * being pushed up the heap during 'faillits' since 'simplifying' is set. + */ + assert (ps->heap < ps->hhead); + for (p = q = ps->heap + 1; p < ps->hhead; p++) + { + r = *p; + lit = RNK2LIT (r); + if (lit->val) + r->pos = 0; + else + *q++ = r; + } + + /* Then resort with respect to EVSIDS score and fix positions. + */ + SORT (Rnk *, cmp_inverse_rnk, ps->heap + 1, ps->hhead - (ps->heap + 1)); + for (p = ps->heap + 1; p < ps->hhead; p++) + (*p)->pos = p - ps->heap; + + sflush (ps); + ps->flseconds += ps->seconds - started; +} + +#endif + +static void +simplify (PS * ps, int forced) +{ + Lit * lit, * notlit, ** t; + unsigned collect, delta; +#ifdef STATS + size_t bytes_collected; +#endif + int * q, ilit; + Cls **p, *c; + Var * v; + +#ifndef NDEDBUG + (void) forced; +#endif + + assert (!ps->mtcls); + assert (!satisfied (ps)); + assert (forced || ps->lsimplify <= ps->propagations); + assert (forced || ps->fsimplify <= ps->fixed); + + if (ps->LEVEL) + undo (ps, 0); +#ifndef NFL + ps->simplifying = 1; + faillits (ps); + ps->simplifying = 0; + + if (ps->mtcls) + return; +#endif + + if (ps->cils != ps->cilshead) + { + assert (ps->ttail == ps->thead); + assert (ps->ttail2 == ps->thead); + ps->ttail = ps->trail; + for (t = ps->trail; t < ps->thead; t++) + { + lit = *t; + v = LIT2VAR (lit); + if (v->internal) + { + assert (LIT2INT (lit) < 0); + assert (lit->val == TRUE); + unassign (ps, lit); + } + else + *ps->ttail++ = lit; + } + ps->ttail2 = ps->thead = ps->ttail; + + for (q = ps->cils; q != ps->cilshead; q++) + { + ilit = *q; + assert (0 < ilit && ilit <= (int) ps->max_var); + v = ps->vars + ilit; + assert (v->internal); + v->level = 0; + v->reason = 0; + lit = int2lit (ps, -ilit); + assert (lit->val == UNDEF); + lit->val = TRUE; + notlit = NOTLIT (lit); + assert (notlit->val == UNDEF); + notlit->val = FALSE; + } + } + + collect = 0; + for (p = SOC; p != EOC; p = NXC (p)) + { + c = *p; + if (!c) + continue; + +#ifdef TRACE + if (c->collected) + continue; +#endif + + if (c->locked) + continue; + + assert (!c->collect); + if (clause_is_toplevel_satisfied (ps, c)) + { + mark_clause_to_be_collected (c); + collect++; + } + } + + LOG ( fprintf (ps->out, "%scollecting %d clauses\n", ps->prefix, collect)); +#ifdef STATS + bytes_collected = +#endif + collect_clauses (ps); +#ifdef STATS + ps->srecycled += bytes_collected; +#endif + + if (ps->cils != ps->cilshead) + { + for (q = ps->cils; q != ps->cilshead; q++) + { + ilit = *q; + assert (0 < ilit && ilit <= (int) ps->max_var); + assert (ps->vars[ilit].internal); + if (ps->rilshead == ps->eorils) + ENLARGE (ps->rils, ps->rilshead, ps->eorils); + *ps->rilshead++ = ilit; + lit = int2lit (ps, -ilit); + assert (lit->val == TRUE); + lit->val = UNDEF; + notlit = NOTLIT (lit); + assert (notlit->val == FALSE); + notlit->val = UNDEF; + } + ps->cilshead = ps->cils; + } + + delta = 10 * (ps->olits + ps->llits) + 100000; + if (delta > 2000000) + delta = 2000000; + ps->lsimplify = ps->propagations + delta; + ps->fsimplify = ps->fixed; + ps->simps++; + report (ps, 1, 's'); +} + +static void +iteration (PS * ps) +{ + assert (!ps->LEVEL); + assert (bcp_queue_is_empty (ps)); + assert (ps->isimplify < ps->fixed); + + ps->iterations++; + report (ps, 2, 'i'); +#ifdef NLUBY + ps->drestart = MINRESTART; + ps->lrestart = ps->conflicts + ps->drestart; +#else + init_restart (ps); +#endif + ps->isimplify = ps->fixed; +} + +static int +cmp_glue_activity_size (PS * ps, Cls * c, Cls * d) +{ + Act a, b, * p, * q; + + (void) ps; + + assert (c->learned); + assert (d->learned); + + if (c->glue < d->glue) // smaller glue preferred + return 1; + + if (c->glue > d->glue) + return -1; + + p = CLS2ACT (c); + q = CLS2ACT (d); + a = *p; + b = *q; + + if (a < b) // then higher activity + return -1; + + if (b < a) + return 1; + + if (c->size < d->size) // then smaller size + return 1; + + if (c->size > d->size) + return -1; + + return 0; +} + +static void +reduce (PS * ps, unsigned percentage) +{ + unsigned redcount, lcollect, collect, target; +#ifdef STATS + size_t bytes_collected; +#endif + Cls **p, *c; + + assert (ps->rhead == ps->resolved); + + ps->lastreduceconflicts = ps->conflicts; + + assert (percentage <= 100); + LOG ( fprintf (ps->out, + "%sreducing %u%% learned clauses\n", + ps->prefix, percentage)); + + while (ps->nlclauses - ps->llocked > (unsigned)(ps->eor - ps->resolved)) + ENLARGE (ps->resolved, ps->rhead, ps->eor); + + collect = 0; + lcollect = 0; + + for (p = ((ps->fsimplify < ps->fixed) ? SOC : ps->lclauses); p != EOC; p = NXC (p)) + { + c = *p; + if (!c) + continue; + +#ifdef TRACE + if (c->collected) + continue; +#endif + + if (c->locked) + continue; + + assert (!c->collect); + if (ps->fsimplify < ps->fixed && clause_is_toplevel_satisfied (ps, c)) + { + mark_clause_to_be_collected (c); + collect++; + + if (c->learned && c->size > 2) + lcollect++; + + continue; + } + + if (!c->learned) + continue; + + if (c->size <= 2) + continue; + + assert (ps->rhead < ps->eor); + *ps->rhead++ = c; + } + assert (ps->rhead <= ps->eor); + + ps->fsimplify = ps->fixed; + + redcount = ps->rhead - ps->resolved; + SORT (Cls *, cmp_glue_activity_size, ps->resolved, redcount); + + assert (ps->nlclauses >= lcollect); + target = ps->nlclauses - lcollect + 1; + + target = (percentage * target + 99) / 100; + + if (target >= redcount) + target = redcount; + + ps->rhead = ps->resolved + target; + while (ps->rhead > ps->resolved) + { + c = *--ps->rhead; + mark_clause_to_be_collected (c); + + collect++; + if (c->learned && c->size > 2) /* just for consistency */ + lcollect++; + } + + if (collect) + { + ps->reductions++; +#ifdef STATS + bytes_collected = +#endif + collect_clauses (ps); +#ifdef STATS + ps->rrecycled += bytes_collected; +#endif + report (ps, 2, '-'); + } + + if (!lcollect) + inc_lreduce (ps); /* avoid dead lock */ + + assert (ps->rhead == ps->resolved); +} + +static void +init_reduce (PS * ps) +{ + // lreduce = loadded / 2; + ps->lreduce = 1000; + + if (ps->lreduce < 100) + ps->lreduce = 100; + + if (ps->verbosity) + fprintf (ps->out, + "%s\n%sinitial reduction limit %u clauses\n%s\n", + ps->prefix, ps->prefix, ps->lreduce, ps->prefix); +} + +static INLINE unsigned +rng (PS * ps) +{ + unsigned res = ps->srng; + ps->srng *= 1664525u; + ps->srng += 1013904223u; + NOLOG ( fprintf (ps->out, "%srng () = %u\n", ps->prefix, res)); + return res; +} + +static unsigned +rrng (PS * ps, unsigned low, unsigned high) +{ + unsigned long long tmp; + unsigned res, elements; + assert (low <= high); + elements = high - low + 1; + tmp = rng (ps); + tmp *= elements; + tmp >>= 32; + tmp += low; + res = tmp; + NOLOG ( fprintf (ps->out, "%srrng (ps, %u, %u) = %u\n", ps->prefix, low, high, res)); + assert (low <= res); + assert (res <= high); + return res; +} + +static Lit * +decide_phase (PS * ps, Lit * lit) +{ + Lit * not_lit = NOTLIT (lit); + Var *v = LIT2VAR (lit); + + assert (LIT2SGN (lit) > 0); + if (v->usedefphase) + { + if (v->defphase) + { + /* assign to TRUE */ + } + else + { + /* assign to FALSE */ + lit = not_lit; + } + } + else if (!v->assigned) + { +#ifdef STATS + ps->staticphasedecisions++; +#endif + if (ps->defaultphase == POSPHASE) + { + /* assign to TRUE */ + } + else if (ps->defaultphase == NEGPHASE) + { + /* assign to FALSE */ + lit = not_lit; + } + else if (ps->defaultphase == RNDPHASE) + { + /* randomly assign default phase */ + if (rrng (ps, 1, 2) != 2) + lit = not_lit; + } + else if (*LIT2JWH(lit) <= *LIT2JWH (not_lit)) + { + /* assign to FALSE (Jeroslow-Wang says there are more short + * clauses with negative occurence of this variable, so satisfy + * those, to minimize BCP) + */ + lit = not_lit; + } + else + { + /* assign to TRUE (... but strictly more positive occurrences) */ + } + } + else + { + /* repeat last phase: phase saving heuristic */ + + if (v->phase) + { + /* assign to TRUE (last phase was TRUE as well) */ + } + else + { + /* assign to FALSE (last phase was FALSE as well) */ + lit = not_lit; + } + } + + return lit; +} + +static unsigned +gcd (unsigned a, unsigned b) +{ + unsigned tmp; + + assert (a); + assert (b); + + if (a < b) + { + tmp = a; + a = b; + b = tmp; + } + + while (b) + { + assert (a >= b); + tmp = b; + b = INT_MOD(a, b); + a = tmp; + } + + return a; +} + +static Lit * +rdecide (PS * ps) +{ + unsigned idx, delta, spread; + Lit * res; + + spread = RDECIDE; + if (rrng (ps, 1, spread) != 2) + return 0; + + assert (1 <= ps->max_var); + idx = rrng (ps, 1, ps->max_var); + res = int2lit (ps, idx); + + if (res->val != UNDEF) + { + delta = rrng (ps, 1, ps->max_var); + while (gcd (delta, ps->max_var) != 1) + delta--; + + assert (1 <= delta); + assert (delta <= ps->max_var); + + do { + idx += delta; + if (idx > ps->max_var) + idx -= ps->max_var; + res = int2lit (ps, idx); + } while (res->val != UNDEF); + } + +#ifdef STATS + ps->rdecisions++; +#endif + res = decide_phase (ps, res); + LOG ( fprintf (ps->out, "%srdecide %d\n", ps->prefix, LIT2INT (res))); + + return res; +} + +static Lit * +sdecide (PS * ps) +{ + Lit *res; + Rnk *r; + + for (;;) + { + r = htop (ps); + res = RNK2LIT (r); + if (res->val == UNDEF) break; + (void) hpop (ps); + NOLOG ( fprintf (ps->out, + "%shpop %u %u %u\n", + ps->prefix, r - ps->rnks, + FLTMANTISSA(r->score), + FLTEXPONENT(r->score))); + } + +#ifdef STATS + ps->sdecisions++; +#endif + res = decide_phase (ps, res); + + LOG ( fprintf (ps->out, "%ssdecide %d\n", ps->prefix, LIT2INT (res))); + + return res; +} + +static Lit * +adecide (PS * ps) +{ + Lit *lit; + Var * v; + + assert (ps->als < ps->alshead); + assert (!ps->failed_assumption); + + while (ps->alstail < ps->alshead) + { + lit = *ps->alstail++; + + if (lit->val == FALSE) + { + ps->failed_assumption = lit; + v = LIT2VAR (lit); + + use_var (ps, v); + + LOG ( fprintf (ps->out, "%sfirst failed assumption %d\n", + ps->prefix, LIT2INT (ps->failed_assumption))); + fanalyze (ps); + return 0; + } + + if (lit->val == TRUE) + { + v = LIT2VAR (lit); + if (v->level > ps->adecidelevel) + ps->adecidelevel = v->level; + continue; + } + +#ifdef STATS + ps->assumptions++; +#endif + LOG ( fprintf (ps->out, "%sadecide %d\n", ps->prefix, LIT2INT (lit))); + ps->adecidelevel = ps->LEVEL + 1; + + return lit; + } + + return 0; +} + +static void +decide (PS * ps) +{ + Lit * lit; + + assert (!satisfied (ps)); + assert (!ps->conflict); + + if (ps->alstail < ps->alshead && (lit = adecide (ps))) + ; + else if (ps->failed_assumption) + return; + else if (satisfied (ps)) + return; + else if (!(lit = rdecide (ps))) + lit = sdecide (ps); + + assert (lit); + assign_decision (ps, lit); + + ps->levelsum += ps->LEVEL; + ps->decisions++; +} + +static int +sat (PS * ps, int l) +{ + int count = 0, backtracked; + + if (!ps->conflict) + bcp (ps); + + if (ps->conflict) + backtrack (ps); + + if (ps->mtcls) + return PICOSAT_UNSATISFIABLE; + + if (satisfied (ps)) + goto SATISFIED; + + if (ps->lsimplify <= ps->propagations) + simplify (ps, 0); + + if (ps->mtcls) + return PICOSAT_UNSATISFIABLE; + + if (satisfied (ps)) + goto SATISFIED; + + init_restart (ps); + + if (!ps->lreduce) + init_reduce (ps); + + ps->isimplify = ps->fixed; + backtracked = 0; + + for (;;) + { + if (!ps->conflict) + bcp (ps); + + if (ps->conflict) + { + incincs (ps); + backtrack (ps); + + if (ps->mtcls) + return PICOSAT_UNSATISFIABLE; + backtracked = 1; + continue; + } + + if (satisfied (ps)) + { +SATISFIED: +#ifndef NDEBUG + original_clauses_satisfied (ps); + assumptions_satisfied (ps); +#endif + return PICOSAT_SATISFIABLE; + } + + if (backtracked) + { + backtracked = 0; + if (!ps->LEVEL && ps->isimplify < ps->fixed) + iteration (ps); + } + + if (l >= 0 && count >= l) /* decision limit reached ? */ + return PICOSAT_UNKNOWN; + + if (ps->interrupt.function && /* external interrupt */ + count > 0 && !(INT_MOD(count, INTERRUPTLIM)) && + ps->interrupt.function (ps->interrupt.state)) + return PICOSAT_UNKNOWN; + + if (ps->propagations >= ps->lpropagations)/* propagation limit reached ? */ + return PICOSAT_UNKNOWN; + +#ifndef NADC + if (!ps->adodisabled && ps->adoconflicts >= ps->adoconflictlimit) + { + assert (bcp_queue_is_empty (ps)); + return PICOSAT_UNKNOWN; + } +#endif + + if (ps->fsimplify < ps->fixed && ps->lsimplify <= ps->propagations) + { + simplify (ps, 0); + if (!bcp_queue_is_empty (ps)) + continue; +#ifndef NFL + if (ps->mtcls) + return PICOSAT_UNSATISFIABLE; + + if (satisfied (ps)) + return PICOSAT_SATISFIABLE; + + assert (!ps->LEVEL); +#endif + } + + if (need_to_reduce (ps)) + reduce (ps, 50); + + if (ps->conflicts >= ps->lrestart && ps->LEVEL > 2) + restart (ps); + + decide (ps); + if (ps->failed_assumption) + return PICOSAT_UNSATISFIABLE; + count++; + } +} + +static void +rebias (PS * ps) +{ + Cls ** p, * c; + Var * v; + + for (v = ps->vars + 1; v <= ps->vars + ps->max_var; v++) + v->assigned = 0; + + memset (ps->jwh, 0, 2 * (ps->max_var + 1) * sizeof *ps->jwh); + + for (p = ps->oclauses; p < ps->ohead; p++) + { + c = *p; + + if (!c) + continue; + + if (c->learned) + continue; + + incjwh (ps, c); + } +} + +#ifdef TRACE + +static unsigned +core (PS * ps) +{ + unsigned idx, prev, this, delta, i, lcore, vcore; + unsigned *stack, *shead, *eos; + Lit **q, **eol, *lit; + Cls *c, *reason; + Znt *p, byte; + Zhn *zhain; + Var *v; + + assert (ps->trace); + + assert (ps->mtcls || ps->failed_assumption); + if (ps->ocore >= 0) + return ps->ocore; + + lcore = ps->ocore = vcore = 0; + + stack = shead = eos = 0; + ENLARGE (stack, shead, eos); + + if (ps->mtcls) + { + idx = CLS2IDX (ps->mtcls); + *shead++ = idx; + } + else + { + assert (ps->failed_assumption); + v = LIT2VAR (ps->failed_assumption); + reason = v->reason; + assert (reason); + idx = CLS2IDX (reason); + *shead++ = idx; + } + + while (shead > stack) + { + idx = *--shead; + zhain = IDX2ZHN (idx); + + if (zhain) + { + if (zhain->core) + continue; + + zhain->core = 1; + lcore++; + + c = IDX2CLS (idx); + if (c) + { + assert (!c->core); + c->core = 1; + } + + i = 0; + delta = 0; + prev = 0; + for (p = zhain->znt; (byte = *p); p++, i += 7) + { + delta |= (byte & 0x7f) << i; + if (byte & 0x80) + continue; + + this = prev + delta; + assert (prev < this); /* no overflow */ + + if (shead == eos) + ENLARGE (stack, shead, eos); + *shead++ = this; + + prev = this; + delta = 0; + i = -7; + } + } + else + { + c = IDX2CLS (idx); + + assert (c); + assert (!c->learned); + + if (c->core) + continue; + + c->core = 1; + ps->ocore++; + + eol = end_of_lits (c); + for (q = c->lits; q < eol; q++) + { + lit = *q; + v = LIT2VAR (lit); + if (v->core) + continue; + + v->core = 1; + vcore++; + + if (!ps->failed_assumption) continue; + if (lit != ps->failed_assumption) continue; + + reason = v->reason; + if (!reason) continue; + if (reason->core) continue; + + idx = CLS2IDX (reason); + if (shead == eos) + ENLARGE (stack, shead, eos); + *shead++ = idx; + } + } + } + + DELETEN (stack, eos - stack); + + if (ps->verbosity) + fprintf (ps->out, + "%s%u core variables out of %u (%.1f%%)\n" + "%s%u core original clauses out of %u (%.1f%%)\n" + "%s%u core learned clauses out of %u (%.1f%%)\n", + ps->prefix, vcore, ps->max_var, PERCENT (vcore, ps->max_var), + ps->prefix, ps->ocore, ps->oadded, PERCENT (ps->ocore, ps->oadded), + ps->prefix, lcore, ps->ladded, PERCENT (lcore, ps->ladded)); + + return ps->ocore; +} + +static void +trace_lits (PS * ps, Cls * c, FILE * file) +{ + Lit **p, **eol = end_of_lits (c); + + assert (c); + assert (c->core); + + for (p = c->lits; p < eol; p++) + fprintf (file, "%d ", LIT2INT (*p)); + + fputc ('0', file); +} + +static void +write_idx (PS * ps, unsigned idx, FILE * file) +{ + fprintf (file, "%ld", EXPORTIDX (idx)); +} + +static void +trace_clause (PS * ps, unsigned idx, Cls * c, FILE * file, int fmt) +{ + assert (c); + assert (c->core); + assert (fmt == RUP_TRACE_FMT || !c->learned); + assert (CLS2IDX (c) == idx); + + if (fmt != RUP_TRACE_FMT) + { + write_idx (ps, idx, file); + fputc (' ', file); + } + + trace_lits (ps, c, file); + + if (fmt != RUP_TRACE_FMT) + fputs (" 0", file); + + fputc ('\n', file); +} + +static void +trace_zhain (PS * ps, unsigned idx, Zhn * zhain, FILE * file, int fmt) +{ + unsigned prev, this, delta, i; + Znt *p, byte; + Cls * c; + + assert (zhain); + assert (zhain->core); + + write_idx (ps, idx, file); + fputc (' ', file); + + if (fmt == EXTENDED_TRACECHECK_TRACE_FMT) + { + c = IDX2CLS (idx); + assert (c); + trace_lits (ps, c, file); + } + else + { + assert (fmt == COMPACT_TRACECHECK_TRACE_FMT); + putc ('*', file); + } + + i = 0; + delta = 0; + prev = 0; + + for (p = zhain->znt; (byte = *p); p++, i += 7) + { + delta |= (byte & 0x7f) << i; + if (byte & 0x80) + continue; + + this = prev + delta; + + putc (' ', file); + write_idx (ps, this, file); + + prev = this; + delta = 0; + i = -7; + } + + fputs (" 0\n", file); +} + +static void +write_core (PS * ps, FILE * file) +{ + Lit **q, **eol; + Cls **p, *c; + + fprintf (file, "p cnf %u %u\n", ps->max_var, core (ps)); + + for (p = SOC; p != EOC; p = NXC (p)) + { + c = *p; + + if (!c || c->learned || !c->core) + continue; + + eol = end_of_lits (c); + for (q = c->lits; q < eol; q++) + fprintf (file, "%d ", LIT2INT (*q)); + + fputs ("0\n", file); + } +} + +#endif + +static void +write_trace (PS * ps, FILE * file, int fmt) +{ +#ifdef TRACE + Cls *c, ** p; + Zhn *zhain; + unsigned i; + + core (ps); + + if (fmt == RUP_TRACE_FMT) + { + ps->rupvariables = picosat_variables (ps), + ps->rupclauses = picosat_added_original_clauses (ps); + write_rup_header (ps, file); + } + + for (p = SOC; p != EOC; p = NXC (p)) + { + c = *p; + + if (ps->oclauses <= p && p < ps->eoo) + { + i = OIDX2IDX (p - ps->oclauses); + assert (!c || CLS2IDX (c) == i); + } + else + { + assert (ps->lclauses <= p && p < ps->EOL); + i = LIDX2IDX (p - ps->lclauses); + } + + zhain = IDX2ZHN (i); + + if (zhain) + { + if (zhain->core) + { + if (fmt == RUP_TRACE_FMT) + trace_clause (ps,i, c, file, fmt); + else + trace_zhain (ps, i, zhain, file, fmt); + } + } + else if (c) + { + if (fmt != RUP_TRACE_FMT && c) + { + if (c->core) + trace_clause (ps, i, c, file, fmt); + } + } + } +#else + (void) file; + (void) fmt; + (void) ps; +#endif +} + +static void +write_core_wrapper (PS * ps, FILE * file, int fmt) +{ + (void) fmt; +#ifdef TRACE + write_core (ps, file); +#else + (void) ps; + (void) file; +#endif +} + +static Lit * +import_lit (PS * ps, int lit, int nointernal) +{ + Lit * res; + Var * v; + + ABORTIF (lit == INT_MIN, "API usage: INT_MIN literal"); + ABORTIF (abs (lit) > (int) ps->max_var && ps->CLS != ps->clshead, + "API usage: new variable index after 'picosat_push'"); + + if (abs (lit) <= (int) ps->max_var) + { + res = int2lit (ps, lit); + v = LIT2VAR (res); + if (nointernal && v->internal) + ABORT ("API usage: trying to import invalid literal"); + else if (!nointernal && !v->internal) + ABORT ("API usage: trying to import invalid context"); + } + else + { + while (abs (lit) > (int) ps->max_var) + inc_max_var (ps); + res = int2lit (ps, lit); + } + + return res; +} + +#ifdef TRACE +static void +reset_core (PS * ps) +{ + Cls ** p, * c; + Zhn ** q, * z; + unsigned i; + + for (i = 1; i <= ps->max_var; i++) + ps->vars[i].core = 0; + + for (p = SOC; p != EOC; p = NXC (p)) + if ((c = *p)) + c->core = 0; + + for (q = ps->zhains; q != ps->zhead; q++) + if ((z = *q)) + z->core = 0; + + ps->ocore = -1; +} +#endif + +static void +reset_assumptions (PS * ps) +{ + Lit ** p; + + ps->failed_assumption = 0; + + if (ps->extracted_all_failed_assumptions) + { + for (p = ps->als; p < ps->alshead; p++) + LIT2VAR (*p)->failed = 0; + + ps->extracted_all_failed_assumptions = 0; + } + + ps->alstail = ps->alshead = ps->als; + ps->adecidelevel = 0; +} + +static INLINE void +check_ready (PS * ps) +{ + ABORTIF (!ps || ps->state == RESET, "API usage: uninitialized"); +} + +static INLINE void +check_sat_state (PS * ps) +{ + ABORTIF (ps->state != SAT, "API usage: expected to be in SAT state"); +} + +static INLINE void +check_unsat_state (PS * ps) +{ + ABORTIF (ps->state != UNSAT, "API usage: expected to be in UNSAT state"); +} + +static INLINE void +check_sat_or_unsat_or_unknown_state (PS * ps) +{ + ABORTIF (ps->state != SAT && ps->state != UNSAT && ps->state != UNKNOWN, + "API usage: expected to be in SAT, UNSAT, or UNKNOWN state"); +} + +static void +reset_partial (PS * ps) +{ + unsigned idx; + if (!ps->partial) + return; + for (idx = 1; idx <= ps->max_var; idx++) + ps->vars[idx].partial = 0; + ps->partial = 0; +} + +static void +reset_incremental_usage (PS * ps) +{ + unsigned num_non_false; + Lit * lit, ** q; + + check_sat_or_unsat_or_unknown_state (ps); + + LOG ( fprintf (ps->out, "%sRESET incremental usage\n", ps->prefix)); + + if (ps->LEVEL) + undo (ps, 0); + + reset_assumptions (ps); + + if (ps->conflict) + { + num_non_false = 0; + for (q = ps->conflict->lits; q < end_of_lits (ps->conflict); q++) + { + lit = *q; + if (lit->val != FALSE) + num_non_false++; + } + + // assert (num_non_false >= 2); // TODO: why this assertion? +#ifdef NO_BINARY_CLAUSES + if (ps->conflict == &ps->cimpl) + resetcimpl (ps); +#endif +#ifndef NADC + if (ps->conflict == ps->adoconflict) + resetadoconflict (ps); +#endif + ps->conflict = 0; + } + +#ifdef TRACE + reset_core (ps); +#endif + + reset_partial (ps); + + ps->saved_flips = ps->flips; + ps->min_flipped = UINT_MAX; + ps->saved_max_var = ps->max_var; + + ps->state = READY; +} + +static void +enter (PS * ps) +{ + if (ps->nentered++) + return; + + check_ready (ps); + ps->entered = picosat_time_stamp (); +} + +static INLINE void +leave (PS * ps) +{ + assert (ps->nentered); + if (--ps->nentered) + return; + + sflush (ps); +} + +static void +check_trace_support_and_execute (PS * ps, + FILE * file, + void (*f)(PS*,FILE*,int), int fmt) +{ + check_ready (ps); + check_unsat_state (ps); +#ifdef TRACE + ABORTIF (!ps->trace, "API usage: tracing disabled"); + enter (ps); + f (ps, file, fmt); + leave (ps); +#else + (void) file; + (void) fmt; + (void) f; + ABORT ("compiled without trace support"); +#endif +} + +static void +extract_all_failed_assumptions (PS * ps) +{ + Lit ** p, ** eol; + Var * v, * u; + int pos; + Cls * c; + + assert (!ps->extracted_all_failed_assumptions); + + assert (ps->failed_assumption); + assert (ps->mhead == ps->marked); + + if (ps->marked == ps->eom) + ENLARGE (ps->marked, ps->mhead, ps->eom); + + v = LIT2VAR (ps->failed_assumption); + mark_var (ps, v); + pos = 0; + + while (pos < ps->mhead - ps->marked) + { + v = ps->marked[pos++]; + assert (v->mark); + c = var2reason (ps, v); + if (!c) + continue; + eol = end_of_lits (c); + for (p = c->lits; p < eol; p++) + { + u = LIT2VAR (*p); + if (!u->mark) + mark_var (ps, u); + } +#ifdef NO_BINARY_CLAUSES + if (c == &ps->impl) + resetimpl (ps); +#endif + } + + for (p = ps->als; p < ps->alshead; p++) + { + u = LIT2VAR (*p); + if (!u->mark) continue; + u->failed = 1; + LOG ( fprintf (ps->out, + "%sfailed assumption %d\n", + ps->prefix, LIT2INT (*p))); + } + + while (ps->mhead > ps->marked) + (*--ps->mhead)->mark = 0; + + ps->extracted_all_failed_assumptions = 1; +} + +const char * +picosat_copyright (void) +{ + return "Copyright (c) 2006 - 2014 Armin Biere JKU Linz"; +} + +PicoSAT * +picosat_init (void) +{ + return init (0, 0, 0, 0); +} + +PicoSAT * +picosat_minit (void * pmgr, + picosat_malloc pnew, + picosat_realloc presize, + picosat_free pfree) +{ + ABORTIF (!pnew, "API usage: zero 'picosat_malloc' argument"); + ABORTIF (!presize, "API usage: zero 'picosat_realloc' argument"); + ABORTIF (!pfree, "API usage: zero 'picosat_free' argument"); + return init (pmgr, pnew, presize, pfree); +} + + +void +picosat_adjust (PS * ps, int new_max_var) +{ + unsigned new_size_vars; + + ABORTIF (abs (new_max_var) > (int) ps->max_var && ps->CLS != ps->clshead, + "API usage: adjusting variable index after 'picosat_push'"); + enter (ps); + + new_max_var = abs (new_max_var); + new_size_vars = new_max_var + 1; + + if (ps->size_vars < new_size_vars) + enlarge (ps, new_size_vars); + + while (ps->max_var < (unsigned) new_max_var) + inc_max_var (ps); + + leave (ps); +} + +int +picosat_inc_max_var (PS * ps) +{ + if (ps->measurealltimeinlib) + enter (ps); + else + check_ready (ps); + + inc_max_var (ps); + + if (ps->measurealltimeinlib) + leave (ps); + + return ps->max_var; +} + +int +picosat_context (PS * ps) +{ + return ps->clshead == ps->CLS ? 0 : LIT2INT (ps->clshead[-1]); +} + +int +picosat_push (PS * ps) +{ + int res; + Lit *lit; + Var * v; + + if (ps->measurealltimeinlib) + enter (ps); + else + check_ready (ps); + + if (ps->state != READY) + reset_incremental_usage (ps); + + if (ps->rils != ps->rilshead) + { + res = *--ps->rilshead; + assert (ps->vars[res].internal); + } + else + { + inc_max_var (ps); + res = ps->max_var; + v = ps->vars + res; + assert (!v->internal); + v->internal = 1; + ps->internals++; + LOG ( fprintf (ps->out, "%snew internal variable index %d\n", ps->prefix, res)); + } + + lit = int2lit (ps, res); + + if (ps->clshead == ps->eocls) + ENLARGE (ps->CLS, ps->clshead, ps->eocls); + *ps->clshead++ = lit; + + ps->contexts++; + + LOG ( fprintf (ps->out, "%snew context %d at depth %ld after push\n", + ps->prefix, res, (long)(ps->clshead - ps->CLS))); + + if (ps->measurealltimeinlib) + leave (ps); + + return res; +} + +int +picosat_pop (PS * ps) +{ + Lit * lit; + int res; + ABORTIF (ps->CLS == ps->clshead, "API usage: too many 'picosat_pop'"); + ABORTIF (ps->added != ps->ahead, "API usage: incomplete clause"); + + if (ps->measurealltimeinlib) + enter (ps); + else + check_ready (ps); + + if (ps->state != READY) + reset_incremental_usage (ps); + + assert (ps->CLS < ps->clshead); + lit = *--ps->clshead; + LOG ( fprintf (ps->out, "%sclosing context %d at depth %ld after pop\n", + ps->prefix, LIT2INT (lit), (long)(ps->clshead - ps->CLS) + 1)); + + if (ps->cilshead == ps->eocils) + ENLARGE (ps->cils, ps->cilshead, ps->eocils); + *ps->cilshead++ = LIT2INT (lit); + + if (ps->cilshead - ps->cils > MAXCILS) { + LOG ( fprintf (ps->out, + "%srecycling %ld interals with forced simplification\n", + ps->prefix, (long)(ps->cilshead - ps->cils))); + simplify (ps, 1); + } + + res = picosat_context (ps); + if (res) + LOG ( fprintf (ps->out, "%snew context %d at depth %ld after pop\n", + ps->prefix, res, (long)(ps->clshead - ps->CLS))); + else + LOG ( fprintf (ps->out, "%souter most context reached after pop\n", ps->prefix)); + + if (ps->measurealltimeinlib) + leave (ps); + + return res; +} + +void +picosat_set_verbosity (PS * ps, int new_verbosity_level) +{ + check_ready (ps); + ps->verbosity = new_verbosity_level; +} + +void +picosat_set_plain (PS * ps, int new_plain_value) +{ + check_ready (ps); + ps->plain = new_plain_value; +} + +int +picosat_enable_trace_generation (PS * ps) +{ + int res = 0; + check_ready (ps); +#ifdef TRACE + ABORTIF (ps->addedclauses, + "API usage: trace generation enabled after adding clauses"); + res = ps->trace = 1; +#endif + return res; +} + +void +picosat_set_incremental_rup_file (PS * ps, FILE * rup_file, int m, int n) +{ + check_ready (ps); + assert (!ps->rupstarted); + ps->rup = rup_file; + ps->rupvariables = m; + ps->rupclauses = n; +} + +void +picosat_set_output (PS * ps, FILE * output_file) +{ + check_ready (ps); + ps->out = output_file; +} + +void +picosat_measure_all_calls (PS * ps) +{ + check_ready (ps); + ps->measurealltimeinlib = 1; +} + +void +picosat_set_prefix (PS * ps, const char * str) +{ + check_ready (ps); + new_prefix (ps, str); +} + +void +picosat_set_seed (PS * ps, unsigned s) +{ + check_ready (ps); + ps->srng = s; +} + +void +picosat_reset (PS * ps) +{ + check_ready (ps); + reset (ps); +} + +int +picosat_add (PS * ps, int int_lit) +{ + int res = ps->oadded; + Lit *lit; + + if (ps->measurealltimeinlib) + enter (ps); + else + check_ready (ps); + + ABORTIF (ps->rup && ps->rupstarted && ps->oadded >= (unsigned)ps->rupclauses, + "API usage: adding too many clauses after RUP header written"); +#ifndef NADC + ABORTIF (ps->addingtoado, + "API usage: 'picosat_add' and 'picosat_add_ado_lit' mixed"); +#endif + if (ps->state != READY) + reset_incremental_usage (ps); + + if (ps->saveorig) + { + if (ps->sohead == ps->eoso) + ENLARGE (ps->soclauses, ps->sohead, ps->eoso); + + *ps->sohead++ = int_lit; + } + + if (int_lit) + { + lit = import_lit (ps, int_lit, 1); + add_lit (ps, lit); + } + else + simplify_and_add_original_clause (ps); + + if (ps->measurealltimeinlib) + leave (ps); + + return res; +} + +int +picosat_add_arg (PS * ps, ...) +{ + int lit; + va_list ap; + va_start (ap, ps); + while ((lit = va_arg (ap, int))) + (void) picosat_add (ps, lit); + va_end (ap); + return picosat_add (ps, 0); +} + +int +picosat_add_lits (PS * ps, int * lits) +{ + const int * p; + int lit; + for (p = lits; (lit = *p); p++) + (void) picosat_add (ps, lit); + return picosat_add (ps, 0); +} + +void +picosat_add_ado_lit (PS * ps, int external_lit) +{ +#ifndef NADC + Lit * internal_lit; + + if (ps->measurealltimeinlib) + enter (ps); + else + check_ready (ps); + + if (ps->state != READY) + reset_incremental_usage (ps); + + ABORTIF (!ps->addingtoado && ps->ahead > ps->added, + "API usage: 'picosat_add' and 'picosat_add_ado_lit' mixed"); + + if (external_lit) + { + ps->addingtoado = 1; + internal_lit = import_lit (ps, external_lit, 1); + add_lit (ps, internal_lit); + } + else + { + ps->addingtoado = 0; + add_ado (ps); + } + if (ps->measurealltimeinlib) + leave (ps); +#else + (void) ps; + (void) external_lit; + ABORT ("compiled without all different constraint support"); +#endif +} + +static void +assume (PS * ps, Lit * lit) +{ + if (ps->alshead == ps->eoals) + { + assert (ps->alstail == ps->als); + ENLARGE (ps->als, ps->alshead, ps->eoals); + ps->alstail = ps->als; + } + + *ps->alshead++ = lit; + LOG ( fprintf (ps->out, "%sassumption %d\n", ps->prefix, LIT2INT (lit))); +} + +static void +assume_contexts (PS * ps) +{ + Lit ** p; + if (ps->als != ps->alshead) + return; + for (p = ps->CLS; p != ps->clshead; p++) + assume (ps, *p); +} + +#ifndef RCODE +static const char * enumstr (int i) { + int last = INT_MOD(i, 10); + if (last == 1) return "st"; + if (last == 2) return "nd"; + if (last == 3) return "rd"; + return "th"; +} +#endif + +static int +tderef (PS * ps, int int_lit) +{ + Lit * lit; + Var * v; + + assert (abs (int_lit) <= (int) ps->max_var); + + lit = int2lit (ps, int_lit); + + v = LIT2VAR (lit); + if (v->level > 0) + return 0; + + if (lit->val == TRUE) + return 1; + + if (lit->val == FALSE) + return -1; + + return 0; +} + +static int +pderef (PS * ps, int int_lit) +{ + Lit * lit; + Var * v; + + assert (abs (int_lit) <= (int) ps->max_var); + + v = ps->vars + abs (int_lit); + if (!v->partial) + return 0; + + lit = int2lit (ps, int_lit); + + if (lit->val == TRUE) + return 1; + + if (lit->val == FALSE) + return -1; + + return 0; +} + +static void +minautarky (PS * ps) +{ + unsigned * occs, maxoccs, tmpoccs, npartial; + int * p, * c, lit, best, val; +#ifdef LOGGING + int tl; +#endif + + assert (!ps->partial); + + npartial = 0; + + NEWN (occs, 2*ps->max_var + 1); + CLRN (occs, 2*ps->max_var + 1); + occs += ps->max_var; + for (p = ps->soclauses; p < ps->sohead; p++) + occs[*p]++; + assert (occs[0] == ps->oadded); + + for (c = ps->soclauses; c < ps->sohead; c = p + 1) + { +#ifdef LOGGING + tl = 0; +#endif + best = 0; + maxoccs = 0; + for (p = c; (lit = *p); p++) + { + val = tderef (ps, lit); + if (val < 0) + continue; + if (val > 0) + { +#ifdef LOGGING + tl = 1; +#endif + best = lit; + maxoccs = occs[lit]; + } + + val = pderef (ps, lit); + if (val > 0) + break; + if (val < 0) + continue; + val = int2lit (ps, lit)->val; + assert (val); + if (val < 0) + continue; + tmpoccs = occs[lit]; + if (best && tmpoccs <= maxoccs) + continue; + best = lit; + maxoccs = tmpoccs; + } + if (!lit) + { + assert (best); + LOG ( fprintf (ps->out, "%sautark %d with %d occs%s\n", + ps->prefix, best, maxoccs, tl ? " (top)" : "")); + ps->vars[abs (best)].partial = 1; + npartial++; + } + for (p = c; (lit = *p); p++) + { + assert (occs[lit] > 0); + occs[lit]--; + } + } + occs -= ps->max_var; + DELETEN (occs, 2*ps->max_var + 1); + ps->partial = 1; + + if (ps->verbosity) + fprintf (ps->out, + "%sautarky of size %u out of %u satisfying all clauses (%.1f%%)\n", + ps->prefix, npartial, ps->max_var, PERCENT (npartial, ps->max_var)); +} + +void +picosat_assume (PS * ps, int int_lit) +{ + Lit *lit; + + if (ps->measurealltimeinlib) + enter (ps); + else + check_ready (ps); + + if (ps->state != READY) + reset_incremental_usage (ps); + + assume_contexts (ps); + lit = import_lit (ps, int_lit, 1); + assume (ps, lit); + + if (ps->measurealltimeinlib) + leave (ps); +} + +int +picosat_sat (PS * ps, int l) +{ + int res; + char ch; + + enter (ps); + + ps->calls++; + LOG ( fprintf (ps->out, "%sSTART call %u\n", ps->prefix, ps->calls)); + + if (ps->added < ps->ahead) + { +#ifndef NADC + if (ps->addingtoado) + ABORT ("API usage: incomplete all different constraint"); + else +#endif + ABORT ("API usage: incomplete clause"); + } + + if (ps->state != READY) + reset_incremental_usage (ps); + + assume_contexts (ps); + + res = sat (ps, l); + + assert (ps->state == READY); + + switch (res) + { + case PICOSAT_UNSATISFIABLE: + ch = '0'; + ps->state = UNSAT; + break; + case PICOSAT_SATISFIABLE: + ch = '1'; + ps->state = SAT; + break; + default: + ch = '?'; + ps->state = UNKNOWN; + break; + } + + if (ps->verbosity) + { + report (ps, 1, ch); + rheader (ps); + } + + leave (ps); + LOG ( fprintf (ps->out, "%sEND call %u result %d\n", ps->prefix, ps->calls, res)); + + ps->last_sat_call_result = res; + + return res; +} + +int +picosat_res (PS * ps) +{ + return ps->last_sat_call_result; +} + +int +picosat_deref (PS * ps, int int_lit) +{ + Lit *lit; + + check_ready (ps); + check_sat_state (ps); + ABORTIF (!int_lit, "API usage: can not deref zero literal"); + ABORTIF (ps->mtcls, "API usage: deref after empty clause generated"); + +#ifdef STATS + ps->derefs++; +#endif + + if (abs (int_lit) > (int) ps->max_var) + return 0; + + lit = int2lit (ps, int_lit); + + if (lit->val == TRUE) + return 1; + + if (lit->val == FALSE) + return -1; + + return 0; +} + +int +picosat_deref_toplevel (PS * ps, int int_lit) +{ + check_ready (ps); + ABORTIF (!int_lit, "API usage: can not deref zero literal"); + +#ifdef STATS + ps->derefs++; +#endif + if (abs (int_lit) > (int) ps->max_var) + return 0; + + return tderef (ps, int_lit); +} + +int +picosat_inconsistent (PS * ps) +{ + check_ready (ps); + return ps->mtcls != 0; +} + +int +picosat_corelit (PS * ps, int int_lit) +{ + check_ready (ps); + check_unsat_state (ps); + ABORTIF (!int_lit, "API usage: zero literal can not be in core"); + + assert (ps->mtcls || ps->failed_assumption); + +#ifdef TRACE + { + int res = 0; + ABORTIF (!ps->trace, "tracing disabled"); + if (ps->measurealltimeinlib) + enter (ps); + core (ps); + if (abs (int_lit) <= (int) ps->max_var) + res = ps->vars[abs (int_lit)].core; + assert (!res || ps->failed_assumption || ps->vars[abs (int_lit)].used); + if (ps->measurealltimeinlib) + leave (ps); + return res; + } +#else + ABORT ("compiled without trace support"); + return 0; +#endif +} + +int +picosat_coreclause (PS * ps, int ocls) +{ + check_ready (ps); + check_unsat_state (ps); + + ABORTIF (ocls < 0, "API usage: negative original clause index"); + ABORTIF (ocls >= (int)ps->oadded, "API usage: original clause index exceeded"); + + assert (ps->mtcls || ps->failed_assumption); + +#ifdef TRACE + { + Cls ** clsptr, * c; + int res = 0; + + ABORTIF (!ps->trace, "tracing disabled"); + if (ps->measurealltimeinlib) + enter (ps); + core (ps); + clsptr = ps->oclauses + ocls; + assert (clsptr < ps->ohead); + c = *clsptr; + if (c) + res = c->core; + if (ps->measurealltimeinlib) + leave (ps); + + return res; + } +#else + ABORT ("compiled without trace support"); + return 0; +#endif +} + +int +picosat_failed_assumption (PS * ps, int int_lit) +{ + Lit * lit; + Var * v; + ABORTIF (!int_lit, "API usage: zero literal as assumption"); + check_ready (ps); + check_unsat_state (ps); + if (ps->mtcls) + return 0; + assert (ps->failed_assumption); + if (abs (int_lit) > (int) ps->max_var) + return 0; + if (!ps->extracted_all_failed_assumptions) + extract_all_failed_assumptions (ps); + lit = import_lit (ps, int_lit, 1); + v = LIT2VAR (lit); + return v->failed; +} + +int +picosat_failed_context (PS * ps, int int_lit) +{ + Lit * lit; + Var * v; + ABORTIF (!int_lit, "API usage: zero literal as context"); + ABORTIF (abs (int_lit) > (int) ps->max_var, "API usage: invalid context"); + check_ready (ps); + check_unsat_state (ps); + assert (ps->failed_assumption); + if (!ps->extracted_all_failed_assumptions) + extract_all_failed_assumptions (ps); + lit = import_lit (ps, int_lit, 0); + v = LIT2VAR (lit); + return v->failed; +} + +const int * +picosat_failed_assumptions (PS * ps) +{ + Lit ** p, * lit; + Var * v; + int ilit; + + ps->falshead = ps->fals; + check_ready (ps); + check_unsat_state (ps); + if (!ps->mtcls) + { + assert (ps->failed_assumption); + if (!ps->extracted_all_failed_assumptions) + extract_all_failed_assumptions (ps); + + for (p = ps->als; p < ps->alshead; p++) + { + lit = *p; + v = LIT2VAR (*p); + if (!v->failed) + continue; + ilit = LIT2INT (lit); + if (ps->falshead == ps->eofals) + ENLARGE (ps->fals, ps->falshead, ps->eofals); + *ps->falshead++ = ilit; + } + } + if (ps->falshead == ps->eofals) + ENLARGE (ps->fals, ps->falshead, ps->eofals); + *ps->falshead++ = 0; + return ps->fals; +} + +const int * +picosat_mus_assumptions (PS * ps, void * s, void (*cb)(void*,const int*), int fix) +{ + int i, j, ilit, len, nwork, * work, res; + signed char * redundant; + Lit ** p, * lit; + int failed; + Var * v; +#ifndef NDEBUG + int oldlen; +#endif +#ifndef RCODE + int norig = ps->alshead - ps->als; +#endif + + check_ready (ps); + check_unsat_state (ps); + len = 0; + if (!ps->mtcls) + { + assert (ps->failed_assumption); + if (!ps->extracted_all_failed_assumptions) + extract_all_failed_assumptions (ps); + + for (p = ps->als; p < ps->alshead; p++) + if (LIT2VAR (*p)->failed) + len++; + } + + if (ps->mass) + DELETEN (ps->mass, ps->szmass); + ps->szmass = len + 1; + NEWN (ps->mass, ps->szmass); + + i = 0; + for (p = ps->als; p < ps->alshead; p++) + { + lit = *p; + v = LIT2VAR (lit); + if (!v->failed) + continue; + ilit = LIT2INT (lit); + assert (i < len); + ps->mass[i++] = ilit; + } + assert (i == len); + ps->mass[i] = 0; + if (ps->verbosity) + fprintf (ps->out, + "%sinitial set of failed assumptions of size %d out of %d (%.0f%%)\n", + ps->prefix, len, norig, PERCENT (len, norig)); + if (cb) + cb (s, ps->mass); + + nwork = len; + NEWN (work, nwork); + for (i = 0; i < len; i++) + work[i] = ps->mass[i]; + + NEWN (redundant, nwork); + CLRN (redundant, nwork); + + for (i = 0; i < nwork; i++) + { + if (redundant[i]) + continue; + + if (ps->verbosity > 1) + fprintf (ps->out, + "%strying to drop %d%s assumption %d\n", + ps->prefix, i, enumstr (i), work[i]); + for (j = 0; j < nwork; j++) + { + if (i == j) continue; + if (j < i && fix) continue; + if (redundant[j]) continue; + picosat_assume (ps, work[j]); + } + + res = picosat_sat (ps, -1); + if (res == 10) + { + if (ps->verbosity > 1) + fprintf (ps->out, + "%sfailed to drop %d%s assumption %d\n", + ps->prefix, i, enumstr (i), work[i]); + + if (fix) + { + picosat_add (ps, work[i]); + picosat_add (ps, 0); + } + } + else + { + assert (res == 20); + if (ps->verbosity > 1) + fprintf (ps->out, + "%ssuceeded to drop %d%s assumption %d\n", + ps->prefix, i, enumstr (i), work[i]); + redundant[i] = 1; + for (j = 0; j < nwork; j++) + { + failed = picosat_failed_assumption (ps, work[j]); + if (j <= i) + { + assert ((j < i && fix) || redundant[j] == !failed); + continue; + } + + if (!failed) + { + redundant[j] = -1; + if (ps->verbosity > 1) + fprintf (ps->out, + "%salso suceeded to drop %d%s assumption %d\n", + ps->prefix, j, enumstr (j), work[j]); + } + } + +#ifndef NDEBUG + oldlen = len; +#endif + len = 0; + for (j = 0; j < nwork; j++) + if (!redundant[j]) + ps->mass[len++] = work[j]; + ps->mass[len] = 0; + assert (len < oldlen); + + if (fix) + { + picosat_add (ps, -work[i]); + picosat_add (ps, 0); + } + +#ifndef NDEBUG + for (j = 0; j <= i; j++) + assert (redundant[j] >= 0); +#endif + for (j = i + 1; j < nwork; j++) + { + if (redundant[j] >= 0) + continue; + + if (fix) + { + picosat_add (ps, -work[j]); + picosat_add (ps, 0); + } + + redundant[j] = 1; + } + + if (ps->verbosity) + fprintf (ps->out, + "%sreduced set of failed assumptions of size %d out of %d (%.0f%%)\n", + ps->prefix, len, norig, PERCENT (len, norig)); + if (cb) + cb (s, ps->mass); + } + } + + DELETEN (work, nwork); + DELETEN (redundant, nwork); + + if (ps->verbosity) + { + fprintf (ps->out, "%sreinitializing unsat state\n", ps->prefix); + fflush (ps->out); + } + + for (i = 0; i < len; i++) + picosat_assume (ps, ps->mass[i]); + +#ifndef NDEBUG + res = +#endif + picosat_sat (ps, -1); + assert (res == 20); + + if (!ps->mtcls) + { + assert (!ps->extracted_all_failed_assumptions); + extract_all_failed_assumptions (ps); + } + + return ps->mass; +} + +static const int * +mss (PS * ps, int * a, int size) +{ + int i, j, k, res; + + assert (!ps->mtcls); + + if (ps->szmssass) + DELETEN (ps->mssass, ps->szmssass); + + ps->szmssass = 0; + ps->mssass = 0; + + ps->szmssass = size + 1; + NEWN (ps->mssass, ps->szmssass); + + LOG ( fprintf (ps->out, "%ssearch MSS over %d assumptions\n", ps->prefix, size)); + + k = 0; + for (i = k; i < size; i++) + { + for (j = 0; j < k; j++) + picosat_assume (ps, ps->mssass[j]); + + LOG ( fprintf (ps->out, + "%strying to add assumption %d to MSS : %d\n", + ps->prefix, i, a[i])); + + picosat_assume (ps, a[i]); + + res = picosat_sat (ps, -1); + if (res == 10) + { + LOG ( fprintf (ps->out, + "%sadding assumption %d to MSS : %d\n", ps->prefix, i, a[i])); + + ps->mssass[k++] = a[i]; + + for (j = i + 1; j < size; j++) + { + if (picosat_deref (ps, a[j]) <= 0) + continue; + + LOG ( fprintf (ps->out, + "%salso adding assumption %d to MSS : %d\n", + ps->prefix, j, a[j])); + + ps->mssass[k++] = a[j]; + + if (++i != j) + { + int tmp = a[i]; + a[i] = a[j]; + a[j] = tmp; + } + } + } + else + { + assert (res == 20); + + LOG ( fprintf (ps->out, + "%signoring assumption %d in MSS : %d\n", ps->prefix, i, a[i])); + } + } + ps->mssass[k] = 0; + LOG ( fprintf (ps->out, "%sfound MSS of size %d\n", ps->prefix, k)); + + return ps->mssass; +} + +static void +reassume (PS * ps, const int * a, int size) +{ + int i; + LOG ( fprintf (ps->out, "%sreassuming all assumptions\n", ps->prefix)); + for (i = 0; i < size; i++) + picosat_assume (ps, a[i]); +} + +const int * +picosat_maximal_satisfiable_subset_of_assumptions (PS * ps) +{ + const int * res; + int i, *a, size; + + ABORTIF (ps->mtcls, + "API usage: CNF inconsistent (use 'picosat_inconsistent')"); + + enter (ps); + + size = ps->alshead - ps->als; + NEWN (a, size); + + for (i = 0; i < size; i++) + a[i] = LIT2INT (ps->als[i]); + + res = mss (ps, a, size); + reassume (ps, a, size); + + DELETEN (a, size); + + leave (ps); + + return res; +} + +static void +check_mss_flags_clean (PS * ps) +{ +#ifndef NDEBUG + unsigned i; + for (i = 1; i <= ps->max_var; i++) + { + assert (!ps->vars[i].msspos); + assert (!ps->vars[i].mssneg); + } +#else + (void) ps; +#endif +} + +static void +push_mcsass (PS * ps, int lit) +{ + if (ps->nmcsass == ps->szmcsass) + { + ps->szmcsass = ps->szmcsass ? 2*ps->szmcsass : 1; + RESIZEN (ps->mcsass, ps->nmcsass, ps->szmcsass); + } + + ps->mcsass[ps->nmcsass++] = lit; +} + +static const int * +next_mss (PS * ps, int mcs) +{ + int i, *a, size, mssize, mcsize, lit, inmss; + const int * res, * p; + Var * v; + + if (ps->mtcls) return 0; + + check_mss_flags_clean (ps); + + if (mcs && ps->mcsass) + { + DELETEN (ps->mcsass, ps->szmcsass); + ps->nmcsass = ps->szmcsass = 0; + ps->mcsass = 0; + } + + size = ps->alshead - ps->als; + NEWN (a, size); + + for (i = 0; i < size; i++) + a[i] = LIT2INT (ps->als[i]); + + (void) picosat_sat (ps, -1); + + //TODO short cut for 'picosat_res () == 10'? + + if (ps->mtcls) + { + assert (picosat_res (ps) == 20); + res = 0; + goto DONE; + } + + res = mss (ps, a, size); + + if (ps->mtcls) + { + res = 0; + goto DONE; + } + + for (p = res; (lit = *p); p++) + { + v = ps->vars + abs (lit); + if (lit < 0) + { + assert (!v->msspos); + v->mssneg = 1; + } + else + { + assert (!v->mssneg); + v->msspos = 1; + } + } + + mssize = p - res; + mcsize = INT_MIN; + + for (i = 0; i < size; i++) + { + lit = a[i]; + v = ps->vars + abs (lit); + if (lit > 0 && v->msspos) + inmss = 1; + else if (lit < 0 && v->mssneg) + inmss = 1; + else + inmss = 0; + + if (mssize < mcsize) + { + if (inmss) + picosat_add (ps, -lit); + } + else + { + if (!inmss) + picosat_add (ps, lit); + } + + if (!inmss && mcs) + push_mcsass (ps, lit); + } + picosat_add (ps, 0); + if (mcs) + push_mcsass (ps, 0); + + for (i = 0; i < size; i++) + { + lit = a[i]; + v = ps->vars + abs (lit); + v->msspos = 0; + v->mssneg = 0; + } + +DONE: + + reassume (ps, a, size); + DELETEN (a, size); + + return res; +} + +const int * +picosat_next_maximal_satisfiable_subset_of_assumptions (PS * ps) +{ + const int * res; + enter (ps); + res = next_mss (ps, 0); + leave (ps); + return res; +} + +const int * +picosat_next_minimal_correcting_subset_of_assumptions (PS * ps) +{ + const int * res, * tmp; + enter (ps); + tmp = next_mss (ps, 1); + res = tmp ? ps->mcsass : 0; + leave (ps); + return res; +} + +const int * +picosat_humus (PS * ps, + void (*callback)(void*state,int nmcs,int nhumus), + void * state) +{ + int lit, nmcs, j, nhumus; + const int * mcs, * p; + unsigned i; + Var * v; + enter (ps); +#ifndef NDEBUG + for (i = 1; i <= ps->max_var; i++) + { + v = ps->vars + i; + assert (!v->humuspos); + assert (!v->humusneg); + } +#endif + nhumus = nmcs = 0; + while ((mcs = picosat_next_minimal_correcting_subset_of_assumptions (ps))) + { + for (p = mcs; (lit = *p); p++) + { + v = ps->vars + abs (lit); + if (lit < 0) + { + if (!v->humusneg) + { + v->humusneg = 1; + nhumus++; + } + } + else + { + if (!v->humuspos) + { + v->humuspos = 1; + nhumus++; + } + } + } + nmcs++; + LOG ( fprintf (ps->out, + "%smcs %d of size %d humus %d\n", + ps->prefix, nmcs, (int)(p - mcs), nhumus)); + if (callback) + callback (state, nmcs, nhumus); + } + assert (!ps->szhumus); + ps->szhumus = 1; + for (i = 1; i <= ps->max_var; i++) + { + v = ps->vars + i; + if (v->humuspos) + ps->szhumus++; + if (v->humusneg) + ps->szhumus++; + } + assert (nhumus + 1 == ps->szhumus); + NEWN (ps->humus, ps->szhumus); + j = 0; + for (i = 1; i <= ps->max_var; i++) + { + v = ps->vars + i; + if (v->humuspos) + { + assert (j < nhumus); + ps->humus[j++] = (int) i; + } + if (v->humusneg) + { + assert (j < nhumus); + assert (i < INT_MAX); + ps->humus[j++] = - (int) i; + } + } + assert (j == nhumus); + assert (j < ps->szhumus); + ps->humus[j] = 0; + leave (ps); + return ps->humus; +} + +int +picosat_usedlit (PS * ps, int int_lit) +{ + int res; + check_ready (ps); + check_sat_or_unsat_or_unknown_state (ps); + ABORTIF (!int_lit, "API usage: zero literal can not be used"); + int_lit = abs (int_lit); + res = (int_lit <= (int) ps->max_var) ? ps->vars[int_lit].used : 0; + return res; +} + +void +picosat_write_clausal_core (PS * ps, FILE * file) +{ + check_trace_support_and_execute (ps, file, write_core_wrapper, 0); +} + +void +picosat_write_compact_trace (PS * ps, FILE * file) +{ + check_trace_support_and_execute (ps, file, write_trace, + COMPACT_TRACECHECK_TRACE_FMT); +} + +void +picosat_write_extended_trace (PS * ps, FILE * file) +{ + check_trace_support_and_execute (ps, file, write_trace, + EXTENDED_TRACECHECK_TRACE_FMT); +} + +void +picosat_write_rup_trace (PS * ps, FILE * file) +{ + check_trace_support_and_execute (ps, file, write_trace, RUP_TRACE_FMT); +} + +size_t +picosat_max_bytes_allocated (PS * ps) +{ + check_ready (ps); + return ps->max_bytes; +} + +void +picosat_set_propagation_limit (PS * ps, unsigned long long l) +{ + ps->lpropagations = l; +} + +unsigned long long +picosat_propagations (PS * ps) +{ + return ps->propagations; +} + +unsigned long long +picosat_visits (PS * ps) +{ + return ps->visits; +} + +unsigned long long +picosat_decisions (PS * ps) +{ + return ps->decisions; +} + +int +picosat_variables (PS * ps) +{ + check_ready (ps); + return (int) ps->max_var; +} + +int +picosat_added_original_clauses (PS * ps) +{ + check_ready (ps); + return (int) ps->oadded; +} + +void +picosat_stats (PS * ps) +{ +#ifndef RCODE + unsigned redlits; +#endif +#ifdef STATS + check_ready (ps); + assert (ps->sdecisions + ps->rdecisions + ps->assumptions == ps->decisions); +#endif + if (ps->calls > 1) + fprintf (ps->out, "%s%u calls\n", ps->prefix, ps->calls); + if (ps->contexts) + { + fprintf (ps->out, "%s%u contexts", ps->prefix, ps->contexts); +#ifdef STATS + fprintf (ps->out, " %u internal variables", ps->internals); +#endif + fprintf (ps->out, "\n"); + } + fprintf (ps->out, "%s%u iterations\n", ps->prefix, ps->iterations); + fprintf (ps->out, "%s%u restarts", ps->prefix, ps->restarts); +#ifdef STATS + fprintf (ps->out, " (%u skipped)", ps->skippedrestarts); +#endif + fputc ('\n', ps->out); +#ifndef NFL + fprintf (ps->out, "%s%u failed literals", ps->prefix, ps->failedlits); +#ifdef STATS + fprintf (ps->out, + ", %u calls, %u rounds, %llu propagations", + ps->flcalls, ps->flrounds, ps->flprops); +#endif + fputc ('\n', ps->out); +#ifdef STATS + fprintf (ps->out, + "%sfl: %u = %.1f%% implicit, %llu oopsed, %llu tried, %llu skipped\n", + ps->prefix, + ps->ifailedlits, PERCENT (ps->ifailedlits, ps->failedlits), + ps->floopsed, ps->fltried, ps->flskipped); +#endif +#endif + fprintf (ps->out, "%s%u conflicts", ps->prefix, ps->conflicts); +#ifdef STATS + fprintf (ps->out, " (%u uips = %.1f%%)\n", ps->uips, PERCENT(ps->uips,ps->conflicts)); +#else + fputc ('\n', ps->out); +#endif +#ifndef NADC + fprintf (ps->out, "%s%u adc conflicts\n", ps->prefix, ps->adoconflicts); +#endif +#ifdef STATS + fprintf (ps->out, "%s%llu dereferenced literals\n", ps->prefix, ps->derefs); +#endif + fprintf (ps->out, "%s%u decisions", ps->prefix, ps->decisions); +#ifdef STATS + fprintf (ps->out, " (%u random = %.2f%%", + ps->rdecisions, PERCENT (ps->rdecisions, ps->decisions)); + fprintf (ps->out, ", %u assumptions", ps->assumptions); + fputc (')', ps->out); +#endif + fputc ('\n', ps->out); +#ifdef STATS + fprintf (ps->out, + "%s%u static phase decisions (%.1f%% of all variables)\n", + ps->prefix, + ps->staticphasedecisions, PERCENT (ps->staticphasedecisions, ps->max_var)); +#endif + fprintf (ps->out, "%s%u fixed variables\n", ps->prefix, ps->fixed); + assert (ps->nonminimizedllits >= ps->minimizedllits); +#ifndef RCODE + redlits = ps->nonminimizedllits - ps->minimizedllits; +#endif + fprintf (ps->out, "%s%u learned literals\n", ps->prefix, ps->llitsadded); + fprintf (ps->out, "%s%.1f%% deleted literals\n", + ps->prefix, PERCENT (redlits, ps->nonminimizedllits)); + +#ifdef STATS +#ifdef TRACE + fprintf (ps->out, + "%s%llu antecedents (%.1f antecedents per clause", + ps->prefix, ps->antecedents, AVERAGE (ps->antecedents, ps->conflicts)); + if (ps->trace) + fprintf (ps->out, ", %.1f bytes/antecedent)", AVERAGE (ps->znts, ps->antecedents)); + fputs (")\n", ps->out); +#endif + + fprintf (ps->out, "%s%llu propagations (%.1f propagations per decision)\n", + ps->prefix, ps->propagations, AVERAGE (ps->propagations, ps->decisions)); + fprintf (ps->out, "%s%llu visits (%.1f per propagation)\n", + ps->prefix, ps->visits, AVERAGE (ps->visits, ps->propagations)); + fprintf (ps->out, + "%s%llu binary clauses visited (%.1f%% %.1f per propagation)\n", + ps->prefix, ps->bvisits, + PERCENT (ps->bvisits, ps->visits), + AVERAGE (ps->bvisits, ps->propagations)); + fprintf (ps->out, + "%s%llu ternary clauses visited (%.1f%% %.1f per propagation)\n", + ps->prefix, ps->tvisits, + PERCENT (ps->tvisits, ps->visits), + AVERAGE (ps->tvisits, ps->propagations)); + fprintf (ps->out, + "%s%llu large clauses visited (%.1f%% %.1f per propagation)\n", + ps->prefix, ps->lvisits, + PERCENT (ps->lvisits, ps->visits), + AVERAGE (ps->lvisits, ps->propagations)); + fprintf (ps->out, "%s%llu other true (%.1f%% of visited clauses)\n", + ps->prefix, ps->othertrue, PERCENT (ps->othertrue, ps->visits)); + fprintf (ps->out, + "%s%llu other true in binary clauses (%.1f%%)" + ", %llu upper (%.1f%%)\n", + ps->prefix, ps->othertrue2, PERCENT (ps->othertrue2, ps->othertrue), + ps->othertrue2u, PERCENT (ps->othertrue2u, ps->othertrue2)); + fprintf (ps->out, + "%s%llu other true in large clauses (%.1f%%)" + ", %llu upper (%.1f%%)\n", + ps->prefix, ps->othertruel, PERCENT (ps->othertruel, ps->othertrue), + ps->othertruelu, PERCENT (ps->othertruelu, ps->othertruel)); + fprintf (ps->out, "%s%llu ternary and large traversals (%.1f per visit)\n", + ps->prefix, ps->traversals, AVERAGE (ps->traversals, ps->visits)); + fprintf (ps->out, "%s%llu large traversals (%.1f per large visit)\n", + ps->prefix, ps->ltraversals, AVERAGE (ps->ltraversals, ps->lvisits)); + fprintf (ps->out, "%s%llu assignments\n", ps->prefix, ps->assignments); +#else + fprintf (ps->out, "%s%llu propagations\n", ps->prefix, picosat_propagations (ps)); + fprintf (ps->out, "%s%llu visits\n", ps->prefix, picosat_visits (ps)); +#endif + fprintf (ps->out, "%s%.1f%% variables used\n", ps->prefix, PERCENT (ps->vused, ps->max_var)); + + sflush (ps); + fprintf (ps->out, "%s%.1f seconds in library\n", ps->prefix, ps->seconds); + fprintf (ps->out, "%s%.1f megaprops/second\n", + ps->prefix, AVERAGE (ps->propagations / 1e6f, ps->seconds)); + fprintf (ps->out, "%s%.1f megavisits/second\n", + ps->prefix, AVERAGE (ps->visits / 1e6f, ps->seconds)); + fprintf (ps->out, "%sprobing %.1f seconds %.0f%%\n", + ps->prefix, ps->flseconds, PERCENT (ps->flseconds, ps->seconds)); +#ifdef STATS + fprintf (ps->out, + "%srecycled %.1f MB in %u reductions\n", + ps->prefix, ps->rrecycled / (double) (1 << 20), ps->reductions); + fprintf (ps->out, + "%srecycled %.1f MB in %u simplifications\n", + ps->prefix, ps->srecycled / (double) (1 << 20), ps->simps); +#else + fprintf (ps->out, "%s%u simplifications\n", ps->prefix, ps->simps); + fprintf (ps->out, "%s%u reductions\n", ps->prefix, ps->reductions); + fprintf (ps->out, "%s%.1f MB recycled\n", ps->prefix, ps->recycled / (double) (1 << 20)); +#endif + fprintf (ps->out, "%s%.1f MB maximally allocated\n", + ps->prefix, picosat_max_bytes_allocated (ps) / (double) (1 << 20)); +} + +#ifndef NGETRUSAGE +#include <sys/time.h> +#include <sys/resource.h> +#include <sys/unistd.h> +#endif + +double +picosat_time_stamp (void) +{ + double res = -1; +#ifndef NGETRUSAGE + struct rusage u; + res = 0; + if (!getrusage (RUSAGE_SELF, &u)) + { + res += u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec; + res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec; + } +#endif + return res; +} + +double +picosat_seconds (PS * ps) +{ + check_ready (ps); + return ps->seconds; +} + +void +picosat_print (PS * ps, FILE * file) +{ +#ifdef NO_BINARY_CLAUSES + Lit * lit, *other, * last; + Ltk * stack; +#endif + Lit **q, **eol; + Cls **p, *c; + unsigned n; + + if (ps->measurealltimeinlib) + enter (ps); + else + check_ready (ps); + + n = 0; + n += ps->alshead - ps->als; + + for (p = SOC; p != EOC; p = NXC (p)) + { + c = *p; + + if (!c) + continue; + +#ifdef TRACE + if (c->collected) + continue; +#endif + n++; + } + +#ifdef NO_BINARY_CLAUSES + last = int2lit (ps, -ps->max_var); + for (lit = int2lit (ps, 1); lit <= last; lit++) + { + stack = LIT2IMPLS (lit); + eol = stack->start + stack->count; + for (q = stack->start; q < eol; q++) + if (*q >= lit) + n++; + } +#endif + + fprintf (file, "p cnf %d %u\n", ps->max_var, n); + + for (p = SOC; p != EOC; p = NXC (p)) + { + c = *p; + if (!c) + continue; + +#ifdef TRACE + if (c->collected) + continue; +#endif + + eol = end_of_lits (c); + for (q = c->lits; q < eol; q++) + fprintf (file, "%d ", LIT2INT (*q)); + + fputs ("0\n", file); + } + +#ifdef NO_BINARY_CLAUSES + last = int2lit (ps, -ps->max_var); + for (lit = int2lit (ps, 1); lit <= last; lit++) + { + stack = LIT2IMPLS (lit); + eol = stack->start + stack->count; + for (q = stack->start; q < eol; q++) + if ((other = *q) >= lit) + fprintf (file, "%d %d 0\n", LIT2INT (lit), LIT2INT (other)); + } +#endif + + { + Lit **r; + for (r = ps->als; r < ps->alshead; r++) + fprintf (file, "%d 0\n", LIT2INT (*r)); + } + + fflush (file); + + if (ps->measurealltimeinlib) + leave (ps); +} + +void +picosat_enter (PS * ps) +{ + enter (ps); +} + +void +picosat_leave (PS * ps) +{ + leave (ps); +} + +void +picosat_message (PS * ps, int vlevel, const char * fmt, ...) +{ + va_list ap; + + if (vlevel > ps->verbosity) + return; + + fputs (ps->prefix, ps->out); + va_start (ap, fmt); + vfprintf (ps->out, fmt, ap); + va_end (ap); + fputc ('\n', ps->out); +} + +int +picosat_changed (PS * ps) +{ + int res; + + check_ready (ps); + check_sat_state (ps); + + res = (ps->min_flipped <= ps->saved_max_var); + assert (!res || ps->saved_flips != ps->flips); + + return res; +} + +void +picosat_reset_phases (PS * ps) +{ + rebias (ps); +} + +void +picosat_reset_scores (PS * ps) +{ + Rnk * r; + ps->hhead = ps->heap + 1; + for (r = ps->rnks + 1; r <= ps->rnks + ps->max_var; r++) + { + CLR (r); + hpush (ps, r); + } +} + +void +picosat_remove_learned (PS * ps, unsigned percentage) +{ + enter (ps); + reset_incremental_usage (ps); + reduce (ps, percentage); + leave (ps); +} + +void +picosat_set_global_default_phase (PS * ps, int phase) +{ + check_ready (ps); + ABORTIF (phase < 0, "API usage: 'picosat_set_global_default_phase' " + "with negative argument"); + ABORTIF (phase > 3, "API usage: 'picosat_set_global_default_phase' " + "with argument > 3"); + ps->defaultphase = phase; +} + +void +picosat_set_default_phase_lit (PS * ps, int int_lit, int phase) +{ + unsigned newphase; + Lit * lit; + Var * v; + + check_ready (ps); + + lit = import_lit (ps, int_lit, 1); + v = LIT2VAR (lit); + + if (phase) + { + newphase = (int_lit < 0) == (phase < 0); + v->defphase = v->phase = newphase; + v->usedefphase = v->assigned = 1; + } + else + { + v->usedefphase = v->assigned = 0; + } +} + +void +picosat_set_more_important_lit (PS * ps, int int_lit) +{ + Lit * lit; + Var * v; + Rnk * r; + + check_ready (ps); + + lit = import_lit (ps, int_lit, 1); + v = LIT2VAR (lit); + r = VAR2RNK (v); + + ABORTIF (r->lessimportant, "can not mark variable more and less important"); + + if (r->moreimportant) + return; + + r->moreimportant = 1; + + if (r->pos) + hup (ps, r); +} + +void +picosat_set_less_important_lit (PS * ps, int int_lit) +{ + Lit * lit; + Var * v; + Rnk * r; + + check_ready (ps); + + lit = import_lit (ps, int_lit, 1); + v = LIT2VAR (lit); + r = VAR2RNK (v); + + ABORTIF (r->moreimportant, "can not mark variable more and less important"); + + if (r->lessimportant) + return; + + r->lessimportant = 1; + + if (r->pos) + hdown (ps, r); +} + +#ifndef NADC + +unsigned +picosat_ado_conflicts (PS * ps) +{ + check_ready (ps); + return ps->adoconflicts; +} + +void +picosat_disable_ado (PS * ps) +{ + check_ready (ps); + assert (!ps->adodisabled); + ps->adodisabled = 1; +} + +void +picosat_enable_ado (PS * ps) +{ + check_ready (ps); + assert (ps->adodisabled); + ps->adodisabled = 0; +} + +void +picosat_set_ado_conflict_limit (PS * ps, unsigned newadoconflictlimit) +{ + check_ready (ps); + ps->adoconflictlimit = newadoconflictlimit; +} + +#endif + +void +picosat_simplify (PS * ps) +{ + enter (ps); + reset_incremental_usage (ps); + simplify (ps, 1); + leave (ps); +} + +int +picosat_haveados (void) +{ +#ifndef NADC + return 1; +#else + return 0; +#endif +} + +void +picosat_save_original_clauses (PS * ps) +{ + if (ps->saveorig) return; + ABORTIF (ps->oadded, "API usage: 'picosat_save_original_clauses' too late"); + ps->saveorig = 1; +} + +void picosat_set_interrupt (PicoSAT * ps, + void * external_state, + int (*interrupted)(void * external_state)) +{ + ps->interrupt.state = external_state; + ps->interrupt.function = interrupted; +} + +int +picosat_deref_partial (PS * ps, int int_lit) +{ + check_ready (ps); + check_sat_state (ps); + ABORTIF (!int_lit, "API usage: can not partial deref zero literal"); + ABORTIF (ps->mtcls, "API usage: deref partial after empty clause generated"); + ABORTIF (!ps->saveorig, "API usage: 'picosat_save_original_clauses' missing"); + +#ifdef STATS + ps->derefs++; +#endif + + if (!ps->partial) + minautarky (ps); + + return pderef (ps, int_lit); +} diff --git a/test/monniaux/picosat-965/picosat.h b/test/monniaux/picosat-965/picosat.h new file mode 100644 index 00000000..e735aec9 --- /dev/null +++ b/test/monniaux/picosat-965/picosat.h @@ -0,0 +1,660 @@ +/**************************************************************************** +Copyright (c) 2006 - 2015, Armin Biere, Johannes Kepler University. + +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 picosat_h_INCLUDED +#define picosat_h_INCLUDED + +#define INT_MOD(x, y) ((x) % (y)) + +/*------------------------------------------------------------------------*/ + +#include <stdlib.h> +#include <stdio.h> +#include <stddef.h> + +/*------------------------------------------------------------------------*/ +/* The following macros allows for users to distiguish between different + * versions of the API. The first 'PICOSAT_REENTRANT_API' is defined for + * the new reentrant API which allows to generate multiple instances of + * PicoSAT in one process. The second 'PICOSAT_API_VERSION' defines the + * (smallest) version of PicoSAT to which this API conforms. + */ +#define PICOSAT_REENTRANT_API +#define PICOSAT_API_VERSION 953 /* API version */ + +/*------------------------------------------------------------------------*/ +/* These are the return values for 'picosat_sat' as for instance + * standardized by the output format of the SAT competition. + */ +#define PICOSAT_UNKNOWN 0 +#define PICOSAT_SATISFIABLE 10 +#define PICOSAT_UNSATISFIABLE 20 + +/*------------------------------------------------------------------------*/ + +typedef struct PicoSAT PicoSAT; + +/*------------------------------------------------------------------------*/ + +const char *picosat_version (void); +const char *picosat_config (void); +const char *picosat_copyright (void); + +/*------------------------------------------------------------------------*/ +/* You can make PicoSAT use an external memory manager instead of the one + * provided by LIBC. But then you need to call these three function before + * 'picosat_init'. The memory manager functions here all have an additional + * first argument which is a pointer to the memory manager, but otherwise + * are supposed to work as their LIBC counter parts 'malloc', 'realloc' and + * 'free'. As exception the 'resize' and 'delete' function have as third + * argument the number of bytes of the block given as second argument. + */ + +typedef void * (*picosat_malloc)(void *, size_t); +typedef void * (*picosat_realloc)(void*, void *, size_t, size_t); +typedef void (*picosat_free)(void*, void*, size_t); + +/*------------------------------------------------------------------------*/ + +PicoSAT * picosat_init (void); /* constructor */ + +PicoSAT * picosat_minit (void * state, + picosat_malloc, + picosat_realloc, + picosat_free); + +void picosat_reset (PicoSAT *); /* destructor */ + +/*------------------------------------------------------------------------*/ +/* The following five functions are essentially parameters to 'init', and + * thus should be called right after 'picosat_init' before doing anything + * else. You should not call any of them after adding a literal. + */ + +/* Set output file, default is 'stdout'. + */ +void picosat_set_output (PicoSAT *, FILE *); + +/* Measure all time spent in all calls in the solver. By default only the + * time spent in 'picosat_sat' is measured. Enabling this function might + * for instance triple the time needed to add large CNFs, since every call + * to 'picosat_add' will trigger a call to 'getrusage'. + */ +void picosat_measure_all_calls (PicoSAT *); + +/* Set the prefix used for printing verbose messages and statistics. + * Default is "c ". + */ +void picosat_set_prefix (PicoSAT *, const char *); + +/* Set verbosity level. A verbosity level of 1 and above prints more and + * more detailed progress reports on the output file, set by + * 'picosat_set_output'. Verbose messages are prefixed with the string set + * by 'picosat_set_prefix'. + */ +void picosat_set_verbosity (PicoSAT *, int new_verbosity_level); + +/* Disable/Enable all pre-processing, currently only failed literal probing. + * + * new_plain_value != 0 only 'plain' solving, so no preprocessing + * new_plain_value == 0 allow preprocessing + */ +void picosat_set_plain (PicoSAT *, int new_plain_value); + +/* Set default initial phase: + * + * 0 = false + * 1 = true + * 2 = Jeroslow-Wang (default) + * 3 = random initial phase + * + * After a variable has been assigned the first time, it will always + * be assigned the previous value if it is picked as decision variable. + * The initial assignment can be chosen with this function. + */ +void picosat_set_global_default_phase (PicoSAT *, int); + +/* Set next/initial phase of a particular variable if picked as decision + * variable. Second argument 'phase' has the following meaning: + * + * negative = next value if picked as decision variable is false + * + * positive = next value if picked as decision variable is true + * + * 0 = use global default phase as next value and + * assume 'lit' was never assigned + * + * Again if 'lit' is assigned afterwards through a forced assignment, + * then this forced assignment is the next phase if this variable is + * used as decision variable. + */ +void picosat_set_default_phase_lit (PicoSAT *, int lit, int phase); + +/* You can reset all phases by the following function. + */ +void picosat_reset_phases (PicoSAT *); + +/* Scores can be erased as well. Note, however, that even after erasing + * scores and phases, learned clauses are kept. In addition head tail + * pointers for literals are not moved either. So expect a difference + * between calling the solver in incremental mode or with a fresh copy of + * the CNF. + */ +void picosat_reset_scores (PicoSAT *); + +/* Reset assignment if in SAT state and then remove the given percentage of + * less active (large) learned clauses. If you specify 100% all large + * learned clauses are removed. + */ +void picosat_remove_learned (PicoSAT *, unsigned percentage); + +/* Set some variables to be more important than others. These variables are + * always used as decisions before other variables are used. Dually there + * is a set of variables that is used last. The default is + * to mark all variables as being indifferent only. + */ +void picosat_set_more_important_lit (PicoSAT *, int lit); +void picosat_set_less_important_lit (PicoSAT *, int lit); + +/* Allows to print to internal 'out' file from client. + */ +void picosat_message (PicoSAT *, int verbosity_level, const char * fmt, ...); + +/* Set a seed for the random number generator. The random number generator + * is currently just used for generating random decisions. In our + * experiments having random decisions did not really help on industrial + * examples, but was rather helpful to randomize the solver in order to + * do proper benchmarking of different internal parameter sets. + */ +void picosat_set_seed (PicoSAT *, unsigned random_number_generator_seed); + +/* If you ever want to extract cores or proof traces with the current + * instance of PicoSAT initialized with 'picosat_init', then make sure to + * call 'picosat_enable_trace_generation' right after 'picosat_init'. This + * is not necessary if you only use 'picosat_set_incremental_rup_file'. + * + * NOTE, trace generation code is not necessarily included, e.g. if you + * configure PicoSAT with full optimzation as './configure.sh -O' or with + + * you do not get any results by trying to generate traces. + * + * The return value is non-zero if code for generating traces is included + * and it is zero if traces can not be generated. + */ +int picosat_enable_trace_generation (PicoSAT *); + +/* You can dump proof traces in RUP format incrementally even without + * keeping the proof trace in memory. The advantage is a reduction of + * memory usage, but the dumped clauses do not necessarily belong to the + * clausal core. Beside the file the additional parameters denotes the + * maximal number of variables and the number of original clauses. + */ +void picosat_set_incremental_rup_file (PicoSAT *, FILE * file, int m, int n); + +/* Save original clauses for 'picosat_deref_partial'. See comments to that + * function further down. + */ +void picosat_save_original_clauses (PicoSAT *); + +/* Add a call back which is checked regularly to notify the SAT solver + * to terminate earlier. This is useful for setting external time limits + * or terminate early in say a portfolio style parallel SAT solver. + */ +void picosat_set_interrupt (PicoSAT *, + void * external_state, + int (*interrupted)(void * external_state)); + +/*------------------------------------------------------------------------*/ +/* This function returns the next available unused variable index and + * allocates a variable for it even though this variable does not occur as + * assumption, nor in a clause or any other constraints. In future calls to + * 'picosat_sat', 'picosat_deref' and particularly for 'picosat_changed', + * this variable is treated as if it had been used. + */ +int picosat_inc_max_var (PicoSAT *); + +/*------------------------------------------------------------------------*/ +/* Push and pop semantics for PicoSAT. 'picosat_push' opens up a new + * context. All clauses added in this context are attached to it and + * discarded when the context is closed with 'picosat_pop'. It is also + * possible to nest contexts. + * + * The current implementation uses a new internal variable for each context. + * However, the indices for these internal variables are shared with + * ordinary external variables. This means that after any call to + * 'picosat_push', new variable indices should be obtained with + * 'picosat_inc_max_var' and not just by incrementing the largest variable + * index used so far. + * + * The return value is the index of the literal that assumes this context. + * This literal can only be used for 'picosat_failed_context' otherwise + * it will lead to an API usage error. + */ +int picosat_push (PicoSAT *); + +/* This is as 'picosat_failed_assumption', but only for internal variables + * generated by 'picosat_push'. + */ +int picosat_failed_context (PicoSAT *, int lit); + +/* Returns the literal that assumes the current context or zero if the + * outer context has been reached. + */ +int picosat_context (PicoSAT *); + +/* Closes the current context and recycles the literal generated for + * assuming this context. The return value is the literal for the new + * outer context or zero if the outer most context has been reached. + */ +int picosat_pop (PicoSAT *); + +/* Force immmediate removal of all satisfied clauses and clauses that are + * added or generated in closed contexts. This function is called + * internally if enough units are learned or after a certain number of + * contexts have been closed. This number is fixed at compile time + * and defined as MAXCILS in 'picosat.c'. + * + * Note that learned clauses which only involve outer contexts are kept. + */ +void picosat_simplify (PicoSAT *); + +/*------------------------------------------------------------------------*/ +/* If you know a good estimate on how many variables you are going to use + * then calling this function before adding literals will result in less + * resizing of the variable table. But this is just a minor optimization. + * Beside exactly allocating enough variables it has the same effect as + * calling 'picosat_inc_max_var'. + */ +void picosat_adjust (PicoSAT *, int max_idx); + +/*------------------------------------------------------------------------*/ +/* Statistics. + */ +int picosat_variables (PicoSAT *); /* p cnf <m> n */ +int picosat_added_original_clauses (PicoSAT *); /* p cnf m <n> */ +size_t picosat_max_bytes_allocated (PicoSAT *); +double picosat_time_stamp (void); /* ... in process */ +void picosat_stats (PicoSAT *); /* > output file */ +unsigned long long picosat_propagations (PicoSAT *); /* #propagations */ +unsigned long long picosat_decisions (PicoSAT *); /* #decisions */ +unsigned long long picosat_visits (PicoSAT *); /* #visits */ + +/* The time spent in calls to the library or in 'picosat_sat' respectively. + * The former is returned if, right after initialization + * 'picosat_measure_all_calls' is called. + */ +double picosat_seconds (PicoSAT *); + +/*------------------------------------------------------------------------*/ +/* Add a literal of the next clause. A zero terminates the clause. The + * solver is incremental. Adding a new literal will reset the previous + * assignment. The return value is the original clause index to which + * this literal respectively the trailing zero belong starting at 0. + */ +int picosat_add (PicoSAT *, int lit); + +/* As the previous function, but allows to add a full clause at once with an + * at compiled time known size. The list of argument literals has to be + * terminated with a zero literal. Literals beyond the first zero literal + * are discarded. + */ +int picosat_add_arg (PicoSAT *, ...); + +/* As the previous function but with an at compile time unknown size. + */ +int picosat_add_lits (PicoSAT *, int * lits); + +/* Print the CNF to the given file in DIMACS format. + */ +void picosat_print (PicoSAT *, FILE *); + +/* You can add arbitrary many assumptions before the next 'picosat_sat' + * call. This is similar to the using assumptions in MiniSAT, except that + * for PicoSAT you do not have to collect all your assumptions in a vector + * yourself. In PicoSAT you can add one after the other, to be used in the + * next call to 'picosat_sat'. + * + * These assumptions can be interpreted as adding unit clauses with those + * assumptions as literals. However these assumption clauses are only valid + * for exactly the next call to 'picosat_sat', and will be removed + * afterwards, e.g. in following future calls to 'picosat_sat' after the + * next 'picosat_sat' call, unless they are assumed again trough + * 'picosat_assume'. + * + * More precisely, assumptions actually remain valid even after the next + * call to 'picosat_sat' has returned. Valid means they remain 'assumed' + * internally until a call to 'picosat_add', 'picosat_assume', or a second + * 'picosat_sat', following the first 'picosat_sat'. The reason for keeping + * them valid is to allow 'picosat_failed_assumption' to return correct + * values. + * + * Example: + * + * picosat_assume (1); // assume unit clause '1 0' + * picosat_assume (-2); // additionally assume clause '-2 0' + * res = picosat_sat (1000); // assumes 1 and -2 to hold + * // 1000 decisions max. + * + * if (res == PICOSAT_UNSATISFIABLE) + * { + * if (picosat_failed_assumption (1)) + * // unit clause '1 0' was necessary to derive UNSAT + * + * if (picosat_failed_assumption (-2)) + * // unit clause '-2 0' was necessary to derive UNSAT + * + * // at least one but also both could be necessary + * + * picosat_assume (17); // previous assumptions are removed + * // now assume unit clause '17 0' for + * // the next call to 'picosat_sat' + * + * // adding a new clause, actually the first literal of + * // a clause would also make the assumptions used in the previous + * // call to 'picosat_sat' invalid. + * + * // The first two assumptions above are not assumed anymore. Only + * // the assumptions, since the last call to 'picosat_sat' returned + * // are assumed, e.g. the unit clause '17 0'. + * + * res = picosat_sat (-1); + * } + * else if (res == PICOSAT_SATISFIABLE) + * { + * // now the assignment is valid and we can call 'picosat_deref' + * + * assert (picosat_deref (1) == 1)); + * assert (picosat_deref (-2) == 1)); + * + * val = picosat_deref (15); + * + * // previous two assumptions are still valid + * + * // would become invalid if 'picosat_add' or 'picosat_assume' is + * // called here, but we immediately call 'picosat_sat'. Now when + * // entering 'picosat_sat' the solver knows that the previous call + * // returned SAT and it can safely reset the previous assumptions + * + * res = picosat_sat (-1); + * } + * else + * { + * assert (res == PICOSAT_UNKNOWN); + * + * // assumptions valid, but assignment invalid + * // except for top level assigned literals which + * // necessarily need to have this value if the formula is SAT + * + * // as above the solver nows that the previous call returned UNKWOWN + * // and will before doing anything else reset assumptions + * + * picosat_sat (-1); + * } + */ +void picosat_assume (PicoSAT *, int lit); + +/*------------------------------------------------------------------------*/ +/* This is an experimental feature for handling 'all different constraints' + * (ADC). Currently only one global ADC can be handled. The bit-width of + * all the bit-vectors entered in this ADC (stored in 'all different + * objects' or ADOs) has to be identical. + * + * TODO: also handle top level assigned literals here. + */ +void picosat_add_ado_lit (PicoSAT *, int); + +/*------------------------------------------------------------------------*/ +/* Call the main SAT routine. A negative decision limit sets no limit on + * the number of decisions. The return values are as above, e.g. + * 'PICOSAT_UNSATISFIABLE', 'PICOSAT_SATISFIABLE', or 'PICOSAT_UNKNOWN'. + */ +int picosat_sat (PicoSAT *, int decision_limit); + +/* As alternative to a decision limit you can use the number of propagations + * as limit. This is more linearly related to execution time. This has to + * be called after 'picosat_init' and before 'picosat_sat'. + */ +void picosat_set_propagation_limit (PicoSAT *, unsigned long long limit); + +/* Return last result of calling 'picosat_sat' or '0' if not called. + */ +int picosat_res (PicoSAT *); + +/* After 'picosat_sat' was called and returned 'PICOSAT_SATISFIABLE', then + * the satisfying assignment can be obtained by 'dereferencing' literals. + * The value of the literal is return as '1' for 'true', '-1' for 'false' + * and '0' for an unknown value. + */ +int picosat_deref (PicoSAT *, int lit); + +/* Same as before but just returns true resp. false if the literals is + * forced to this assignment at the top level. This function does not + * require that 'picosat_sat' was called and also does not internally reset + * incremental usage. + */ +int picosat_deref_toplevel (PicoSAT *, int lit); + +/* After 'picosat_sat' was called and returned 'PICOSAT_SATISFIABLE' a + * partial satisfying assignment can be obtained as well. It satisfies all + * original clauses. The value of the literal is return as '1' for 'true', + * '-1' for 'false' and '0' for an unknown value. In order to make this + * work all original clauses have to be saved internally, which has to be + * enabled by 'picosat_save_original_clauses' right after initialization. + */ +int picosat_deref_partial (PicoSAT *, int lit); + +/* Returns non zero if the CNF is unsatisfiable because an empty clause was + * added or derived. + */ +int picosat_inconsistent (PicoSAT *); + +/* Returns non zero if the literal is a failed assumption, which is defined + * as an assumption used to derive unsatisfiability. This is as accurate as + * generating core literals, but still of course is an overapproximation of + * the set of assumptions really necessary. The technique does not need + * clausal core generation nor tracing to be enabled and thus can be much + * more effective. The function can only be called as long the current + * assumptions are valid. See 'picosat_assume' for more details. + */ +int picosat_failed_assumption (PicoSAT *, int lit); + +/* Returns a zero terminated list of failed assumption in the last call to + * 'picosat_sat'. The pointer is valid until the next call to + * 'picosat_sat' or 'picosat_failed_assumptions'. It only makes sense if the + * last call to 'picosat_sat' returned 'PICOSAT_UNSATISFIABLE'. + */ +const int * picosat_failed_assumptions (PicoSAT *); + +/* Returns a zero terminated minimized list of failed assumption for the last + * call to 'picosat_sat'. The pointer is valid until the next call to this + * function or 'picosat_sat' or 'picosat_mus_assumptions'. It only makes sense + * if the last call to 'picosat_sat' returned 'PICOSAT_UNSATISFIABLE'. + * + * The call back function is called for all successful simplification + * attempts. The first argument of the call back function is the state + * given as first argument to 'picosat_mus_assumptions'. The second + * argument to the call back function is the new reduced list of failed + * assumptions. + * + * This function will call 'picosat_assume' and 'picosat_sat' internally but + * before returning reestablish a proper UNSAT state, e.g. + * 'picosat_failed_assumption' will work afterwards as expected. + * + * The last argument if non zero fixes assumptions. In particular, if an + * assumption can not be removed it is permanently assigned true, otherwise + * if it turns out to be redundant it is permanently assumed to be false. + */ +const int * picosat_mus_assumptions (PicoSAT *, void *, + void(*)(void*,const int*),int); + +/* Compute one maximal subset of satisfiable assumptions. You need to set + * the assumptions, call 'picosat_sat' and check for 'picosat_inconsistent', + * before calling this function. The result is a zero terminated array of + * assumptions that consistently can be asserted at the same time. Before + * returing the library 'reassumes' all assumptions. + * + * It could be beneficial to set the default phase of assumptions + * to true (positive). This can speed up the computation. + */ +const int * picosat_maximal_satisfiable_subset_of_assumptions (PicoSAT *); + +/* This function assumes that you have set up all assumptions with + * 'picosat_assume'. Then it calls 'picosat_sat' internally unless the + * formula is already inconsistent without assumptions, i.e. it contains + * the empty clause. After that it extracts a maximal satisfiable subset of + * assumptions. + * + * The result is a zero terminated maximal subset of consistent assumptions + * or a zero pointer if the formula contains the empty clause and thus no + * more maximal consistent subsets of assumptions can be extracted. In the + * first case, before returning, a blocking clause is added, that rules out + * the result for the next call. + * + * NOTE: adding the blocking clause changes the CNF. + * + * So the following idiom + * + * const int * mss; + * picosat_assume (a1); + * picosat_assume (a2); + * picosat_assume (a3); + * picosat_assume (a4); + * while ((mss = picosat_next_maximal_satisfiable_subset_of_assumptions ())) + * process_mss (mss); + * + * can be used to iterate over all maximal consistent subsets of + * the set of assumptions {a1,a2,a3,a4}. + * + * It could be beneficial to set the default phase of assumptions + * to true (positive). This might speed up the computation. + */ +const int * +picosat_next_maximal_satisfiable_subset_of_assumptions (PicoSAT *); + +/* Similarly we can iterate over all minimal correcting assumption sets. + * See the CAMUS literature [M. Liffiton, K. Sakallah JAR 2008]. + * + * The result contains each assumed literal only once, even if it + * was assumed multiple times (in contrast to the maximal consistent + * subset functions above). + * + * It could be beneficial to set the default phase of assumptions + * to true (positive). This might speed up the computation. + */ +const int * +picosat_next_minimal_correcting_subset_of_assumptions (PicoSAT *); + +/* Compute the union of all minmal correcting sets, which is called + * the 'high level union of all minimal unsatisfiable subset sets' + * or 'HUMUS' in our papers. + * + * It uses 'picosat_next_minimal_correcting_subset_of_assumptions' and + * the same notes and advices apply. In particular, this implies that + * after calling the function once, the current CNF becomes inconsistent, + * and PicoSAT has to be reset. So even this function internally uses + * PicoSAT incrementally, it can not be used incrementally itself at this + * point. + * + * The 'callback' can be used for progress logging and is called after + * each extracted minimal correcting set if non zero. The 'nhumus' + * parameter of 'callback' denotes the number of assumptions found to be + * part of the HUMUS sofar. + */ +const int * +picosat_humus (PicoSAT *, + void (*callback)(void * state, int nmcs, int nhumus), + void * state); + +/*------------------------------------------------------------------------*/ +/* Assume that a previous call to 'picosat_sat' in incremental usage, + * returned 'SATISFIABLE'. Then a couple of clauses and optionally new + * variables were added (a new variable is a variable that has an index + * larger then the maximum variable added so far). The next call to + * 'picosat_sat' also returns 'SATISFIABLE'. If this function + * 'picosat_changed' returns '0', then the assignment to the old variables + * is guaranteed to not have changed. Otherwise it might have changed. + * + * The return value to this function is only valid until new clauses are + * added through 'picosat_add', an assumption is made through + * 'picosat_assume', or again 'picosat_sat' is called. This is the same + * assumption as for 'picosat_deref'. + * + * TODO currently this function might also return a non zero value even if + * the old assignment did not change, because it only checks whether the + * assignment of at least one old variable was flipped at least once during + * the search. In principle it should be possible to be exact in the other + * direction as well by using a counter of variables that have an odd number + * of flips. But this is not implemented yet. + */ +int picosat_changed (PicoSAT *); + +/*------------------------------------------------------------------------*/ +/* The following six functions internally extract the variable and clausal + * core and thus require trace generation to be enabled with + * 'picosat_enable_trace_generation' right after calling 'picosat_init'. + * + * TODO: using these functions in incremental mode with failed assumptions + * has only been tested for 'picosat_corelit' thoroughly. The others + * probably only work in non-incremental mode or without using + * 'picosat_assume'. + */ + +/* This function determines whether the i'th added original clause is in the + * core. The 'i' is the return value of 'picosat_add', which starts at zero + * and is incremented by one after a original clause is added (that is after + * 'picosat_add (0)'). For the index 'i' the following has to hold: + * + * 0 <= i < picosat_added_original_clauses () + */ +int picosat_coreclause (PicoSAT *, int i); + +/* This function gives access to the variable core, which is made up of the + * variables that were resolved in deriving the empty clause. + */ +int picosat_corelit (PicoSAT *, int lit); + +/* Write the clauses that were used in deriving the empty clause to a file + * in DIMACS format. + */ +void picosat_write_clausal_core (PicoSAT *, FILE * core_file); + +/* Write a proof trace in TraceCheck format to a file. + */ +void picosat_write_compact_trace (PicoSAT *, FILE * trace_file); +void picosat_write_extended_trace (PicoSAT *, FILE * trace_file); + +/* Write a RUP trace to a file. This trace file contains only the learned + * core clauses while this is not necessarily the case for the RUP file + * obtained with 'picosat_set_incremental_rup_file'. + */ +void picosat_write_rup_trace (PicoSAT *, FILE * trace_file); + +/*------------------------------------------------------------------------*/ +/* Keeping the proof trace around is not necessary if an over-approximation + * of the core is enough. A literal is 'used' if it was involved in a + * resolution to derive a learned clause. The core literals are necessarily + * a subset of the 'used' literals. + */ + +int picosat_usedlit (PicoSAT *, int lit); +/*------------------------------------------------------------------------*/ +#endif diff --git a/test/monniaux/picosat-965/sudoku.sat b/test/monniaux/picosat-965/sudoku.sat new file mode 100644 index 00000000..23effaed --- /dev/null +++ b/test/monniaux/picosat-965/sudoku.sat @@ -0,0 +1,20519 @@ +c sudoku +p cnf 729 20517 +-1 -2 0 +-1 -3 0 +-1 -4 0 +-1 -5 0 +-1 -6 0 +-1 -7 0 +-1 -8 0 +-1 -9 0 +-2 -1 0 +-2 -3 0 +-2 -4 0 +-2 -5 0 +-2 -6 0 +-2 -7 0 +-2 -8 0 +-2 -9 0 +-3 -1 0 +-3 -2 0 +-3 -4 0 +-3 -5 0 +-3 -6 0 +-3 -7 0 +-3 -8 0 +-3 -9 0 +-4 -1 0 +-4 -2 0 +-4 -3 0 +-4 -5 0 +-4 -6 0 +-4 -7 0 +-4 -8 0 +-4 -9 0 +-5 -1 0 +-5 -2 0 +-5 -3 0 +-5 -4 0 +-5 -6 0 +-5 -7 0 +-5 -8 0 +-5 -9 0 +-6 -1 0 +-6 -2 0 +-6 -3 0 +-6 -4 0 +-6 -5 0 +-6 -7 0 +-6 -8 0 +-6 -9 0 +-7 -1 0 +-7 -2 0 +-7 -3 0 +-7 -4 0 +-7 -5 0 +-7 -6 0 +-7 -8 0 +-7 -9 0 +-8 -1 0 +-8 -2 0 +-8 -3 0 +-8 -4 0 +-8 -5 0 +-8 -6 0 +-8 -7 0 +-8 -9 0 +-9 -1 0 +-9 -2 0 +-9 -3 0 +-9 -4 0 +-9 -5 0 +-9 -6 0 +-9 -7 0 +-9 -8 0 +1 2 3 4 5 6 7 8 9 0 +-10 -11 0 +-10 -12 0 +-10 -13 0 +-10 -14 0 +-10 -15 0 +-10 -16 0 +-10 -17 0 +-10 -18 0 +-11 -10 0 +-11 -12 0 +-11 -13 0 +-11 -14 0 +-11 -15 0 +-11 -16 0 +-11 -17 0 +-11 -18 0 +-12 -10 0 +-12 -11 0 +-12 -13 0 +-12 -14 0 +-12 -15 0 +-12 -16 0 +-12 -17 0 +-12 -18 0 +-13 -10 0 +-13 -11 0 +-13 -12 0 +-13 -14 0 +-13 -15 0 +-13 -16 0 +-13 -17 0 +-13 -18 0 +-14 -10 0 +-14 -11 0 +-14 -12 0 +-14 -13 0 +-14 -15 0 +-14 -16 0 +-14 -17 0 +-14 -18 0 +-15 -10 0 +-15 -11 0 +-15 -12 0 +-15 -13 0 +-15 -14 0 +-15 -16 0 +-15 -17 0 +-15 -18 0 +-16 -10 0 +-16 -11 0 +-16 -12 0 +-16 -13 0 +-16 -14 0 +-16 -15 0 +-16 -17 0 +-16 -18 0 +-17 -10 0 +-17 -11 0 +-17 -12 0 +-17 -13 0 +-17 -14 0 +-17 -15 0 +-17 -16 0 +-17 -18 0 +-18 -10 0 +-18 -11 0 +-18 -12 0 +-18 -13 0 +-18 -14 0 +-18 -15 0 +-18 -16 0 +-18 -17 0 +10 11 12 13 14 15 16 17 18 0 +-19 -20 0 +-19 -21 0 +-19 -22 0 +-19 -23 0 +-19 -24 0 +-19 -25 0 +-19 -26 0 +-19 -27 0 +-20 -19 0 +-20 -21 0 +-20 -22 0 +-20 -23 0 +-20 -24 0 +-20 -25 0 +-20 -26 0 +-20 -27 0 +-21 -19 0 +-21 -20 0 +-21 -22 0 +-21 -23 0 +-21 -24 0 +-21 -25 0 +-21 -26 0 +-21 -27 0 +-22 -19 0 +-22 -20 0 +-22 -21 0 +-22 -23 0 +-22 -24 0 +-22 -25 0 +-22 -26 0 +-22 -27 0 +-23 -19 0 +-23 -20 0 +-23 -21 0 +-23 -22 0 +-23 -24 0 +-23 -25 0 +-23 -26 0 +-23 -27 0 +-24 -19 0 +-24 -20 0 +-24 -21 0 +-24 -22 0 +-24 -23 0 +-24 -25 0 +-24 -26 0 +-24 -27 0 +-25 -19 0 +-25 -20 0 +-25 -21 0 +-25 -22 0 +-25 -23 0 +-25 -24 0 +-25 -26 0 +-25 -27 0 +-26 -19 0 +-26 -20 0 +-26 -21 0 +-26 -22 0 +-26 -23 0 +-26 -24 0 +-26 -25 0 +-26 -27 0 +-27 -19 0 +-27 -20 0 +-27 -21 0 +-27 -22 0 +-27 -23 0 +-27 -24 0 +-27 -25 0 +-27 -26 0 +19 20 21 22 23 24 25 26 27 0 +-28 -29 0 +-28 -30 0 +-28 -31 0 +-28 -32 0 +-28 -33 0 +-28 -34 0 +-28 -35 0 +-28 -36 0 +-29 -28 0 +-29 -30 0 +-29 -31 0 +-29 -32 0 +-29 -33 0 +-29 -34 0 +-29 -35 0 +-29 -36 0 +-30 -28 0 +-30 -29 0 +-30 -31 0 +-30 -32 0 +-30 -33 0 +-30 -34 0 +-30 -35 0 +-30 -36 0 +-31 -28 0 +-31 -29 0 +-31 -30 0 +-31 -32 0 +-31 -33 0 +-31 -34 0 +-31 -35 0 +-31 -36 0 +-32 -28 0 +-32 -29 0 +-32 -30 0 +-32 -31 0 +-32 -33 0 +-32 -34 0 +-32 -35 0 +-32 -36 0 +-33 -28 0 +-33 -29 0 +-33 -30 0 +-33 -31 0 +-33 -32 0 +-33 -34 0 +-33 -35 0 +-33 -36 0 +-34 -28 0 +-34 -29 0 +-34 -30 0 +-34 -31 0 +-34 -32 0 +-34 -33 0 +-34 -35 0 +-34 -36 0 +-35 -28 0 +-35 -29 0 +-35 -30 0 +-35 -31 0 +-35 -32 0 +-35 -33 0 +-35 -34 0 +-35 -36 0 +-36 -28 0 +-36 -29 0 +-36 -30 0 +-36 -31 0 +-36 -32 0 +-36 -33 0 +-36 -34 0 +-36 -35 0 +28 29 30 31 32 33 34 35 36 0 +-37 -38 0 +-37 -39 0 +-37 -40 0 +-37 -41 0 +-37 -42 0 +-37 -43 0 +-37 -44 0 +-37 -45 0 +-38 -37 0 +-38 -39 0 +-38 -40 0 +-38 -41 0 +-38 -42 0 +-38 -43 0 +-38 -44 0 +-38 -45 0 +-39 -37 0 +-39 -38 0 +-39 -40 0 +-39 -41 0 +-39 -42 0 +-39 -43 0 +-39 -44 0 +-39 -45 0 +-40 -37 0 +-40 -38 0 +-40 -39 0 +-40 -41 0 +-40 -42 0 +-40 -43 0 +-40 -44 0 +-40 -45 0 +-41 -37 0 +-41 -38 0 +-41 -39 0 +-41 -40 0 +-41 -42 0 +-41 -43 0 +-41 -44 0 +-41 -45 0 +-42 -37 0 +-42 -38 0 +-42 -39 0 +-42 -40 0 +-42 -41 0 +-42 -43 0 +-42 -44 0 +-42 -45 0 +-43 -37 0 +-43 -38 0 +-43 -39 0 +-43 -40 0 +-43 -41 0 +-43 -42 0 +-43 -44 0 +-43 -45 0 +-44 -37 0 +-44 -38 0 +-44 -39 0 +-44 -40 0 +-44 -41 0 +-44 -42 0 +-44 -43 0 +-44 -45 0 +-45 -37 0 +-45 -38 0 +-45 -39 0 +-45 -40 0 +-45 -41 0 +-45 -42 0 +-45 -43 0 +-45 -44 0 +37 38 39 40 41 42 43 44 45 0 +-46 -47 0 +-46 -48 0 +-46 -49 0 +-46 -50 0 +-46 -51 0 +-46 -52 0 +-46 -53 0 +-46 -54 0 +-47 -46 0 +-47 -48 0 +-47 -49 0 +-47 -50 0 +-47 -51 0 +-47 -52 0 +-47 -53 0 +-47 -54 0 +-48 -46 0 +-48 -47 0 +-48 -49 0 +-48 -50 0 +-48 -51 0 +-48 -52 0 +-48 -53 0 +-48 -54 0 +-49 -46 0 +-49 -47 0 +-49 -48 0 +-49 -50 0 +-49 -51 0 +-49 -52 0 +-49 -53 0 +-49 -54 0 +-50 -46 0 +-50 -47 0 +-50 -48 0 +-50 -49 0 +-50 -51 0 +-50 -52 0 +-50 -53 0 +-50 -54 0 +-51 -46 0 +-51 -47 0 +-51 -48 0 +-51 -49 0 +-51 -50 0 +-51 -52 0 +-51 -53 0 +-51 -54 0 +-52 -46 0 +-52 -47 0 +-52 -48 0 +-52 -49 0 +-52 -50 0 +-52 -51 0 +-52 -53 0 +-52 -54 0 +-53 -46 0 +-53 -47 0 +-53 -48 0 +-53 -49 0 +-53 -50 0 +-53 -51 0 +-53 -52 0 +-53 -54 0 +-54 -46 0 +-54 -47 0 +-54 -48 0 +-54 -49 0 +-54 -50 0 +-54 -51 0 +-54 -52 0 +-54 -53 0 +46 47 48 49 50 51 52 53 54 0 +-55 -56 0 +-55 -57 0 +-55 -58 0 +-55 -59 0 +-55 -60 0 +-55 -61 0 +-55 -62 0 +-55 -63 0 +-56 -55 0 +-56 -57 0 +-56 -58 0 +-56 -59 0 +-56 -60 0 +-56 -61 0 +-56 -62 0 +-56 -63 0 +-57 -55 0 +-57 -56 0 +-57 -58 0 +-57 -59 0 +-57 -60 0 +-57 -61 0 +-57 -62 0 +-57 -63 0 +-58 -55 0 +-58 -56 0 +-58 -57 0 +-58 -59 0 +-58 -60 0 +-58 -61 0 +-58 -62 0 +-58 -63 0 +-59 -55 0 +-59 -56 0 +-59 -57 0 +-59 -58 0 +-59 -60 0 +-59 -61 0 +-59 -62 0 +-59 -63 0 +-60 -55 0 +-60 -56 0 +-60 -57 0 +-60 -58 0 +-60 -59 0 +-60 -61 0 +-60 -62 0 +-60 -63 0 +-61 -55 0 +-61 -56 0 +-61 -57 0 +-61 -58 0 +-61 -59 0 +-61 -60 0 +-61 -62 0 +-61 -63 0 +-62 -55 0 +-62 -56 0 +-62 -57 0 +-62 -58 0 +-62 -59 0 +-62 -60 0 +-62 -61 0 +-62 -63 0 +-63 -55 0 +-63 -56 0 +-63 -57 0 +-63 -58 0 +-63 -59 0 +-63 -60 0 +-63 -61 0 +-63 -62 0 +55 56 57 58 59 60 61 62 63 0 +-64 -65 0 +-64 -66 0 +-64 -67 0 +-64 -68 0 +-64 -69 0 +-64 -70 0 +-64 -71 0 +-64 -72 0 +-65 -64 0 +-65 -66 0 +-65 -67 0 +-65 -68 0 +-65 -69 0 +-65 -70 0 +-65 -71 0 +-65 -72 0 +-66 -64 0 +-66 -65 0 +-66 -67 0 +-66 -68 0 +-66 -69 0 +-66 -70 0 +-66 -71 0 +-66 -72 0 +-67 -64 0 +-67 -65 0 +-67 -66 0 +-67 -68 0 +-67 -69 0 +-67 -70 0 +-67 -71 0 +-67 -72 0 +-68 -64 0 +-68 -65 0 +-68 -66 0 +-68 -67 0 +-68 -69 0 +-68 -70 0 +-68 -71 0 +-68 -72 0 +-69 -64 0 +-69 -65 0 +-69 -66 0 +-69 -67 0 +-69 -68 0 +-69 -70 0 +-69 -71 0 +-69 -72 0 +-70 -64 0 +-70 -65 0 +-70 -66 0 +-70 -67 0 +-70 -68 0 +-70 -69 0 +-70 -71 0 +-70 -72 0 +-71 -64 0 +-71 -65 0 +-71 -66 0 +-71 -67 0 +-71 -68 0 +-71 -69 0 +-71 -70 0 +-71 -72 0 +-72 -64 0 +-72 -65 0 +-72 -66 0 +-72 -67 0 +-72 -68 0 +-72 -69 0 +-72 -70 0 +-72 -71 0 +64 65 66 67 68 69 70 71 72 0 +-73 -74 0 +-73 -75 0 +-73 -76 0 +-73 -77 0 +-73 -78 0 +-73 -79 0 +-73 -80 0 +-73 -81 0 +-74 -73 0 +-74 -75 0 +-74 -76 0 +-74 -77 0 +-74 -78 0 +-74 -79 0 +-74 -80 0 +-74 -81 0 +-75 -73 0 +-75 -74 0 +-75 -76 0 +-75 -77 0 +-75 -78 0 +-75 -79 0 +-75 -80 0 +-75 -81 0 +-76 -73 0 +-76 -74 0 +-76 -75 0 +-76 -77 0 +-76 -78 0 +-76 -79 0 +-76 -80 0 +-76 -81 0 +-77 -73 0 +-77 -74 0 +-77 -75 0 +-77 -76 0 +-77 -78 0 +-77 -79 0 +-77 -80 0 +-77 -81 0 +-78 -73 0 +-78 -74 0 +-78 -75 0 +-78 -76 0 +-78 -77 0 +-78 -79 0 +-78 -80 0 +-78 -81 0 +-79 -73 0 +-79 -74 0 +-79 -75 0 +-79 -76 0 +-79 -77 0 +-79 -78 0 +-79 -80 0 +-79 -81 0 +-80 -73 0 +-80 -74 0 +-80 -75 0 +-80 -76 0 +-80 -77 0 +-80 -78 0 +-80 -79 0 +-80 -81 0 +-81 -73 0 +-81 -74 0 +-81 -75 0 +-81 -76 0 +-81 -77 0 +-81 -78 0 +-81 -79 0 +-81 -80 0 +73 74 75 76 77 78 79 80 81 0 +-82 -83 0 +-82 -84 0 +-82 -85 0 +-82 -86 0 +-82 -87 0 +-82 -88 0 +-82 -89 0 +-82 -90 0 +-83 -82 0 +-83 -84 0 +-83 -85 0 +-83 -86 0 +-83 -87 0 +-83 -88 0 +-83 -89 0 +-83 -90 0 +-84 -82 0 +-84 -83 0 +-84 -85 0 +-84 -86 0 +-84 -87 0 +-84 -88 0 +-84 -89 0 +-84 -90 0 +-85 -82 0 +-85 -83 0 +-85 -84 0 +-85 -86 0 +-85 -87 0 +-85 -88 0 +-85 -89 0 +-85 -90 0 +-86 -82 0 +-86 -83 0 +-86 -84 0 +-86 -85 0 +-86 -87 0 +-86 -88 0 +-86 -89 0 +-86 -90 0 +-87 -82 0 +-87 -83 0 +-87 -84 0 +-87 -85 0 +-87 -86 0 +-87 -88 0 +-87 -89 0 +-87 -90 0 +-88 -82 0 +-88 -83 0 +-88 -84 0 +-88 -85 0 +-88 -86 0 +-88 -87 0 +-88 -89 0 +-88 -90 0 +-89 -82 0 +-89 -83 0 +-89 -84 0 +-89 -85 0 +-89 -86 0 +-89 -87 0 +-89 -88 0 +-89 -90 0 +-90 -82 0 +-90 -83 0 +-90 -84 0 +-90 -85 0 +-90 -86 0 +-90 -87 0 +-90 -88 0 +-90 -89 0 +82 83 84 85 86 87 88 89 90 0 +-91 -92 0 +-91 -93 0 +-91 -94 0 +-91 -95 0 +-91 -96 0 +-91 -97 0 +-91 -98 0 +-91 -99 0 +-92 -91 0 +-92 -93 0 +-92 -94 0 +-92 -95 0 +-92 -96 0 +-92 -97 0 +-92 -98 0 +-92 -99 0 +-93 -91 0 +-93 -92 0 +-93 -94 0 +-93 -95 0 +-93 -96 0 +-93 -97 0 +-93 -98 0 +-93 -99 0 +-94 -91 0 +-94 -92 0 +-94 -93 0 +-94 -95 0 +-94 -96 0 +-94 -97 0 +-94 -98 0 +-94 -99 0 +-95 -91 0 +-95 -92 0 +-95 -93 0 +-95 -94 0 +-95 -96 0 +-95 -97 0 +-95 -98 0 +-95 -99 0 +-96 -91 0 +-96 -92 0 +-96 -93 0 +-96 -94 0 +-96 -95 0 +-96 -97 0 +-96 -98 0 +-96 -99 0 +-97 -91 0 +-97 -92 0 +-97 -93 0 +-97 -94 0 +-97 -95 0 +-97 -96 0 +-97 -98 0 +-97 -99 0 +-98 -91 0 +-98 -92 0 +-98 -93 0 +-98 -94 0 +-98 -95 0 +-98 -96 0 +-98 -97 0 +-98 -99 0 +-99 -91 0 +-99 -92 0 +-99 -93 0 +-99 -94 0 +-99 -95 0 +-99 -96 0 +-99 -97 0 +-99 -98 0 +91 92 93 94 95 96 97 98 99 0 +-100 -101 0 +-100 -102 0 +-100 -103 0 +-100 -104 0 +-100 -105 0 +-100 -106 0 +-100 -107 0 +-100 -108 0 +-101 -100 0 +-101 -102 0 +-101 -103 0 +-101 -104 0 +-101 -105 0 +-101 -106 0 +-101 -107 0 +-101 -108 0 +-102 -100 0 +-102 -101 0 +-102 -103 0 +-102 -104 0 +-102 -105 0 +-102 -106 0 +-102 -107 0 +-102 -108 0 +-103 -100 0 +-103 -101 0 +-103 -102 0 +-103 -104 0 +-103 -105 0 +-103 -106 0 +-103 -107 0 +-103 -108 0 +-104 -100 0 +-104 -101 0 +-104 -102 0 +-104 -103 0 +-104 -105 0 +-104 -106 0 +-104 -107 0 +-104 -108 0 +-105 -100 0 +-105 -101 0 +-105 -102 0 +-105 -103 0 +-105 -104 0 +-105 -106 0 +-105 -107 0 +-105 -108 0 +-106 -100 0 +-106 -101 0 +-106 -102 0 +-106 -103 0 +-106 -104 0 +-106 -105 0 +-106 -107 0 +-106 -108 0 +-107 -100 0 +-107 -101 0 +-107 -102 0 +-107 -103 0 +-107 -104 0 +-107 -105 0 +-107 -106 0 +-107 -108 0 +-108 -100 0 +-108 -101 0 +-108 -102 0 +-108 -103 0 +-108 -104 0 +-108 -105 0 +-108 -106 0 +-108 -107 0 +100 101 102 103 104 105 106 107 108 0 +-109 -110 0 +-109 -111 0 +-109 -112 0 +-109 -113 0 +-109 -114 0 +-109 -115 0 +-109 -116 0 +-109 -117 0 +-110 -109 0 +-110 -111 0 +-110 -112 0 +-110 -113 0 +-110 -114 0 +-110 -115 0 +-110 -116 0 +-110 -117 0 +-111 -109 0 +-111 -110 0 +-111 -112 0 +-111 -113 0 +-111 -114 0 +-111 -115 0 +-111 -116 0 +-111 -117 0 +-112 -109 0 +-112 -110 0 +-112 -111 0 +-112 -113 0 +-112 -114 0 +-112 -115 0 +-112 -116 0 +-112 -117 0 +-113 -109 0 +-113 -110 0 +-113 -111 0 +-113 -112 0 +-113 -114 0 +-113 -115 0 +-113 -116 0 +-113 -117 0 +-114 -109 0 +-114 -110 0 +-114 -111 0 +-114 -112 0 +-114 -113 0 +-114 -115 0 +-114 -116 0 +-114 -117 0 +-115 -109 0 +-115 -110 0 +-115 -111 0 +-115 -112 0 +-115 -113 0 +-115 -114 0 +-115 -116 0 +-115 -117 0 +-116 -109 0 +-116 -110 0 +-116 -111 0 +-116 -112 0 +-116 -113 0 +-116 -114 0 +-116 -115 0 +-116 -117 0 +-117 -109 0 +-117 -110 0 +-117 -111 0 +-117 -112 0 +-117 -113 0 +-117 -114 0 +-117 -115 0 +-117 -116 0 +109 110 111 112 113 114 115 116 117 0 +-118 -119 0 +-118 -120 0 +-118 -121 0 +-118 -122 0 +-118 -123 0 +-118 -124 0 +-118 -125 0 +-118 -126 0 +-119 -118 0 +-119 -120 0 +-119 -121 0 +-119 -122 0 +-119 -123 0 +-119 -124 0 +-119 -125 0 +-119 -126 0 +-120 -118 0 +-120 -119 0 +-120 -121 0 +-120 -122 0 +-120 -123 0 +-120 -124 0 +-120 -125 0 +-120 -126 0 +-121 -118 0 +-121 -119 0 +-121 -120 0 +-121 -122 0 +-121 -123 0 +-121 -124 0 +-121 -125 0 +-121 -126 0 +-122 -118 0 +-122 -119 0 +-122 -120 0 +-122 -121 0 +-122 -123 0 +-122 -124 0 +-122 -125 0 +-122 -126 0 +-123 -118 0 +-123 -119 0 +-123 -120 0 +-123 -121 0 +-123 -122 0 +-123 -124 0 +-123 -125 0 +-123 -126 0 +-124 -118 0 +-124 -119 0 +-124 -120 0 +-124 -121 0 +-124 -122 0 +-124 -123 0 +-124 -125 0 +-124 -126 0 +-125 -118 0 +-125 -119 0 +-125 -120 0 +-125 -121 0 +-125 -122 0 +-125 -123 0 +-125 -124 0 +-125 -126 0 +-126 -118 0 +-126 -119 0 +-126 -120 0 +-126 -121 0 +-126 -122 0 +-126 -123 0 +-126 -124 0 +-126 -125 0 +118 119 120 121 122 123 124 125 126 0 +-127 -128 0 +-127 -129 0 +-127 -130 0 +-127 -131 0 +-127 -132 0 +-127 -133 0 +-127 -134 0 +-127 -135 0 +-128 -127 0 +-128 -129 0 +-128 -130 0 +-128 -131 0 +-128 -132 0 +-128 -133 0 +-128 -134 0 +-128 -135 0 +-129 -127 0 +-129 -128 0 +-129 -130 0 +-129 -131 0 +-129 -132 0 +-129 -133 0 +-129 -134 0 +-129 -135 0 +-130 -127 0 +-130 -128 0 +-130 -129 0 +-130 -131 0 +-130 -132 0 +-130 -133 0 +-130 -134 0 +-130 -135 0 +-131 -127 0 +-131 -128 0 +-131 -129 0 +-131 -130 0 +-131 -132 0 +-131 -133 0 +-131 -134 0 +-131 -135 0 +-132 -127 0 +-132 -128 0 +-132 -129 0 +-132 -130 0 +-132 -131 0 +-132 -133 0 +-132 -134 0 +-132 -135 0 +-133 -127 0 +-133 -128 0 +-133 -129 0 +-133 -130 0 +-133 -131 0 +-133 -132 0 +-133 -134 0 +-133 -135 0 +-134 -127 0 +-134 -128 0 +-134 -129 0 +-134 -130 0 +-134 -131 0 +-134 -132 0 +-134 -133 0 +-134 -135 0 +-135 -127 0 +-135 -128 0 +-135 -129 0 +-135 -130 0 +-135 -131 0 +-135 -132 0 +-135 -133 0 +-135 -134 0 +127 128 129 130 131 132 133 134 135 0 +-136 -137 0 +-136 -138 0 +-136 -139 0 +-136 -140 0 +-136 -141 0 +-136 -142 0 +-136 -143 0 +-136 -144 0 +-137 -136 0 +-137 -138 0 +-137 -139 0 +-137 -140 0 +-137 -141 0 +-137 -142 0 +-137 -143 0 +-137 -144 0 +-138 -136 0 +-138 -137 0 +-138 -139 0 +-138 -140 0 +-138 -141 0 +-138 -142 0 +-138 -143 0 +-138 -144 0 +-139 -136 0 +-139 -137 0 +-139 -138 0 +-139 -140 0 +-139 -141 0 +-139 -142 0 +-139 -143 0 +-139 -144 0 +-140 -136 0 +-140 -137 0 +-140 -138 0 +-140 -139 0 +-140 -141 0 +-140 -142 0 +-140 -143 0 +-140 -144 0 +-141 -136 0 +-141 -137 0 +-141 -138 0 +-141 -139 0 +-141 -140 0 +-141 -142 0 +-141 -143 0 +-141 -144 0 +-142 -136 0 +-142 -137 0 +-142 -138 0 +-142 -139 0 +-142 -140 0 +-142 -141 0 +-142 -143 0 +-142 -144 0 +-143 -136 0 +-143 -137 0 +-143 -138 0 +-143 -139 0 +-143 -140 0 +-143 -141 0 +-143 -142 0 +-143 -144 0 +-144 -136 0 +-144 -137 0 +-144 -138 0 +-144 -139 0 +-144 -140 0 +-144 -141 0 +-144 -142 0 +-144 -143 0 +136 137 138 139 140 141 142 143 144 0 +-145 -146 0 +-145 -147 0 +-145 -148 0 +-145 -149 0 +-145 -150 0 +-145 -151 0 +-145 -152 0 +-145 -153 0 +-146 -145 0 +-146 -147 0 +-146 -148 0 +-146 -149 0 +-146 -150 0 +-146 -151 0 +-146 -152 0 +-146 -153 0 +-147 -145 0 +-147 -146 0 +-147 -148 0 +-147 -149 0 +-147 -150 0 +-147 -151 0 +-147 -152 0 +-147 -153 0 +-148 -145 0 +-148 -146 0 +-148 -147 0 +-148 -149 0 +-148 -150 0 +-148 -151 0 +-148 -152 0 +-148 -153 0 +-149 -145 0 +-149 -146 0 +-149 -147 0 +-149 -148 0 +-149 -150 0 +-149 -151 0 +-149 -152 0 +-149 -153 0 +-150 -145 0 +-150 -146 0 +-150 -147 0 +-150 -148 0 +-150 -149 0 +-150 -151 0 +-150 -152 0 +-150 -153 0 +-151 -145 0 +-151 -146 0 +-151 -147 0 +-151 -148 0 +-151 -149 0 +-151 -150 0 +-151 -152 0 +-151 -153 0 +-152 -145 0 +-152 -146 0 +-152 -147 0 +-152 -148 0 +-152 -149 0 +-152 -150 0 +-152 -151 0 +-152 -153 0 +-153 -145 0 +-153 -146 0 +-153 -147 0 +-153 -148 0 +-153 -149 0 +-153 -150 0 +-153 -151 0 +-153 -152 0 +145 146 147 148 149 150 151 152 153 0 +-154 -155 0 +-154 -156 0 +-154 -157 0 +-154 -158 0 +-154 -159 0 +-154 -160 0 +-154 -161 0 +-154 -162 0 +-155 -154 0 +-155 -156 0 +-155 -157 0 +-155 -158 0 +-155 -159 0 +-155 -160 0 +-155 -161 0 +-155 -162 0 +-156 -154 0 +-156 -155 0 +-156 -157 0 +-156 -158 0 +-156 -159 0 +-156 -160 0 +-156 -161 0 +-156 -162 0 +-157 -154 0 +-157 -155 0 +-157 -156 0 +-157 -158 0 +-157 -159 0 +-157 -160 0 +-157 -161 0 +-157 -162 0 +-158 -154 0 +-158 -155 0 +-158 -156 0 +-158 -157 0 +-158 -159 0 +-158 -160 0 +-158 -161 0 +-158 -162 0 +-159 -154 0 +-159 -155 0 +-159 -156 0 +-159 -157 0 +-159 -158 0 +-159 -160 0 +-159 -161 0 +-159 -162 0 +-160 -154 0 +-160 -155 0 +-160 -156 0 +-160 -157 0 +-160 -158 0 +-160 -159 0 +-160 -161 0 +-160 -162 0 +-161 -154 0 +-161 -155 0 +-161 -156 0 +-161 -157 0 +-161 -158 0 +-161 -159 0 +-161 -160 0 +-161 -162 0 +-162 -154 0 +-162 -155 0 +-162 -156 0 +-162 -157 0 +-162 -158 0 +-162 -159 0 +-162 -160 0 +-162 -161 0 +154 155 156 157 158 159 160 161 162 0 +-163 -164 0 +-163 -165 0 +-163 -166 0 +-163 -167 0 +-163 -168 0 +-163 -169 0 +-163 -170 0 +-163 -171 0 +-164 -163 0 +-164 -165 0 +-164 -166 0 +-164 -167 0 +-164 -168 0 +-164 -169 0 +-164 -170 0 +-164 -171 0 +-165 -163 0 +-165 -164 0 +-165 -166 0 +-165 -167 0 +-165 -168 0 +-165 -169 0 +-165 -170 0 +-165 -171 0 +-166 -163 0 +-166 -164 0 +-166 -165 0 +-166 -167 0 +-166 -168 0 +-166 -169 0 +-166 -170 0 +-166 -171 0 +-167 -163 0 +-167 -164 0 +-167 -165 0 +-167 -166 0 +-167 -168 0 +-167 -169 0 +-167 -170 0 +-167 -171 0 +-168 -163 0 +-168 -164 0 +-168 -165 0 +-168 -166 0 +-168 -167 0 +-168 -169 0 +-168 -170 0 +-168 -171 0 +-169 -163 0 +-169 -164 0 +-169 -165 0 +-169 -166 0 +-169 -167 0 +-169 -168 0 +-169 -170 0 +-169 -171 0 +-170 -163 0 +-170 -164 0 +-170 -165 0 +-170 -166 0 +-170 -167 0 +-170 -168 0 +-170 -169 0 +-170 -171 0 +-171 -163 0 +-171 -164 0 +-171 -165 0 +-171 -166 0 +-171 -167 0 +-171 -168 0 +-171 -169 0 +-171 -170 0 +163 164 165 166 167 168 169 170 171 0 +-172 -173 0 +-172 -174 0 +-172 -175 0 +-172 -176 0 +-172 -177 0 +-172 -178 0 +-172 -179 0 +-172 -180 0 +-173 -172 0 +-173 -174 0 +-173 -175 0 +-173 -176 0 +-173 -177 0 +-173 -178 0 +-173 -179 0 +-173 -180 0 +-174 -172 0 +-174 -173 0 +-174 -175 0 +-174 -176 0 +-174 -177 0 +-174 -178 0 +-174 -179 0 +-174 -180 0 +-175 -172 0 +-175 -173 0 +-175 -174 0 +-175 -176 0 +-175 -177 0 +-175 -178 0 +-175 -179 0 +-175 -180 0 +-176 -172 0 +-176 -173 0 +-176 -174 0 +-176 -175 0 +-176 -177 0 +-176 -178 0 +-176 -179 0 +-176 -180 0 +-177 -172 0 +-177 -173 0 +-177 -174 0 +-177 -175 0 +-177 -176 0 +-177 -178 0 +-177 -179 0 +-177 -180 0 +-178 -172 0 +-178 -173 0 +-178 -174 0 +-178 -175 0 +-178 -176 0 +-178 -177 0 +-178 -179 0 +-178 -180 0 +-179 -172 0 +-179 -173 0 +-179 -174 0 +-179 -175 0 +-179 -176 0 +-179 -177 0 +-179 -178 0 +-179 -180 0 +-180 -172 0 +-180 -173 0 +-180 -174 0 +-180 -175 0 +-180 -176 0 +-180 -177 0 +-180 -178 0 +-180 -179 0 +172 173 174 175 176 177 178 179 180 0 +-181 -182 0 +-181 -183 0 +-181 -184 0 +-181 -185 0 +-181 -186 0 +-181 -187 0 +-181 -188 0 +-181 -189 0 +-182 -181 0 +-182 -183 0 +-182 -184 0 +-182 -185 0 +-182 -186 0 +-182 -187 0 +-182 -188 0 +-182 -189 0 +-183 -181 0 +-183 -182 0 +-183 -184 0 +-183 -185 0 +-183 -186 0 +-183 -187 0 +-183 -188 0 +-183 -189 0 +-184 -181 0 +-184 -182 0 +-184 -183 0 +-184 -185 0 +-184 -186 0 +-184 -187 0 +-184 -188 0 +-184 -189 0 +-185 -181 0 +-185 -182 0 +-185 -183 0 +-185 -184 0 +-185 -186 0 +-185 -187 0 +-185 -188 0 +-185 -189 0 +-186 -181 0 +-186 -182 0 +-186 -183 0 +-186 -184 0 +-186 -185 0 +-186 -187 0 +-186 -188 0 +-186 -189 0 +-187 -181 0 +-187 -182 0 +-187 -183 0 +-187 -184 0 +-187 -185 0 +-187 -186 0 +-187 -188 0 +-187 -189 0 +-188 -181 0 +-188 -182 0 +-188 -183 0 +-188 -184 0 +-188 -185 0 +-188 -186 0 +-188 -187 0 +-188 -189 0 +-189 -181 0 +-189 -182 0 +-189 -183 0 +-189 -184 0 +-189 -185 0 +-189 -186 0 +-189 -187 0 +-189 -188 0 +181 182 183 184 185 186 187 188 189 0 +-190 -191 0 +-190 -192 0 +-190 -193 0 +-190 -194 0 +-190 -195 0 +-190 -196 0 +-190 -197 0 +-190 -198 0 +-191 -190 0 +-191 -192 0 +-191 -193 0 +-191 -194 0 +-191 -195 0 +-191 -196 0 +-191 -197 0 +-191 -198 0 +-192 -190 0 +-192 -191 0 +-192 -193 0 +-192 -194 0 +-192 -195 0 +-192 -196 0 +-192 -197 0 +-192 -198 0 +-193 -190 0 +-193 -191 0 +-193 -192 0 +-193 -194 0 +-193 -195 0 +-193 -196 0 +-193 -197 0 +-193 -198 0 +-194 -190 0 +-194 -191 0 +-194 -192 0 +-194 -193 0 +-194 -195 0 +-194 -196 0 +-194 -197 0 +-194 -198 0 +-195 -190 0 +-195 -191 0 +-195 -192 0 +-195 -193 0 +-195 -194 0 +-195 -196 0 +-195 -197 0 +-195 -198 0 +-196 -190 0 +-196 -191 0 +-196 -192 0 +-196 -193 0 +-196 -194 0 +-196 -195 0 +-196 -197 0 +-196 -198 0 +-197 -190 0 +-197 -191 0 +-197 -192 0 +-197 -193 0 +-197 -194 0 +-197 -195 0 +-197 -196 0 +-197 -198 0 +-198 -190 0 +-198 -191 0 +-198 -192 0 +-198 -193 0 +-198 -194 0 +-198 -195 0 +-198 -196 0 +-198 -197 0 +190 191 192 193 194 195 196 197 198 0 +-199 -200 0 +-199 -201 0 +-199 -202 0 +-199 -203 0 +-199 -204 0 +-199 -205 0 +-199 -206 0 +-199 -207 0 +-200 -199 0 +-200 -201 0 +-200 -202 0 +-200 -203 0 +-200 -204 0 +-200 -205 0 +-200 -206 0 +-200 -207 0 +-201 -199 0 +-201 -200 0 +-201 -202 0 +-201 -203 0 +-201 -204 0 +-201 -205 0 +-201 -206 0 +-201 -207 0 +-202 -199 0 +-202 -200 0 +-202 -201 0 +-202 -203 0 +-202 -204 0 +-202 -205 0 +-202 -206 0 +-202 -207 0 +-203 -199 0 +-203 -200 0 +-203 -201 0 +-203 -202 0 +-203 -204 0 +-203 -205 0 +-203 -206 0 +-203 -207 0 +-204 -199 0 +-204 -200 0 +-204 -201 0 +-204 -202 0 +-204 -203 0 +-204 -205 0 +-204 -206 0 +-204 -207 0 +-205 -199 0 +-205 -200 0 +-205 -201 0 +-205 -202 0 +-205 -203 0 +-205 -204 0 +-205 -206 0 +-205 -207 0 +-206 -199 0 +-206 -200 0 +-206 -201 0 +-206 -202 0 +-206 -203 0 +-206 -204 0 +-206 -205 0 +-206 -207 0 +-207 -199 0 +-207 -200 0 +-207 -201 0 +-207 -202 0 +-207 -203 0 +-207 -204 0 +-207 -205 0 +-207 -206 0 +199 200 201 202 203 204 205 206 207 0 +-208 -209 0 +-208 -210 0 +-208 -211 0 +-208 -212 0 +-208 -213 0 +-208 -214 0 +-208 -215 0 +-208 -216 0 +-209 -208 0 +-209 -210 0 +-209 -211 0 +-209 -212 0 +-209 -213 0 +-209 -214 0 +-209 -215 0 +-209 -216 0 +-210 -208 0 +-210 -209 0 +-210 -211 0 +-210 -212 0 +-210 -213 0 +-210 -214 0 +-210 -215 0 +-210 -216 0 +-211 -208 0 +-211 -209 0 +-211 -210 0 +-211 -212 0 +-211 -213 0 +-211 -214 0 +-211 -215 0 +-211 -216 0 +-212 -208 0 +-212 -209 0 +-212 -210 0 +-212 -211 0 +-212 -213 0 +-212 -214 0 +-212 -215 0 +-212 -216 0 +-213 -208 0 +-213 -209 0 +-213 -210 0 +-213 -211 0 +-213 -212 0 +-213 -214 0 +-213 -215 0 +-213 -216 0 +-214 -208 0 +-214 -209 0 +-214 -210 0 +-214 -211 0 +-214 -212 0 +-214 -213 0 +-214 -215 0 +-214 -216 0 +-215 -208 0 +-215 -209 0 +-215 -210 0 +-215 -211 0 +-215 -212 0 +-215 -213 0 +-215 -214 0 +-215 -216 0 +-216 -208 0 +-216 -209 0 +-216 -210 0 +-216 -211 0 +-216 -212 0 +-216 -213 0 +-216 -214 0 +-216 -215 0 +208 209 210 211 212 213 214 215 216 0 +-217 -218 0 +-217 -219 0 +-217 -220 0 +-217 -221 0 +-217 -222 0 +-217 -223 0 +-217 -224 0 +-217 -225 0 +-218 -217 0 +-218 -219 0 +-218 -220 0 +-218 -221 0 +-218 -222 0 +-218 -223 0 +-218 -224 0 +-218 -225 0 +-219 -217 0 +-219 -218 0 +-219 -220 0 +-219 -221 0 +-219 -222 0 +-219 -223 0 +-219 -224 0 +-219 -225 0 +-220 -217 0 +-220 -218 0 +-220 -219 0 +-220 -221 0 +-220 -222 0 +-220 -223 0 +-220 -224 0 +-220 -225 0 +-221 -217 0 +-221 -218 0 +-221 -219 0 +-221 -220 0 +-221 -222 0 +-221 -223 0 +-221 -224 0 +-221 -225 0 +-222 -217 0 +-222 -218 0 +-222 -219 0 +-222 -220 0 +-222 -221 0 +-222 -223 0 +-222 -224 0 +-222 -225 0 +-223 -217 0 +-223 -218 0 +-223 -219 0 +-223 -220 0 +-223 -221 0 +-223 -222 0 +-223 -224 0 +-223 -225 0 +-224 -217 0 +-224 -218 0 +-224 -219 0 +-224 -220 0 +-224 -221 0 +-224 -222 0 +-224 -223 0 +-224 -225 0 +-225 -217 0 +-225 -218 0 +-225 -219 0 +-225 -220 0 +-225 -221 0 +-225 -222 0 +-225 -223 0 +-225 -224 0 +217 218 219 220 221 222 223 224 225 0 +-226 -227 0 +-226 -228 0 +-226 -229 0 +-226 -230 0 +-226 -231 0 +-226 -232 0 +-226 -233 0 +-226 -234 0 +-227 -226 0 +-227 -228 0 +-227 -229 0 +-227 -230 0 +-227 -231 0 +-227 -232 0 +-227 -233 0 +-227 -234 0 +-228 -226 0 +-228 -227 0 +-228 -229 0 +-228 -230 0 +-228 -231 0 +-228 -232 0 +-228 -233 0 +-228 -234 0 +-229 -226 0 +-229 -227 0 +-229 -228 0 +-229 -230 0 +-229 -231 0 +-229 -232 0 +-229 -233 0 +-229 -234 0 +-230 -226 0 +-230 -227 0 +-230 -228 0 +-230 -229 0 +-230 -231 0 +-230 -232 0 +-230 -233 0 +-230 -234 0 +-231 -226 0 +-231 -227 0 +-231 -228 0 +-231 -229 0 +-231 -230 0 +-231 -232 0 +-231 -233 0 +-231 -234 0 +-232 -226 0 +-232 -227 0 +-232 -228 0 +-232 -229 0 +-232 -230 0 +-232 -231 0 +-232 -233 0 +-232 -234 0 +-233 -226 0 +-233 -227 0 +-233 -228 0 +-233 -229 0 +-233 -230 0 +-233 -231 0 +-233 -232 0 +-233 -234 0 +-234 -226 0 +-234 -227 0 +-234 -228 0 +-234 -229 0 +-234 -230 0 +-234 -231 0 +-234 -232 0 +-234 -233 0 +226 227 228 229 230 231 232 233 234 0 +-235 -236 0 +-235 -237 0 +-235 -238 0 +-235 -239 0 +-235 -240 0 +-235 -241 0 +-235 -242 0 +-235 -243 0 +-236 -235 0 +-236 -237 0 +-236 -238 0 +-236 -239 0 +-236 -240 0 +-236 -241 0 +-236 -242 0 +-236 -243 0 +-237 -235 0 +-237 -236 0 +-237 -238 0 +-237 -239 0 +-237 -240 0 +-237 -241 0 +-237 -242 0 +-237 -243 0 +-238 -235 0 +-238 -236 0 +-238 -237 0 +-238 -239 0 +-238 -240 0 +-238 -241 0 +-238 -242 0 +-238 -243 0 +-239 -235 0 +-239 -236 0 +-239 -237 0 +-239 -238 0 +-239 -240 0 +-239 -241 0 +-239 -242 0 +-239 -243 0 +-240 -235 0 +-240 -236 0 +-240 -237 0 +-240 -238 0 +-240 -239 0 +-240 -241 0 +-240 -242 0 +-240 -243 0 +-241 -235 0 +-241 -236 0 +-241 -237 0 +-241 -238 0 +-241 -239 0 +-241 -240 0 +-241 -242 0 +-241 -243 0 +-242 -235 0 +-242 -236 0 +-242 -237 0 +-242 -238 0 +-242 -239 0 +-242 -240 0 +-242 -241 0 +-242 -243 0 +-243 -235 0 +-243 -236 0 +-243 -237 0 +-243 -238 0 +-243 -239 0 +-243 -240 0 +-243 -241 0 +-243 -242 0 +235 236 237 238 239 240 241 242 243 0 +-244 -245 0 +-244 -246 0 +-244 -247 0 +-244 -248 0 +-244 -249 0 +-244 -250 0 +-244 -251 0 +-244 -252 0 +-245 -244 0 +-245 -246 0 +-245 -247 0 +-245 -248 0 +-245 -249 0 +-245 -250 0 +-245 -251 0 +-245 -252 0 +-246 -244 0 +-246 -245 0 +-246 -247 0 +-246 -248 0 +-246 -249 0 +-246 -250 0 +-246 -251 0 +-246 -252 0 +-247 -244 0 +-247 -245 0 +-247 -246 0 +-247 -248 0 +-247 -249 0 +-247 -250 0 +-247 -251 0 +-247 -252 0 +-248 -244 0 +-248 -245 0 +-248 -246 0 +-248 -247 0 +-248 -249 0 +-248 -250 0 +-248 -251 0 +-248 -252 0 +-249 -244 0 +-249 -245 0 +-249 -246 0 +-249 -247 0 +-249 -248 0 +-249 -250 0 +-249 -251 0 +-249 -252 0 +-250 -244 0 +-250 -245 0 +-250 -246 0 +-250 -247 0 +-250 -248 0 +-250 -249 0 +-250 -251 0 +-250 -252 0 +-251 -244 0 +-251 -245 0 +-251 -246 0 +-251 -247 0 +-251 -248 0 +-251 -249 0 +-251 -250 0 +-251 -252 0 +-252 -244 0 +-252 -245 0 +-252 -246 0 +-252 -247 0 +-252 -248 0 +-252 -249 0 +-252 -250 0 +-252 -251 0 +244 245 246 247 248 249 250 251 252 0 +-253 -254 0 +-253 -255 0 +-253 -256 0 +-253 -257 0 +-253 -258 0 +-253 -259 0 +-253 -260 0 +-253 -261 0 +-254 -253 0 +-254 -255 0 +-254 -256 0 +-254 -257 0 +-254 -258 0 +-254 -259 0 +-254 -260 0 +-254 -261 0 +-255 -253 0 +-255 -254 0 +-255 -256 0 +-255 -257 0 +-255 -258 0 +-255 -259 0 +-255 -260 0 +-255 -261 0 +-256 -253 0 +-256 -254 0 +-256 -255 0 +-256 -257 0 +-256 -258 0 +-256 -259 0 +-256 -260 0 +-256 -261 0 +-257 -253 0 +-257 -254 0 +-257 -255 0 +-257 -256 0 +-257 -258 0 +-257 -259 0 +-257 -260 0 +-257 -261 0 +-258 -253 0 +-258 -254 0 +-258 -255 0 +-258 -256 0 +-258 -257 0 +-258 -259 0 +-258 -260 0 +-258 -261 0 +-259 -253 0 +-259 -254 0 +-259 -255 0 +-259 -256 0 +-259 -257 0 +-259 -258 0 +-259 -260 0 +-259 -261 0 +-260 -253 0 +-260 -254 0 +-260 -255 0 +-260 -256 0 +-260 -257 0 +-260 -258 0 +-260 -259 0 +-260 -261 0 +-261 -253 0 +-261 -254 0 +-261 -255 0 +-261 -256 0 +-261 -257 0 +-261 -258 0 +-261 -259 0 +-261 -260 0 +253 254 255 256 257 258 259 260 261 0 +-262 -263 0 +-262 -264 0 +-262 -265 0 +-262 -266 0 +-262 -267 0 +-262 -268 0 +-262 -269 0 +-262 -270 0 +-263 -262 0 +-263 -264 0 +-263 -265 0 +-263 -266 0 +-263 -267 0 +-263 -268 0 +-263 -269 0 +-263 -270 0 +-264 -262 0 +-264 -263 0 +-264 -265 0 +-264 -266 0 +-264 -267 0 +-264 -268 0 +-264 -269 0 +-264 -270 0 +-265 -262 0 +-265 -263 0 +-265 -264 0 +-265 -266 0 +-265 -267 0 +-265 -268 0 +-265 -269 0 +-265 -270 0 +-266 -262 0 +-266 -263 0 +-266 -264 0 +-266 -265 0 +-266 -267 0 +-266 -268 0 +-266 -269 0 +-266 -270 0 +-267 -262 0 +-267 -263 0 +-267 -264 0 +-267 -265 0 +-267 -266 0 +-267 -268 0 +-267 -269 0 +-267 -270 0 +-268 -262 0 +-268 -263 0 +-268 -264 0 +-268 -265 0 +-268 -266 0 +-268 -267 0 +-268 -269 0 +-268 -270 0 +-269 -262 0 +-269 -263 0 +-269 -264 0 +-269 -265 0 +-269 -266 0 +-269 -267 0 +-269 -268 0 +-269 -270 0 +-270 -262 0 +-270 -263 0 +-270 -264 0 +-270 -265 0 +-270 -266 0 +-270 -267 0 +-270 -268 0 +-270 -269 0 +262 263 264 265 266 267 268 269 270 0 +-271 -272 0 +-271 -273 0 +-271 -274 0 +-271 -275 0 +-271 -276 0 +-271 -277 0 +-271 -278 0 +-271 -279 0 +-272 -271 0 +-272 -273 0 +-272 -274 0 +-272 -275 0 +-272 -276 0 +-272 -277 0 +-272 -278 0 +-272 -279 0 +-273 -271 0 +-273 -272 0 +-273 -274 0 +-273 -275 0 +-273 -276 0 +-273 -277 0 +-273 -278 0 +-273 -279 0 +-274 -271 0 +-274 -272 0 +-274 -273 0 +-274 -275 0 +-274 -276 0 +-274 -277 0 +-274 -278 0 +-274 -279 0 +-275 -271 0 +-275 -272 0 +-275 -273 0 +-275 -274 0 +-275 -276 0 +-275 -277 0 +-275 -278 0 +-275 -279 0 +-276 -271 0 +-276 -272 0 +-276 -273 0 +-276 -274 0 +-276 -275 0 +-276 -277 0 +-276 -278 0 +-276 -279 0 +-277 -271 0 +-277 -272 0 +-277 -273 0 +-277 -274 0 +-277 -275 0 +-277 -276 0 +-277 -278 0 +-277 -279 0 +-278 -271 0 +-278 -272 0 +-278 -273 0 +-278 -274 0 +-278 -275 0 +-278 -276 0 +-278 -277 0 +-278 -279 0 +-279 -271 0 +-279 -272 0 +-279 -273 0 +-279 -274 0 +-279 -275 0 +-279 -276 0 +-279 -277 0 +-279 -278 0 +271 272 273 274 275 276 277 278 279 0 +-280 -281 0 +-280 -282 0 +-280 -283 0 +-280 -284 0 +-280 -285 0 +-280 -286 0 +-280 -287 0 +-280 -288 0 +-281 -280 0 +-281 -282 0 +-281 -283 0 +-281 -284 0 +-281 -285 0 +-281 -286 0 +-281 -287 0 +-281 -288 0 +-282 -280 0 +-282 -281 0 +-282 -283 0 +-282 -284 0 +-282 -285 0 +-282 -286 0 +-282 -287 0 +-282 -288 0 +-283 -280 0 +-283 -281 0 +-283 -282 0 +-283 -284 0 +-283 -285 0 +-283 -286 0 +-283 -287 0 +-283 -288 0 +-284 -280 0 +-284 -281 0 +-284 -282 0 +-284 -283 0 +-284 -285 0 +-284 -286 0 +-284 -287 0 +-284 -288 0 +-285 -280 0 +-285 -281 0 +-285 -282 0 +-285 -283 0 +-285 -284 0 +-285 -286 0 +-285 -287 0 +-285 -288 0 +-286 -280 0 +-286 -281 0 +-286 -282 0 +-286 -283 0 +-286 -284 0 +-286 -285 0 +-286 -287 0 +-286 -288 0 +-287 -280 0 +-287 -281 0 +-287 -282 0 +-287 -283 0 +-287 -284 0 +-287 -285 0 +-287 -286 0 +-287 -288 0 +-288 -280 0 +-288 -281 0 +-288 -282 0 +-288 -283 0 +-288 -284 0 +-288 -285 0 +-288 -286 0 +-288 -287 0 +280 281 282 283 284 285 286 287 288 0 +-289 -290 0 +-289 -291 0 +-289 -292 0 +-289 -293 0 +-289 -294 0 +-289 -295 0 +-289 -296 0 +-289 -297 0 +-290 -289 0 +-290 -291 0 +-290 -292 0 +-290 -293 0 +-290 -294 0 +-290 -295 0 +-290 -296 0 +-290 -297 0 +-291 -289 0 +-291 -290 0 +-291 -292 0 +-291 -293 0 +-291 -294 0 +-291 -295 0 +-291 -296 0 +-291 -297 0 +-292 -289 0 +-292 -290 0 +-292 -291 0 +-292 -293 0 +-292 -294 0 +-292 -295 0 +-292 -296 0 +-292 -297 0 +-293 -289 0 +-293 -290 0 +-293 -291 0 +-293 -292 0 +-293 -294 0 +-293 -295 0 +-293 -296 0 +-293 -297 0 +-294 -289 0 +-294 -290 0 +-294 -291 0 +-294 -292 0 +-294 -293 0 +-294 -295 0 +-294 -296 0 +-294 -297 0 +-295 -289 0 +-295 -290 0 +-295 -291 0 +-295 -292 0 +-295 -293 0 +-295 -294 0 +-295 -296 0 +-295 -297 0 +-296 -289 0 +-296 -290 0 +-296 -291 0 +-296 -292 0 +-296 -293 0 +-296 -294 0 +-296 -295 0 +-296 -297 0 +-297 -289 0 +-297 -290 0 +-297 -291 0 +-297 -292 0 +-297 -293 0 +-297 -294 0 +-297 -295 0 +-297 -296 0 +289 290 291 292 293 294 295 296 297 0 +-298 -299 0 +-298 -300 0 +-298 -301 0 +-298 -302 0 +-298 -303 0 +-298 -304 0 +-298 -305 0 +-298 -306 0 +-299 -298 0 +-299 -300 0 +-299 -301 0 +-299 -302 0 +-299 -303 0 +-299 -304 0 +-299 -305 0 +-299 -306 0 +-300 -298 0 +-300 -299 0 +-300 -301 0 +-300 -302 0 +-300 -303 0 +-300 -304 0 +-300 -305 0 +-300 -306 0 +-301 -298 0 +-301 -299 0 +-301 -300 0 +-301 -302 0 +-301 -303 0 +-301 -304 0 +-301 -305 0 +-301 -306 0 +-302 -298 0 +-302 -299 0 +-302 -300 0 +-302 -301 0 +-302 -303 0 +-302 -304 0 +-302 -305 0 +-302 -306 0 +-303 -298 0 +-303 -299 0 +-303 -300 0 +-303 -301 0 +-303 -302 0 +-303 -304 0 +-303 -305 0 +-303 -306 0 +-304 -298 0 +-304 -299 0 +-304 -300 0 +-304 -301 0 +-304 -302 0 +-304 -303 0 +-304 -305 0 +-304 -306 0 +-305 -298 0 +-305 -299 0 +-305 -300 0 +-305 -301 0 +-305 -302 0 +-305 -303 0 +-305 -304 0 +-305 -306 0 +-306 -298 0 +-306 -299 0 +-306 -300 0 +-306 -301 0 +-306 -302 0 +-306 -303 0 +-306 -304 0 +-306 -305 0 +298 299 300 301 302 303 304 305 306 0 +-307 -308 0 +-307 -309 0 +-307 -310 0 +-307 -311 0 +-307 -312 0 +-307 -313 0 +-307 -314 0 +-307 -315 0 +-308 -307 0 +-308 -309 0 +-308 -310 0 +-308 -311 0 +-308 -312 0 +-308 -313 0 +-308 -314 0 +-308 -315 0 +-309 -307 0 +-309 -308 0 +-309 -310 0 +-309 -311 0 +-309 -312 0 +-309 -313 0 +-309 -314 0 +-309 -315 0 +-310 -307 0 +-310 -308 0 +-310 -309 0 +-310 -311 0 +-310 -312 0 +-310 -313 0 +-310 -314 0 +-310 -315 0 +-311 -307 0 +-311 -308 0 +-311 -309 0 +-311 -310 0 +-311 -312 0 +-311 -313 0 +-311 -314 0 +-311 -315 0 +-312 -307 0 +-312 -308 0 +-312 -309 0 +-312 -310 0 +-312 -311 0 +-312 -313 0 +-312 -314 0 +-312 -315 0 +-313 -307 0 +-313 -308 0 +-313 -309 0 +-313 -310 0 +-313 -311 0 +-313 -312 0 +-313 -314 0 +-313 -315 0 +-314 -307 0 +-314 -308 0 +-314 -309 0 +-314 -310 0 +-314 -311 0 +-314 -312 0 +-314 -313 0 +-314 -315 0 +-315 -307 0 +-315 -308 0 +-315 -309 0 +-315 -310 0 +-315 -311 0 +-315 -312 0 +-315 -313 0 +-315 -314 0 +307 308 309 310 311 312 313 314 315 0 +-316 -317 0 +-316 -318 0 +-316 -319 0 +-316 -320 0 +-316 -321 0 +-316 -322 0 +-316 -323 0 +-316 -324 0 +-317 -316 0 +-317 -318 0 +-317 -319 0 +-317 -320 0 +-317 -321 0 +-317 -322 0 +-317 -323 0 +-317 -324 0 +-318 -316 0 +-318 -317 0 +-318 -319 0 +-318 -320 0 +-318 -321 0 +-318 -322 0 +-318 -323 0 +-318 -324 0 +-319 -316 0 +-319 -317 0 +-319 -318 0 +-319 -320 0 +-319 -321 0 +-319 -322 0 +-319 -323 0 +-319 -324 0 +-320 -316 0 +-320 -317 0 +-320 -318 0 +-320 -319 0 +-320 -321 0 +-320 -322 0 +-320 -323 0 +-320 -324 0 +-321 -316 0 +-321 -317 0 +-321 -318 0 +-321 -319 0 +-321 -320 0 +-321 -322 0 +-321 -323 0 +-321 -324 0 +-322 -316 0 +-322 -317 0 +-322 -318 0 +-322 -319 0 +-322 -320 0 +-322 -321 0 +-322 -323 0 +-322 -324 0 +-323 -316 0 +-323 -317 0 +-323 -318 0 +-323 -319 0 +-323 -320 0 +-323 -321 0 +-323 -322 0 +-323 -324 0 +-324 -316 0 +-324 -317 0 +-324 -318 0 +-324 -319 0 +-324 -320 0 +-324 -321 0 +-324 -322 0 +-324 -323 0 +316 317 318 319 320 321 322 323 324 0 +-325 -326 0 +-325 -327 0 +-325 -328 0 +-325 -329 0 +-325 -330 0 +-325 -331 0 +-325 -332 0 +-325 -333 0 +-326 -325 0 +-326 -327 0 +-326 -328 0 +-326 -329 0 +-326 -330 0 +-326 -331 0 +-326 -332 0 +-326 -333 0 +-327 -325 0 +-327 -326 0 +-327 -328 0 +-327 -329 0 +-327 -330 0 +-327 -331 0 +-327 -332 0 +-327 -333 0 +-328 -325 0 +-328 -326 0 +-328 -327 0 +-328 -329 0 +-328 -330 0 +-328 -331 0 +-328 -332 0 +-328 -333 0 +-329 -325 0 +-329 -326 0 +-329 -327 0 +-329 -328 0 +-329 -330 0 +-329 -331 0 +-329 -332 0 +-329 -333 0 +-330 -325 0 +-330 -326 0 +-330 -327 0 +-330 -328 0 +-330 -329 0 +-330 -331 0 +-330 -332 0 +-330 -333 0 +-331 -325 0 +-331 -326 0 +-331 -327 0 +-331 -328 0 +-331 -329 0 +-331 -330 0 +-331 -332 0 +-331 -333 0 +-332 -325 0 +-332 -326 0 +-332 -327 0 +-332 -328 0 +-332 -329 0 +-332 -330 0 +-332 -331 0 +-332 -333 0 +-333 -325 0 +-333 -326 0 +-333 -327 0 +-333 -328 0 +-333 -329 0 +-333 -330 0 +-333 -331 0 +-333 -332 0 +325 326 327 328 329 330 331 332 333 0 +-334 -335 0 +-334 -336 0 +-334 -337 0 +-334 -338 0 +-334 -339 0 +-334 -340 0 +-334 -341 0 +-334 -342 0 +-335 -334 0 +-335 -336 0 +-335 -337 0 +-335 -338 0 +-335 -339 0 +-335 -340 0 +-335 -341 0 +-335 -342 0 +-336 -334 0 +-336 -335 0 +-336 -337 0 +-336 -338 0 +-336 -339 0 +-336 -340 0 +-336 -341 0 +-336 -342 0 +-337 -334 0 +-337 -335 0 +-337 -336 0 +-337 -338 0 +-337 -339 0 +-337 -340 0 +-337 -341 0 +-337 -342 0 +-338 -334 0 +-338 -335 0 +-338 -336 0 +-338 -337 0 +-338 -339 0 +-338 -340 0 +-338 -341 0 +-338 -342 0 +-339 -334 0 +-339 -335 0 +-339 -336 0 +-339 -337 0 +-339 -338 0 +-339 -340 0 +-339 -341 0 +-339 -342 0 +-340 -334 0 +-340 -335 0 +-340 -336 0 +-340 -337 0 +-340 -338 0 +-340 -339 0 +-340 -341 0 +-340 -342 0 +-341 -334 0 +-341 -335 0 +-341 -336 0 +-341 -337 0 +-341 -338 0 +-341 -339 0 +-341 -340 0 +-341 -342 0 +-342 -334 0 +-342 -335 0 +-342 -336 0 +-342 -337 0 +-342 -338 0 +-342 -339 0 +-342 -340 0 +-342 -341 0 +334 335 336 337 338 339 340 341 342 0 +-343 -344 0 +-343 -345 0 +-343 -346 0 +-343 -347 0 +-343 -348 0 +-343 -349 0 +-343 -350 0 +-343 -351 0 +-344 -343 0 +-344 -345 0 +-344 -346 0 +-344 -347 0 +-344 -348 0 +-344 -349 0 +-344 -350 0 +-344 -351 0 +-345 -343 0 +-345 -344 0 +-345 -346 0 +-345 -347 0 +-345 -348 0 +-345 -349 0 +-345 -350 0 +-345 -351 0 +-346 -343 0 +-346 -344 0 +-346 -345 0 +-346 -347 0 +-346 -348 0 +-346 -349 0 +-346 -350 0 +-346 -351 0 +-347 -343 0 +-347 -344 0 +-347 -345 0 +-347 -346 0 +-347 -348 0 +-347 -349 0 +-347 -350 0 +-347 -351 0 +-348 -343 0 +-348 -344 0 +-348 -345 0 +-348 -346 0 +-348 -347 0 +-348 -349 0 +-348 -350 0 +-348 -351 0 +-349 -343 0 +-349 -344 0 +-349 -345 0 +-349 -346 0 +-349 -347 0 +-349 -348 0 +-349 -350 0 +-349 -351 0 +-350 -343 0 +-350 -344 0 +-350 -345 0 +-350 -346 0 +-350 -347 0 +-350 -348 0 +-350 -349 0 +-350 -351 0 +-351 -343 0 +-351 -344 0 +-351 -345 0 +-351 -346 0 +-351 -347 0 +-351 -348 0 +-351 -349 0 +-351 -350 0 +343 344 345 346 347 348 349 350 351 0 +-352 -353 0 +-352 -354 0 +-352 -355 0 +-352 -356 0 +-352 -357 0 +-352 -358 0 +-352 -359 0 +-352 -360 0 +-353 -352 0 +-353 -354 0 +-353 -355 0 +-353 -356 0 +-353 -357 0 +-353 -358 0 +-353 -359 0 +-353 -360 0 +-354 -352 0 +-354 -353 0 +-354 -355 0 +-354 -356 0 +-354 -357 0 +-354 -358 0 +-354 -359 0 +-354 -360 0 +-355 -352 0 +-355 -353 0 +-355 -354 0 +-355 -356 0 +-355 -357 0 +-355 -358 0 +-355 -359 0 +-355 -360 0 +-356 -352 0 +-356 -353 0 +-356 -354 0 +-356 -355 0 +-356 -357 0 +-356 -358 0 +-356 -359 0 +-356 -360 0 +-357 -352 0 +-357 -353 0 +-357 -354 0 +-357 -355 0 +-357 -356 0 +-357 -358 0 +-357 -359 0 +-357 -360 0 +-358 -352 0 +-358 -353 0 +-358 -354 0 +-358 -355 0 +-358 -356 0 +-358 -357 0 +-358 -359 0 +-358 -360 0 +-359 -352 0 +-359 -353 0 +-359 -354 0 +-359 -355 0 +-359 -356 0 +-359 -357 0 +-359 -358 0 +-359 -360 0 +-360 -352 0 +-360 -353 0 +-360 -354 0 +-360 -355 0 +-360 -356 0 +-360 -357 0 +-360 -358 0 +-360 -359 0 +352 353 354 355 356 357 358 359 360 0 +-361 -362 0 +-361 -363 0 +-361 -364 0 +-361 -365 0 +-361 -366 0 +-361 -367 0 +-361 -368 0 +-361 -369 0 +-362 -361 0 +-362 -363 0 +-362 -364 0 +-362 -365 0 +-362 -366 0 +-362 -367 0 +-362 -368 0 +-362 -369 0 +-363 -361 0 +-363 -362 0 +-363 -364 0 +-363 -365 0 +-363 -366 0 +-363 -367 0 +-363 -368 0 +-363 -369 0 +-364 -361 0 +-364 -362 0 +-364 -363 0 +-364 -365 0 +-364 -366 0 +-364 -367 0 +-364 -368 0 +-364 -369 0 +-365 -361 0 +-365 -362 0 +-365 -363 0 +-365 -364 0 +-365 -366 0 +-365 -367 0 +-365 -368 0 +-365 -369 0 +-366 -361 0 +-366 -362 0 +-366 -363 0 +-366 -364 0 +-366 -365 0 +-366 -367 0 +-366 -368 0 +-366 -369 0 +-367 -361 0 +-367 -362 0 +-367 -363 0 +-367 -364 0 +-367 -365 0 +-367 -366 0 +-367 -368 0 +-367 -369 0 +-368 -361 0 +-368 -362 0 +-368 -363 0 +-368 -364 0 +-368 -365 0 +-368 -366 0 +-368 -367 0 +-368 -369 0 +-369 -361 0 +-369 -362 0 +-369 -363 0 +-369 -364 0 +-369 -365 0 +-369 -366 0 +-369 -367 0 +-369 -368 0 +361 362 363 364 365 366 367 368 369 0 +-370 -371 0 +-370 -372 0 +-370 -373 0 +-370 -374 0 +-370 -375 0 +-370 -376 0 +-370 -377 0 +-370 -378 0 +-371 -370 0 +-371 -372 0 +-371 -373 0 +-371 -374 0 +-371 -375 0 +-371 -376 0 +-371 -377 0 +-371 -378 0 +-372 -370 0 +-372 -371 0 +-372 -373 0 +-372 -374 0 +-372 -375 0 +-372 -376 0 +-372 -377 0 +-372 -378 0 +-373 -370 0 +-373 -371 0 +-373 -372 0 +-373 -374 0 +-373 -375 0 +-373 -376 0 +-373 -377 0 +-373 -378 0 +-374 -370 0 +-374 -371 0 +-374 -372 0 +-374 -373 0 +-374 -375 0 +-374 -376 0 +-374 -377 0 +-374 -378 0 +-375 -370 0 +-375 -371 0 +-375 -372 0 +-375 -373 0 +-375 -374 0 +-375 -376 0 +-375 -377 0 +-375 -378 0 +-376 -370 0 +-376 -371 0 +-376 -372 0 +-376 -373 0 +-376 -374 0 +-376 -375 0 +-376 -377 0 +-376 -378 0 +-377 -370 0 +-377 -371 0 +-377 -372 0 +-377 -373 0 +-377 -374 0 +-377 -375 0 +-377 -376 0 +-377 -378 0 +-378 -370 0 +-378 -371 0 +-378 -372 0 +-378 -373 0 +-378 -374 0 +-378 -375 0 +-378 -376 0 +-378 -377 0 +370 371 372 373 374 375 376 377 378 0 +-379 -380 0 +-379 -381 0 +-379 -382 0 +-379 -383 0 +-379 -384 0 +-379 -385 0 +-379 -386 0 +-379 -387 0 +-380 -379 0 +-380 -381 0 +-380 -382 0 +-380 -383 0 +-380 -384 0 +-380 -385 0 +-380 -386 0 +-380 -387 0 +-381 -379 0 +-381 -380 0 +-381 -382 0 +-381 -383 0 +-381 -384 0 +-381 -385 0 +-381 -386 0 +-381 -387 0 +-382 -379 0 +-382 -380 0 +-382 -381 0 +-382 -383 0 +-382 -384 0 +-382 -385 0 +-382 -386 0 +-382 -387 0 +-383 -379 0 +-383 -380 0 +-383 -381 0 +-383 -382 0 +-383 -384 0 +-383 -385 0 +-383 -386 0 +-383 -387 0 +-384 -379 0 +-384 -380 0 +-384 -381 0 +-384 -382 0 +-384 -383 0 +-384 -385 0 +-384 -386 0 +-384 -387 0 +-385 -379 0 +-385 -380 0 +-385 -381 0 +-385 -382 0 +-385 -383 0 +-385 -384 0 +-385 -386 0 +-385 -387 0 +-386 -379 0 +-386 -380 0 +-386 -381 0 +-386 -382 0 +-386 -383 0 +-386 -384 0 +-386 -385 0 +-386 -387 0 +-387 -379 0 +-387 -380 0 +-387 -381 0 +-387 -382 0 +-387 -383 0 +-387 -384 0 +-387 -385 0 +-387 -386 0 +379 380 381 382 383 384 385 386 387 0 +-388 -389 0 +-388 -390 0 +-388 -391 0 +-388 -392 0 +-388 -393 0 +-388 -394 0 +-388 -395 0 +-388 -396 0 +-389 -388 0 +-389 -390 0 +-389 -391 0 +-389 -392 0 +-389 -393 0 +-389 -394 0 +-389 -395 0 +-389 -396 0 +-390 -388 0 +-390 -389 0 +-390 -391 0 +-390 -392 0 +-390 -393 0 +-390 -394 0 +-390 -395 0 +-390 -396 0 +-391 -388 0 +-391 -389 0 +-391 -390 0 +-391 -392 0 +-391 -393 0 +-391 -394 0 +-391 -395 0 +-391 -396 0 +-392 -388 0 +-392 -389 0 +-392 -390 0 +-392 -391 0 +-392 -393 0 +-392 -394 0 +-392 -395 0 +-392 -396 0 +-393 -388 0 +-393 -389 0 +-393 -390 0 +-393 -391 0 +-393 -392 0 +-393 -394 0 +-393 -395 0 +-393 -396 0 +-394 -388 0 +-394 -389 0 +-394 -390 0 +-394 -391 0 +-394 -392 0 +-394 -393 0 +-394 -395 0 +-394 -396 0 +-395 -388 0 +-395 -389 0 +-395 -390 0 +-395 -391 0 +-395 -392 0 +-395 -393 0 +-395 -394 0 +-395 -396 0 +-396 -388 0 +-396 -389 0 +-396 -390 0 +-396 -391 0 +-396 -392 0 +-396 -393 0 +-396 -394 0 +-396 -395 0 +388 389 390 391 392 393 394 395 396 0 +-397 -398 0 +-397 -399 0 +-397 -400 0 +-397 -401 0 +-397 -402 0 +-397 -403 0 +-397 -404 0 +-397 -405 0 +-398 -397 0 +-398 -399 0 +-398 -400 0 +-398 -401 0 +-398 -402 0 +-398 -403 0 +-398 -404 0 +-398 -405 0 +-399 -397 0 +-399 -398 0 +-399 -400 0 +-399 -401 0 +-399 -402 0 +-399 -403 0 +-399 -404 0 +-399 -405 0 +-400 -397 0 +-400 -398 0 +-400 -399 0 +-400 -401 0 +-400 -402 0 +-400 -403 0 +-400 -404 0 +-400 -405 0 +-401 -397 0 +-401 -398 0 +-401 -399 0 +-401 -400 0 +-401 -402 0 +-401 -403 0 +-401 -404 0 +-401 -405 0 +-402 -397 0 +-402 -398 0 +-402 -399 0 +-402 -400 0 +-402 -401 0 +-402 -403 0 +-402 -404 0 +-402 -405 0 +-403 -397 0 +-403 -398 0 +-403 -399 0 +-403 -400 0 +-403 -401 0 +-403 -402 0 +-403 -404 0 +-403 -405 0 +-404 -397 0 +-404 -398 0 +-404 -399 0 +-404 -400 0 +-404 -401 0 +-404 -402 0 +-404 -403 0 +-404 -405 0 +-405 -397 0 +-405 -398 0 +-405 -399 0 +-405 -400 0 +-405 -401 0 +-405 -402 0 +-405 -403 0 +-405 -404 0 +397 398 399 400 401 402 403 404 405 0 +-406 -407 0 +-406 -408 0 +-406 -409 0 +-406 -410 0 +-406 -411 0 +-406 -412 0 +-406 -413 0 +-406 -414 0 +-407 -406 0 +-407 -408 0 +-407 -409 0 +-407 -410 0 +-407 -411 0 +-407 -412 0 +-407 -413 0 +-407 -414 0 +-408 -406 0 +-408 -407 0 +-408 -409 0 +-408 -410 0 +-408 -411 0 +-408 -412 0 +-408 -413 0 +-408 -414 0 +-409 -406 0 +-409 -407 0 +-409 -408 0 +-409 -410 0 +-409 -411 0 +-409 -412 0 +-409 -413 0 +-409 -414 0 +-410 -406 0 +-410 -407 0 +-410 -408 0 +-410 -409 0 +-410 -411 0 +-410 -412 0 +-410 -413 0 +-410 -414 0 +-411 -406 0 +-411 -407 0 +-411 -408 0 +-411 -409 0 +-411 -410 0 +-411 -412 0 +-411 -413 0 +-411 -414 0 +-412 -406 0 +-412 -407 0 +-412 -408 0 +-412 -409 0 +-412 -410 0 +-412 -411 0 +-412 -413 0 +-412 -414 0 +-413 -406 0 +-413 -407 0 +-413 -408 0 +-413 -409 0 +-413 -410 0 +-413 -411 0 +-413 -412 0 +-413 -414 0 +-414 -406 0 +-414 -407 0 +-414 -408 0 +-414 -409 0 +-414 -410 0 +-414 -411 0 +-414 -412 0 +-414 -413 0 +406 407 408 409 410 411 412 413 414 0 +-415 -416 0 +-415 -417 0 +-415 -418 0 +-415 -419 0 +-415 -420 0 +-415 -421 0 +-415 -422 0 +-415 -423 0 +-416 -415 0 +-416 -417 0 +-416 -418 0 +-416 -419 0 +-416 -420 0 +-416 -421 0 +-416 -422 0 +-416 -423 0 +-417 -415 0 +-417 -416 0 +-417 -418 0 +-417 -419 0 +-417 -420 0 +-417 -421 0 +-417 -422 0 +-417 -423 0 +-418 -415 0 +-418 -416 0 +-418 -417 0 +-418 -419 0 +-418 -420 0 +-418 -421 0 +-418 -422 0 +-418 -423 0 +-419 -415 0 +-419 -416 0 +-419 -417 0 +-419 -418 0 +-419 -420 0 +-419 -421 0 +-419 -422 0 +-419 -423 0 +-420 -415 0 +-420 -416 0 +-420 -417 0 +-420 -418 0 +-420 -419 0 +-420 -421 0 +-420 -422 0 +-420 -423 0 +-421 -415 0 +-421 -416 0 +-421 -417 0 +-421 -418 0 +-421 -419 0 +-421 -420 0 +-421 -422 0 +-421 -423 0 +-422 -415 0 +-422 -416 0 +-422 -417 0 +-422 -418 0 +-422 -419 0 +-422 -420 0 +-422 -421 0 +-422 -423 0 +-423 -415 0 +-423 -416 0 +-423 -417 0 +-423 -418 0 +-423 -419 0 +-423 -420 0 +-423 -421 0 +-423 -422 0 +415 416 417 418 419 420 421 422 423 0 +-424 -425 0 +-424 -426 0 +-424 -427 0 +-424 -428 0 +-424 -429 0 +-424 -430 0 +-424 -431 0 +-424 -432 0 +-425 -424 0 +-425 -426 0 +-425 -427 0 +-425 -428 0 +-425 -429 0 +-425 -430 0 +-425 -431 0 +-425 -432 0 +-426 -424 0 +-426 -425 0 +-426 -427 0 +-426 -428 0 +-426 -429 0 +-426 -430 0 +-426 -431 0 +-426 -432 0 +-427 -424 0 +-427 -425 0 +-427 -426 0 +-427 -428 0 +-427 -429 0 +-427 -430 0 +-427 -431 0 +-427 -432 0 +-428 -424 0 +-428 -425 0 +-428 -426 0 +-428 -427 0 +-428 -429 0 +-428 -430 0 +-428 -431 0 +-428 -432 0 +-429 -424 0 +-429 -425 0 +-429 -426 0 +-429 -427 0 +-429 -428 0 +-429 -430 0 +-429 -431 0 +-429 -432 0 +-430 -424 0 +-430 -425 0 +-430 -426 0 +-430 -427 0 +-430 -428 0 +-430 -429 0 +-430 -431 0 +-430 -432 0 +-431 -424 0 +-431 -425 0 +-431 -426 0 +-431 -427 0 +-431 -428 0 +-431 -429 0 +-431 -430 0 +-431 -432 0 +-432 -424 0 +-432 -425 0 +-432 -426 0 +-432 -427 0 +-432 -428 0 +-432 -429 0 +-432 -430 0 +-432 -431 0 +424 425 426 427 428 429 430 431 432 0 +-433 -434 0 +-433 -435 0 +-433 -436 0 +-433 -437 0 +-433 -438 0 +-433 -439 0 +-433 -440 0 +-433 -441 0 +-434 -433 0 +-434 -435 0 +-434 -436 0 +-434 -437 0 +-434 -438 0 +-434 -439 0 +-434 -440 0 +-434 -441 0 +-435 -433 0 +-435 -434 0 +-435 -436 0 +-435 -437 0 +-435 -438 0 +-435 -439 0 +-435 -440 0 +-435 -441 0 +-436 -433 0 +-436 -434 0 +-436 -435 0 +-436 -437 0 +-436 -438 0 +-436 -439 0 +-436 -440 0 +-436 -441 0 +-437 -433 0 +-437 -434 0 +-437 -435 0 +-437 -436 0 +-437 -438 0 +-437 -439 0 +-437 -440 0 +-437 -441 0 +-438 -433 0 +-438 -434 0 +-438 -435 0 +-438 -436 0 +-438 -437 0 +-438 -439 0 +-438 -440 0 +-438 -441 0 +-439 -433 0 +-439 -434 0 +-439 -435 0 +-439 -436 0 +-439 -437 0 +-439 -438 0 +-439 -440 0 +-439 -441 0 +-440 -433 0 +-440 -434 0 +-440 -435 0 +-440 -436 0 +-440 -437 0 +-440 -438 0 +-440 -439 0 +-440 -441 0 +-441 -433 0 +-441 -434 0 +-441 -435 0 +-441 -436 0 +-441 -437 0 +-441 -438 0 +-441 -439 0 +-441 -440 0 +433 434 435 436 437 438 439 440 441 0 +-442 -443 0 +-442 -444 0 +-442 -445 0 +-442 -446 0 +-442 -447 0 +-442 -448 0 +-442 -449 0 +-442 -450 0 +-443 -442 0 +-443 -444 0 +-443 -445 0 +-443 -446 0 +-443 -447 0 +-443 -448 0 +-443 -449 0 +-443 -450 0 +-444 -442 0 +-444 -443 0 +-444 -445 0 +-444 -446 0 +-444 -447 0 +-444 -448 0 +-444 -449 0 +-444 -450 0 +-445 -442 0 +-445 -443 0 +-445 -444 0 +-445 -446 0 +-445 -447 0 +-445 -448 0 +-445 -449 0 +-445 -450 0 +-446 -442 0 +-446 -443 0 +-446 -444 0 +-446 -445 0 +-446 -447 0 +-446 -448 0 +-446 -449 0 +-446 -450 0 +-447 -442 0 +-447 -443 0 +-447 -444 0 +-447 -445 0 +-447 -446 0 +-447 -448 0 +-447 -449 0 +-447 -450 0 +-448 -442 0 +-448 -443 0 +-448 -444 0 +-448 -445 0 +-448 -446 0 +-448 -447 0 +-448 -449 0 +-448 -450 0 +-449 -442 0 +-449 -443 0 +-449 -444 0 +-449 -445 0 +-449 -446 0 +-449 -447 0 +-449 -448 0 +-449 -450 0 +-450 -442 0 +-450 -443 0 +-450 -444 0 +-450 -445 0 +-450 -446 0 +-450 -447 0 +-450 -448 0 +-450 -449 0 +442 443 444 445 446 447 448 449 450 0 +-451 -452 0 +-451 -453 0 +-451 -454 0 +-451 -455 0 +-451 -456 0 +-451 -457 0 +-451 -458 0 +-451 -459 0 +-452 -451 0 +-452 -453 0 +-452 -454 0 +-452 -455 0 +-452 -456 0 +-452 -457 0 +-452 -458 0 +-452 -459 0 +-453 -451 0 +-453 -452 0 +-453 -454 0 +-453 -455 0 +-453 -456 0 +-453 -457 0 +-453 -458 0 +-453 -459 0 +-454 -451 0 +-454 -452 0 +-454 -453 0 +-454 -455 0 +-454 -456 0 +-454 -457 0 +-454 -458 0 +-454 -459 0 +-455 -451 0 +-455 -452 0 +-455 -453 0 +-455 -454 0 +-455 -456 0 +-455 -457 0 +-455 -458 0 +-455 -459 0 +-456 -451 0 +-456 -452 0 +-456 -453 0 +-456 -454 0 +-456 -455 0 +-456 -457 0 +-456 -458 0 +-456 -459 0 +-457 -451 0 +-457 -452 0 +-457 -453 0 +-457 -454 0 +-457 -455 0 +-457 -456 0 +-457 -458 0 +-457 -459 0 +-458 -451 0 +-458 -452 0 +-458 -453 0 +-458 -454 0 +-458 -455 0 +-458 -456 0 +-458 -457 0 +-458 -459 0 +-459 -451 0 +-459 -452 0 +-459 -453 0 +-459 -454 0 +-459 -455 0 +-459 -456 0 +-459 -457 0 +-459 -458 0 +451 452 453 454 455 456 457 458 459 0 +-460 -461 0 +-460 -462 0 +-460 -463 0 +-460 -464 0 +-460 -465 0 +-460 -466 0 +-460 -467 0 +-460 -468 0 +-461 -460 0 +-461 -462 0 +-461 -463 0 +-461 -464 0 +-461 -465 0 +-461 -466 0 +-461 -467 0 +-461 -468 0 +-462 -460 0 +-462 -461 0 +-462 -463 0 +-462 -464 0 +-462 -465 0 +-462 -466 0 +-462 -467 0 +-462 -468 0 +-463 -460 0 +-463 -461 0 +-463 -462 0 +-463 -464 0 +-463 -465 0 +-463 -466 0 +-463 -467 0 +-463 -468 0 +-464 -460 0 +-464 -461 0 +-464 -462 0 +-464 -463 0 +-464 -465 0 +-464 -466 0 +-464 -467 0 +-464 -468 0 +-465 -460 0 +-465 -461 0 +-465 -462 0 +-465 -463 0 +-465 -464 0 +-465 -466 0 +-465 -467 0 +-465 -468 0 +-466 -460 0 +-466 -461 0 +-466 -462 0 +-466 -463 0 +-466 -464 0 +-466 -465 0 +-466 -467 0 +-466 -468 0 +-467 -460 0 +-467 -461 0 +-467 -462 0 +-467 -463 0 +-467 -464 0 +-467 -465 0 +-467 -466 0 +-467 -468 0 +-468 -460 0 +-468 -461 0 +-468 -462 0 +-468 -463 0 +-468 -464 0 +-468 -465 0 +-468 -466 0 +-468 -467 0 +460 461 462 463 464 465 466 467 468 0 +-469 -470 0 +-469 -471 0 +-469 -472 0 +-469 -473 0 +-469 -474 0 +-469 -475 0 +-469 -476 0 +-469 -477 0 +-470 -469 0 +-470 -471 0 +-470 -472 0 +-470 -473 0 +-470 -474 0 +-470 -475 0 +-470 -476 0 +-470 -477 0 +-471 -469 0 +-471 -470 0 +-471 -472 0 +-471 -473 0 +-471 -474 0 +-471 -475 0 +-471 -476 0 +-471 -477 0 +-472 -469 0 +-472 -470 0 +-472 -471 0 +-472 -473 0 +-472 -474 0 +-472 -475 0 +-472 -476 0 +-472 -477 0 +-473 -469 0 +-473 -470 0 +-473 -471 0 +-473 -472 0 +-473 -474 0 +-473 -475 0 +-473 -476 0 +-473 -477 0 +-474 -469 0 +-474 -470 0 +-474 -471 0 +-474 -472 0 +-474 -473 0 +-474 -475 0 +-474 -476 0 +-474 -477 0 +-475 -469 0 +-475 -470 0 +-475 -471 0 +-475 -472 0 +-475 -473 0 +-475 -474 0 +-475 -476 0 +-475 -477 0 +-476 -469 0 +-476 -470 0 +-476 -471 0 +-476 -472 0 +-476 -473 0 +-476 -474 0 +-476 -475 0 +-476 -477 0 +-477 -469 0 +-477 -470 0 +-477 -471 0 +-477 -472 0 +-477 -473 0 +-477 -474 0 +-477 -475 0 +-477 -476 0 +469 470 471 472 473 474 475 476 477 0 +-478 -479 0 +-478 -480 0 +-478 -481 0 +-478 -482 0 +-478 -483 0 +-478 -484 0 +-478 -485 0 +-478 -486 0 +-479 -478 0 +-479 -480 0 +-479 -481 0 +-479 -482 0 +-479 -483 0 +-479 -484 0 +-479 -485 0 +-479 -486 0 +-480 -478 0 +-480 -479 0 +-480 -481 0 +-480 -482 0 +-480 -483 0 +-480 -484 0 +-480 -485 0 +-480 -486 0 +-481 -478 0 +-481 -479 0 +-481 -480 0 +-481 -482 0 +-481 -483 0 +-481 -484 0 +-481 -485 0 +-481 -486 0 +-482 -478 0 +-482 -479 0 +-482 -480 0 +-482 -481 0 +-482 -483 0 +-482 -484 0 +-482 -485 0 +-482 -486 0 +-483 -478 0 +-483 -479 0 +-483 -480 0 +-483 -481 0 +-483 -482 0 +-483 -484 0 +-483 -485 0 +-483 -486 0 +-484 -478 0 +-484 -479 0 +-484 -480 0 +-484 -481 0 +-484 -482 0 +-484 -483 0 +-484 -485 0 +-484 -486 0 +-485 -478 0 +-485 -479 0 +-485 -480 0 +-485 -481 0 +-485 -482 0 +-485 -483 0 +-485 -484 0 +-485 -486 0 +-486 -478 0 +-486 -479 0 +-486 -480 0 +-486 -481 0 +-486 -482 0 +-486 -483 0 +-486 -484 0 +-486 -485 0 +478 479 480 481 482 483 484 485 486 0 +-487 -488 0 +-487 -489 0 +-487 -490 0 +-487 -491 0 +-487 -492 0 +-487 -493 0 +-487 -494 0 +-487 -495 0 +-488 -487 0 +-488 -489 0 +-488 -490 0 +-488 -491 0 +-488 -492 0 +-488 -493 0 +-488 -494 0 +-488 -495 0 +-489 -487 0 +-489 -488 0 +-489 -490 0 +-489 -491 0 +-489 -492 0 +-489 -493 0 +-489 -494 0 +-489 -495 0 +-490 -487 0 +-490 -488 0 +-490 -489 0 +-490 -491 0 +-490 -492 0 +-490 -493 0 +-490 -494 0 +-490 -495 0 +-491 -487 0 +-491 -488 0 +-491 -489 0 +-491 -490 0 +-491 -492 0 +-491 -493 0 +-491 -494 0 +-491 -495 0 +-492 -487 0 +-492 -488 0 +-492 -489 0 +-492 -490 0 +-492 -491 0 +-492 -493 0 +-492 -494 0 +-492 -495 0 +-493 -487 0 +-493 -488 0 +-493 -489 0 +-493 -490 0 +-493 -491 0 +-493 -492 0 +-493 -494 0 +-493 -495 0 +-494 -487 0 +-494 -488 0 +-494 -489 0 +-494 -490 0 +-494 -491 0 +-494 -492 0 +-494 -493 0 +-494 -495 0 +-495 -487 0 +-495 -488 0 +-495 -489 0 +-495 -490 0 +-495 -491 0 +-495 -492 0 +-495 -493 0 +-495 -494 0 +487 488 489 490 491 492 493 494 495 0 +-496 -497 0 +-496 -498 0 +-496 -499 0 +-496 -500 0 +-496 -501 0 +-496 -502 0 +-496 -503 0 +-496 -504 0 +-497 -496 0 +-497 -498 0 +-497 -499 0 +-497 -500 0 +-497 -501 0 +-497 -502 0 +-497 -503 0 +-497 -504 0 +-498 -496 0 +-498 -497 0 +-498 -499 0 +-498 -500 0 +-498 -501 0 +-498 -502 0 +-498 -503 0 +-498 -504 0 +-499 -496 0 +-499 -497 0 +-499 -498 0 +-499 -500 0 +-499 -501 0 +-499 -502 0 +-499 -503 0 +-499 -504 0 +-500 -496 0 +-500 -497 0 +-500 -498 0 +-500 -499 0 +-500 -501 0 +-500 -502 0 +-500 -503 0 +-500 -504 0 +-501 -496 0 +-501 -497 0 +-501 -498 0 +-501 -499 0 +-501 -500 0 +-501 -502 0 +-501 -503 0 +-501 -504 0 +-502 -496 0 +-502 -497 0 +-502 -498 0 +-502 -499 0 +-502 -500 0 +-502 -501 0 +-502 -503 0 +-502 -504 0 +-503 -496 0 +-503 -497 0 +-503 -498 0 +-503 -499 0 +-503 -500 0 +-503 -501 0 +-503 -502 0 +-503 -504 0 +-504 -496 0 +-504 -497 0 +-504 -498 0 +-504 -499 0 +-504 -500 0 +-504 -501 0 +-504 -502 0 +-504 -503 0 +496 497 498 499 500 501 502 503 504 0 +-505 -506 0 +-505 -507 0 +-505 -508 0 +-505 -509 0 +-505 -510 0 +-505 -511 0 +-505 -512 0 +-505 -513 0 +-506 -505 0 +-506 -507 0 +-506 -508 0 +-506 -509 0 +-506 -510 0 +-506 -511 0 +-506 -512 0 +-506 -513 0 +-507 -505 0 +-507 -506 0 +-507 -508 0 +-507 -509 0 +-507 -510 0 +-507 -511 0 +-507 -512 0 +-507 -513 0 +-508 -505 0 +-508 -506 0 +-508 -507 0 +-508 -509 0 +-508 -510 0 +-508 -511 0 +-508 -512 0 +-508 -513 0 +-509 -505 0 +-509 -506 0 +-509 -507 0 +-509 -508 0 +-509 -510 0 +-509 -511 0 +-509 -512 0 +-509 -513 0 +-510 -505 0 +-510 -506 0 +-510 -507 0 +-510 -508 0 +-510 -509 0 +-510 -511 0 +-510 -512 0 +-510 -513 0 +-511 -505 0 +-511 -506 0 +-511 -507 0 +-511 -508 0 +-511 -509 0 +-511 -510 0 +-511 -512 0 +-511 -513 0 +-512 -505 0 +-512 -506 0 +-512 -507 0 +-512 -508 0 +-512 -509 0 +-512 -510 0 +-512 -511 0 +-512 -513 0 +-513 -505 0 +-513 -506 0 +-513 -507 0 +-513 -508 0 +-513 -509 0 +-513 -510 0 +-513 -511 0 +-513 -512 0 +505 506 507 508 509 510 511 512 513 0 +-514 -515 0 +-514 -516 0 +-514 -517 0 +-514 -518 0 +-514 -519 0 +-514 -520 0 +-514 -521 0 +-514 -522 0 +-515 -514 0 +-515 -516 0 +-515 -517 0 +-515 -518 0 +-515 -519 0 +-515 -520 0 +-515 -521 0 +-515 -522 0 +-516 -514 0 +-516 -515 0 +-516 -517 0 +-516 -518 0 +-516 -519 0 +-516 -520 0 +-516 -521 0 +-516 -522 0 +-517 -514 0 +-517 -515 0 +-517 -516 0 +-517 -518 0 +-517 -519 0 +-517 -520 0 +-517 -521 0 +-517 -522 0 +-518 -514 0 +-518 -515 0 +-518 -516 0 +-518 -517 0 +-518 -519 0 +-518 -520 0 +-518 -521 0 +-518 -522 0 +-519 -514 0 +-519 -515 0 +-519 -516 0 +-519 -517 0 +-519 -518 0 +-519 -520 0 +-519 -521 0 +-519 -522 0 +-520 -514 0 +-520 -515 0 +-520 -516 0 +-520 -517 0 +-520 -518 0 +-520 -519 0 +-520 -521 0 +-520 -522 0 +-521 -514 0 +-521 -515 0 +-521 -516 0 +-521 -517 0 +-521 -518 0 +-521 -519 0 +-521 -520 0 +-521 -522 0 +-522 -514 0 +-522 -515 0 +-522 -516 0 +-522 -517 0 +-522 -518 0 +-522 -519 0 +-522 -520 0 +-522 -521 0 +514 515 516 517 518 519 520 521 522 0 +-523 -524 0 +-523 -525 0 +-523 -526 0 +-523 -527 0 +-523 -528 0 +-523 -529 0 +-523 -530 0 +-523 -531 0 +-524 -523 0 +-524 -525 0 +-524 -526 0 +-524 -527 0 +-524 -528 0 +-524 -529 0 +-524 -530 0 +-524 -531 0 +-525 -523 0 +-525 -524 0 +-525 -526 0 +-525 -527 0 +-525 -528 0 +-525 -529 0 +-525 -530 0 +-525 -531 0 +-526 -523 0 +-526 -524 0 +-526 -525 0 +-526 -527 0 +-526 -528 0 +-526 -529 0 +-526 -530 0 +-526 -531 0 +-527 -523 0 +-527 -524 0 +-527 -525 0 +-527 -526 0 +-527 -528 0 +-527 -529 0 +-527 -530 0 +-527 -531 0 +-528 -523 0 +-528 -524 0 +-528 -525 0 +-528 -526 0 +-528 -527 0 +-528 -529 0 +-528 -530 0 +-528 -531 0 +-529 -523 0 +-529 -524 0 +-529 -525 0 +-529 -526 0 +-529 -527 0 +-529 -528 0 +-529 -530 0 +-529 -531 0 +-530 -523 0 +-530 -524 0 +-530 -525 0 +-530 -526 0 +-530 -527 0 +-530 -528 0 +-530 -529 0 +-530 -531 0 +-531 -523 0 +-531 -524 0 +-531 -525 0 +-531 -526 0 +-531 -527 0 +-531 -528 0 +-531 -529 0 +-531 -530 0 +523 524 525 526 527 528 529 530 531 0 +-532 -533 0 +-532 -534 0 +-532 -535 0 +-532 -536 0 +-532 -537 0 +-532 -538 0 +-532 -539 0 +-532 -540 0 +-533 -532 0 +-533 -534 0 +-533 -535 0 +-533 -536 0 +-533 -537 0 +-533 -538 0 +-533 -539 0 +-533 -540 0 +-534 -532 0 +-534 -533 0 +-534 -535 0 +-534 -536 0 +-534 -537 0 +-534 -538 0 +-534 -539 0 +-534 -540 0 +-535 -532 0 +-535 -533 0 +-535 -534 0 +-535 -536 0 +-535 -537 0 +-535 -538 0 +-535 -539 0 +-535 -540 0 +-536 -532 0 +-536 -533 0 +-536 -534 0 +-536 -535 0 +-536 -537 0 +-536 -538 0 +-536 -539 0 +-536 -540 0 +-537 -532 0 +-537 -533 0 +-537 -534 0 +-537 -535 0 +-537 -536 0 +-537 -538 0 +-537 -539 0 +-537 -540 0 +-538 -532 0 +-538 -533 0 +-538 -534 0 +-538 -535 0 +-538 -536 0 +-538 -537 0 +-538 -539 0 +-538 -540 0 +-539 -532 0 +-539 -533 0 +-539 -534 0 +-539 -535 0 +-539 -536 0 +-539 -537 0 +-539 -538 0 +-539 -540 0 +-540 -532 0 +-540 -533 0 +-540 -534 0 +-540 -535 0 +-540 -536 0 +-540 -537 0 +-540 -538 0 +-540 -539 0 +532 533 534 535 536 537 538 539 540 0 +-541 -542 0 +-541 -543 0 +-541 -544 0 +-541 -545 0 +-541 -546 0 +-541 -547 0 +-541 -548 0 +-541 -549 0 +-542 -541 0 +-542 -543 0 +-542 -544 0 +-542 -545 0 +-542 -546 0 +-542 -547 0 +-542 -548 0 +-542 -549 0 +-543 -541 0 +-543 -542 0 +-543 -544 0 +-543 -545 0 +-543 -546 0 +-543 -547 0 +-543 -548 0 +-543 -549 0 +-544 -541 0 +-544 -542 0 +-544 -543 0 +-544 -545 0 +-544 -546 0 +-544 -547 0 +-544 -548 0 +-544 -549 0 +-545 -541 0 +-545 -542 0 +-545 -543 0 +-545 -544 0 +-545 -546 0 +-545 -547 0 +-545 -548 0 +-545 -549 0 +-546 -541 0 +-546 -542 0 +-546 -543 0 +-546 -544 0 +-546 -545 0 +-546 -547 0 +-546 -548 0 +-546 -549 0 +-547 -541 0 +-547 -542 0 +-547 -543 0 +-547 -544 0 +-547 -545 0 +-547 -546 0 +-547 -548 0 +-547 -549 0 +-548 -541 0 +-548 -542 0 +-548 -543 0 +-548 -544 0 +-548 -545 0 +-548 -546 0 +-548 -547 0 +-548 -549 0 +-549 -541 0 +-549 -542 0 +-549 -543 0 +-549 -544 0 +-549 -545 0 +-549 -546 0 +-549 -547 0 +-549 -548 0 +541 542 543 544 545 546 547 548 549 0 +-550 -551 0 +-550 -552 0 +-550 -553 0 +-550 -554 0 +-550 -555 0 +-550 -556 0 +-550 -557 0 +-550 -558 0 +-551 -550 0 +-551 -552 0 +-551 -553 0 +-551 -554 0 +-551 -555 0 +-551 -556 0 +-551 -557 0 +-551 -558 0 +-552 -550 0 +-552 -551 0 +-552 -553 0 +-552 -554 0 +-552 -555 0 +-552 -556 0 +-552 -557 0 +-552 -558 0 +-553 -550 0 +-553 -551 0 +-553 -552 0 +-553 -554 0 +-553 -555 0 +-553 -556 0 +-553 -557 0 +-553 -558 0 +-554 -550 0 +-554 -551 0 +-554 -552 0 +-554 -553 0 +-554 -555 0 +-554 -556 0 +-554 -557 0 +-554 -558 0 +-555 -550 0 +-555 -551 0 +-555 -552 0 +-555 -553 0 +-555 -554 0 +-555 -556 0 +-555 -557 0 +-555 -558 0 +-556 -550 0 +-556 -551 0 +-556 -552 0 +-556 -553 0 +-556 -554 0 +-556 -555 0 +-556 -557 0 +-556 -558 0 +-557 -550 0 +-557 -551 0 +-557 -552 0 +-557 -553 0 +-557 -554 0 +-557 -555 0 +-557 -556 0 +-557 -558 0 +-558 -550 0 +-558 -551 0 +-558 -552 0 +-558 -553 0 +-558 -554 0 +-558 -555 0 +-558 -556 0 +-558 -557 0 +550 551 552 553 554 555 556 557 558 0 +-559 -560 0 +-559 -561 0 +-559 -562 0 +-559 -563 0 +-559 -564 0 +-559 -565 0 +-559 -566 0 +-559 -567 0 +-560 -559 0 +-560 -561 0 +-560 -562 0 +-560 -563 0 +-560 -564 0 +-560 -565 0 +-560 -566 0 +-560 -567 0 +-561 -559 0 +-561 -560 0 +-561 -562 0 +-561 -563 0 +-561 -564 0 +-561 -565 0 +-561 -566 0 +-561 -567 0 +-562 -559 0 +-562 -560 0 +-562 -561 0 +-562 -563 0 +-562 -564 0 +-562 -565 0 +-562 -566 0 +-562 -567 0 +-563 -559 0 +-563 -560 0 +-563 -561 0 +-563 -562 0 +-563 -564 0 +-563 -565 0 +-563 -566 0 +-563 -567 0 +-564 -559 0 +-564 -560 0 +-564 -561 0 +-564 -562 0 +-564 -563 0 +-564 -565 0 +-564 -566 0 +-564 -567 0 +-565 -559 0 +-565 -560 0 +-565 -561 0 +-565 -562 0 +-565 -563 0 +-565 -564 0 +-565 -566 0 +-565 -567 0 +-566 -559 0 +-566 -560 0 +-566 -561 0 +-566 -562 0 +-566 -563 0 +-566 -564 0 +-566 -565 0 +-566 -567 0 +-567 -559 0 +-567 -560 0 +-567 -561 0 +-567 -562 0 +-567 -563 0 +-567 -564 0 +-567 -565 0 +-567 -566 0 +559 560 561 562 563 564 565 566 567 0 +-568 -569 0 +-568 -570 0 +-568 -571 0 +-568 -572 0 +-568 -573 0 +-568 -574 0 +-568 -575 0 +-568 -576 0 +-569 -568 0 +-569 -570 0 +-569 -571 0 +-569 -572 0 +-569 -573 0 +-569 -574 0 +-569 -575 0 +-569 -576 0 +-570 -568 0 +-570 -569 0 +-570 -571 0 +-570 -572 0 +-570 -573 0 +-570 -574 0 +-570 -575 0 +-570 -576 0 +-571 -568 0 +-571 -569 0 +-571 -570 0 +-571 -572 0 +-571 -573 0 +-571 -574 0 +-571 -575 0 +-571 -576 0 +-572 -568 0 +-572 -569 0 +-572 -570 0 +-572 -571 0 +-572 -573 0 +-572 -574 0 +-572 -575 0 +-572 -576 0 +-573 -568 0 +-573 -569 0 +-573 -570 0 +-573 -571 0 +-573 -572 0 +-573 -574 0 +-573 -575 0 +-573 -576 0 +-574 -568 0 +-574 -569 0 +-574 -570 0 +-574 -571 0 +-574 -572 0 +-574 -573 0 +-574 -575 0 +-574 -576 0 +-575 -568 0 +-575 -569 0 +-575 -570 0 +-575 -571 0 +-575 -572 0 +-575 -573 0 +-575 -574 0 +-575 -576 0 +-576 -568 0 +-576 -569 0 +-576 -570 0 +-576 -571 0 +-576 -572 0 +-576 -573 0 +-576 -574 0 +-576 -575 0 +568 569 570 571 572 573 574 575 576 0 +-577 -578 0 +-577 -579 0 +-577 -580 0 +-577 -581 0 +-577 -582 0 +-577 -583 0 +-577 -584 0 +-577 -585 0 +-578 -577 0 +-578 -579 0 +-578 -580 0 +-578 -581 0 +-578 -582 0 +-578 -583 0 +-578 -584 0 +-578 -585 0 +-579 -577 0 +-579 -578 0 +-579 -580 0 +-579 -581 0 +-579 -582 0 +-579 -583 0 +-579 -584 0 +-579 -585 0 +-580 -577 0 +-580 -578 0 +-580 -579 0 +-580 -581 0 +-580 -582 0 +-580 -583 0 +-580 -584 0 +-580 -585 0 +-581 -577 0 +-581 -578 0 +-581 -579 0 +-581 -580 0 +-581 -582 0 +-581 -583 0 +-581 -584 0 +-581 -585 0 +-582 -577 0 +-582 -578 0 +-582 -579 0 +-582 -580 0 +-582 -581 0 +-582 -583 0 +-582 -584 0 +-582 -585 0 +-583 -577 0 +-583 -578 0 +-583 -579 0 +-583 -580 0 +-583 -581 0 +-583 -582 0 +-583 -584 0 +-583 -585 0 +-584 -577 0 +-584 -578 0 +-584 -579 0 +-584 -580 0 +-584 -581 0 +-584 -582 0 +-584 -583 0 +-584 -585 0 +-585 -577 0 +-585 -578 0 +-585 -579 0 +-585 -580 0 +-585 -581 0 +-585 -582 0 +-585 -583 0 +-585 -584 0 +577 578 579 580 581 582 583 584 585 0 +-586 -587 0 +-586 -588 0 +-586 -589 0 +-586 -590 0 +-586 -591 0 +-586 -592 0 +-586 -593 0 +-586 -594 0 +-587 -586 0 +-587 -588 0 +-587 -589 0 +-587 -590 0 +-587 -591 0 +-587 -592 0 +-587 -593 0 +-587 -594 0 +-588 -586 0 +-588 -587 0 +-588 -589 0 +-588 -590 0 +-588 -591 0 +-588 -592 0 +-588 -593 0 +-588 -594 0 +-589 -586 0 +-589 -587 0 +-589 -588 0 +-589 -590 0 +-589 -591 0 +-589 -592 0 +-589 -593 0 +-589 -594 0 +-590 -586 0 +-590 -587 0 +-590 -588 0 +-590 -589 0 +-590 -591 0 +-590 -592 0 +-590 -593 0 +-590 -594 0 +-591 -586 0 +-591 -587 0 +-591 -588 0 +-591 -589 0 +-591 -590 0 +-591 -592 0 +-591 -593 0 +-591 -594 0 +-592 -586 0 +-592 -587 0 +-592 -588 0 +-592 -589 0 +-592 -590 0 +-592 -591 0 +-592 -593 0 +-592 -594 0 +-593 -586 0 +-593 -587 0 +-593 -588 0 +-593 -589 0 +-593 -590 0 +-593 -591 0 +-593 -592 0 +-593 -594 0 +-594 -586 0 +-594 -587 0 +-594 -588 0 +-594 -589 0 +-594 -590 0 +-594 -591 0 +-594 -592 0 +-594 -593 0 +586 587 588 589 590 591 592 593 594 0 +-595 -596 0 +-595 -597 0 +-595 -598 0 +-595 -599 0 +-595 -600 0 +-595 -601 0 +-595 -602 0 +-595 -603 0 +-596 -595 0 +-596 -597 0 +-596 -598 0 +-596 -599 0 +-596 -600 0 +-596 -601 0 +-596 -602 0 +-596 -603 0 +-597 -595 0 +-597 -596 0 +-597 -598 0 +-597 -599 0 +-597 -600 0 +-597 -601 0 +-597 -602 0 +-597 -603 0 +-598 -595 0 +-598 -596 0 +-598 -597 0 +-598 -599 0 +-598 -600 0 +-598 -601 0 +-598 -602 0 +-598 -603 0 +-599 -595 0 +-599 -596 0 +-599 -597 0 +-599 -598 0 +-599 -600 0 +-599 -601 0 +-599 -602 0 +-599 -603 0 +-600 -595 0 +-600 -596 0 +-600 -597 0 +-600 -598 0 +-600 -599 0 +-600 -601 0 +-600 -602 0 +-600 -603 0 +-601 -595 0 +-601 -596 0 +-601 -597 0 +-601 -598 0 +-601 -599 0 +-601 -600 0 +-601 -602 0 +-601 -603 0 +-602 -595 0 +-602 -596 0 +-602 -597 0 +-602 -598 0 +-602 -599 0 +-602 -600 0 +-602 -601 0 +-602 -603 0 +-603 -595 0 +-603 -596 0 +-603 -597 0 +-603 -598 0 +-603 -599 0 +-603 -600 0 +-603 -601 0 +-603 -602 0 +595 596 597 598 599 600 601 602 603 0 +-604 -605 0 +-604 -606 0 +-604 -607 0 +-604 -608 0 +-604 -609 0 +-604 -610 0 +-604 -611 0 +-604 -612 0 +-605 -604 0 +-605 -606 0 +-605 -607 0 +-605 -608 0 +-605 -609 0 +-605 -610 0 +-605 -611 0 +-605 -612 0 +-606 -604 0 +-606 -605 0 +-606 -607 0 +-606 -608 0 +-606 -609 0 +-606 -610 0 +-606 -611 0 +-606 -612 0 +-607 -604 0 +-607 -605 0 +-607 -606 0 +-607 -608 0 +-607 -609 0 +-607 -610 0 +-607 -611 0 +-607 -612 0 +-608 -604 0 +-608 -605 0 +-608 -606 0 +-608 -607 0 +-608 -609 0 +-608 -610 0 +-608 -611 0 +-608 -612 0 +-609 -604 0 +-609 -605 0 +-609 -606 0 +-609 -607 0 +-609 -608 0 +-609 -610 0 +-609 -611 0 +-609 -612 0 +-610 -604 0 +-610 -605 0 +-610 -606 0 +-610 -607 0 +-610 -608 0 +-610 -609 0 +-610 -611 0 +-610 -612 0 +-611 -604 0 +-611 -605 0 +-611 -606 0 +-611 -607 0 +-611 -608 0 +-611 -609 0 +-611 -610 0 +-611 -612 0 +-612 -604 0 +-612 -605 0 +-612 -606 0 +-612 -607 0 +-612 -608 0 +-612 -609 0 +-612 -610 0 +-612 -611 0 +604 605 606 607 608 609 610 611 612 0 +-613 -614 0 +-613 -615 0 +-613 -616 0 +-613 -617 0 +-613 -618 0 +-613 -619 0 +-613 -620 0 +-613 -621 0 +-614 -613 0 +-614 -615 0 +-614 -616 0 +-614 -617 0 +-614 -618 0 +-614 -619 0 +-614 -620 0 +-614 -621 0 +-615 -613 0 +-615 -614 0 +-615 -616 0 +-615 -617 0 +-615 -618 0 +-615 -619 0 +-615 -620 0 +-615 -621 0 +-616 -613 0 +-616 -614 0 +-616 -615 0 +-616 -617 0 +-616 -618 0 +-616 -619 0 +-616 -620 0 +-616 -621 0 +-617 -613 0 +-617 -614 0 +-617 -615 0 +-617 -616 0 +-617 -618 0 +-617 -619 0 +-617 -620 0 +-617 -621 0 +-618 -613 0 +-618 -614 0 +-618 -615 0 +-618 -616 0 +-618 -617 0 +-618 -619 0 +-618 -620 0 +-618 -621 0 +-619 -613 0 +-619 -614 0 +-619 -615 0 +-619 -616 0 +-619 -617 0 +-619 -618 0 +-619 -620 0 +-619 -621 0 +-620 -613 0 +-620 -614 0 +-620 -615 0 +-620 -616 0 +-620 -617 0 +-620 -618 0 +-620 -619 0 +-620 -621 0 +-621 -613 0 +-621 -614 0 +-621 -615 0 +-621 -616 0 +-621 -617 0 +-621 -618 0 +-621 -619 0 +-621 -620 0 +613 614 615 616 617 618 619 620 621 0 +-622 -623 0 +-622 -624 0 +-622 -625 0 +-622 -626 0 +-622 -627 0 +-622 -628 0 +-622 -629 0 +-622 -630 0 +-623 -622 0 +-623 -624 0 +-623 -625 0 +-623 -626 0 +-623 -627 0 +-623 -628 0 +-623 -629 0 +-623 -630 0 +-624 -622 0 +-624 -623 0 +-624 -625 0 +-624 -626 0 +-624 -627 0 +-624 -628 0 +-624 -629 0 +-624 -630 0 +-625 -622 0 +-625 -623 0 +-625 -624 0 +-625 -626 0 +-625 -627 0 +-625 -628 0 +-625 -629 0 +-625 -630 0 +-626 -622 0 +-626 -623 0 +-626 -624 0 +-626 -625 0 +-626 -627 0 +-626 -628 0 +-626 -629 0 +-626 -630 0 +-627 -622 0 +-627 -623 0 +-627 -624 0 +-627 -625 0 +-627 -626 0 +-627 -628 0 +-627 -629 0 +-627 -630 0 +-628 -622 0 +-628 -623 0 +-628 -624 0 +-628 -625 0 +-628 -626 0 +-628 -627 0 +-628 -629 0 +-628 -630 0 +-629 -622 0 +-629 -623 0 +-629 -624 0 +-629 -625 0 +-629 -626 0 +-629 -627 0 +-629 -628 0 +-629 -630 0 +-630 -622 0 +-630 -623 0 +-630 -624 0 +-630 -625 0 +-630 -626 0 +-630 -627 0 +-630 -628 0 +-630 -629 0 +622 623 624 625 626 627 628 629 630 0 +-631 -632 0 +-631 -633 0 +-631 -634 0 +-631 -635 0 +-631 -636 0 +-631 -637 0 +-631 -638 0 +-631 -639 0 +-632 -631 0 +-632 -633 0 +-632 -634 0 +-632 -635 0 +-632 -636 0 +-632 -637 0 +-632 -638 0 +-632 -639 0 +-633 -631 0 +-633 -632 0 +-633 -634 0 +-633 -635 0 +-633 -636 0 +-633 -637 0 +-633 -638 0 +-633 -639 0 +-634 -631 0 +-634 -632 0 +-634 -633 0 +-634 -635 0 +-634 -636 0 +-634 -637 0 +-634 -638 0 +-634 -639 0 +-635 -631 0 +-635 -632 0 +-635 -633 0 +-635 -634 0 +-635 -636 0 +-635 -637 0 +-635 -638 0 +-635 -639 0 +-636 -631 0 +-636 -632 0 +-636 -633 0 +-636 -634 0 +-636 -635 0 +-636 -637 0 +-636 -638 0 +-636 -639 0 +-637 -631 0 +-637 -632 0 +-637 -633 0 +-637 -634 0 +-637 -635 0 +-637 -636 0 +-637 -638 0 +-637 -639 0 +-638 -631 0 +-638 -632 0 +-638 -633 0 +-638 -634 0 +-638 -635 0 +-638 -636 0 +-638 -637 0 +-638 -639 0 +-639 -631 0 +-639 -632 0 +-639 -633 0 +-639 -634 0 +-639 -635 0 +-639 -636 0 +-639 -637 0 +-639 -638 0 +631 632 633 634 635 636 637 638 639 0 +-640 -641 0 +-640 -642 0 +-640 -643 0 +-640 -644 0 +-640 -645 0 +-640 -646 0 +-640 -647 0 +-640 -648 0 +-641 -640 0 +-641 -642 0 +-641 -643 0 +-641 -644 0 +-641 -645 0 +-641 -646 0 +-641 -647 0 +-641 -648 0 +-642 -640 0 +-642 -641 0 +-642 -643 0 +-642 -644 0 +-642 -645 0 +-642 -646 0 +-642 -647 0 +-642 -648 0 +-643 -640 0 +-643 -641 0 +-643 -642 0 +-643 -644 0 +-643 -645 0 +-643 -646 0 +-643 -647 0 +-643 -648 0 +-644 -640 0 +-644 -641 0 +-644 -642 0 +-644 -643 0 +-644 -645 0 +-644 -646 0 +-644 -647 0 +-644 -648 0 +-645 -640 0 +-645 -641 0 +-645 -642 0 +-645 -643 0 +-645 -644 0 +-645 -646 0 +-645 -647 0 +-645 -648 0 +-646 -640 0 +-646 -641 0 +-646 -642 0 +-646 -643 0 +-646 -644 0 +-646 -645 0 +-646 -647 0 +-646 -648 0 +-647 -640 0 +-647 -641 0 +-647 -642 0 +-647 -643 0 +-647 -644 0 +-647 -645 0 +-647 -646 0 +-647 -648 0 +-648 -640 0 +-648 -641 0 +-648 -642 0 +-648 -643 0 +-648 -644 0 +-648 -645 0 +-648 -646 0 +-648 -647 0 +640 641 642 643 644 645 646 647 648 0 +-649 -650 0 +-649 -651 0 +-649 -652 0 +-649 -653 0 +-649 -654 0 +-649 -655 0 +-649 -656 0 +-649 -657 0 +-650 -649 0 +-650 -651 0 +-650 -652 0 +-650 -653 0 +-650 -654 0 +-650 -655 0 +-650 -656 0 +-650 -657 0 +-651 -649 0 +-651 -650 0 +-651 -652 0 +-651 -653 0 +-651 -654 0 +-651 -655 0 +-651 -656 0 +-651 -657 0 +-652 -649 0 +-652 -650 0 +-652 -651 0 +-652 -653 0 +-652 -654 0 +-652 -655 0 +-652 -656 0 +-652 -657 0 +-653 -649 0 +-653 -650 0 +-653 -651 0 +-653 -652 0 +-653 -654 0 +-653 -655 0 +-653 -656 0 +-653 -657 0 +-654 -649 0 +-654 -650 0 +-654 -651 0 +-654 -652 0 +-654 -653 0 +-654 -655 0 +-654 -656 0 +-654 -657 0 +-655 -649 0 +-655 -650 0 +-655 -651 0 +-655 -652 0 +-655 -653 0 +-655 -654 0 +-655 -656 0 +-655 -657 0 +-656 -649 0 +-656 -650 0 +-656 -651 0 +-656 -652 0 +-656 -653 0 +-656 -654 0 +-656 -655 0 +-656 -657 0 +-657 -649 0 +-657 -650 0 +-657 -651 0 +-657 -652 0 +-657 -653 0 +-657 -654 0 +-657 -655 0 +-657 -656 0 +649 650 651 652 653 654 655 656 657 0 +-658 -659 0 +-658 -660 0 +-658 -661 0 +-658 -662 0 +-658 -663 0 +-658 -664 0 +-658 -665 0 +-658 -666 0 +-659 -658 0 +-659 -660 0 +-659 -661 0 +-659 -662 0 +-659 -663 0 +-659 -664 0 +-659 -665 0 +-659 -666 0 +-660 -658 0 +-660 -659 0 +-660 -661 0 +-660 -662 0 +-660 -663 0 +-660 -664 0 +-660 -665 0 +-660 -666 0 +-661 -658 0 +-661 -659 0 +-661 -660 0 +-661 -662 0 +-661 -663 0 +-661 -664 0 +-661 -665 0 +-661 -666 0 +-662 -658 0 +-662 -659 0 +-662 -660 0 +-662 -661 0 +-662 -663 0 +-662 -664 0 +-662 -665 0 +-662 -666 0 +-663 -658 0 +-663 -659 0 +-663 -660 0 +-663 -661 0 +-663 -662 0 +-663 -664 0 +-663 -665 0 +-663 -666 0 +-664 -658 0 +-664 -659 0 +-664 -660 0 +-664 -661 0 +-664 -662 0 +-664 -663 0 +-664 -665 0 +-664 -666 0 +-665 -658 0 +-665 -659 0 +-665 -660 0 +-665 -661 0 +-665 -662 0 +-665 -663 0 +-665 -664 0 +-665 -666 0 +-666 -658 0 +-666 -659 0 +-666 -660 0 +-666 -661 0 +-666 -662 0 +-666 -663 0 +-666 -664 0 +-666 -665 0 +658 659 660 661 662 663 664 665 666 0 +-667 -668 0 +-667 -669 0 +-667 -670 0 +-667 -671 0 +-667 -672 0 +-667 -673 0 +-667 -674 0 +-667 -675 0 +-668 -667 0 +-668 -669 0 +-668 -670 0 +-668 -671 0 +-668 -672 0 +-668 -673 0 +-668 -674 0 +-668 -675 0 +-669 -667 0 +-669 -668 0 +-669 -670 0 +-669 -671 0 +-669 -672 0 +-669 -673 0 +-669 -674 0 +-669 -675 0 +-670 -667 0 +-670 -668 0 +-670 -669 0 +-670 -671 0 +-670 -672 0 +-670 -673 0 +-670 -674 0 +-670 -675 0 +-671 -667 0 +-671 -668 0 +-671 -669 0 +-671 -670 0 +-671 -672 0 +-671 -673 0 +-671 -674 0 +-671 -675 0 +-672 -667 0 +-672 -668 0 +-672 -669 0 +-672 -670 0 +-672 -671 0 +-672 -673 0 +-672 -674 0 +-672 -675 0 +-673 -667 0 +-673 -668 0 +-673 -669 0 +-673 -670 0 +-673 -671 0 +-673 -672 0 +-673 -674 0 +-673 -675 0 +-674 -667 0 +-674 -668 0 +-674 -669 0 +-674 -670 0 +-674 -671 0 +-674 -672 0 +-674 -673 0 +-674 -675 0 +-675 -667 0 +-675 -668 0 +-675 -669 0 +-675 -670 0 +-675 -671 0 +-675 -672 0 +-675 -673 0 +-675 -674 0 +667 668 669 670 671 672 673 674 675 0 +-676 -677 0 +-676 -678 0 +-676 -679 0 +-676 -680 0 +-676 -681 0 +-676 -682 0 +-676 -683 0 +-676 -684 0 +-677 -676 0 +-677 -678 0 +-677 -679 0 +-677 -680 0 +-677 -681 0 +-677 -682 0 +-677 -683 0 +-677 -684 0 +-678 -676 0 +-678 -677 0 +-678 -679 0 +-678 -680 0 +-678 -681 0 +-678 -682 0 +-678 -683 0 +-678 -684 0 +-679 -676 0 +-679 -677 0 +-679 -678 0 +-679 -680 0 +-679 -681 0 +-679 -682 0 +-679 -683 0 +-679 -684 0 +-680 -676 0 +-680 -677 0 +-680 -678 0 +-680 -679 0 +-680 -681 0 +-680 -682 0 +-680 -683 0 +-680 -684 0 +-681 -676 0 +-681 -677 0 +-681 -678 0 +-681 -679 0 +-681 -680 0 +-681 -682 0 +-681 -683 0 +-681 -684 0 +-682 -676 0 +-682 -677 0 +-682 -678 0 +-682 -679 0 +-682 -680 0 +-682 -681 0 +-682 -683 0 +-682 -684 0 +-683 -676 0 +-683 -677 0 +-683 -678 0 +-683 -679 0 +-683 -680 0 +-683 -681 0 +-683 -682 0 +-683 -684 0 +-684 -676 0 +-684 -677 0 +-684 -678 0 +-684 -679 0 +-684 -680 0 +-684 -681 0 +-684 -682 0 +-684 -683 0 +676 677 678 679 680 681 682 683 684 0 +-685 -686 0 +-685 -687 0 +-685 -688 0 +-685 -689 0 +-685 -690 0 +-685 -691 0 +-685 -692 0 +-685 -693 0 +-686 -685 0 +-686 -687 0 +-686 -688 0 +-686 -689 0 +-686 -690 0 +-686 -691 0 +-686 -692 0 +-686 -693 0 +-687 -685 0 +-687 -686 0 +-687 -688 0 +-687 -689 0 +-687 -690 0 +-687 -691 0 +-687 -692 0 +-687 -693 0 +-688 -685 0 +-688 -686 0 +-688 -687 0 +-688 -689 0 +-688 -690 0 +-688 -691 0 +-688 -692 0 +-688 -693 0 +-689 -685 0 +-689 -686 0 +-689 -687 0 +-689 -688 0 +-689 -690 0 +-689 -691 0 +-689 -692 0 +-689 -693 0 +-690 -685 0 +-690 -686 0 +-690 -687 0 +-690 -688 0 +-690 -689 0 +-690 -691 0 +-690 -692 0 +-690 -693 0 +-691 -685 0 +-691 -686 0 +-691 -687 0 +-691 -688 0 +-691 -689 0 +-691 -690 0 +-691 -692 0 +-691 -693 0 +-692 -685 0 +-692 -686 0 +-692 -687 0 +-692 -688 0 +-692 -689 0 +-692 -690 0 +-692 -691 0 +-692 -693 0 +-693 -685 0 +-693 -686 0 +-693 -687 0 +-693 -688 0 +-693 -689 0 +-693 -690 0 +-693 -691 0 +-693 -692 0 +685 686 687 688 689 690 691 692 693 0 +-694 -695 0 +-694 -696 0 +-694 -697 0 +-694 -698 0 +-694 -699 0 +-694 -700 0 +-694 -701 0 +-694 -702 0 +-695 -694 0 +-695 -696 0 +-695 -697 0 +-695 -698 0 +-695 -699 0 +-695 -700 0 +-695 -701 0 +-695 -702 0 +-696 -694 0 +-696 -695 0 +-696 -697 0 +-696 -698 0 +-696 -699 0 +-696 -700 0 +-696 -701 0 +-696 -702 0 +-697 -694 0 +-697 -695 0 +-697 -696 0 +-697 -698 0 +-697 -699 0 +-697 -700 0 +-697 -701 0 +-697 -702 0 +-698 -694 0 +-698 -695 0 +-698 -696 0 +-698 -697 0 +-698 -699 0 +-698 -700 0 +-698 -701 0 +-698 -702 0 +-699 -694 0 +-699 -695 0 +-699 -696 0 +-699 -697 0 +-699 -698 0 +-699 -700 0 +-699 -701 0 +-699 -702 0 +-700 -694 0 +-700 -695 0 +-700 -696 0 +-700 -697 0 +-700 -698 0 +-700 -699 0 +-700 -701 0 +-700 -702 0 +-701 -694 0 +-701 -695 0 +-701 -696 0 +-701 -697 0 +-701 -698 0 +-701 -699 0 +-701 -700 0 +-701 -702 0 +-702 -694 0 +-702 -695 0 +-702 -696 0 +-702 -697 0 +-702 -698 0 +-702 -699 0 +-702 -700 0 +-702 -701 0 +694 695 696 697 698 699 700 701 702 0 +-703 -704 0 +-703 -705 0 +-703 -706 0 +-703 -707 0 +-703 -708 0 +-703 -709 0 +-703 -710 0 +-703 -711 0 +-704 -703 0 +-704 -705 0 +-704 -706 0 +-704 -707 0 +-704 -708 0 +-704 -709 0 +-704 -710 0 +-704 -711 0 +-705 -703 0 +-705 -704 0 +-705 -706 0 +-705 -707 0 +-705 -708 0 +-705 -709 0 +-705 -710 0 +-705 -711 0 +-706 -703 0 +-706 -704 0 +-706 -705 0 +-706 -707 0 +-706 -708 0 +-706 -709 0 +-706 -710 0 +-706 -711 0 +-707 -703 0 +-707 -704 0 +-707 -705 0 +-707 -706 0 +-707 -708 0 +-707 -709 0 +-707 -710 0 +-707 -711 0 +-708 -703 0 +-708 -704 0 +-708 -705 0 +-708 -706 0 +-708 -707 0 +-708 -709 0 +-708 -710 0 +-708 -711 0 +-709 -703 0 +-709 -704 0 +-709 -705 0 +-709 -706 0 +-709 -707 0 +-709 -708 0 +-709 -710 0 +-709 -711 0 +-710 -703 0 +-710 -704 0 +-710 -705 0 +-710 -706 0 +-710 -707 0 +-710 -708 0 +-710 -709 0 +-710 -711 0 +-711 -703 0 +-711 -704 0 +-711 -705 0 +-711 -706 0 +-711 -707 0 +-711 -708 0 +-711 -709 0 +-711 -710 0 +703 704 705 706 707 708 709 710 711 0 +-712 -713 0 +-712 -714 0 +-712 -715 0 +-712 -716 0 +-712 -717 0 +-712 -718 0 +-712 -719 0 +-712 -720 0 +-713 -712 0 +-713 -714 0 +-713 -715 0 +-713 -716 0 +-713 -717 0 +-713 -718 0 +-713 -719 0 +-713 -720 0 +-714 -712 0 +-714 -713 0 +-714 -715 0 +-714 -716 0 +-714 -717 0 +-714 -718 0 +-714 -719 0 +-714 -720 0 +-715 -712 0 +-715 -713 0 +-715 -714 0 +-715 -716 0 +-715 -717 0 +-715 -718 0 +-715 -719 0 +-715 -720 0 +-716 -712 0 +-716 -713 0 +-716 -714 0 +-716 -715 0 +-716 -717 0 +-716 -718 0 +-716 -719 0 +-716 -720 0 +-717 -712 0 +-717 -713 0 +-717 -714 0 +-717 -715 0 +-717 -716 0 +-717 -718 0 +-717 -719 0 +-717 -720 0 +-718 -712 0 +-718 -713 0 +-718 -714 0 +-718 -715 0 +-718 -716 0 +-718 -717 0 +-718 -719 0 +-718 -720 0 +-719 -712 0 +-719 -713 0 +-719 -714 0 +-719 -715 0 +-719 -716 0 +-719 -717 0 +-719 -718 0 +-719 -720 0 +-720 -712 0 +-720 -713 0 +-720 -714 0 +-720 -715 0 +-720 -716 0 +-720 -717 0 +-720 -718 0 +-720 -719 0 +712 713 714 715 716 717 718 719 720 0 +-721 -722 0 +-721 -723 0 +-721 -724 0 +-721 -725 0 +-721 -726 0 +-721 -727 0 +-721 -728 0 +-721 -729 0 +-722 -721 0 +-722 -723 0 +-722 -724 0 +-722 -725 0 +-722 -726 0 +-722 -727 0 +-722 -728 0 +-722 -729 0 +-723 -721 0 +-723 -722 0 +-723 -724 0 +-723 -725 0 +-723 -726 0 +-723 -727 0 +-723 -728 0 +-723 -729 0 +-724 -721 0 +-724 -722 0 +-724 -723 0 +-724 -725 0 +-724 -726 0 +-724 -727 0 +-724 -728 0 +-724 -729 0 +-725 -721 0 +-725 -722 0 +-725 -723 0 +-725 -724 0 +-725 -726 0 +-725 -727 0 +-725 -728 0 +-725 -729 0 +-726 -721 0 +-726 -722 0 +-726 -723 0 +-726 -724 0 +-726 -725 0 +-726 -727 0 +-726 -728 0 +-726 -729 0 +-727 -721 0 +-727 -722 0 +-727 -723 0 +-727 -724 0 +-727 -725 0 +-727 -726 0 +-727 -728 0 +-727 -729 0 +-728 -721 0 +-728 -722 0 +-728 -723 0 +-728 -724 0 +-728 -725 0 +-728 -726 0 +-728 -727 0 +-728 -729 0 +-729 -721 0 +-729 -722 0 +-729 -723 0 +-729 -724 0 +-729 -725 0 +-729 -726 0 +-729 -727 0 +-729 -728 0 +721 722 723 724 725 726 727 728 729 0 +2 0 +18 0 +30 0 +53 0 +105 0 +112 0 +149 0 +196 0 +234 0 +262 0 +323 0 +331 0 +369 0 +381 0 +408 0 +482 0 +533 0 +564 0 +584 0 +604 0 +626 0 +653 0 +659 0 +692 0 +-1 -10 0 +-2 -11 0 +-3 -12 0 +-4 -13 0 +-5 -14 0 +-6 -15 0 +-7 -16 0 +-8 -17 0 +-9 -18 0 +-1 -19 0 +-2 -20 0 +-3 -21 0 +-4 -22 0 +-5 -23 0 +-6 -24 0 +-7 -25 0 +-8 -26 0 +-9 -27 0 +-1 -28 0 +-2 -29 0 +-3 -30 0 +-4 -31 0 +-5 -32 0 +-6 -33 0 +-7 -34 0 +-8 -35 0 +-9 -36 0 +-1 -37 0 +-2 -38 0 +-3 -39 0 +-4 -40 0 +-5 -41 0 +-6 -42 0 +-7 -43 0 +-8 -44 0 +-9 -45 0 +-1 -46 0 +-2 -47 0 +-3 -48 0 +-4 -49 0 +-5 -50 0 +-6 -51 0 +-7 -52 0 +-8 -53 0 +-9 -54 0 +-1 -55 0 +-2 -56 0 +-3 -57 0 +-4 -58 0 +-5 -59 0 +-6 -60 0 +-7 -61 0 +-8 -62 0 +-9 -63 0 +-1 -64 0 +-2 -65 0 +-3 -66 0 +-4 -67 0 +-5 -68 0 +-6 -69 0 +-7 -70 0 +-8 -71 0 +-9 -72 0 +-1 -73 0 +-2 -74 0 +-3 -75 0 +-4 -76 0 +-5 -77 0 +-6 -78 0 +-7 -79 0 +-8 -80 0 +-9 -81 0 +-10 -1 0 +-11 -2 0 +-12 -3 0 +-13 -4 0 +-14 -5 0 +-15 -6 0 +-16 -7 0 +-17 -8 0 +-18 -9 0 +-10 -19 0 +-11 -20 0 +-12 -21 0 +-13 -22 0 +-14 -23 0 +-15 -24 0 +-16 -25 0 +-17 -26 0 +-18 -27 0 +-10 -28 0 +-11 -29 0 +-12 -30 0 +-13 -31 0 +-14 -32 0 +-15 -33 0 +-16 -34 0 +-17 -35 0 +-18 -36 0 +-10 -37 0 +-11 -38 0 +-12 -39 0 +-13 -40 0 +-14 -41 0 +-15 -42 0 +-16 -43 0 +-17 -44 0 +-18 -45 0 +-10 -46 0 +-11 -47 0 +-12 -48 0 +-13 -49 0 +-14 -50 0 +-15 -51 0 +-16 -52 0 +-17 -53 0 +-18 -54 0 +-10 -55 0 +-11 -56 0 +-12 -57 0 +-13 -58 0 +-14 -59 0 +-15 -60 0 +-16 -61 0 +-17 -62 0 +-18 -63 0 +-10 -64 0 +-11 -65 0 +-12 -66 0 +-13 -67 0 +-14 -68 0 +-15 -69 0 +-16 -70 0 +-17 -71 0 +-18 -72 0 +-10 -73 0 +-11 -74 0 +-12 -75 0 +-13 -76 0 +-14 -77 0 +-15 -78 0 +-16 -79 0 +-17 -80 0 +-18 -81 0 +-19 -1 0 +-20 -2 0 +-21 -3 0 +-22 -4 0 +-23 -5 0 +-24 -6 0 +-25 -7 0 +-26 -8 0 +-27 -9 0 +-19 -10 0 +-20 -11 0 +-21 -12 0 +-22 -13 0 +-23 -14 0 +-24 -15 0 +-25 -16 0 +-26 -17 0 +-27 -18 0 +-19 -28 0 +-20 -29 0 +-21 -30 0 +-22 -31 0 +-23 -32 0 +-24 -33 0 +-25 -34 0 +-26 -35 0 +-27 -36 0 +-19 -37 0 +-20 -38 0 +-21 -39 0 +-22 -40 0 +-23 -41 0 +-24 -42 0 +-25 -43 0 +-26 -44 0 +-27 -45 0 +-19 -46 0 +-20 -47 0 +-21 -48 0 +-22 -49 0 +-23 -50 0 +-24 -51 0 +-25 -52 0 +-26 -53 0 +-27 -54 0 +-19 -55 0 +-20 -56 0 +-21 -57 0 +-22 -58 0 +-23 -59 0 +-24 -60 0 +-25 -61 0 +-26 -62 0 +-27 -63 0 +-19 -64 0 +-20 -65 0 +-21 -66 0 +-22 -67 0 +-23 -68 0 +-24 -69 0 +-25 -70 0 +-26 -71 0 +-27 -72 0 +-19 -73 0 +-20 -74 0 +-21 -75 0 +-22 -76 0 +-23 -77 0 +-24 -78 0 +-25 -79 0 +-26 -80 0 +-27 -81 0 +-28 -1 0 +-29 -2 0 +-30 -3 0 +-31 -4 0 +-32 -5 0 +-33 -6 0 +-34 -7 0 +-35 -8 0 +-36 -9 0 +-28 -10 0 +-29 -11 0 +-30 -12 0 +-31 -13 0 +-32 -14 0 +-33 -15 0 +-34 -16 0 +-35 -17 0 +-36 -18 0 +-28 -19 0 +-29 -20 0 +-30 -21 0 +-31 -22 0 +-32 -23 0 +-33 -24 0 +-34 -25 0 +-35 -26 0 +-36 -27 0 +-28 -37 0 +-29 -38 0 +-30 -39 0 +-31 -40 0 +-32 -41 0 +-33 -42 0 +-34 -43 0 +-35 -44 0 +-36 -45 0 +-28 -46 0 +-29 -47 0 +-30 -48 0 +-31 -49 0 +-32 -50 0 +-33 -51 0 +-34 -52 0 +-35 -53 0 +-36 -54 0 +-28 -55 0 +-29 -56 0 +-30 -57 0 +-31 -58 0 +-32 -59 0 +-33 -60 0 +-34 -61 0 +-35 -62 0 +-36 -63 0 +-28 -64 0 +-29 -65 0 +-30 -66 0 +-31 -67 0 +-32 -68 0 +-33 -69 0 +-34 -70 0 +-35 -71 0 +-36 -72 0 +-28 -73 0 +-29 -74 0 +-30 -75 0 +-31 -76 0 +-32 -77 0 +-33 -78 0 +-34 -79 0 +-35 -80 0 +-36 -81 0 +-37 -1 0 +-38 -2 0 +-39 -3 0 +-40 -4 0 +-41 -5 0 +-42 -6 0 +-43 -7 0 +-44 -8 0 +-45 -9 0 +-37 -10 0 +-38 -11 0 +-39 -12 0 +-40 -13 0 +-41 -14 0 +-42 -15 0 +-43 -16 0 +-44 -17 0 +-45 -18 0 +-37 -19 0 +-38 -20 0 +-39 -21 0 +-40 -22 0 +-41 -23 0 +-42 -24 0 +-43 -25 0 +-44 -26 0 +-45 -27 0 +-37 -28 0 +-38 -29 0 +-39 -30 0 +-40 -31 0 +-41 -32 0 +-42 -33 0 +-43 -34 0 +-44 -35 0 +-45 -36 0 +-37 -46 0 +-38 -47 0 +-39 -48 0 +-40 -49 0 +-41 -50 0 +-42 -51 0 +-43 -52 0 +-44 -53 0 +-45 -54 0 +-37 -55 0 +-38 -56 0 +-39 -57 0 +-40 -58 0 +-41 -59 0 +-42 -60 0 +-43 -61 0 +-44 -62 0 +-45 -63 0 +-37 -64 0 +-38 -65 0 +-39 -66 0 +-40 -67 0 +-41 -68 0 +-42 -69 0 +-43 -70 0 +-44 -71 0 +-45 -72 0 +-37 -73 0 +-38 -74 0 +-39 -75 0 +-40 -76 0 +-41 -77 0 +-42 -78 0 +-43 -79 0 +-44 -80 0 +-45 -81 0 +-46 -1 0 +-47 -2 0 +-48 -3 0 +-49 -4 0 +-50 -5 0 +-51 -6 0 +-52 -7 0 +-53 -8 0 +-54 -9 0 +-46 -10 0 +-47 -11 0 +-48 -12 0 +-49 -13 0 +-50 -14 0 +-51 -15 0 +-52 -16 0 +-53 -17 0 +-54 -18 0 +-46 -19 0 +-47 -20 0 +-48 -21 0 +-49 -22 0 +-50 -23 0 +-51 -24 0 +-52 -25 0 +-53 -26 0 +-54 -27 0 +-46 -28 0 +-47 -29 0 +-48 -30 0 +-49 -31 0 +-50 -32 0 +-51 -33 0 +-52 -34 0 +-53 -35 0 +-54 -36 0 +-46 -37 0 +-47 -38 0 +-48 -39 0 +-49 -40 0 +-50 -41 0 +-51 -42 0 +-52 -43 0 +-53 -44 0 +-54 -45 0 +-46 -55 0 +-47 -56 0 +-48 -57 0 +-49 -58 0 +-50 -59 0 +-51 -60 0 +-52 -61 0 +-53 -62 0 +-54 -63 0 +-46 -64 0 +-47 -65 0 +-48 -66 0 +-49 -67 0 +-50 -68 0 +-51 -69 0 +-52 -70 0 +-53 -71 0 +-54 -72 0 +-46 -73 0 +-47 -74 0 +-48 -75 0 +-49 -76 0 +-50 -77 0 +-51 -78 0 +-52 -79 0 +-53 -80 0 +-54 -81 0 +-55 -1 0 +-56 -2 0 +-57 -3 0 +-58 -4 0 +-59 -5 0 +-60 -6 0 +-61 -7 0 +-62 -8 0 +-63 -9 0 +-55 -10 0 +-56 -11 0 +-57 -12 0 +-58 -13 0 +-59 -14 0 +-60 -15 0 +-61 -16 0 +-62 -17 0 +-63 -18 0 +-55 -19 0 +-56 -20 0 +-57 -21 0 +-58 -22 0 +-59 -23 0 +-60 -24 0 +-61 -25 0 +-62 -26 0 +-63 -27 0 +-55 -28 0 +-56 -29 0 +-57 -30 0 +-58 -31 0 +-59 -32 0 +-60 -33 0 +-61 -34 0 +-62 -35 0 +-63 -36 0 +-55 -37 0 +-56 -38 0 +-57 -39 0 +-58 -40 0 +-59 -41 0 +-60 -42 0 +-61 -43 0 +-62 -44 0 +-63 -45 0 +-55 -46 0 +-56 -47 0 +-57 -48 0 +-58 -49 0 +-59 -50 0 +-60 -51 0 +-61 -52 0 +-62 -53 0 +-63 -54 0 +-55 -64 0 +-56 -65 0 +-57 -66 0 +-58 -67 0 +-59 -68 0 +-60 -69 0 +-61 -70 0 +-62 -71 0 +-63 -72 0 +-55 -73 0 +-56 -74 0 +-57 -75 0 +-58 -76 0 +-59 -77 0 +-60 -78 0 +-61 -79 0 +-62 -80 0 +-63 -81 0 +-64 -1 0 +-65 -2 0 +-66 -3 0 +-67 -4 0 +-68 -5 0 +-69 -6 0 +-70 -7 0 +-71 -8 0 +-72 -9 0 +-64 -10 0 +-65 -11 0 +-66 -12 0 +-67 -13 0 +-68 -14 0 +-69 -15 0 +-70 -16 0 +-71 -17 0 +-72 -18 0 +-64 -19 0 +-65 -20 0 +-66 -21 0 +-67 -22 0 +-68 -23 0 +-69 -24 0 +-70 -25 0 +-71 -26 0 +-72 -27 0 +-64 -28 0 +-65 -29 0 +-66 -30 0 +-67 -31 0 +-68 -32 0 +-69 -33 0 +-70 -34 0 +-71 -35 0 +-72 -36 0 +-64 -37 0 +-65 -38 0 +-66 -39 0 +-67 -40 0 +-68 -41 0 +-69 -42 0 +-70 -43 0 +-71 -44 0 +-72 -45 0 +-64 -46 0 +-65 -47 0 +-66 -48 0 +-67 -49 0 +-68 -50 0 +-69 -51 0 +-70 -52 0 +-71 -53 0 +-72 -54 0 +-64 -55 0 +-65 -56 0 +-66 -57 0 +-67 -58 0 +-68 -59 0 +-69 -60 0 +-70 -61 0 +-71 -62 0 +-72 -63 0 +-64 -73 0 +-65 -74 0 +-66 -75 0 +-67 -76 0 +-68 -77 0 +-69 -78 0 +-70 -79 0 +-71 -80 0 +-72 -81 0 +-73 -1 0 +-74 -2 0 +-75 -3 0 +-76 -4 0 +-77 -5 0 +-78 -6 0 +-79 -7 0 +-80 -8 0 +-81 -9 0 +-73 -10 0 +-74 -11 0 +-75 -12 0 +-76 -13 0 +-77 -14 0 +-78 -15 0 +-79 -16 0 +-80 -17 0 +-81 -18 0 +-73 -19 0 +-74 -20 0 +-75 -21 0 +-76 -22 0 +-77 -23 0 +-78 -24 0 +-79 -25 0 +-80 -26 0 +-81 -27 0 +-73 -28 0 +-74 -29 0 +-75 -30 0 +-76 -31 0 +-77 -32 0 +-78 -33 0 +-79 -34 0 +-80 -35 0 +-81 -36 0 +-73 -37 0 +-74 -38 0 +-75 -39 0 +-76 -40 0 +-77 -41 0 +-78 -42 0 +-79 -43 0 +-80 -44 0 +-81 -45 0 +-73 -46 0 +-74 -47 0 +-75 -48 0 +-76 -49 0 +-77 -50 0 +-78 -51 0 +-79 -52 0 +-80 -53 0 +-81 -54 0 +-73 -55 0 +-74 -56 0 +-75 -57 0 +-76 -58 0 +-77 -59 0 +-78 -60 0 +-79 -61 0 +-80 -62 0 +-81 -63 0 +-73 -64 0 +-74 -65 0 +-75 -66 0 +-76 -67 0 +-77 -68 0 +-78 -69 0 +-79 -70 0 +-80 -71 0 +-81 -72 0 +-82 -91 0 +-83 -92 0 +-84 -93 0 +-85 -94 0 +-86 -95 0 +-87 -96 0 +-88 -97 0 +-89 -98 0 +-90 -99 0 +-82 -100 0 +-83 -101 0 +-84 -102 0 +-85 -103 0 +-86 -104 0 +-87 -105 0 +-88 -106 0 +-89 -107 0 +-90 -108 0 +-82 -109 0 +-83 -110 0 +-84 -111 0 +-85 -112 0 +-86 -113 0 +-87 -114 0 +-88 -115 0 +-89 -116 0 +-90 -117 0 +-82 -118 0 +-83 -119 0 +-84 -120 0 +-85 -121 0 +-86 -122 0 +-87 -123 0 +-88 -124 0 +-89 -125 0 +-90 -126 0 +-82 -127 0 +-83 -128 0 +-84 -129 0 +-85 -130 0 +-86 -131 0 +-87 -132 0 +-88 -133 0 +-89 -134 0 +-90 -135 0 +-82 -136 0 +-83 -137 0 +-84 -138 0 +-85 -139 0 +-86 -140 0 +-87 -141 0 +-88 -142 0 +-89 -143 0 +-90 -144 0 +-82 -145 0 +-83 -146 0 +-84 -147 0 +-85 -148 0 +-86 -149 0 +-87 -150 0 +-88 -151 0 +-89 -152 0 +-90 -153 0 +-82 -154 0 +-83 -155 0 +-84 -156 0 +-85 -157 0 +-86 -158 0 +-87 -159 0 +-88 -160 0 +-89 -161 0 +-90 -162 0 +-91 -82 0 +-92 -83 0 +-93 -84 0 +-94 -85 0 +-95 -86 0 +-96 -87 0 +-97 -88 0 +-98 -89 0 +-99 -90 0 +-91 -100 0 +-92 -101 0 +-93 -102 0 +-94 -103 0 +-95 -104 0 +-96 -105 0 +-97 -106 0 +-98 -107 0 +-99 -108 0 +-91 -109 0 +-92 -110 0 +-93 -111 0 +-94 -112 0 +-95 -113 0 +-96 -114 0 +-97 -115 0 +-98 -116 0 +-99 -117 0 +-91 -118 0 +-92 -119 0 +-93 -120 0 +-94 -121 0 +-95 -122 0 +-96 -123 0 +-97 -124 0 +-98 -125 0 +-99 -126 0 +-91 -127 0 +-92 -128 0 +-93 -129 0 +-94 -130 0 +-95 -131 0 +-96 -132 0 +-97 -133 0 +-98 -134 0 +-99 -135 0 +-91 -136 0 +-92 -137 0 +-93 -138 0 +-94 -139 0 +-95 -140 0 +-96 -141 0 +-97 -142 0 +-98 -143 0 +-99 -144 0 +-91 -145 0 +-92 -146 0 +-93 -147 0 +-94 -148 0 +-95 -149 0 +-96 -150 0 +-97 -151 0 +-98 -152 0 +-99 -153 0 +-91 -154 0 +-92 -155 0 +-93 -156 0 +-94 -157 0 +-95 -158 0 +-96 -159 0 +-97 -160 0 +-98 -161 0 +-99 -162 0 +-100 -82 0 +-101 -83 0 +-102 -84 0 +-103 -85 0 +-104 -86 0 +-105 -87 0 +-106 -88 0 +-107 -89 0 +-108 -90 0 +-100 -91 0 +-101 -92 0 +-102 -93 0 +-103 -94 0 +-104 -95 0 +-105 -96 0 +-106 -97 0 +-107 -98 0 +-108 -99 0 +-100 -109 0 +-101 -110 0 +-102 -111 0 +-103 -112 0 +-104 -113 0 +-105 -114 0 +-106 -115 0 +-107 -116 0 +-108 -117 0 +-100 -118 0 +-101 -119 0 +-102 -120 0 +-103 -121 0 +-104 -122 0 +-105 -123 0 +-106 -124 0 +-107 -125 0 +-108 -126 0 +-100 -127 0 +-101 -128 0 +-102 -129 0 +-103 -130 0 +-104 -131 0 +-105 -132 0 +-106 -133 0 +-107 -134 0 +-108 -135 0 +-100 -136 0 +-101 -137 0 +-102 -138 0 +-103 -139 0 +-104 -140 0 +-105 -141 0 +-106 -142 0 +-107 -143 0 +-108 -144 0 +-100 -145 0 +-101 -146 0 +-102 -147 0 +-103 -148 0 +-104 -149 0 +-105 -150 0 +-106 -151 0 +-107 -152 0 +-108 -153 0 +-100 -154 0 +-101 -155 0 +-102 -156 0 +-103 -157 0 +-104 -158 0 +-105 -159 0 +-106 -160 0 +-107 -161 0 +-108 -162 0 +-109 -82 0 +-110 -83 0 +-111 -84 0 +-112 -85 0 +-113 -86 0 +-114 -87 0 +-115 -88 0 +-116 -89 0 +-117 -90 0 +-109 -91 0 +-110 -92 0 +-111 -93 0 +-112 -94 0 +-113 -95 0 +-114 -96 0 +-115 -97 0 +-116 -98 0 +-117 -99 0 +-109 -100 0 +-110 -101 0 +-111 -102 0 +-112 -103 0 +-113 -104 0 +-114 -105 0 +-115 -106 0 +-116 -107 0 +-117 -108 0 +-109 -118 0 +-110 -119 0 +-111 -120 0 +-112 -121 0 +-113 -122 0 +-114 -123 0 +-115 -124 0 +-116 -125 0 +-117 -126 0 +-109 -127 0 +-110 -128 0 +-111 -129 0 +-112 -130 0 +-113 -131 0 +-114 -132 0 +-115 -133 0 +-116 -134 0 +-117 -135 0 +-109 -136 0 +-110 -137 0 +-111 -138 0 +-112 -139 0 +-113 -140 0 +-114 -141 0 +-115 -142 0 +-116 -143 0 +-117 -144 0 +-109 -145 0 +-110 -146 0 +-111 -147 0 +-112 -148 0 +-113 -149 0 +-114 -150 0 +-115 -151 0 +-116 -152 0 +-117 -153 0 +-109 -154 0 +-110 -155 0 +-111 -156 0 +-112 -157 0 +-113 -158 0 +-114 -159 0 +-115 -160 0 +-116 -161 0 +-117 -162 0 +-118 -82 0 +-119 -83 0 +-120 -84 0 +-121 -85 0 +-122 -86 0 +-123 -87 0 +-124 -88 0 +-125 -89 0 +-126 -90 0 +-118 -91 0 +-119 -92 0 +-120 -93 0 +-121 -94 0 +-122 -95 0 +-123 -96 0 +-124 -97 0 +-125 -98 0 +-126 -99 0 +-118 -100 0 +-119 -101 0 +-120 -102 0 +-121 -103 0 +-122 -104 0 +-123 -105 0 +-124 -106 0 +-125 -107 0 +-126 -108 0 +-118 -109 0 +-119 -110 0 +-120 -111 0 +-121 -112 0 +-122 -113 0 +-123 -114 0 +-124 -115 0 +-125 -116 0 +-126 -117 0 +-118 -127 0 +-119 -128 0 +-120 -129 0 +-121 -130 0 +-122 -131 0 +-123 -132 0 +-124 -133 0 +-125 -134 0 +-126 -135 0 +-118 -136 0 +-119 -137 0 +-120 -138 0 +-121 -139 0 +-122 -140 0 +-123 -141 0 +-124 -142 0 +-125 -143 0 +-126 -144 0 +-118 -145 0 +-119 -146 0 +-120 -147 0 +-121 -148 0 +-122 -149 0 +-123 -150 0 +-124 -151 0 +-125 -152 0 +-126 -153 0 +-118 -154 0 +-119 -155 0 +-120 -156 0 +-121 -157 0 +-122 -158 0 +-123 -159 0 +-124 -160 0 +-125 -161 0 +-126 -162 0 +-127 -82 0 +-128 -83 0 +-129 -84 0 +-130 -85 0 +-131 -86 0 +-132 -87 0 +-133 -88 0 +-134 -89 0 +-135 -90 0 +-127 -91 0 +-128 -92 0 +-129 -93 0 +-130 -94 0 +-131 -95 0 +-132 -96 0 +-133 -97 0 +-134 -98 0 +-135 -99 0 +-127 -100 0 +-128 -101 0 +-129 -102 0 +-130 -103 0 +-131 -104 0 +-132 -105 0 +-133 -106 0 +-134 -107 0 +-135 -108 0 +-127 -109 0 +-128 -110 0 +-129 -111 0 +-130 -112 0 +-131 -113 0 +-132 -114 0 +-133 -115 0 +-134 -116 0 +-135 -117 0 +-127 -118 0 +-128 -119 0 +-129 -120 0 +-130 -121 0 +-131 -122 0 +-132 -123 0 +-133 -124 0 +-134 -125 0 +-135 -126 0 +-127 -136 0 +-128 -137 0 +-129 -138 0 +-130 -139 0 +-131 -140 0 +-132 -141 0 +-133 -142 0 +-134 -143 0 +-135 -144 0 +-127 -145 0 +-128 -146 0 +-129 -147 0 +-130 -148 0 +-131 -149 0 +-132 -150 0 +-133 -151 0 +-134 -152 0 +-135 -153 0 +-127 -154 0 +-128 -155 0 +-129 -156 0 +-130 -157 0 +-131 -158 0 +-132 -159 0 +-133 -160 0 +-134 -161 0 +-135 -162 0 +-136 -82 0 +-137 -83 0 +-138 -84 0 +-139 -85 0 +-140 -86 0 +-141 -87 0 +-142 -88 0 +-143 -89 0 +-144 -90 0 +-136 -91 0 +-137 -92 0 +-138 -93 0 +-139 -94 0 +-140 -95 0 +-141 -96 0 +-142 -97 0 +-143 -98 0 +-144 -99 0 +-136 -100 0 +-137 -101 0 +-138 -102 0 +-139 -103 0 +-140 -104 0 +-141 -105 0 +-142 -106 0 +-143 -107 0 +-144 -108 0 +-136 -109 0 +-137 -110 0 +-138 -111 0 +-139 -112 0 +-140 -113 0 +-141 -114 0 +-142 -115 0 +-143 -116 0 +-144 -117 0 +-136 -118 0 +-137 -119 0 +-138 -120 0 +-139 -121 0 +-140 -122 0 +-141 -123 0 +-142 -124 0 +-143 -125 0 +-144 -126 0 +-136 -127 0 +-137 -128 0 +-138 -129 0 +-139 -130 0 +-140 -131 0 +-141 -132 0 +-142 -133 0 +-143 -134 0 +-144 -135 0 +-136 -145 0 +-137 -146 0 +-138 -147 0 +-139 -148 0 +-140 -149 0 +-141 -150 0 +-142 -151 0 +-143 -152 0 +-144 -153 0 +-136 -154 0 +-137 -155 0 +-138 -156 0 +-139 -157 0 +-140 -158 0 +-141 -159 0 +-142 -160 0 +-143 -161 0 +-144 -162 0 +-145 -82 0 +-146 -83 0 +-147 -84 0 +-148 -85 0 +-149 -86 0 +-150 -87 0 +-151 -88 0 +-152 -89 0 +-153 -90 0 +-145 -91 0 +-146 -92 0 +-147 -93 0 +-148 -94 0 +-149 -95 0 +-150 -96 0 +-151 -97 0 +-152 -98 0 +-153 -99 0 +-145 -100 0 +-146 -101 0 +-147 -102 0 +-148 -103 0 +-149 -104 0 +-150 -105 0 +-151 -106 0 +-152 -107 0 +-153 -108 0 +-145 -109 0 +-146 -110 0 +-147 -111 0 +-148 -112 0 +-149 -113 0 +-150 -114 0 +-151 -115 0 +-152 -116 0 +-153 -117 0 +-145 -118 0 +-146 -119 0 +-147 -120 0 +-148 -121 0 +-149 -122 0 +-150 -123 0 +-151 -124 0 +-152 -125 0 +-153 -126 0 +-145 -127 0 +-146 -128 0 +-147 -129 0 +-148 -130 0 +-149 -131 0 +-150 -132 0 +-151 -133 0 +-152 -134 0 +-153 -135 0 +-145 -136 0 +-146 -137 0 +-147 -138 0 +-148 -139 0 +-149 -140 0 +-150 -141 0 +-151 -142 0 +-152 -143 0 +-153 -144 0 +-145 -154 0 +-146 -155 0 +-147 -156 0 +-148 -157 0 +-149 -158 0 +-150 -159 0 +-151 -160 0 +-152 -161 0 +-153 -162 0 +-154 -82 0 +-155 -83 0 +-156 -84 0 +-157 -85 0 +-158 -86 0 +-159 -87 0 +-160 -88 0 +-161 -89 0 +-162 -90 0 +-154 -91 0 +-155 -92 0 +-156 -93 0 +-157 -94 0 +-158 -95 0 +-159 -96 0 +-160 -97 0 +-161 -98 0 +-162 -99 0 +-154 -100 0 +-155 -101 0 +-156 -102 0 +-157 -103 0 +-158 -104 0 +-159 -105 0 +-160 -106 0 +-161 -107 0 +-162 -108 0 +-154 -109 0 +-155 -110 0 +-156 -111 0 +-157 -112 0 +-158 -113 0 +-159 -114 0 +-160 -115 0 +-161 -116 0 +-162 -117 0 +-154 -118 0 +-155 -119 0 +-156 -120 0 +-157 -121 0 +-158 -122 0 +-159 -123 0 +-160 -124 0 +-161 -125 0 +-162 -126 0 +-154 -127 0 +-155 -128 0 +-156 -129 0 +-157 -130 0 +-158 -131 0 +-159 -132 0 +-160 -133 0 +-161 -134 0 +-162 -135 0 +-154 -136 0 +-155 -137 0 +-156 -138 0 +-157 -139 0 +-158 -140 0 +-159 -141 0 +-160 -142 0 +-161 -143 0 +-162 -144 0 +-154 -145 0 +-155 -146 0 +-156 -147 0 +-157 -148 0 +-158 -149 0 +-159 -150 0 +-160 -151 0 +-161 -152 0 +-162 -153 0 +-163 -172 0 +-164 -173 0 +-165 -174 0 +-166 -175 0 +-167 -176 0 +-168 -177 0 +-169 -178 0 +-170 -179 0 +-171 -180 0 +-163 -181 0 +-164 -182 0 +-165 -183 0 +-166 -184 0 +-167 -185 0 +-168 -186 0 +-169 -187 0 +-170 -188 0 +-171 -189 0 +-163 -190 0 +-164 -191 0 +-165 -192 0 +-166 -193 0 +-167 -194 0 +-168 -195 0 +-169 -196 0 +-170 -197 0 +-171 -198 0 +-163 -199 0 +-164 -200 0 +-165 -201 0 +-166 -202 0 +-167 -203 0 +-168 -204 0 +-169 -205 0 +-170 -206 0 +-171 -207 0 +-163 -208 0 +-164 -209 0 +-165 -210 0 +-166 -211 0 +-167 -212 0 +-168 -213 0 +-169 -214 0 +-170 -215 0 +-171 -216 0 +-163 -217 0 +-164 -218 0 +-165 -219 0 +-166 -220 0 +-167 -221 0 +-168 -222 0 +-169 -223 0 +-170 -224 0 +-171 -225 0 +-163 -226 0 +-164 -227 0 +-165 -228 0 +-166 -229 0 +-167 -230 0 +-168 -231 0 +-169 -232 0 +-170 -233 0 +-171 -234 0 +-163 -235 0 +-164 -236 0 +-165 -237 0 +-166 -238 0 +-167 -239 0 +-168 -240 0 +-169 -241 0 +-170 -242 0 +-171 -243 0 +-172 -163 0 +-173 -164 0 +-174 -165 0 +-175 -166 0 +-176 -167 0 +-177 -168 0 +-178 -169 0 +-179 -170 0 +-180 -171 0 +-172 -181 0 +-173 -182 0 +-174 -183 0 +-175 -184 0 +-176 -185 0 +-177 -186 0 +-178 -187 0 +-179 -188 0 +-180 -189 0 +-172 -190 0 +-173 -191 0 +-174 -192 0 +-175 -193 0 +-176 -194 0 +-177 -195 0 +-178 -196 0 +-179 -197 0 +-180 -198 0 +-172 -199 0 +-173 -200 0 +-174 -201 0 +-175 -202 0 +-176 -203 0 +-177 -204 0 +-178 -205 0 +-179 -206 0 +-180 -207 0 +-172 -208 0 +-173 -209 0 +-174 -210 0 +-175 -211 0 +-176 -212 0 +-177 -213 0 +-178 -214 0 +-179 -215 0 +-180 -216 0 +-172 -217 0 +-173 -218 0 +-174 -219 0 +-175 -220 0 +-176 -221 0 +-177 -222 0 +-178 -223 0 +-179 -224 0 +-180 -225 0 +-172 -226 0 +-173 -227 0 +-174 -228 0 +-175 -229 0 +-176 -230 0 +-177 -231 0 +-178 -232 0 +-179 -233 0 +-180 -234 0 +-172 -235 0 +-173 -236 0 +-174 -237 0 +-175 -238 0 +-176 -239 0 +-177 -240 0 +-178 -241 0 +-179 -242 0 +-180 -243 0 +-181 -163 0 +-182 -164 0 +-183 -165 0 +-184 -166 0 +-185 -167 0 +-186 -168 0 +-187 -169 0 +-188 -170 0 +-189 -171 0 +-181 -172 0 +-182 -173 0 +-183 -174 0 +-184 -175 0 +-185 -176 0 +-186 -177 0 +-187 -178 0 +-188 -179 0 +-189 -180 0 +-181 -190 0 +-182 -191 0 +-183 -192 0 +-184 -193 0 +-185 -194 0 +-186 -195 0 +-187 -196 0 +-188 -197 0 +-189 -198 0 +-181 -199 0 +-182 -200 0 +-183 -201 0 +-184 -202 0 +-185 -203 0 +-186 -204 0 +-187 -205 0 +-188 -206 0 +-189 -207 0 +-181 -208 0 +-182 -209 0 +-183 -210 0 +-184 -211 0 +-185 -212 0 +-186 -213 0 +-187 -214 0 +-188 -215 0 +-189 -216 0 +-181 -217 0 +-182 -218 0 +-183 -219 0 +-184 -220 0 +-185 -221 0 +-186 -222 0 +-187 -223 0 +-188 -224 0 +-189 -225 0 +-181 -226 0 +-182 -227 0 +-183 -228 0 +-184 -229 0 +-185 -230 0 +-186 -231 0 +-187 -232 0 +-188 -233 0 +-189 -234 0 +-181 -235 0 +-182 -236 0 +-183 -237 0 +-184 -238 0 +-185 -239 0 +-186 -240 0 +-187 -241 0 +-188 -242 0 +-189 -243 0 +-190 -163 0 +-191 -164 0 +-192 -165 0 +-193 -166 0 +-194 -167 0 +-195 -168 0 +-196 -169 0 +-197 -170 0 +-198 -171 0 +-190 -172 0 +-191 -173 0 +-192 -174 0 +-193 -175 0 +-194 -176 0 +-195 -177 0 +-196 -178 0 +-197 -179 0 +-198 -180 0 +-190 -181 0 +-191 -182 0 +-192 -183 0 +-193 -184 0 +-194 -185 0 +-195 -186 0 +-196 -187 0 +-197 -188 0 +-198 -189 0 +-190 -199 0 +-191 -200 0 +-192 -201 0 +-193 -202 0 +-194 -203 0 +-195 -204 0 +-196 -205 0 +-197 -206 0 +-198 -207 0 +-190 -208 0 +-191 -209 0 +-192 -210 0 +-193 -211 0 +-194 -212 0 +-195 -213 0 +-196 -214 0 +-197 -215 0 +-198 -216 0 +-190 -217 0 +-191 -218 0 +-192 -219 0 +-193 -220 0 +-194 -221 0 +-195 -222 0 +-196 -223 0 +-197 -224 0 +-198 -225 0 +-190 -226 0 +-191 -227 0 +-192 -228 0 +-193 -229 0 +-194 -230 0 +-195 -231 0 +-196 -232 0 +-197 -233 0 +-198 -234 0 +-190 -235 0 +-191 -236 0 +-192 -237 0 +-193 -238 0 +-194 -239 0 +-195 -240 0 +-196 -241 0 +-197 -242 0 +-198 -243 0 +-199 -163 0 +-200 -164 0 +-201 -165 0 +-202 -166 0 +-203 -167 0 +-204 -168 0 +-205 -169 0 +-206 -170 0 +-207 -171 0 +-199 -172 0 +-200 -173 0 +-201 -174 0 +-202 -175 0 +-203 -176 0 +-204 -177 0 +-205 -178 0 +-206 -179 0 +-207 -180 0 +-199 -181 0 +-200 -182 0 +-201 -183 0 +-202 -184 0 +-203 -185 0 +-204 -186 0 +-205 -187 0 +-206 -188 0 +-207 -189 0 +-199 -190 0 +-200 -191 0 +-201 -192 0 +-202 -193 0 +-203 -194 0 +-204 -195 0 +-205 -196 0 +-206 -197 0 +-207 -198 0 +-199 -208 0 +-200 -209 0 +-201 -210 0 +-202 -211 0 +-203 -212 0 +-204 -213 0 +-205 -214 0 +-206 -215 0 +-207 -216 0 +-199 -217 0 +-200 -218 0 +-201 -219 0 +-202 -220 0 +-203 -221 0 +-204 -222 0 +-205 -223 0 +-206 -224 0 +-207 -225 0 +-199 -226 0 +-200 -227 0 +-201 -228 0 +-202 -229 0 +-203 -230 0 +-204 -231 0 +-205 -232 0 +-206 -233 0 +-207 -234 0 +-199 -235 0 +-200 -236 0 +-201 -237 0 +-202 -238 0 +-203 -239 0 +-204 -240 0 +-205 -241 0 +-206 -242 0 +-207 -243 0 +-208 -163 0 +-209 -164 0 +-210 -165 0 +-211 -166 0 +-212 -167 0 +-213 -168 0 +-214 -169 0 +-215 -170 0 +-216 -171 0 +-208 -172 0 +-209 -173 0 +-210 -174 0 +-211 -175 0 +-212 -176 0 +-213 -177 0 +-214 -178 0 +-215 -179 0 +-216 -180 0 +-208 -181 0 +-209 -182 0 +-210 -183 0 +-211 -184 0 +-212 -185 0 +-213 -186 0 +-214 -187 0 +-215 -188 0 +-216 -189 0 +-208 -190 0 +-209 -191 0 +-210 -192 0 +-211 -193 0 +-212 -194 0 +-213 -195 0 +-214 -196 0 +-215 -197 0 +-216 -198 0 +-208 -199 0 +-209 -200 0 +-210 -201 0 +-211 -202 0 +-212 -203 0 +-213 -204 0 +-214 -205 0 +-215 -206 0 +-216 -207 0 +-208 -217 0 +-209 -218 0 +-210 -219 0 +-211 -220 0 +-212 -221 0 +-213 -222 0 +-214 -223 0 +-215 -224 0 +-216 -225 0 +-208 -226 0 +-209 -227 0 +-210 -228 0 +-211 -229 0 +-212 -230 0 +-213 -231 0 +-214 -232 0 +-215 -233 0 +-216 -234 0 +-208 -235 0 +-209 -236 0 +-210 -237 0 +-211 -238 0 +-212 -239 0 +-213 -240 0 +-214 -241 0 +-215 -242 0 +-216 -243 0 +-217 -163 0 +-218 -164 0 +-219 -165 0 +-220 -166 0 +-221 -167 0 +-222 -168 0 +-223 -169 0 +-224 -170 0 +-225 -171 0 +-217 -172 0 +-218 -173 0 +-219 -174 0 +-220 -175 0 +-221 -176 0 +-222 -177 0 +-223 -178 0 +-224 -179 0 +-225 -180 0 +-217 -181 0 +-218 -182 0 +-219 -183 0 +-220 -184 0 +-221 -185 0 +-222 -186 0 +-223 -187 0 +-224 -188 0 +-225 -189 0 +-217 -190 0 +-218 -191 0 +-219 -192 0 +-220 -193 0 +-221 -194 0 +-222 -195 0 +-223 -196 0 +-224 -197 0 +-225 -198 0 +-217 -199 0 +-218 -200 0 +-219 -201 0 +-220 -202 0 +-221 -203 0 +-222 -204 0 +-223 -205 0 +-224 -206 0 +-225 -207 0 +-217 -208 0 +-218 -209 0 +-219 -210 0 +-220 -211 0 +-221 -212 0 +-222 -213 0 +-223 -214 0 +-224 -215 0 +-225 -216 0 +-217 -226 0 +-218 -227 0 +-219 -228 0 +-220 -229 0 +-221 -230 0 +-222 -231 0 +-223 -232 0 +-224 -233 0 +-225 -234 0 +-217 -235 0 +-218 -236 0 +-219 -237 0 +-220 -238 0 +-221 -239 0 +-222 -240 0 +-223 -241 0 +-224 -242 0 +-225 -243 0 +-226 -163 0 +-227 -164 0 +-228 -165 0 +-229 -166 0 +-230 -167 0 +-231 -168 0 +-232 -169 0 +-233 -170 0 +-234 -171 0 +-226 -172 0 +-227 -173 0 +-228 -174 0 +-229 -175 0 +-230 -176 0 +-231 -177 0 +-232 -178 0 +-233 -179 0 +-234 -180 0 +-226 -181 0 +-227 -182 0 +-228 -183 0 +-229 -184 0 +-230 -185 0 +-231 -186 0 +-232 -187 0 +-233 -188 0 +-234 -189 0 +-226 -190 0 +-227 -191 0 +-228 -192 0 +-229 -193 0 +-230 -194 0 +-231 -195 0 +-232 -196 0 +-233 -197 0 +-234 -198 0 +-226 -199 0 +-227 -200 0 +-228 -201 0 +-229 -202 0 +-230 -203 0 +-231 -204 0 +-232 -205 0 +-233 -206 0 +-234 -207 0 +-226 -208 0 +-227 -209 0 +-228 -210 0 +-229 -211 0 +-230 -212 0 +-231 -213 0 +-232 -214 0 +-233 -215 0 +-234 -216 0 +-226 -217 0 +-227 -218 0 +-228 -219 0 +-229 -220 0 +-230 -221 0 +-231 -222 0 +-232 -223 0 +-233 -224 0 +-234 -225 0 +-226 -235 0 +-227 -236 0 +-228 -237 0 +-229 -238 0 +-230 -239 0 +-231 -240 0 +-232 -241 0 +-233 -242 0 +-234 -243 0 +-235 -163 0 +-236 -164 0 +-237 -165 0 +-238 -166 0 +-239 -167 0 +-240 -168 0 +-241 -169 0 +-242 -170 0 +-243 -171 0 +-235 -172 0 +-236 -173 0 +-237 -174 0 +-238 -175 0 +-239 -176 0 +-240 -177 0 +-241 -178 0 +-242 -179 0 +-243 -180 0 +-235 -181 0 +-236 -182 0 +-237 -183 0 +-238 -184 0 +-239 -185 0 +-240 -186 0 +-241 -187 0 +-242 -188 0 +-243 -189 0 +-235 -190 0 +-236 -191 0 +-237 -192 0 +-238 -193 0 +-239 -194 0 +-240 -195 0 +-241 -196 0 +-242 -197 0 +-243 -198 0 +-235 -199 0 +-236 -200 0 +-237 -201 0 +-238 -202 0 +-239 -203 0 +-240 -204 0 +-241 -205 0 +-242 -206 0 +-243 -207 0 +-235 -208 0 +-236 -209 0 +-237 -210 0 +-238 -211 0 +-239 -212 0 +-240 -213 0 +-241 -214 0 +-242 -215 0 +-243 -216 0 +-235 -217 0 +-236 -218 0 +-237 -219 0 +-238 -220 0 +-239 -221 0 +-240 -222 0 +-241 -223 0 +-242 -224 0 +-243 -225 0 +-235 -226 0 +-236 -227 0 +-237 -228 0 +-238 -229 0 +-239 -230 0 +-240 -231 0 +-241 -232 0 +-242 -233 0 +-243 -234 0 +-244 -253 0 +-245 -254 0 +-246 -255 0 +-247 -256 0 +-248 -257 0 +-249 -258 0 +-250 -259 0 +-251 -260 0 +-252 -261 0 +-244 -262 0 +-245 -263 0 +-246 -264 0 +-247 -265 0 +-248 -266 0 +-249 -267 0 +-250 -268 0 +-251 -269 0 +-252 -270 0 +-244 -271 0 +-245 -272 0 +-246 -273 0 +-247 -274 0 +-248 -275 0 +-249 -276 0 +-250 -277 0 +-251 -278 0 +-252 -279 0 +-244 -280 0 +-245 -281 0 +-246 -282 0 +-247 -283 0 +-248 -284 0 +-249 -285 0 +-250 -286 0 +-251 -287 0 +-252 -288 0 +-244 -289 0 +-245 -290 0 +-246 -291 0 +-247 -292 0 +-248 -293 0 +-249 -294 0 +-250 -295 0 +-251 -296 0 +-252 -297 0 +-244 -298 0 +-245 -299 0 +-246 -300 0 +-247 -301 0 +-248 -302 0 +-249 -303 0 +-250 -304 0 +-251 -305 0 +-252 -306 0 +-244 -307 0 +-245 -308 0 +-246 -309 0 +-247 -310 0 +-248 -311 0 +-249 -312 0 +-250 -313 0 +-251 -314 0 +-252 -315 0 +-244 -316 0 +-245 -317 0 +-246 -318 0 +-247 -319 0 +-248 -320 0 +-249 -321 0 +-250 -322 0 +-251 -323 0 +-252 -324 0 +-253 -244 0 +-254 -245 0 +-255 -246 0 +-256 -247 0 +-257 -248 0 +-258 -249 0 +-259 -250 0 +-260 -251 0 +-261 -252 0 +-253 -262 0 +-254 -263 0 +-255 -264 0 +-256 -265 0 +-257 -266 0 +-258 -267 0 +-259 -268 0 +-260 -269 0 +-261 -270 0 +-253 -271 0 +-254 -272 0 +-255 -273 0 +-256 -274 0 +-257 -275 0 +-258 -276 0 +-259 -277 0 +-260 -278 0 +-261 -279 0 +-253 -280 0 +-254 -281 0 +-255 -282 0 +-256 -283 0 +-257 -284 0 +-258 -285 0 +-259 -286 0 +-260 -287 0 +-261 -288 0 +-253 -289 0 +-254 -290 0 +-255 -291 0 +-256 -292 0 +-257 -293 0 +-258 -294 0 +-259 -295 0 +-260 -296 0 +-261 -297 0 +-253 -298 0 +-254 -299 0 +-255 -300 0 +-256 -301 0 +-257 -302 0 +-258 -303 0 +-259 -304 0 +-260 -305 0 +-261 -306 0 +-253 -307 0 +-254 -308 0 +-255 -309 0 +-256 -310 0 +-257 -311 0 +-258 -312 0 +-259 -313 0 +-260 -314 0 +-261 -315 0 +-253 -316 0 +-254 -317 0 +-255 -318 0 +-256 -319 0 +-257 -320 0 +-258 -321 0 +-259 -322 0 +-260 -323 0 +-261 -324 0 +-262 -244 0 +-263 -245 0 +-264 -246 0 +-265 -247 0 +-266 -248 0 +-267 -249 0 +-268 -250 0 +-269 -251 0 +-270 -252 0 +-262 -253 0 +-263 -254 0 +-264 -255 0 +-265 -256 0 +-266 -257 0 +-267 -258 0 +-268 -259 0 +-269 -260 0 +-270 -261 0 +-262 -271 0 +-263 -272 0 +-264 -273 0 +-265 -274 0 +-266 -275 0 +-267 -276 0 +-268 -277 0 +-269 -278 0 +-270 -279 0 +-262 -280 0 +-263 -281 0 +-264 -282 0 +-265 -283 0 +-266 -284 0 +-267 -285 0 +-268 -286 0 +-269 -287 0 +-270 -288 0 +-262 -289 0 +-263 -290 0 +-264 -291 0 +-265 -292 0 +-266 -293 0 +-267 -294 0 +-268 -295 0 +-269 -296 0 +-270 -297 0 +-262 -298 0 +-263 -299 0 +-264 -300 0 +-265 -301 0 +-266 -302 0 +-267 -303 0 +-268 -304 0 +-269 -305 0 +-270 -306 0 +-262 -307 0 +-263 -308 0 +-264 -309 0 +-265 -310 0 +-266 -311 0 +-267 -312 0 +-268 -313 0 +-269 -314 0 +-270 -315 0 +-262 -316 0 +-263 -317 0 +-264 -318 0 +-265 -319 0 +-266 -320 0 +-267 -321 0 +-268 -322 0 +-269 -323 0 +-270 -324 0 +-271 -244 0 +-272 -245 0 +-273 -246 0 +-274 -247 0 +-275 -248 0 +-276 -249 0 +-277 -250 0 +-278 -251 0 +-279 -252 0 +-271 -253 0 +-272 -254 0 +-273 -255 0 +-274 -256 0 +-275 -257 0 +-276 -258 0 +-277 -259 0 +-278 -260 0 +-279 -261 0 +-271 -262 0 +-272 -263 0 +-273 -264 0 +-274 -265 0 +-275 -266 0 +-276 -267 0 +-277 -268 0 +-278 -269 0 +-279 -270 0 +-271 -280 0 +-272 -281 0 +-273 -282 0 +-274 -283 0 +-275 -284 0 +-276 -285 0 +-277 -286 0 +-278 -287 0 +-279 -288 0 +-271 -289 0 +-272 -290 0 +-273 -291 0 +-274 -292 0 +-275 -293 0 +-276 -294 0 +-277 -295 0 +-278 -296 0 +-279 -297 0 +-271 -298 0 +-272 -299 0 +-273 -300 0 +-274 -301 0 +-275 -302 0 +-276 -303 0 +-277 -304 0 +-278 -305 0 +-279 -306 0 +-271 -307 0 +-272 -308 0 +-273 -309 0 +-274 -310 0 +-275 -311 0 +-276 -312 0 +-277 -313 0 +-278 -314 0 +-279 -315 0 +-271 -316 0 +-272 -317 0 +-273 -318 0 +-274 -319 0 +-275 -320 0 +-276 -321 0 +-277 -322 0 +-278 -323 0 +-279 -324 0 +-280 -244 0 +-281 -245 0 +-282 -246 0 +-283 -247 0 +-284 -248 0 +-285 -249 0 +-286 -250 0 +-287 -251 0 +-288 -252 0 +-280 -253 0 +-281 -254 0 +-282 -255 0 +-283 -256 0 +-284 -257 0 +-285 -258 0 +-286 -259 0 +-287 -260 0 +-288 -261 0 +-280 -262 0 +-281 -263 0 +-282 -264 0 +-283 -265 0 +-284 -266 0 +-285 -267 0 +-286 -268 0 +-287 -269 0 +-288 -270 0 +-280 -271 0 +-281 -272 0 +-282 -273 0 +-283 -274 0 +-284 -275 0 +-285 -276 0 +-286 -277 0 +-287 -278 0 +-288 -279 0 +-280 -289 0 +-281 -290 0 +-282 -291 0 +-283 -292 0 +-284 -293 0 +-285 -294 0 +-286 -295 0 +-287 -296 0 +-288 -297 0 +-280 -298 0 +-281 -299 0 +-282 -300 0 +-283 -301 0 +-284 -302 0 +-285 -303 0 +-286 -304 0 +-287 -305 0 +-288 -306 0 +-280 -307 0 +-281 -308 0 +-282 -309 0 +-283 -310 0 +-284 -311 0 +-285 -312 0 +-286 -313 0 +-287 -314 0 +-288 -315 0 +-280 -316 0 +-281 -317 0 +-282 -318 0 +-283 -319 0 +-284 -320 0 +-285 -321 0 +-286 -322 0 +-287 -323 0 +-288 -324 0 +-289 -244 0 +-290 -245 0 +-291 -246 0 +-292 -247 0 +-293 -248 0 +-294 -249 0 +-295 -250 0 +-296 -251 0 +-297 -252 0 +-289 -253 0 +-290 -254 0 +-291 -255 0 +-292 -256 0 +-293 -257 0 +-294 -258 0 +-295 -259 0 +-296 -260 0 +-297 -261 0 +-289 -262 0 +-290 -263 0 +-291 -264 0 +-292 -265 0 +-293 -266 0 +-294 -267 0 +-295 -268 0 +-296 -269 0 +-297 -270 0 +-289 -271 0 +-290 -272 0 +-291 -273 0 +-292 -274 0 +-293 -275 0 +-294 -276 0 +-295 -277 0 +-296 -278 0 +-297 -279 0 +-289 -280 0 +-290 -281 0 +-291 -282 0 +-292 -283 0 +-293 -284 0 +-294 -285 0 +-295 -286 0 +-296 -287 0 +-297 -288 0 +-289 -298 0 +-290 -299 0 +-291 -300 0 +-292 -301 0 +-293 -302 0 +-294 -303 0 +-295 -304 0 +-296 -305 0 +-297 -306 0 +-289 -307 0 +-290 -308 0 +-291 -309 0 +-292 -310 0 +-293 -311 0 +-294 -312 0 +-295 -313 0 +-296 -314 0 +-297 -315 0 +-289 -316 0 +-290 -317 0 +-291 -318 0 +-292 -319 0 +-293 -320 0 +-294 -321 0 +-295 -322 0 +-296 -323 0 +-297 -324 0 +-298 -244 0 +-299 -245 0 +-300 -246 0 +-301 -247 0 +-302 -248 0 +-303 -249 0 +-304 -250 0 +-305 -251 0 +-306 -252 0 +-298 -253 0 +-299 -254 0 +-300 -255 0 +-301 -256 0 +-302 -257 0 +-303 -258 0 +-304 -259 0 +-305 -260 0 +-306 -261 0 +-298 -262 0 +-299 -263 0 +-300 -264 0 +-301 -265 0 +-302 -266 0 +-303 -267 0 +-304 -268 0 +-305 -269 0 +-306 -270 0 +-298 -271 0 +-299 -272 0 +-300 -273 0 +-301 -274 0 +-302 -275 0 +-303 -276 0 +-304 -277 0 +-305 -278 0 +-306 -279 0 +-298 -280 0 +-299 -281 0 +-300 -282 0 +-301 -283 0 +-302 -284 0 +-303 -285 0 +-304 -286 0 +-305 -287 0 +-306 -288 0 +-298 -289 0 +-299 -290 0 +-300 -291 0 +-301 -292 0 +-302 -293 0 +-303 -294 0 +-304 -295 0 +-305 -296 0 +-306 -297 0 +-298 -307 0 +-299 -308 0 +-300 -309 0 +-301 -310 0 +-302 -311 0 +-303 -312 0 +-304 -313 0 +-305 -314 0 +-306 -315 0 +-298 -316 0 +-299 -317 0 +-300 -318 0 +-301 -319 0 +-302 -320 0 +-303 -321 0 +-304 -322 0 +-305 -323 0 +-306 -324 0 +-307 -244 0 +-308 -245 0 +-309 -246 0 +-310 -247 0 +-311 -248 0 +-312 -249 0 +-313 -250 0 +-314 -251 0 +-315 -252 0 +-307 -253 0 +-308 -254 0 +-309 -255 0 +-310 -256 0 +-311 -257 0 +-312 -258 0 +-313 -259 0 +-314 -260 0 +-315 -261 0 +-307 -262 0 +-308 -263 0 +-309 -264 0 +-310 -265 0 +-311 -266 0 +-312 -267 0 +-313 -268 0 +-314 -269 0 +-315 -270 0 +-307 -271 0 +-308 -272 0 +-309 -273 0 +-310 -274 0 +-311 -275 0 +-312 -276 0 +-313 -277 0 +-314 -278 0 +-315 -279 0 +-307 -280 0 +-308 -281 0 +-309 -282 0 +-310 -283 0 +-311 -284 0 +-312 -285 0 +-313 -286 0 +-314 -287 0 +-315 -288 0 +-307 -289 0 +-308 -290 0 +-309 -291 0 +-310 -292 0 +-311 -293 0 +-312 -294 0 +-313 -295 0 +-314 -296 0 +-315 -297 0 +-307 -298 0 +-308 -299 0 +-309 -300 0 +-310 -301 0 +-311 -302 0 +-312 -303 0 +-313 -304 0 +-314 -305 0 +-315 -306 0 +-307 -316 0 +-308 -317 0 +-309 -318 0 +-310 -319 0 +-311 -320 0 +-312 -321 0 +-313 -322 0 +-314 -323 0 +-315 -324 0 +-316 -244 0 +-317 -245 0 +-318 -246 0 +-319 -247 0 +-320 -248 0 +-321 -249 0 +-322 -250 0 +-323 -251 0 +-324 -252 0 +-316 -253 0 +-317 -254 0 +-318 -255 0 +-319 -256 0 +-320 -257 0 +-321 -258 0 +-322 -259 0 +-323 -260 0 +-324 -261 0 +-316 -262 0 +-317 -263 0 +-318 -264 0 +-319 -265 0 +-320 -266 0 +-321 -267 0 +-322 -268 0 +-323 -269 0 +-324 -270 0 +-316 -271 0 +-317 -272 0 +-318 -273 0 +-319 -274 0 +-320 -275 0 +-321 -276 0 +-322 -277 0 +-323 -278 0 +-324 -279 0 +-316 -280 0 +-317 -281 0 +-318 -282 0 +-319 -283 0 +-320 -284 0 +-321 -285 0 +-322 -286 0 +-323 -287 0 +-324 -288 0 +-316 -289 0 +-317 -290 0 +-318 -291 0 +-319 -292 0 +-320 -293 0 +-321 -294 0 +-322 -295 0 +-323 -296 0 +-324 -297 0 +-316 -298 0 +-317 -299 0 +-318 -300 0 +-319 -301 0 +-320 -302 0 +-321 -303 0 +-322 -304 0 +-323 -305 0 +-324 -306 0 +-316 -307 0 +-317 -308 0 +-318 -309 0 +-319 -310 0 +-320 -311 0 +-321 -312 0 +-322 -313 0 +-323 -314 0 +-324 -315 0 +-325 -334 0 +-326 -335 0 +-327 -336 0 +-328 -337 0 +-329 -338 0 +-330 -339 0 +-331 -340 0 +-332 -341 0 +-333 -342 0 +-325 -343 0 +-326 -344 0 +-327 -345 0 +-328 -346 0 +-329 -347 0 +-330 -348 0 +-331 -349 0 +-332 -350 0 +-333 -351 0 +-325 -352 0 +-326 -353 0 +-327 -354 0 +-328 -355 0 +-329 -356 0 +-330 -357 0 +-331 -358 0 +-332 -359 0 +-333 -360 0 +-325 -361 0 +-326 -362 0 +-327 -363 0 +-328 -364 0 +-329 -365 0 +-330 -366 0 +-331 -367 0 +-332 -368 0 +-333 -369 0 +-325 -370 0 +-326 -371 0 +-327 -372 0 +-328 -373 0 +-329 -374 0 +-330 -375 0 +-331 -376 0 +-332 -377 0 +-333 -378 0 +-325 -379 0 +-326 -380 0 +-327 -381 0 +-328 -382 0 +-329 -383 0 +-330 -384 0 +-331 -385 0 +-332 -386 0 +-333 -387 0 +-325 -388 0 +-326 -389 0 +-327 -390 0 +-328 -391 0 +-329 -392 0 +-330 -393 0 +-331 -394 0 +-332 -395 0 +-333 -396 0 +-325 -397 0 +-326 -398 0 +-327 -399 0 +-328 -400 0 +-329 -401 0 +-330 -402 0 +-331 -403 0 +-332 -404 0 +-333 -405 0 +-334 -325 0 +-335 -326 0 +-336 -327 0 +-337 -328 0 +-338 -329 0 +-339 -330 0 +-340 -331 0 +-341 -332 0 +-342 -333 0 +-334 -343 0 +-335 -344 0 +-336 -345 0 +-337 -346 0 +-338 -347 0 +-339 -348 0 +-340 -349 0 +-341 -350 0 +-342 -351 0 +-334 -352 0 +-335 -353 0 +-336 -354 0 +-337 -355 0 +-338 -356 0 +-339 -357 0 +-340 -358 0 +-341 -359 0 +-342 -360 0 +-334 -361 0 +-335 -362 0 +-336 -363 0 +-337 -364 0 +-338 -365 0 +-339 -366 0 +-340 -367 0 +-341 -368 0 +-342 -369 0 +-334 -370 0 +-335 -371 0 +-336 -372 0 +-337 -373 0 +-338 -374 0 +-339 -375 0 +-340 -376 0 +-341 -377 0 +-342 -378 0 +-334 -379 0 +-335 -380 0 +-336 -381 0 +-337 -382 0 +-338 -383 0 +-339 -384 0 +-340 -385 0 +-341 -386 0 +-342 -387 0 +-334 -388 0 +-335 -389 0 +-336 -390 0 +-337 -391 0 +-338 -392 0 +-339 -393 0 +-340 -394 0 +-341 -395 0 +-342 -396 0 +-334 -397 0 +-335 -398 0 +-336 -399 0 +-337 -400 0 +-338 -401 0 +-339 -402 0 +-340 -403 0 +-341 -404 0 +-342 -405 0 +-343 -325 0 +-344 -326 0 +-345 -327 0 +-346 -328 0 +-347 -329 0 +-348 -330 0 +-349 -331 0 +-350 -332 0 +-351 -333 0 +-343 -334 0 +-344 -335 0 +-345 -336 0 +-346 -337 0 +-347 -338 0 +-348 -339 0 +-349 -340 0 +-350 -341 0 +-351 -342 0 +-343 -352 0 +-344 -353 0 +-345 -354 0 +-346 -355 0 +-347 -356 0 +-348 -357 0 +-349 -358 0 +-350 -359 0 +-351 -360 0 +-343 -361 0 +-344 -362 0 +-345 -363 0 +-346 -364 0 +-347 -365 0 +-348 -366 0 +-349 -367 0 +-350 -368 0 +-351 -369 0 +-343 -370 0 +-344 -371 0 +-345 -372 0 +-346 -373 0 +-347 -374 0 +-348 -375 0 +-349 -376 0 +-350 -377 0 +-351 -378 0 +-343 -379 0 +-344 -380 0 +-345 -381 0 +-346 -382 0 +-347 -383 0 +-348 -384 0 +-349 -385 0 +-350 -386 0 +-351 -387 0 +-343 -388 0 +-344 -389 0 +-345 -390 0 +-346 -391 0 +-347 -392 0 +-348 -393 0 +-349 -394 0 +-350 -395 0 +-351 -396 0 +-343 -397 0 +-344 -398 0 +-345 -399 0 +-346 -400 0 +-347 -401 0 +-348 -402 0 +-349 -403 0 +-350 -404 0 +-351 -405 0 +-352 -325 0 +-353 -326 0 +-354 -327 0 +-355 -328 0 +-356 -329 0 +-357 -330 0 +-358 -331 0 +-359 -332 0 +-360 -333 0 +-352 -334 0 +-353 -335 0 +-354 -336 0 +-355 -337 0 +-356 -338 0 +-357 -339 0 +-358 -340 0 +-359 -341 0 +-360 -342 0 +-352 -343 0 +-353 -344 0 +-354 -345 0 +-355 -346 0 +-356 -347 0 +-357 -348 0 +-358 -349 0 +-359 -350 0 +-360 -351 0 +-352 -361 0 +-353 -362 0 +-354 -363 0 +-355 -364 0 +-356 -365 0 +-357 -366 0 +-358 -367 0 +-359 -368 0 +-360 -369 0 +-352 -370 0 +-353 -371 0 +-354 -372 0 +-355 -373 0 +-356 -374 0 +-357 -375 0 +-358 -376 0 +-359 -377 0 +-360 -378 0 +-352 -379 0 +-353 -380 0 +-354 -381 0 +-355 -382 0 +-356 -383 0 +-357 -384 0 +-358 -385 0 +-359 -386 0 +-360 -387 0 +-352 -388 0 +-353 -389 0 +-354 -390 0 +-355 -391 0 +-356 -392 0 +-357 -393 0 +-358 -394 0 +-359 -395 0 +-360 -396 0 +-352 -397 0 +-353 -398 0 +-354 -399 0 +-355 -400 0 +-356 -401 0 +-357 -402 0 +-358 -403 0 +-359 -404 0 +-360 -405 0 +-361 -325 0 +-362 -326 0 +-363 -327 0 +-364 -328 0 +-365 -329 0 +-366 -330 0 +-367 -331 0 +-368 -332 0 +-369 -333 0 +-361 -334 0 +-362 -335 0 +-363 -336 0 +-364 -337 0 +-365 -338 0 +-366 -339 0 +-367 -340 0 +-368 -341 0 +-369 -342 0 +-361 -343 0 +-362 -344 0 +-363 -345 0 +-364 -346 0 +-365 -347 0 +-366 -348 0 +-367 -349 0 +-368 -350 0 +-369 -351 0 +-361 -352 0 +-362 -353 0 +-363 -354 0 +-364 -355 0 +-365 -356 0 +-366 -357 0 +-367 -358 0 +-368 -359 0 +-369 -360 0 +-361 -370 0 +-362 -371 0 +-363 -372 0 +-364 -373 0 +-365 -374 0 +-366 -375 0 +-367 -376 0 +-368 -377 0 +-369 -378 0 +-361 -379 0 +-362 -380 0 +-363 -381 0 +-364 -382 0 +-365 -383 0 +-366 -384 0 +-367 -385 0 +-368 -386 0 +-369 -387 0 +-361 -388 0 +-362 -389 0 +-363 -390 0 +-364 -391 0 +-365 -392 0 +-366 -393 0 +-367 -394 0 +-368 -395 0 +-369 -396 0 +-361 -397 0 +-362 -398 0 +-363 -399 0 +-364 -400 0 +-365 -401 0 +-366 -402 0 +-367 -403 0 +-368 -404 0 +-369 -405 0 +-370 -325 0 +-371 -326 0 +-372 -327 0 +-373 -328 0 +-374 -329 0 +-375 -330 0 +-376 -331 0 +-377 -332 0 +-378 -333 0 +-370 -334 0 +-371 -335 0 +-372 -336 0 +-373 -337 0 +-374 -338 0 +-375 -339 0 +-376 -340 0 +-377 -341 0 +-378 -342 0 +-370 -343 0 +-371 -344 0 +-372 -345 0 +-373 -346 0 +-374 -347 0 +-375 -348 0 +-376 -349 0 +-377 -350 0 +-378 -351 0 +-370 -352 0 +-371 -353 0 +-372 -354 0 +-373 -355 0 +-374 -356 0 +-375 -357 0 +-376 -358 0 +-377 -359 0 +-378 -360 0 +-370 -361 0 +-371 -362 0 +-372 -363 0 +-373 -364 0 +-374 -365 0 +-375 -366 0 +-376 -367 0 +-377 -368 0 +-378 -369 0 +-370 -379 0 +-371 -380 0 +-372 -381 0 +-373 -382 0 +-374 -383 0 +-375 -384 0 +-376 -385 0 +-377 -386 0 +-378 -387 0 +-370 -388 0 +-371 -389 0 +-372 -390 0 +-373 -391 0 +-374 -392 0 +-375 -393 0 +-376 -394 0 +-377 -395 0 +-378 -396 0 +-370 -397 0 +-371 -398 0 +-372 -399 0 +-373 -400 0 +-374 -401 0 +-375 -402 0 +-376 -403 0 +-377 -404 0 +-378 -405 0 +-379 -325 0 +-380 -326 0 +-381 -327 0 +-382 -328 0 +-383 -329 0 +-384 -330 0 +-385 -331 0 +-386 -332 0 +-387 -333 0 +-379 -334 0 +-380 -335 0 +-381 -336 0 +-382 -337 0 +-383 -338 0 +-384 -339 0 +-385 -340 0 +-386 -341 0 +-387 -342 0 +-379 -343 0 +-380 -344 0 +-381 -345 0 +-382 -346 0 +-383 -347 0 +-384 -348 0 +-385 -349 0 +-386 -350 0 +-387 -351 0 +-379 -352 0 +-380 -353 0 +-381 -354 0 +-382 -355 0 +-383 -356 0 +-384 -357 0 +-385 -358 0 +-386 -359 0 +-387 -360 0 +-379 -361 0 +-380 -362 0 +-381 -363 0 +-382 -364 0 +-383 -365 0 +-384 -366 0 +-385 -367 0 +-386 -368 0 +-387 -369 0 +-379 -370 0 +-380 -371 0 +-381 -372 0 +-382 -373 0 +-383 -374 0 +-384 -375 0 +-385 -376 0 +-386 -377 0 +-387 -378 0 +-379 -388 0 +-380 -389 0 +-381 -390 0 +-382 -391 0 +-383 -392 0 +-384 -393 0 +-385 -394 0 +-386 -395 0 +-387 -396 0 +-379 -397 0 +-380 -398 0 +-381 -399 0 +-382 -400 0 +-383 -401 0 +-384 -402 0 +-385 -403 0 +-386 -404 0 +-387 -405 0 +-388 -325 0 +-389 -326 0 +-390 -327 0 +-391 -328 0 +-392 -329 0 +-393 -330 0 +-394 -331 0 +-395 -332 0 +-396 -333 0 +-388 -334 0 +-389 -335 0 +-390 -336 0 +-391 -337 0 +-392 -338 0 +-393 -339 0 +-394 -340 0 +-395 -341 0 +-396 -342 0 +-388 -343 0 +-389 -344 0 +-390 -345 0 +-391 -346 0 +-392 -347 0 +-393 -348 0 +-394 -349 0 +-395 -350 0 +-396 -351 0 +-388 -352 0 +-389 -353 0 +-390 -354 0 +-391 -355 0 +-392 -356 0 +-393 -357 0 +-394 -358 0 +-395 -359 0 +-396 -360 0 +-388 -361 0 +-389 -362 0 +-390 -363 0 +-391 -364 0 +-392 -365 0 +-393 -366 0 +-394 -367 0 +-395 -368 0 +-396 -369 0 +-388 -370 0 +-389 -371 0 +-390 -372 0 +-391 -373 0 +-392 -374 0 +-393 -375 0 +-394 -376 0 +-395 -377 0 +-396 -378 0 +-388 -379 0 +-389 -380 0 +-390 -381 0 +-391 -382 0 +-392 -383 0 +-393 -384 0 +-394 -385 0 +-395 -386 0 +-396 -387 0 +-388 -397 0 +-389 -398 0 +-390 -399 0 +-391 -400 0 +-392 -401 0 +-393 -402 0 +-394 -403 0 +-395 -404 0 +-396 -405 0 +-397 -325 0 +-398 -326 0 +-399 -327 0 +-400 -328 0 +-401 -329 0 +-402 -330 0 +-403 -331 0 +-404 -332 0 +-405 -333 0 +-397 -334 0 +-398 -335 0 +-399 -336 0 +-400 -337 0 +-401 -338 0 +-402 -339 0 +-403 -340 0 +-404 -341 0 +-405 -342 0 +-397 -343 0 +-398 -344 0 +-399 -345 0 +-400 -346 0 +-401 -347 0 +-402 -348 0 +-403 -349 0 +-404 -350 0 +-405 -351 0 +-397 -352 0 +-398 -353 0 +-399 -354 0 +-400 -355 0 +-401 -356 0 +-402 -357 0 +-403 -358 0 +-404 -359 0 +-405 -360 0 +-397 -361 0 +-398 -362 0 +-399 -363 0 +-400 -364 0 +-401 -365 0 +-402 -366 0 +-403 -367 0 +-404 -368 0 +-405 -369 0 +-397 -370 0 +-398 -371 0 +-399 -372 0 +-400 -373 0 +-401 -374 0 +-402 -375 0 +-403 -376 0 +-404 -377 0 +-405 -378 0 +-397 -379 0 +-398 -380 0 +-399 -381 0 +-400 -382 0 +-401 -383 0 +-402 -384 0 +-403 -385 0 +-404 -386 0 +-405 -387 0 +-397 -388 0 +-398 -389 0 +-399 -390 0 +-400 -391 0 +-401 -392 0 +-402 -393 0 +-403 -394 0 +-404 -395 0 +-405 -396 0 +-406 -415 0 +-407 -416 0 +-408 -417 0 +-409 -418 0 +-410 -419 0 +-411 -420 0 +-412 -421 0 +-413 -422 0 +-414 -423 0 +-406 -424 0 +-407 -425 0 +-408 -426 0 +-409 -427 0 +-410 -428 0 +-411 -429 0 +-412 -430 0 +-413 -431 0 +-414 -432 0 +-406 -433 0 +-407 -434 0 +-408 -435 0 +-409 -436 0 +-410 -437 0 +-411 -438 0 +-412 -439 0 +-413 -440 0 +-414 -441 0 +-406 -442 0 +-407 -443 0 +-408 -444 0 +-409 -445 0 +-410 -446 0 +-411 -447 0 +-412 -448 0 +-413 -449 0 +-414 -450 0 +-406 -451 0 +-407 -452 0 +-408 -453 0 +-409 -454 0 +-410 -455 0 +-411 -456 0 +-412 -457 0 +-413 -458 0 +-414 -459 0 +-406 -460 0 +-407 -461 0 +-408 -462 0 +-409 -463 0 +-410 -464 0 +-411 -465 0 +-412 -466 0 +-413 -467 0 +-414 -468 0 +-406 -469 0 +-407 -470 0 +-408 -471 0 +-409 -472 0 +-410 -473 0 +-411 -474 0 +-412 -475 0 +-413 -476 0 +-414 -477 0 +-406 -478 0 +-407 -479 0 +-408 -480 0 +-409 -481 0 +-410 -482 0 +-411 -483 0 +-412 -484 0 +-413 -485 0 +-414 -486 0 +-415 -406 0 +-416 -407 0 +-417 -408 0 +-418 -409 0 +-419 -410 0 +-420 -411 0 +-421 -412 0 +-422 -413 0 +-423 -414 0 +-415 -424 0 +-416 -425 0 +-417 -426 0 +-418 -427 0 +-419 -428 0 +-420 -429 0 +-421 -430 0 +-422 -431 0 +-423 -432 0 +-415 -433 0 +-416 -434 0 +-417 -435 0 +-418 -436 0 +-419 -437 0 +-420 -438 0 +-421 -439 0 +-422 -440 0 +-423 -441 0 +-415 -442 0 +-416 -443 0 +-417 -444 0 +-418 -445 0 +-419 -446 0 +-420 -447 0 +-421 -448 0 +-422 -449 0 +-423 -450 0 +-415 -451 0 +-416 -452 0 +-417 -453 0 +-418 -454 0 +-419 -455 0 +-420 -456 0 +-421 -457 0 +-422 -458 0 +-423 -459 0 +-415 -460 0 +-416 -461 0 +-417 -462 0 +-418 -463 0 +-419 -464 0 +-420 -465 0 +-421 -466 0 +-422 -467 0 +-423 -468 0 +-415 -469 0 +-416 -470 0 +-417 -471 0 +-418 -472 0 +-419 -473 0 +-420 -474 0 +-421 -475 0 +-422 -476 0 +-423 -477 0 +-415 -478 0 +-416 -479 0 +-417 -480 0 +-418 -481 0 +-419 -482 0 +-420 -483 0 +-421 -484 0 +-422 -485 0 +-423 -486 0 +-424 -406 0 +-425 -407 0 +-426 -408 0 +-427 -409 0 +-428 -410 0 +-429 -411 0 +-430 -412 0 +-431 -413 0 +-432 -414 0 +-424 -415 0 +-425 -416 0 +-426 -417 0 +-427 -418 0 +-428 -419 0 +-429 -420 0 +-430 -421 0 +-431 -422 0 +-432 -423 0 +-424 -433 0 +-425 -434 0 +-426 -435 0 +-427 -436 0 +-428 -437 0 +-429 -438 0 +-430 -439 0 +-431 -440 0 +-432 -441 0 +-424 -442 0 +-425 -443 0 +-426 -444 0 +-427 -445 0 +-428 -446 0 +-429 -447 0 +-430 -448 0 +-431 -449 0 +-432 -450 0 +-424 -451 0 +-425 -452 0 +-426 -453 0 +-427 -454 0 +-428 -455 0 +-429 -456 0 +-430 -457 0 +-431 -458 0 +-432 -459 0 +-424 -460 0 +-425 -461 0 +-426 -462 0 +-427 -463 0 +-428 -464 0 +-429 -465 0 +-430 -466 0 +-431 -467 0 +-432 -468 0 +-424 -469 0 +-425 -470 0 +-426 -471 0 +-427 -472 0 +-428 -473 0 +-429 -474 0 +-430 -475 0 +-431 -476 0 +-432 -477 0 +-424 -478 0 +-425 -479 0 +-426 -480 0 +-427 -481 0 +-428 -482 0 +-429 -483 0 +-430 -484 0 +-431 -485 0 +-432 -486 0 +-433 -406 0 +-434 -407 0 +-435 -408 0 +-436 -409 0 +-437 -410 0 +-438 -411 0 +-439 -412 0 +-440 -413 0 +-441 -414 0 +-433 -415 0 +-434 -416 0 +-435 -417 0 +-436 -418 0 +-437 -419 0 +-438 -420 0 +-439 -421 0 +-440 -422 0 +-441 -423 0 +-433 -424 0 +-434 -425 0 +-435 -426 0 +-436 -427 0 +-437 -428 0 +-438 -429 0 +-439 -430 0 +-440 -431 0 +-441 -432 0 +-433 -442 0 +-434 -443 0 +-435 -444 0 +-436 -445 0 +-437 -446 0 +-438 -447 0 +-439 -448 0 +-440 -449 0 +-441 -450 0 +-433 -451 0 +-434 -452 0 +-435 -453 0 +-436 -454 0 +-437 -455 0 +-438 -456 0 +-439 -457 0 +-440 -458 0 +-441 -459 0 +-433 -460 0 +-434 -461 0 +-435 -462 0 +-436 -463 0 +-437 -464 0 +-438 -465 0 +-439 -466 0 +-440 -467 0 +-441 -468 0 +-433 -469 0 +-434 -470 0 +-435 -471 0 +-436 -472 0 +-437 -473 0 +-438 -474 0 +-439 -475 0 +-440 -476 0 +-441 -477 0 +-433 -478 0 +-434 -479 0 +-435 -480 0 +-436 -481 0 +-437 -482 0 +-438 -483 0 +-439 -484 0 +-440 -485 0 +-441 -486 0 +-442 -406 0 +-443 -407 0 +-444 -408 0 +-445 -409 0 +-446 -410 0 +-447 -411 0 +-448 -412 0 +-449 -413 0 +-450 -414 0 +-442 -415 0 +-443 -416 0 +-444 -417 0 +-445 -418 0 +-446 -419 0 +-447 -420 0 +-448 -421 0 +-449 -422 0 +-450 -423 0 +-442 -424 0 +-443 -425 0 +-444 -426 0 +-445 -427 0 +-446 -428 0 +-447 -429 0 +-448 -430 0 +-449 -431 0 +-450 -432 0 +-442 -433 0 +-443 -434 0 +-444 -435 0 +-445 -436 0 +-446 -437 0 +-447 -438 0 +-448 -439 0 +-449 -440 0 +-450 -441 0 +-442 -451 0 +-443 -452 0 +-444 -453 0 +-445 -454 0 +-446 -455 0 +-447 -456 0 +-448 -457 0 +-449 -458 0 +-450 -459 0 +-442 -460 0 +-443 -461 0 +-444 -462 0 +-445 -463 0 +-446 -464 0 +-447 -465 0 +-448 -466 0 +-449 -467 0 +-450 -468 0 +-442 -469 0 +-443 -470 0 +-444 -471 0 +-445 -472 0 +-446 -473 0 +-447 -474 0 +-448 -475 0 +-449 -476 0 +-450 -477 0 +-442 -478 0 +-443 -479 0 +-444 -480 0 +-445 -481 0 +-446 -482 0 +-447 -483 0 +-448 -484 0 +-449 -485 0 +-450 -486 0 +-451 -406 0 +-452 -407 0 +-453 -408 0 +-454 -409 0 +-455 -410 0 +-456 -411 0 +-457 -412 0 +-458 -413 0 +-459 -414 0 +-451 -415 0 +-452 -416 0 +-453 -417 0 +-454 -418 0 +-455 -419 0 +-456 -420 0 +-457 -421 0 +-458 -422 0 +-459 -423 0 +-451 -424 0 +-452 -425 0 +-453 -426 0 +-454 -427 0 +-455 -428 0 +-456 -429 0 +-457 -430 0 +-458 -431 0 +-459 -432 0 +-451 -433 0 +-452 -434 0 +-453 -435 0 +-454 -436 0 +-455 -437 0 +-456 -438 0 +-457 -439 0 +-458 -440 0 +-459 -441 0 +-451 -442 0 +-452 -443 0 +-453 -444 0 +-454 -445 0 +-455 -446 0 +-456 -447 0 +-457 -448 0 +-458 -449 0 +-459 -450 0 +-451 -460 0 +-452 -461 0 +-453 -462 0 +-454 -463 0 +-455 -464 0 +-456 -465 0 +-457 -466 0 +-458 -467 0 +-459 -468 0 +-451 -469 0 +-452 -470 0 +-453 -471 0 +-454 -472 0 +-455 -473 0 +-456 -474 0 +-457 -475 0 +-458 -476 0 +-459 -477 0 +-451 -478 0 +-452 -479 0 +-453 -480 0 +-454 -481 0 +-455 -482 0 +-456 -483 0 +-457 -484 0 +-458 -485 0 +-459 -486 0 +-460 -406 0 +-461 -407 0 +-462 -408 0 +-463 -409 0 +-464 -410 0 +-465 -411 0 +-466 -412 0 +-467 -413 0 +-468 -414 0 +-460 -415 0 +-461 -416 0 +-462 -417 0 +-463 -418 0 +-464 -419 0 +-465 -420 0 +-466 -421 0 +-467 -422 0 +-468 -423 0 +-460 -424 0 +-461 -425 0 +-462 -426 0 +-463 -427 0 +-464 -428 0 +-465 -429 0 +-466 -430 0 +-467 -431 0 +-468 -432 0 +-460 -433 0 +-461 -434 0 +-462 -435 0 +-463 -436 0 +-464 -437 0 +-465 -438 0 +-466 -439 0 +-467 -440 0 +-468 -441 0 +-460 -442 0 +-461 -443 0 +-462 -444 0 +-463 -445 0 +-464 -446 0 +-465 -447 0 +-466 -448 0 +-467 -449 0 +-468 -450 0 +-460 -451 0 +-461 -452 0 +-462 -453 0 +-463 -454 0 +-464 -455 0 +-465 -456 0 +-466 -457 0 +-467 -458 0 +-468 -459 0 +-460 -469 0 +-461 -470 0 +-462 -471 0 +-463 -472 0 +-464 -473 0 +-465 -474 0 +-466 -475 0 +-467 -476 0 +-468 -477 0 +-460 -478 0 +-461 -479 0 +-462 -480 0 +-463 -481 0 +-464 -482 0 +-465 -483 0 +-466 -484 0 +-467 -485 0 +-468 -486 0 +-469 -406 0 +-470 -407 0 +-471 -408 0 +-472 -409 0 +-473 -410 0 +-474 -411 0 +-475 -412 0 +-476 -413 0 +-477 -414 0 +-469 -415 0 +-470 -416 0 +-471 -417 0 +-472 -418 0 +-473 -419 0 +-474 -420 0 +-475 -421 0 +-476 -422 0 +-477 -423 0 +-469 -424 0 +-470 -425 0 +-471 -426 0 +-472 -427 0 +-473 -428 0 +-474 -429 0 +-475 -430 0 +-476 -431 0 +-477 -432 0 +-469 -433 0 +-470 -434 0 +-471 -435 0 +-472 -436 0 +-473 -437 0 +-474 -438 0 +-475 -439 0 +-476 -440 0 +-477 -441 0 +-469 -442 0 +-470 -443 0 +-471 -444 0 +-472 -445 0 +-473 -446 0 +-474 -447 0 +-475 -448 0 +-476 -449 0 +-477 -450 0 +-469 -451 0 +-470 -452 0 +-471 -453 0 +-472 -454 0 +-473 -455 0 +-474 -456 0 +-475 -457 0 +-476 -458 0 +-477 -459 0 +-469 -460 0 +-470 -461 0 +-471 -462 0 +-472 -463 0 +-473 -464 0 +-474 -465 0 +-475 -466 0 +-476 -467 0 +-477 -468 0 +-469 -478 0 +-470 -479 0 +-471 -480 0 +-472 -481 0 +-473 -482 0 +-474 -483 0 +-475 -484 0 +-476 -485 0 +-477 -486 0 +-478 -406 0 +-479 -407 0 +-480 -408 0 +-481 -409 0 +-482 -410 0 +-483 -411 0 +-484 -412 0 +-485 -413 0 +-486 -414 0 +-478 -415 0 +-479 -416 0 +-480 -417 0 +-481 -418 0 +-482 -419 0 +-483 -420 0 +-484 -421 0 +-485 -422 0 +-486 -423 0 +-478 -424 0 +-479 -425 0 +-480 -426 0 +-481 -427 0 +-482 -428 0 +-483 -429 0 +-484 -430 0 +-485 -431 0 +-486 -432 0 +-478 -433 0 +-479 -434 0 +-480 -435 0 +-481 -436 0 +-482 -437 0 +-483 -438 0 +-484 -439 0 +-485 -440 0 +-486 -441 0 +-478 -442 0 +-479 -443 0 +-480 -444 0 +-481 -445 0 +-482 -446 0 +-483 -447 0 +-484 -448 0 +-485 -449 0 +-486 -450 0 +-478 -451 0 +-479 -452 0 +-480 -453 0 +-481 -454 0 +-482 -455 0 +-483 -456 0 +-484 -457 0 +-485 -458 0 +-486 -459 0 +-478 -460 0 +-479 -461 0 +-480 -462 0 +-481 -463 0 +-482 -464 0 +-483 -465 0 +-484 -466 0 +-485 -467 0 +-486 -468 0 +-478 -469 0 +-479 -470 0 +-480 -471 0 +-481 -472 0 +-482 -473 0 +-483 -474 0 +-484 -475 0 +-485 -476 0 +-486 -477 0 +-487 -496 0 +-488 -497 0 +-489 -498 0 +-490 -499 0 +-491 -500 0 +-492 -501 0 +-493 -502 0 +-494 -503 0 +-495 -504 0 +-487 -505 0 +-488 -506 0 +-489 -507 0 +-490 -508 0 +-491 -509 0 +-492 -510 0 +-493 -511 0 +-494 -512 0 +-495 -513 0 +-487 -514 0 +-488 -515 0 +-489 -516 0 +-490 -517 0 +-491 -518 0 +-492 -519 0 +-493 -520 0 +-494 -521 0 +-495 -522 0 +-487 -523 0 +-488 -524 0 +-489 -525 0 +-490 -526 0 +-491 -527 0 +-492 -528 0 +-493 -529 0 +-494 -530 0 +-495 -531 0 +-487 -532 0 +-488 -533 0 +-489 -534 0 +-490 -535 0 +-491 -536 0 +-492 -537 0 +-493 -538 0 +-494 -539 0 +-495 -540 0 +-487 -541 0 +-488 -542 0 +-489 -543 0 +-490 -544 0 +-491 -545 0 +-492 -546 0 +-493 -547 0 +-494 -548 0 +-495 -549 0 +-487 -550 0 +-488 -551 0 +-489 -552 0 +-490 -553 0 +-491 -554 0 +-492 -555 0 +-493 -556 0 +-494 -557 0 +-495 -558 0 +-487 -559 0 +-488 -560 0 +-489 -561 0 +-490 -562 0 +-491 -563 0 +-492 -564 0 +-493 -565 0 +-494 -566 0 +-495 -567 0 +-496 -487 0 +-497 -488 0 +-498 -489 0 +-499 -490 0 +-500 -491 0 +-501 -492 0 +-502 -493 0 +-503 -494 0 +-504 -495 0 +-496 -505 0 +-497 -506 0 +-498 -507 0 +-499 -508 0 +-500 -509 0 +-501 -510 0 +-502 -511 0 +-503 -512 0 +-504 -513 0 +-496 -514 0 +-497 -515 0 +-498 -516 0 +-499 -517 0 +-500 -518 0 +-501 -519 0 +-502 -520 0 +-503 -521 0 +-504 -522 0 +-496 -523 0 +-497 -524 0 +-498 -525 0 +-499 -526 0 +-500 -527 0 +-501 -528 0 +-502 -529 0 +-503 -530 0 +-504 -531 0 +-496 -532 0 +-497 -533 0 +-498 -534 0 +-499 -535 0 +-500 -536 0 +-501 -537 0 +-502 -538 0 +-503 -539 0 +-504 -540 0 +-496 -541 0 +-497 -542 0 +-498 -543 0 +-499 -544 0 +-500 -545 0 +-501 -546 0 +-502 -547 0 +-503 -548 0 +-504 -549 0 +-496 -550 0 +-497 -551 0 +-498 -552 0 +-499 -553 0 +-500 -554 0 +-501 -555 0 +-502 -556 0 +-503 -557 0 +-504 -558 0 +-496 -559 0 +-497 -560 0 +-498 -561 0 +-499 -562 0 +-500 -563 0 +-501 -564 0 +-502 -565 0 +-503 -566 0 +-504 -567 0 +-505 -487 0 +-506 -488 0 +-507 -489 0 +-508 -490 0 +-509 -491 0 +-510 -492 0 +-511 -493 0 +-512 -494 0 +-513 -495 0 +-505 -496 0 +-506 -497 0 +-507 -498 0 +-508 -499 0 +-509 -500 0 +-510 -501 0 +-511 -502 0 +-512 -503 0 +-513 -504 0 +-505 -514 0 +-506 -515 0 +-507 -516 0 +-508 -517 0 +-509 -518 0 +-510 -519 0 +-511 -520 0 +-512 -521 0 +-513 -522 0 +-505 -523 0 +-506 -524 0 +-507 -525 0 +-508 -526 0 +-509 -527 0 +-510 -528 0 +-511 -529 0 +-512 -530 0 +-513 -531 0 +-505 -532 0 +-506 -533 0 +-507 -534 0 +-508 -535 0 +-509 -536 0 +-510 -537 0 +-511 -538 0 +-512 -539 0 +-513 -540 0 +-505 -541 0 +-506 -542 0 +-507 -543 0 +-508 -544 0 +-509 -545 0 +-510 -546 0 +-511 -547 0 +-512 -548 0 +-513 -549 0 +-505 -550 0 +-506 -551 0 +-507 -552 0 +-508 -553 0 +-509 -554 0 +-510 -555 0 +-511 -556 0 +-512 -557 0 +-513 -558 0 +-505 -559 0 +-506 -560 0 +-507 -561 0 +-508 -562 0 +-509 -563 0 +-510 -564 0 +-511 -565 0 +-512 -566 0 +-513 -567 0 +-514 -487 0 +-515 -488 0 +-516 -489 0 +-517 -490 0 +-518 -491 0 +-519 -492 0 +-520 -493 0 +-521 -494 0 +-522 -495 0 +-514 -496 0 +-515 -497 0 +-516 -498 0 +-517 -499 0 +-518 -500 0 +-519 -501 0 +-520 -502 0 +-521 -503 0 +-522 -504 0 +-514 -505 0 +-515 -506 0 +-516 -507 0 +-517 -508 0 +-518 -509 0 +-519 -510 0 +-520 -511 0 +-521 -512 0 +-522 -513 0 +-514 -523 0 +-515 -524 0 +-516 -525 0 +-517 -526 0 +-518 -527 0 +-519 -528 0 +-520 -529 0 +-521 -530 0 +-522 -531 0 +-514 -532 0 +-515 -533 0 +-516 -534 0 +-517 -535 0 +-518 -536 0 +-519 -537 0 +-520 -538 0 +-521 -539 0 +-522 -540 0 +-514 -541 0 +-515 -542 0 +-516 -543 0 +-517 -544 0 +-518 -545 0 +-519 -546 0 +-520 -547 0 +-521 -548 0 +-522 -549 0 +-514 -550 0 +-515 -551 0 +-516 -552 0 +-517 -553 0 +-518 -554 0 +-519 -555 0 +-520 -556 0 +-521 -557 0 +-522 -558 0 +-514 -559 0 +-515 -560 0 +-516 -561 0 +-517 -562 0 +-518 -563 0 +-519 -564 0 +-520 -565 0 +-521 -566 0 +-522 -567 0 +-523 -487 0 +-524 -488 0 +-525 -489 0 +-526 -490 0 +-527 -491 0 +-528 -492 0 +-529 -493 0 +-530 -494 0 +-531 -495 0 +-523 -496 0 +-524 -497 0 +-525 -498 0 +-526 -499 0 +-527 -500 0 +-528 -501 0 +-529 -502 0 +-530 -503 0 +-531 -504 0 +-523 -505 0 +-524 -506 0 +-525 -507 0 +-526 -508 0 +-527 -509 0 +-528 -510 0 +-529 -511 0 +-530 -512 0 +-531 -513 0 +-523 -514 0 +-524 -515 0 +-525 -516 0 +-526 -517 0 +-527 -518 0 +-528 -519 0 +-529 -520 0 +-530 -521 0 +-531 -522 0 +-523 -532 0 +-524 -533 0 +-525 -534 0 +-526 -535 0 +-527 -536 0 +-528 -537 0 +-529 -538 0 +-530 -539 0 +-531 -540 0 +-523 -541 0 +-524 -542 0 +-525 -543 0 +-526 -544 0 +-527 -545 0 +-528 -546 0 +-529 -547 0 +-530 -548 0 +-531 -549 0 +-523 -550 0 +-524 -551 0 +-525 -552 0 +-526 -553 0 +-527 -554 0 +-528 -555 0 +-529 -556 0 +-530 -557 0 +-531 -558 0 +-523 -559 0 +-524 -560 0 +-525 -561 0 +-526 -562 0 +-527 -563 0 +-528 -564 0 +-529 -565 0 +-530 -566 0 +-531 -567 0 +-532 -487 0 +-533 -488 0 +-534 -489 0 +-535 -490 0 +-536 -491 0 +-537 -492 0 +-538 -493 0 +-539 -494 0 +-540 -495 0 +-532 -496 0 +-533 -497 0 +-534 -498 0 +-535 -499 0 +-536 -500 0 +-537 -501 0 +-538 -502 0 +-539 -503 0 +-540 -504 0 +-532 -505 0 +-533 -506 0 +-534 -507 0 +-535 -508 0 +-536 -509 0 +-537 -510 0 +-538 -511 0 +-539 -512 0 +-540 -513 0 +-532 -514 0 +-533 -515 0 +-534 -516 0 +-535 -517 0 +-536 -518 0 +-537 -519 0 +-538 -520 0 +-539 -521 0 +-540 -522 0 +-532 -523 0 +-533 -524 0 +-534 -525 0 +-535 -526 0 +-536 -527 0 +-537 -528 0 +-538 -529 0 +-539 -530 0 +-540 -531 0 +-532 -541 0 +-533 -542 0 +-534 -543 0 +-535 -544 0 +-536 -545 0 +-537 -546 0 +-538 -547 0 +-539 -548 0 +-540 -549 0 +-532 -550 0 +-533 -551 0 +-534 -552 0 +-535 -553 0 +-536 -554 0 +-537 -555 0 +-538 -556 0 +-539 -557 0 +-540 -558 0 +-532 -559 0 +-533 -560 0 +-534 -561 0 +-535 -562 0 +-536 -563 0 +-537 -564 0 +-538 -565 0 +-539 -566 0 +-540 -567 0 +-541 -487 0 +-542 -488 0 +-543 -489 0 +-544 -490 0 +-545 -491 0 +-546 -492 0 +-547 -493 0 +-548 -494 0 +-549 -495 0 +-541 -496 0 +-542 -497 0 +-543 -498 0 +-544 -499 0 +-545 -500 0 +-546 -501 0 +-547 -502 0 +-548 -503 0 +-549 -504 0 +-541 -505 0 +-542 -506 0 +-543 -507 0 +-544 -508 0 +-545 -509 0 +-546 -510 0 +-547 -511 0 +-548 -512 0 +-549 -513 0 +-541 -514 0 +-542 -515 0 +-543 -516 0 +-544 -517 0 +-545 -518 0 +-546 -519 0 +-547 -520 0 +-548 -521 0 +-549 -522 0 +-541 -523 0 +-542 -524 0 +-543 -525 0 +-544 -526 0 +-545 -527 0 +-546 -528 0 +-547 -529 0 +-548 -530 0 +-549 -531 0 +-541 -532 0 +-542 -533 0 +-543 -534 0 +-544 -535 0 +-545 -536 0 +-546 -537 0 +-547 -538 0 +-548 -539 0 +-549 -540 0 +-541 -550 0 +-542 -551 0 +-543 -552 0 +-544 -553 0 +-545 -554 0 +-546 -555 0 +-547 -556 0 +-548 -557 0 +-549 -558 0 +-541 -559 0 +-542 -560 0 +-543 -561 0 +-544 -562 0 +-545 -563 0 +-546 -564 0 +-547 -565 0 +-548 -566 0 +-549 -567 0 +-550 -487 0 +-551 -488 0 +-552 -489 0 +-553 -490 0 +-554 -491 0 +-555 -492 0 +-556 -493 0 +-557 -494 0 +-558 -495 0 +-550 -496 0 +-551 -497 0 +-552 -498 0 +-553 -499 0 +-554 -500 0 +-555 -501 0 +-556 -502 0 +-557 -503 0 +-558 -504 0 +-550 -505 0 +-551 -506 0 +-552 -507 0 +-553 -508 0 +-554 -509 0 +-555 -510 0 +-556 -511 0 +-557 -512 0 +-558 -513 0 +-550 -514 0 +-551 -515 0 +-552 -516 0 +-553 -517 0 +-554 -518 0 +-555 -519 0 +-556 -520 0 +-557 -521 0 +-558 -522 0 +-550 -523 0 +-551 -524 0 +-552 -525 0 +-553 -526 0 +-554 -527 0 +-555 -528 0 +-556 -529 0 +-557 -530 0 +-558 -531 0 +-550 -532 0 +-551 -533 0 +-552 -534 0 +-553 -535 0 +-554 -536 0 +-555 -537 0 +-556 -538 0 +-557 -539 0 +-558 -540 0 +-550 -541 0 +-551 -542 0 +-552 -543 0 +-553 -544 0 +-554 -545 0 +-555 -546 0 +-556 -547 0 +-557 -548 0 +-558 -549 0 +-550 -559 0 +-551 -560 0 +-552 -561 0 +-553 -562 0 +-554 -563 0 +-555 -564 0 +-556 -565 0 +-557 -566 0 +-558 -567 0 +-559 -487 0 +-560 -488 0 +-561 -489 0 +-562 -490 0 +-563 -491 0 +-564 -492 0 +-565 -493 0 +-566 -494 0 +-567 -495 0 +-559 -496 0 +-560 -497 0 +-561 -498 0 +-562 -499 0 +-563 -500 0 +-564 -501 0 +-565 -502 0 +-566 -503 0 +-567 -504 0 +-559 -505 0 +-560 -506 0 +-561 -507 0 +-562 -508 0 +-563 -509 0 +-564 -510 0 +-565 -511 0 +-566 -512 0 +-567 -513 0 +-559 -514 0 +-560 -515 0 +-561 -516 0 +-562 -517 0 +-563 -518 0 +-564 -519 0 +-565 -520 0 +-566 -521 0 +-567 -522 0 +-559 -523 0 +-560 -524 0 +-561 -525 0 +-562 -526 0 +-563 -527 0 +-564 -528 0 +-565 -529 0 +-566 -530 0 +-567 -531 0 +-559 -532 0 +-560 -533 0 +-561 -534 0 +-562 -535 0 +-563 -536 0 +-564 -537 0 +-565 -538 0 +-566 -539 0 +-567 -540 0 +-559 -541 0 +-560 -542 0 +-561 -543 0 +-562 -544 0 +-563 -545 0 +-564 -546 0 +-565 -547 0 +-566 -548 0 +-567 -549 0 +-559 -550 0 +-560 -551 0 +-561 -552 0 +-562 -553 0 +-563 -554 0 +-564 -555 0 +-565 -556 0 +-566 -557 0 +-567 -558 0 +-568 -577 0 +-569 -578 0 +-570 -579 0 +-571 -580 0 +-572 -581 0 +-573 -582 0 +-574 -583 0 +-575 -584 0 +-576 -585 0 +-568 -586 0 +-569 -587 0 +-570 -588 0 +-571 -589 0 +-572 -590 0 +-573 -591 0 +-574 -592 0 +-575 -593 0 +-576 -594 0 +-568 -595 0 +-569 -596 0 +-570 -597 0 +-571 -598 0 +-572 -599 0 +-573 -600 0 +-574 -601 0 +-575 -602 0 +-576 -603 0 +-568 -604 0 +-569 -605 0 +-570 -606 0 +-571 -607 0 +-572 -608 0 +-573 -609 0 +-574 -610 0 +-575 -611 0 +-576 -612 0 +-568 -613 0 +-569 -614 0 +-570 -615 0 +-571 -616 0 +-572 -617 0 +-573 -618 0 +-574 -619 0 +-575 -620 0 +-576 -621 0 +-568 -622 0 +-569 -623 0 +-570 -624 0 +-571 -625 0 +-572 -626 0 +-573 -627 0 +-574 -628 0 +-575 -629 0 +-576 -630 0 +-568 -631 0 +-569 -632 0 +-570 -633 0 +-571 -634 0 +-572 -635 0 +-573 -636 0 +-574 -637 0 +-575 -638 0 +-576 -639 0 +-568 -640 0 +-569 -641 0 +-570 -642 0 +-571 -643 0 +-572 -644 0 +-573 -645 0 +-574 -646 0 +-575 -647 0 +-576 -648 0 +-577 -568 0 +-578 -569 0 +-579 -570 0 +-580 -571 0 +-581 -572 0 +-582 -573 0 +-583 -574 0 +-584 -575 0 +-585 -576 0 +-577 -586 0 +-578 -587 0 +-579 -588 0 +-580 -589 0 +-581 -590 0 +-582 -591 0 +-583 -592 0 +-584 -593 0 +-585 -594 0 +-577 -595 0 +-578 -596 0 +-579 -597 0 +-580 -598 0 +-581 -599 0 +-582 -600 0 +-583 -601 0 +-584 -602 0 +-585 -603 0 +-577 -604 0 +-578 -605 0 +-579 -606 0 +-580 -607 0 +-581 -608 0 +-582 -609 0 +-583 -610 0 +-584 -611 0 +-585 -612 0 +-577 -613 0 +-578 -614 0 +-579 -615 0 +-580 -616 0 +-581 -617 0 +-582 -618 0 +-583 -619 0 +-584 -620 0 +-585 -621 0 +-577 -622 0 +-578 -623 0 +-579 -624 0 +-580 -625 0 +-581 -626 0 +-582 -627 0 +-583 -628 0 +-584 -629 0 +-585 -630 0 +-577 -631 0 +-578 -632 0 +-579 -633 0 +-580 -634 0 +-581 -635 0 +-582 -636 0 +-583 -637 0 +-584 -638 0 +-585 -639 0 +-577 -640 0 +-578 -641 0 +-579 -642 0 +-580 -643 0 +-581 -644 0 +-582 -645 0 +-583 -646 0 +-584 -647 0 +-585 -648 0 +-586 -568 0 +-587 -569 0 +-588 -570 0 +-589 -571 0 +-590 -572 0 +-591 -573 0 +-592 -574 0 +-593 -575 0 +-594 -576 0 +-586 -577 0 +-587 -578 0 +-588 -579 0 +-589 -580 0 +-590 -581 0 +-591 -582 0 +-592 -583 0 +-593 -584 0 +-594 -585 0 +-586 -595 0 +-587 -596 0 +-588 -597 0 +-589 -598 0 +-590 -599 0 +-591 -600 0 +-592 -601 0 +-593 -602 0 +-594 -603 0 +-586 -604 0 +-587 -605 0 +-588 -606 0 +-589 -607 0 +-590 -608 0 +-591 -609 0 +-592 -610 0 +-593 -611 0 +-594 -612 0 +-586 -613 0 +-587 -614 0 +-588 -615 0 +-589 -616 0 +-590 -617 0 +-591 -618 0 +-592 -619 0 +-593 -620 0 +-594 -621 0 +-586 -622 0 +-587 -623 0 +-588 -624 0 +-589 -625 0 +-590 -626 0 +-591 -627 0 +-592 -628 0 +-593 -629 0 +-594 -630 0 +-586 -631 0 +-587 -632 0 +-588 -633 0 +-589 -634 0 +-590 -635 0 +-591 -636 0 +-592 -637 0 +-593 -638 0 +-594 -639 0 +-586 -640 0 +-587 -641 0 +-588 -642 0 +-589 -643 0 +-590 -644 0 +-591 -645 0 +-592 -646 0 +-593 -647 0 +-594 -648 0 +-595 -568 0 +-596 -569 0 +-597 -570 0 +-598 -571 0 +-599 -572 0 +-600 -573 0 +-601 -574 0 +-602 -575 0 +-603 -576 0 +-595 -577 0 +-596 -578 0 +-597 -579 0 +-598 -580 0 +-599 -581 0 +-600 -582 0 +-601 -583 0 +-602 -584 0 +-603 -585 0 +-595 -586 0 +-596 -587 0 +-597 -588 0 +-598 -589 0 +-599 -590 0 +-600 -591 0 +-601 -592 0 +-602 -593 0 +-603 -594 0 +-595 -604 0 +-596 -605 0 +-597 -606 0 +-598 -607 0 +-599 -608 0 +-600 -609 0 +-601 -610 0 +-602 -611 0 +-603 -612 0 +-595 -613 0 +-596 -614 0 +-597 -615 0 +-598 -616 0 +-599 -617 0 +-600 -618 0 +-601 -619 0 +-602 -620 0 +-603 -621 0 +-595 -622 0 +-596 -623 0 +-597 -624 0 +-598 -625 0 +-599 -626 0 +-600 -627 0 +-601 -628 0 +-602 -629 0 +-603 -630 0 +-595 -631 0 +-596 -632 0 +-597 -633 0 +-598 -634 0 +-599 -635 0 +-600 -636 0 +-601 -637 0 +-602 -638 0 +-603 -639 0 +-595 -640 0 +-596 -641 0 +-597 -642 0 +-598 -643 0 +-599 -644 0 +-600 -645 0 +-601 -646 0 +-602 -647 0 +-603 -648 0 +-604 -568 0 +-605 -569 0 +-606 -570 0 +-607 -571 0 +-608 -572 0 +-609 -573 0 +-610 -574 0 +-611 -575 0 +-612 -576 0 +-604 -577 0 +-605 -578 0 +-606 -579 0 +-607 -580 0 +-608 -581 0 +-609 -582 0 +-610 -583 0 +-611 -584 0 +-612 -585 0 +-604 -586 0 +-605 -587 0 +-606 -588 0 +-607 -589 0 +-608 -590 0 +-609 -591 0 +-610 -592 0 +-611 -593 0 +-612 -594 0 +-604 -595 0 +-605 -596 0 +-606 -597 0 +-607 -598 0 +-608 -599 0 +-609 -600 0 +-610 -601 0 +-611 -602 0 +-612 -603 0 +-604 -613 0 +-605 -614 0 +-606 -615 0 +-607 -616 0 +-608 -617 0 +-609 -618 0 +-610 -619 0 +-611 -620 0 +-612 -621 0 +-604 -622 0 +-605 -623 0 +-606 -624 0 +-607 -625 0 +-608 -626 0 +-609 -627 0 +-610 -628 0 +-611 -629 0 +-612 -630 0 +-604 -631 0 +-605 -632 0 +-606 -633 0 +-607 -634 0 +-608 -635 0 +-609 -636 0 +-610 -637 0 +-611 -638 0 +-612 -639 0 +-604 -640 0 +-605 -641 0 +-606 -642 0 +-607 -643 0 +-608 -644 0 +-609 -645 0 +-610 -646 0 +-611 -647 0 +-612 -648 0 +-613 -568 0 +-614 -569 0 +-615 -570 0 +-616 -571 0 +-617 -572 0 +-618 -573 0 +-619 -574 0 +-620 -575 0 +-621 -576 0 +-613 -577 0 +-614 -578 0 +-615 -579 0 +-616 -580 0 +-617 -581 0 +-618 -582 0 +-619 -583 0 +-620 -584 0 +-621 -585 0 +-613 -586 0 +-614 -587 0 +-615 -588 0 +-616 -589 0 +-617 -590 0 +-618 -591 0 +-619 -592 0 +-620 -593 0 +-621 -594 0 +-613 -595 0 +-614 -596 0 +-615 -597 0 +-616 -598 0 +-617 -599 0 +-618 -600 0 +-619 -601 0 +-620 -602 0 +-621 -603 0 +-613 -604 0 +-614 -605 0 +-615 -606 0 +-616 -607 0 +-617 -608 0 +-618 -609 0 +-619 -610 0 +-620 -611 0 +-621 -612 0 +-613 -622 0 +-614 -623 0 +-615 -624 0 +-616 -625 0 +-617 -626 0 +-618 -627 0 +-619 -628 0 +-620 -629 0 +-621 -630 0 +-613 -631 0 +-614 -632 0 +-615 -633 0 +-616 -634 0 +-617 -635 0 +-618 -636 0 +-619 -637 0 +-620 -638 0 +-621 -639 0 +-613 -640 0 +-614 -641 0 +-615 -642 0 +-616 -643 0 +-617 -644 0 +-618 -645 0 +-619 -646 0 +-620 -647 0 +-621 -648 0 +-622 -568 0 +-623 -569 0 +-624 -570 0 +-625 -571 0 +-626 -572 0 +-627 -573 0 +-628 -574 0 +-629 -575 0 +-630 -576 0 +-622 -577 0 +-623 -578 0 +-624 -579 0 +-625 -580 0 +-626 -581 0 +-627 -582 0 +-628 -583 0 +-629 -584 0 +-630 -585 0 +-622 -586 0 +-623 -587 0 +-624 -588 0 +-625 -589 0 +-626 -590 0 +-627 -591 0 +-628 -592 0 +-629 -593 0 +-630 -594 0 +-622 -595 0 +-623 -596 0 +-624 -597 0 +-625 -598 0 +-626 -599 0 +-627 -600 0 +-628 -601 0 +-629 -602 0 +-630 -603 0 +-622 -604 0 +-623 -605 0 +-624 -606 0 +-625 -607 0 +-626 -608 0 +-627 -609 0 +-628 -610 0 +-629 -611 0 +-630 -612 0 +-622 -613 0 +-623 -614 0 +-624 -615 0 +-625 -616 0 +-626 -617 0 +-627 -618 0 +-628 -619 0 +-629 -620 0 +-630 -621 0 +-622 -631 0 +-623 -632 0 +-624 -633 0 +-625 -634 0 +-626 -635 0 +-627 -636 0 +-628 -637 0 +-629 -638 0 +-630 -639 0 +-622 -640 0 +-623 -641 0 +-624 -642 0 +-625 -643 0 +-626 -644 0 +-627 -645 0 +-628 -646 0 +-629 -647 0 +-630 -648 0 +-631 -568 0 +-632 -569 0 +-633 -570 0 +-634 -571 0 +-635 -572 0 +-636 -573 0 +-637 -574 0 +-638 -575 0 +-639 -576 0 +-631 -577 0 +-632 -578 0 +-633 -579 0 +-634 -580 0 +-635 -581 0 +-636 -582 0 +-637 -583 0 +-638 -584 0 +-639 -585 0 +-631 -586 0 +-632 -587 0 +-633 -588 0 +-634 -589 0 +-635 -590 0 +-636 -591 0 +-637 -592 0 +-638 -593 0 +-639 -594 0 +-631 -595 0 +-632 -596 0 +-633 -597 0 +-634 -598 0 +-635 -599 0 +-636 -600 0 +-637 -601 0 +-638 -602 0 +-639 -603 0 +-631 -604 0 +-632 -605 0 +-633 -606 0 +-634 -607 0 +-635 -608 0 +-636 -609 0 +-637 -610 0 +-638 -611 0 +-639 -612 0 +-631 -613 0 +-632 -614 0 +-633 -615 0 +-634 -616 0 +-635 -617 0 +-636 -618 0 +-637 -619 0 +-638 -620 0 +-639 -621 0 +-631 -622 0 +-632 -623 0 +-633 -624 0 +-634 -625 0 +-635 -626 0 +-636 -627 0 +-637 -628 0 +-638 -629 0 +-639 -630 0 +-631 -640 0 +-632 -641 0 +-633 -642 0 +-634 -643 0 +-635 -644 0 +-636 -645 0 +-637 -646 0 +-638 -647 0 +-639 -648 0 +-640 -568 0 +-641 -569 0 +-642 -570 0 +-643 -571 0 +-644 -572 0 +-645 -573 0 +-646 -574 0 +-647 -575 0 +-648 -576 0 +-640 -577 0 +-641 -578 0 +-642 -579 0 +-643 -580 0 +-644 -581 0 +-645 -582 0 +-646 -583 0 +-647 -584 0 +-648 -585 0 +-640 -586 0 +-641 -587 0 +-642 -588 0 +-643 -589 0 +-644 -590 0 +-645 -591 0 +-646 -592 0 +-647 -593 0 +-648 -594 0 +-640 -595 0 +-641 -596 0 +-642 -597 0 +-643 -598 0 +-644 -599 0 +-645 -600 0 +-646 -601 0 +-647 -602 0 +-648 -603 0 +-640 -604 0 +-641 -605 0 +-642 -606 0 +-643 -607 0 +-644 -608 0 +-645 -609 0 +-646 -610 0 +-647 -611 0 +-648 -612 0 +-640 -613 0 +-641 -614 0 +-642 -615 0 +-643 -616 0 +-644 -617 0 +-645 -618 0 +-646 -619 0 +-647 -620 0 +-648 -621 0 +-640 -622 0 +-641 -623 0 +-642 -624 0 +-643 -625 0 +-644 -626 0 +-645 -627 0 +-646 -628 0 +-647 -629 0 +-648 -630 0 +-640 -631 0 +-641 -632 0 +-642 -633 0 +-643 -634 0 +-644 -635 0 +-645 -636 0 +-646 -637 0 +-647 -638 0 +-648 -639 0 +-649 -658 0 +-650 -659 0 +-651 -660 0 +-652 -661 0 +-653 -662 0 +-654 -663 0 +-655 -664 0 +-656 -665 0 +-657 -666 0 +-649 -667 0 +-650 -668 0 +-651 -669 0 +-652 -670 0 +-653 -671 0 +-654 -672 0 +-655 -673 0 +-656 -674 0 +-657 -675 0 +-649 -676 0 +-650 -677 0 +-651 -678 0 +-652 -679 0 +-653 -680 0 +-654 -681 0 +-655 -682 0 +-656 -683 0 +-657 -684 0 +-649 -685 0 +-650 -686 0 +-651 -687 0 +-652 -688 0 +-653 -689 0 +-654 -690 0 +-655 -691 0 +-656 -692 0 +-657 -693 0 +-649 -694 0 +-650 -695 0 +-651 -696 0 +-652 -697 0 +-653 -698 0 +-654 -699 0 +-655 -700 0 +-656 -701 0 +-657 -702 0 +-649 -703 0 +-650 -704 0 +-651 -705 0 +-652 -706 0 +-653 -707 0 +-654 -708 0 +-655 -709 0 +-656 -710 0 +-657 -711 0 +-649 -712 0 +-650 -713 0 +-651 -714 0 +-652 -715 0 +-653 -716 0 +-654 -717 0 +-655 -718 0 +-656 -719 0 +-657 -720 0 +-649 -721 0 +-650 -722 0 +-651 -723 0 +-652 -724 0 +-653 -725 0 +-654 -726 0 +-655 -727 0 +-656 -728 0 +-657 -729 0 +-658 -649 0 +-659 -650 0 +-660 -651 0 +-661 -652 0 +-662 -653 0 +-663 -654 0 +-664 -655 0 +-665 -656 0 +-666 -657 0 +-658 -667 0 +-659 -668 0 +-660 -669 0 +-661 -670 0 +-662 -671 0 +-663 -672 0 +-664 -673 0 +-665 -674 0 +-666 -675 0 +-658 -676 0 +-659 -677 0 +-660 -678 0 +-661 -679 0 +-662 -680 0 +-663 -681 0 +-664 -682 0 +-665 -683 0 +-666 -684 0 +-658 -685 0 +-659 -686 0 +-660 -687 0 +-661 -688 0 +-662 -689 0 +-663 -690 0 +-664 -691 0 +-665 -692 0 +-666 -693 0 +-658 -694 0 +-659 -695 0 +-660 -696 0 +-661 -697 0 +-662 -698 0 +-663 -699 0 +-664 -700 0 +-665 -701 0 +-666 -702 0 +-658 -703 0 +-659 -704 0 +-660 -705 0 +-661 -706 0 +-662 -707 0 +-663 -708 0 +-664 -709 0 +-665 -710 0 +-666 -711 0 +-658 -712 0 +-659 -713 0 +-660 -714 0 +-661 -715 0 +-662 -716 0 +-663 -717 0 +-664 -718 0 +-665 -719 0 +-666 -720 0 +-658 -721 0 +-659 -722 0 +-660 -723 0 +-661 -724 0 +-662 -725 0 +-663 -726 0 +-664 -727 0 +-665 -728 0 +-666 -729 0 +-667 -649 0 +-668 -650 0 +-669 -651 0 +-670 -652 0 +-671 -653 0 +-672 -654 0 +-673 -655 0 +-674 -656 0 +-675 -657 0 +-667 -658 0 +-668 -659 0 +-669 -660 0 +-670 -661 0 +-671 -662 0 +-672 -663 0 +-673 -664 0 +-674 -665 0 +-675 -666 0 +-667 -676 0 +-668 -677 0 +-669 -678 0 +-670 -679 0 +-671 -680 0 +-672 -681 0 +-673 -682 0 +-674 -683 0 +-675 -684 0 +-667 -685 0 +-668 -686 0 +-669 -687 0 +-670 -688 0 +-671 -689 0 +-672 -690 0 +-673 -691 0 +-674 -692 0 +-675 -693 0 +-667 -694 0 +-668 -695 0 +-669 -696 0 +-670 -697 0 +-671 -698 0 +-672 -699 0 +-673 -700 0 +-674 -701 0 +-675 -702 0 +-667 -703 0 +-668 -704 0 +-669 -705 0 +-670 -706 0 +-671 -707 0 +-672 -708 0 +-673 -709 0 +-674 -710 0 +-675 -711 0 +-667 -712 0 +-668 -713 0 +-669 -714 0 +-670 -715 0 +-671 -716 0 +-672 -717 0 +-673 -718 0 +-674 -719 0 +-675 -720 0 +-667 -721 0 +-668 -722 0 +-669 -723 0 +-670 -724 0 +-671 -725 0 +-672 -726 0 +-673 -727 0 +-674 -728 0 +-675 -729 0 +-676 -649 0 +-677 -650 0 +-678 -651 0 +-679 -652 0 +-680 -653 0 +-681 -654 0 +-682 -655 0 +-683 -656 0 +-684 -657 0 +-676 -658 0 +-677 -659 0 +-678 -660 0 +-679 -661 0 +-680 -662 0 +-681 -663 0 +-682 -664 0 +-683 -665 0 +-684 -666 0 +-676 -667 0 +-677 -668 0 +-678 -669 0 +-679 -670 0 +-680 -671 0 +-681 -672 0 +-682 -673 0 +-683 -674 0 +-684 -675 0 +-676 -685 0 +-677 -686 0 +-678 -687 0 +-679 -688 0 +-680 -689 0 +-681 -690 0 +-682 -691 0 +-683 -692 0 +-684 -693 0 +-676 -694 0 +-677 -695 0 +-678 -696 0 +-679 -697 0 +-680 -698 0 +-681 -699 0 +-682 -700 0 +-683 -701 0 +-684 -702 0 +-676 -703 0 +-677 -704 0 +-678 -705 0 +-679 -706 0 +-680 -707 0 +-681 -708 0 +-682 -709 0 +-683 -710 0 +-684 -711 0 +-676 -712 0 +-677 -713 0 +-678 -714 0 +-679 -715 0 +-680 -716 0 +-681 -717 0 +-682 -718 0 +-683 -719 0 +-684 -720 0 +-676 -721 0 +-677 -722 0 +-678 -723 0 +-679 -724 0 +-680 -725 0 +-681 -726 0 +-682 -727 0 +-683 -728 0 +-684 -729 0 +-685 -649 0 +-686 -650 0 +-687 -651 0 +-688 -652 0 +-689 -653 0 +-690 -654 0 +-691 -655 0 +-692 -656 0 +-693 -657 0 +-685 -658 0 +-686 -659 0 +-687 -660 0 +-688 -661 0 +-689 -662 0 +-690 -663 0 +-691 -664 0 +-692 -665 0 +-693 -666 0 +-685 -667 0 +-686 -668 0 +-687 -669 0 +-688 -670 0 +-689 -671 0 +-690 -672 0 +-691 -673 0 +-692 -674 0 +-693 -675 0 +-685 -676 0 +-686 -677 0 +-687 -678 0 +-688 -679 0 +-689 -680 0 +-690 -681 0 +-691 -682 0 +-692 -683 0 +-693 -684 0 +-685 -694 0 +-686 -695 0 +-687 -696 0 +-688 -697 0 +-689 -698 0 +-690 -699 0 +-691 -700 0 +-692 -701 0 +-693 -702 0 +-685 -703 0 +-686 -704 0 +-687 -705 0 +-688 -706 0 +-689 -707 0 +-690 -708 0 +-691 -709 0 +-692 -710 0 +-693 -711 0 +-685 -712 0 +-686 -713 0 +-687 -714 0 +-688 -715 0 +-689 -716 0 +-690 -717 0 +-691 -718 0 +-692 -719 0 +-693 -720 0 +-685 -721 0 +-686 -722 0 +-687 -723 0 +-688 -724 0 +-689 -725 0 +-690 -726 0 +-691 -727 0 +-692 -728 0 +-693 -729 0 +-694 -649 0 +-695 -650 0 +-696 -651 0 +-697 -652 0 +-698 -653 0 +-699 -654 0 +-700 -655 0 +-701 -656 0 +-702 -657 0 +-694 -658 0 +-695 -659 0 +-696 -660 0 +-697 -661 0 +-698 -662 0 +-699 -663 0 +-700 -664 0 +-701 -665 0 +-702 -666 0 +-694 -667 0 +-695 -668 0 +-696 -669 0 +-697 -670 0 +-698 -671 0 +-699 -672 0 +-700 -673 0 +-701 -674 0 +-702 -675 0 +-694 -676 0 +-695 -677 0 +-696 -678 0 +-697 -679 0 +-698 -680 0 +-699 -681 0 +-700 -682 0 +-701 -683 0 +-702 -684 0 +-694 -685 0 +-695 -686 0 +-696 -687 0 +-697 -688 0 +-698 -689 0 +-699 -690 0 +-700 -691 0 +-701 -692 0 +-702 -693 0 +-694 -703 0 +-695 -704 0 +-696 -705 0 +-697 -706 0 +-698 -707 0 +-699 -708 0 +-700 -709 0 +-701 -710 0 +-702 -711 0 +-694 -712 0 +-695 -713 0 +-696 -714 0 +-697 -715 0 +-698 -716 0 +-699 -717 0 +-700 -718 0 +-701 -719 0 +-702 -720 0 +-694 -721 0 +-695 -722 0 +-696 -723 0 +-697 -724 0 +-698 -725 0 +-699 -726 0 +-700 -727 0 +-701 -728 0 +-702 -729 0 +-703 -649 0 +-704 -650 0 +-705 -651 0 +-706 -652 0 +-707 -653 0 +-708 -654 0 +-709 -655 0 +-710 -656 0 +-711 -657 0 +-703 -658 0 +-704 -659 0 +-705 -660 0 +-706 -661 0 +-707 -662 0 +-708 -663 0 +-709 -664 0 +-710 -665 0 +-711 -666 0 +-703 -667 0 +-704 -668 0 +-705 -669 0 +-706 -670 0 +-707 -671 0 +-708 -672 0 +-709 -673 0 +-710 -674 0 +-711 -675 0 +-703 -676 0 +-704 -677 0 +-705 -678 0 +-706 -679 0 +-707 -680 0 +-708 -681 0 +-709 -682 0 +-710 -683 0 +-711 -684 0 +-703 -685 0 +-704 -686 0 +-705 -687 0 +-706 -688 0 +-707 -689 0 +-708 -690 0 +-709 -691 0 +-710 -692 0 +-711 -693 0 +-703 -694 0 +-704 -695 0 +-705 -696 0 +-706 -697 0 +-707 -698 0 +-708 -699 0 +-709 -700 0 +-710 -701 0 +-711 -702 0 +-703 -712 0 +-704 -713 0 +-705 -714 0 +-706 -715 0 +-707 -716 0 +-708 -717 0 +-709 -718 0 +-710 -719 0 +-711 -720 0 +-703 -721 0 +-704 -722 0 +-705 -723 0 +-706 -724 0 +-707 -725 0 +-708 -726 0 +-709 -727 0 +-710 -728 0 +-711 -729 0 +-712 -649 0 +-713 -650 0 +-714 -651 0 +-715 -652 0 +-716 -653 0 +-717 -654 0 +-718 -655 0 +-719 -656 0 +-720 -657 0 +-712 -658 0 +-713 -659 0 +-714 -660 0 +-715 -661 0 +-716 -662 0 +-717 -663 0 +-718 -664 0 +-719 -665 0 +-720 -666 0 +-712 -667 0 +-713 -668 0 +-714 -669 0 +-715 -670 0 +-716 -671 0 +-717 -672 0 +-718 -673 0 +-719 -674 0 +-720 -675 0 +-712 -676 0 +-713 -677 0 +-714 -678 0 +-715 -679 0 +-716 -680 0 +-717 -681 0 +-718 -682 0 +-719 -683 0 +-720 -684 0 +-712 -685 0 +-713 -686 0 +-714 -687 0 +-715 -688 0 +-716 -689 0 +-717 -690 0 +-718 -691 0 +-719 -692 0 +-720 -693 0 +-712 -694 0 +-713 -695 0 +-714 -696 0 +-715 -697 0 +-716 -698 0 +-717 -699 0 +-718 -700 0 +-719 -701 0 +-720 -702 0 +-712 -703 0 +-713 -704 0 +-714 -705 0 +-715 -706 0 +-716 -707 0 +-717 -708 0 +-718 -709 0 +-719 -710 0 +-720 -711 0 +-712 -721 0 +-713 -722 0 +-714 -723 0 +-715 -724 0 +-716 -725 0 +-717 -726 0 +-718 -727 0 +-719 -728 0 +-720 -729 0 +-721 -649 0 +-722 -650 0 +-723 -651 0 +-724 -652 0 +-725 -653 0 +-726 -654 0 +-727 -655 0 +-728 -656 0 +-729 -657 0 +-721 -658 0 +-722 -659 0 +-723 -660 0 +-724 -661 0 +-725 -662 0 +-726 -663 0 +-727 -664 0 +-728 -665 0 +-729 -666 0 +-721 -667 0 +-722 -668 0 +-723 -669 0 +-724 -670 0 +-725 -671 0 +-726 -672 0 +-727 -673 0 +-728 -674 0 +-729 -675 0 +-721 -676 0 +-722 -677 0 +-723 -678 0 +-724 -679 0 +-725 -680 0 +-726 -681 0 +-727 -682 0 +-728 -683 0 +-729 -684 0 +-721 -685 0 +-722 -686 0 +-723 -687 0 +-724 -688 0 +-725 -689 0 +-726 -690 0 +-727 -691 0 +-728 -692 0 +-729 -693 0 +-721 -694 0 +-722 -695 0 +-723 -696 0 +-724 -697 0 +-725 -698 0 +-726 -699 0 +-727 -700 0 +-728 -701 0 +-729 -702 0 +-721 -703 0 +-722 -704 0 +-723 -705 0 +-724 -706 0 +-725 -707 0 +-726 -708 0 +-727 -709 0 +-728 -710 0 +-729 -711 0 +-721 -712 0 +-722 -713 0 +-723 -714 0 +-724 -715 0 +-725 -716 0 +-726 -717 0 +-727 -718 0 +-728 -719 0 +-729 -720 0 +-1 -82 0 +-2 -83 0 +-3 -84 0 +-4 -85 0 +-5 -86 0 +-6 -87 0 +-7 -88 0 +-8 -89 0 +-9 -90 0 +-10 -91 0 +-11 -92 0 +-12 -93 0 +-13 -94 0 +-14 -95 0 +-15 -96 0 +-16 -97 0 +-17 -98 0 +-18 -99 0 +-19 -100 0 +-20 -101 0 +-21 -102 0 +-22 -103 0 +-23 -104 0 +-24 -105 0 +-25 -106 0 +-26 -107 0 +-27 -108 0 +-28 -109 0 +-29 -110 0 +-30 -111 0 +-31 -112 0 +-32 -113 0 +-33 -114 0 +-34 -115 0 +-35 -116 0 +-36 -117 0 +-37 -118 0 +-38 -119 0 +-39 -120 0 +-40 -121 0 +-41 -122 0 +-42 -123 0 +-43 -124 0 +-44 -125 0 +-45 -126 0 +-46 -127 0 +-47 -128 0 +-48 -129 0 +-49 -130 0 +-50 -131 0 +-51 -132 0 +-52 -133 0 +-53 -134 0 +-54 -135 0 +-55 -136 0 +-56 -137 0 +-57 -138 0 +-58 -139 0 +-59 -140 0 +-60 -141 0 +-61 -142 0 +-62 -143 0 +-63 -144 0 +-64 -145 0 +-65 -146 0 +-66 -147 0 +-67 -148 0 +-68 -149 0 +-69 -150 0 +-70 -151 0 +-71 -152 0 +-72 -153 0 +-73 -154 0 +-74 -155 0 +-75 -156 0 +-76 -157 0 +-77 -158 0 +-78 -159 0 +-79 -160 0 +-80 -161 0 +-81 -162 0 +-1 -163 0 +-2 -164 0 +-3 -165 0 +-4 -166 0 +-5 -167 0 +-6 -168 0 +-7 -169 0 +-8 -170 0 +-9 -171 0 +-10 -172 0 +-11 -173 0 +-12 -174 0 +-13 -175 0 +-14 -176 0 +-15 -177 0 +-16 -178 0 +-17 -179 0 +-18 -180 0 +-19 -181 0 +-20 -182 0 +-21 -183 0 +-22 -184 0 +-23 -185 0 +-24 -186 0 +-25 -187 0 +-26 -188 0 +-27 -189 0 +-28 -190 0 +-29 -191 0 +-30 -192 0 +-31 -193 0 +-32 -194 0 +-33 -195 0 +-34 -196 0 +-35 -197 0 +-36 -198 0 +-37 -199 0 +-38 -200 0 +-39 -201 0 +-40 -202 0 +-41 -203 0 +-42 -204 0 +-43 -205 0 +-44 -206 0 +-45 -207 0 +-46 -208 0 +-47 -209 0 +-48 -210 0 +-49 -211 0 +-50 -212 0 +-51 -213 0 +-52 -214 0 +-53 -215 0 +-54 -216 0 +-55 -217 0 +-56 -218 0 +-57 -219 0 +-58 -220 0 +-59 -221 0 +-60 -222 0 +-61 -223 0 +-62 -224 0 +-63 -225 0 +-64 -226 0 +-65 -227 0 +-66 -228 0 +-67 -229 0 +-68 -230 0 +-69 -231 0 +-70 -232 0 +-71 -233 0 +-72 -234 0 +-73 -235 0 +-74 -236 0 +-75 -237 0 +-76 -238 0 +-77 -239 0 +-78 -240 0 +-79 -241 0 +-80 -242 0 +-81 -243 0 +-1 -244 0 +-2 -245 0 +-3 -246 0 +-4 -247 0 +-5 -248 0 +-6 -249 0 +-7 -250 0 +-8 -251 0 +-9 -252 0 +-10 -253 0 +-11 -254 0 +-12 -255 0 +-13 -256 0 +-14 -257 0 +-15 -258 0 +-16 -259 0 +-17 -260 0 +-18 -261 0 +-19 -262 0 +-20 -263 0 +-21 -264 0 +-22 -265 0 +-23 -266 0 +-24 -267 0 +-25 -268 0 +-26 -269 0 +-27 -270 0 +-28 -271 0 +-29 -272 0 +-30 -273 0 +-31 -274 0 +-32 -275 0 +-33 -276 0 +-34 -277 0 +-35 -278 0 +-36 -279 0 +-37 -280 0 +-38 -281 0 +-39 -282 0 +-40 -283 0 +-41 -284 0 +-42 -285 0 +-43 -286 0 +-44 -287 0 +-45 -288 0 +-46 -289 0 +-47 -290 0 +-48 -291 0 +-49 -292 0 +-50 -293 0 +-51 -294 0 +-52 -295 0 +-53 -296 0 +-54 -297 0 +-55 -298 0 +-56 -299 0 +-57 -300 0 +-58 -301 0 +-59 -302 0 +-60 -303 0 +-61 -304 0 +-62 -305 0 +-63 -306 0 +-64 -307 0 +-65 -308 0 +-66 -309 0 +-67 -310 0 +-68 -311 0 +-69 -312 0 +-70 -313 0 +-71 -314 0 +-72 -315 0 +-73 -316 0 +-74 -317 0 +-75 -318 0 +-76 -319 0 +-77 -320 0 +-78 -321 0 +-79 -322 0 +-80 -323 0 +-81 -324 0 +-1 -325 0 +-2 -326 0 +-3 -327 0 +-4 -328 0 +-5 -329 0 +-6 -330 0 +-7 -331 0 +-8 -332 0 +-9 -333 0 +-10 -334 0 +-11 -335 0 +-12 -336 0 +-13 -337 0 +-14 -338 0 +-15 -339 0 +-16 -340 0 +-17 -341 0 +-18 -342 0 +-19 -343 0 +-20 -344 0 +-21 -345 0 +-22 -346 0 +-23 -347 0 +-24 -348 0 +-25 -349 0 +-26 -350 0 +-27 -351 0 +-28 -352 0 +-29 -353 0 +-30 -354 0 +-31 -355 0 +-32 -356 0 +-33 -357 0 +-34 -358 0 +-35 -359 0 +-36 -360 0 +-37 -361 0 +-38 -362 0 +-39 -363 0 +-40 -364 0 +-41 -365 0 +-42 -366 0 +-43 -367 0 +-44 -368 0 +-45 -369 0 +-46 -370 0 +-47 -371 0 +-48 -372 0 +-49 -373 0 +-50 -374 0 +-51 -375 0 +-52 -376 0 +-53 -377 0 +-54 -378 0 +-55 -379 0 +-56 -380 0 +-57 -381 0 +-58 -382 0 +-59 -383 0 +-60 -384 0 +-61 -385 0 +-62 -386 0 +-63 -387 0 +-64 -388 0 +-65 -389 0 +-66 -390 0 +-67 -391 0 +-68 -392 0 +-69 -393 0 +-70 -394 0 +-71 -395 0 +-72 -396 0 +-73 -397 0 +-74 -398 0 +-75 -399 0 +-76 -400 0 +-77 -401 0 +-78 -402 0 +-79 -403 0 +-80 -404 0 +-81 -405 0 +-1 -406 0 +-2 -407 0 +-3 -408 0 +-4 -409 0 +-5 -410 0 +-6 -411 0 +-7 -412 0 +-8 -413 0 +-9 -414 0 +-10 -415 0 +-11 -416 0 +-12 -417 0 +-13 -418 0 +-14 -419 0 +-15 -420 0 +-16 -421 0 +-17 -422 0 +-18 -423 0 +-19 -424 0 +-20 -425 0 +-21 -426 0 +-22 -427 0 +-23 -428 0 +-24 -429 0 +-25 -430 0 +-26 -431 0 +-27 -432 0 +-28 -433 0 +-29 -434 0 +-30 -435 0 +-31 -436 0 +-32 -437 0 +-33 -438 0 +-34 -439 0 +-35 -440 0 +-36 -441 0 +-37 -442 0 +-38 -443 0 +-39 -444 0 +-40 -445 0 +-41 -446 0 +-42 -447 0 +-43 -448 0 +-44 -449 0 +-45 -450 0 +-46 -451 0 +-47 -452 0 +-48 -453 0 +-49 -454 0 +-50 -455 0 +-51 -456 0 +-52 -457 0 +-53 -458 0 +-54 -459 0 +-55 -460 0 +-56 -461 0 +-57 -462 0 +-58 -463 0 +-59 -464 0 +-60 -465 0 +-61 -466 0 +-62 -467 0 +-63 -468 0 +-64 -469 0 +-65 -470 0 +-66 -471 0 +-67 -472 0 +-68 -473 0 +-69 -474 0 +-70 -475 0 +-71 -476 0 +-72 -477 0 +-73 -478 0 +-74 -479 0 +-75 -480 0 +-76 -481 0 +-77 -482 0 +-78 -483 0 +-79 -484 0 +-80 -485 0 +-81 -486 0 +-1 -487 0 +-2 -488 0 +-3 -489 0 +-4 -490 0 +-5 -491 0 +-6 -492 0 +-7 -493 0 +-8 -494 0 +-9 -495 0 +-10 -496 0 +-11 -497 0 +-12 -498 0 +-13 -499 0 +-14 -500 0 +-15 -501 0 +-16 -502 0 +-17 -503 0 +-18 -504 0 +-19 -505 0 +-20 -506 0 +-21 -507 0 +-22 -508 0 +-23 -509 0 +-24 -510 0 +-25 -511 0 +-26 -512 0 +-27 -513 0 +-28 -514 0 +-29 -515 0 +-30 -516 0 +-31 -517 0 +-32 -518 0 +-33 -519 0 +-34 -520 0 +-35 -521 0 +-36 -522 0 +-37 -523 0 +-38 -524 0 +-39 -525 0 +-40 -526 0 +-41 -527 0 +-42 -528 0 +-43 -529 0 +-44 -530 0 +-45 -531 0 +-46 -532 0 +-47 -533 0 +-48 -534 0 +-49 -535 0 +-50 -536 0 +-51 -537 0 +-52 -538 0 +-53 -539 0 +-54 -540 0 +-55 -541 0 +-56 -542 0 +-57 -543 0 +-58 -544 0 +-59 -545 0 +-60 -546 0 +-61 -547 0 +-62 -548 0 +-63 -549 0 +-64 -550 0 +-65 -551 0 +-66 -552 0 +-67 -553 0 +-68 -554 0 +-69 -555 0 +-70 -556 0 +-71 -557 0 +-72 -558 0 +-73 -559 0 +-74 -560 0 +-75 -561 0 +-76 -562 0 +-77 -563 0 +-78 -564 0 +-79 -565 0 +-80 -566 0 +-81 -567 0 +-1 -568 0 +-2 -569 0 +-3 -570 0 +-4 -571 0 +-5 -572 0 +-6 -573 0 +-7 -574 0 +-8 -575 0 +-9 -576 0 +-10 -577 0 +-11 -578 0 +-12 -579 0 +-13 -580 0 +-14 -581 0 +-15 -582 0 +-16 -583 0 +-17 -584 0 +-18 -585 0 +-19 -586 0 +-20 -587 0 +-21 -588 0 +-22 -589 0 +-23 -590 0 +-24 -591 0 +-25 -592 0 +-26 -593 0 +-27 -594 0 +-28 -595 0 +-29 -596 0 +-30 -597 0 +-31 -598 0 +-32 -599 0 +-33 -600 0 +-34 -601 0 +-35 -602 0 +-36 -603 0 +-37 -604 0 +-38 -605 0 +-39 -606 0 +-40 -607 0 +-41 -608 0 +-42 -609 0 +-43 -610 0 +-44 -611 0 +-45 -612 0 +-46 -613 0 +-47 -614 0 +-48 -615 0 +-49 -616 0 +-50 -617 0 +-51 -618 0 +-52 -619 0 +-53 -620 0 +-54 -621 0 +-55 -622 0 +-56 -623 0 +-57 -624 0 +-58 -625 0 +-59 -626 0 +-60 -627 0 +-61 -628 0 +-62 -629 0 +-63 -630 0 +-64 -631 0 +-65 -632 0 +-66 -633 0 +-67 -634 0 +-68 -635 0 +-69 -636 0 +-70 -637 0 +-71 -638 0 +-72 -639 0 +-73 -640 0 +-74 -641 0 +-75 -642 0 +-76 -643 0 +-77 -644 0 +-78 -645 0 +-79 -646 0 +-80 -647 0 +-81 -648 0 +-1 -649 0 +-2 -650 0 +-3 -651 0 +-4 -652 0 +-5 -653 0 +-6 -654 0 +-7 -655 0 +-8 -656 0 +-9 -657 0 +-10 -658 0 +-11 -659 0 +-12 -660 0 +-13 -661 0 +-14 -662 0 +-15 -663 0 +-16 -664 0 +-17 -665 0 +-18 -666 0 +-19 -667 0 +-20 -668 0 +-21 -669 0 +-22 -670 0 +-23 -671 0 +-24 -672 0 +-25 -673 0 +-26 -674 0 +-27 -675 0 +-28 -676 0 +-29 -677 0 +-30 -678 0 +-31 -679 0 +-32 -680 0 +-33 -681 0 +-34 -682 0 +-35 -683 0 +-36 -684 0 +-37 -685 0 +-38 -686 0 +-39 -687 0 +-40 -688 0 +-41 -689 0 +-42 -690 0 +-43 -691 0 +-44 -692 0 +-45 -693 0 +-46 -694 0 +-47 -695 0 +-48 -696 0 +-49 -697 0 +-50 -698 0 +-51 -699 0 +-52 -700 0 +-53 -701 0 +-54 -702 0 +-55 -703 0 +-56 -704 0 +-57 -705 0 +-58 -706 0 +-59 -707 0 +-60 -708 0 +-61 -709 0 +-62 -710 0 +-63 -711 0 +-64 -712 0 +-65 -713 0 +-66 -714 0 +-67 -715 0 +-68 -716 0 +-69 -717 0 +-70 -718 0 +-71 -719 0 +-72 -720 0 +-73 -721 0 +-74 -722 0 +-75 -723 0 +-76 -724 0 +-77 -725 0 +-78 -726 0 +-79 -727 0 +-80 -728 0 +-81 -729 0 +-82 -1 0 +-83 -2 0 +-84 -3 0 +-85 -4 0 +-86 -5 0 +-87 -6 0 +-88 -7 0 +-89 -8 0 +-90 -9 0 +-91 -10 0 +-92 -11 0 +-93 -12 0 +-94 -13 0 +-95 -14 0 +-96 -15 0 +-97 -16 0 +-98 -17 0 +-99 -18 0 +-100 -19 0 +-101 -20 0 +-102 -21 0 +-103 -22 0 +-104 -23 0 +-105 -24 0 +-106 -25 0 +-107 -26 0 +-108 -27 0 +-109 -28 0 +-110 -29 0 +-111 -30 0 +-112 -31 0 +-113 -32 0 +-114 -33 0 +-115 -34 0 +-116 -35 0 +-117 -36 0 +-118 -37 0 +-119 -38 0 +-120 -39 0 +-121 -40 0 +-122 -41 0 +-123 -42 0 +-124 -43 0 +-125 -44 0 +-126 -45 0 +-127 -46 0 +-128 -47 0 +-129 -48 0 +-130 -49 0 +-131 -50 0 +-132 -51 0 +-133 -52 0 +-134 -53 0 +-135 -54 0 +-136 -55 0 +-137 -56 0 +-138 -57 0 +-139 -58 0 +-140 -59 0 +-141 -60 0 +-142 -61 0 +-143 -62 0 +-144 -63 0 +-145 -64 0 +-146 -65 0 +-147 -66 0 +-148 -67 0 +-149 -68 0 +-150 -69 0 +-151 -70 0 +-152 -71 0 +-153 -72 0 +-154 -73 0 +-155 -74 0 +-156 -75 0 +-157 -76 0 +-158 -77 0 +-159 -78 0 +-160 -79 0 +-161 -80 0 +-162 -81 0 +-82 -163 0 +-83 -164 0 +-84 -165 0 +-85 -166 0 +-86 -167 0 +-87 -168 0 +-88 -169 0 +-89 -170 0 +-90 -171 0 +-91 -172 0 +-92 -173 0 +-93 -174 0 +-94 -175 0 +-95 -176 0 +-96 -177 0 +-97 -178 0 +-98 -179 0 +-99 -180 0 +-100 -181 0 +-101 -182 0 +-102 -183 0 +-103 -184 0 +-104 -185 0 +-105 -186 0 +-106 -187 0 +-107 -188 0 +-108 -189 0 +-109 -190 0 +-110 -191 0 +-111 -192 0 +-112 -193 0 +-113 -194 0 +-114 -195 0 +-115 -196 0 +-116 -197 0 +-117 -198 0 +-118 -199 0 +-119 -200 0 +-120 -201 0 +-121 -202 0 +-122 -203 0 +-123 -204 0 +-124 -205 0 +-125 -206 0 +-126 -207 0 +-127 -208 0 +-128 -209 0 +-129 -210 0 +-130 -211 0 +-131 -212 0 +-132 -213 0 +-133 -214 0 +-134 -215 0 +-135 -216 0 +-136 -217 0 +-137 -218 0 +-138 -219 0 +-139 -220 0 +-140 -221 0 +-141 -222 0 +-142 -223 0 +-143 -224 0 +-144 -225 0 +-145 -226 0 +-146 -227 0 +-147 -228 0 +-148 -229 0 +-149 -230 0 +-150 -231 0 +-151 -232 0 +-152 -233 0 +-153 -234 0 +-154 -235 0 +-155 -236 0 +-156 -237 0 +-157 -238 0 +-158 -239 0 +-159 -240 0 +-160 -241 0 +-161 -242 0 +-162 -243 0 +-82 -244 0 +-83 -245 0 +-84 -246 0 +-85 -247 0 +-86 -248 0 +-87 -249 0 +-88 -250 0 +-89 -251 0 +-90 -252 0 +-91 -253 0 +-92 -254 0 +-93 -255 0 +-94 -256 0 +-95 -257 0 +-96 -258 0 +-97 -259 0 +-98 -260 0 +-99 -261 0 +-100 -262 0 +-101 -263 0 +-102 -264 0 +-103 -265 0 +-104 -266 0 +-105 -267 0 +-106 -268 0 +-107 -269 0 +-108 -270 0 +-109 -271 0 +-110 -272 0 +-111 -273 0 +-112 -274 0 +-113 -275 0 +-114 -276 0 +-115 -277 0 +-116 -278 0 +-117 -279 0 +-118 -280 0 +-119 -281 0 +-120 -282 0 +-121 -283 0 +-122 -284 0 +-123 -285 0 +-124 -286 0 +-125 -287 0 +-126 -288 0 +-127 -289 0 +-128 -290 0 +-129 -291 0 +-130 -292 0 +-131 -293 0 +-132 -294 0 +-133 -295 0 +-134 -296 0 +-135 -297 0 +-136 -298 0 +-137 -299 0 +-138 -300 0 +-139 -301 0 +-140 -302 0 +-141 -303 0 +-142 -304 0 +-143 -305 0 +-144 -306 0 +-145 -307 0 +-146 -308 0 +-147 -309 0 +-148 -310 0 +-149 -311 0 +-150 -312 0 +-151 -313 0 +-152 -314 0 +-153 -315 0 +-154 -316 0 +-155 -317 0 +-156 -318 0 +-157 -319 0 +-158 -320 0 +-159 -321 0 +-160 -322 0 +-161 -323 0 +-162 -324 0 +-82 -325 0 +-83 -326 0 +-84 -327 0 +-85 -328 0 +-86 -329 0 +-87 -330 0 +-88 -331 0 +-89 -332 0 +-90 -333 0 +-91 -334 0 +-92 -335 0 +-93 -336 0 +-94 -337 0 +-95 -338 0 +-96 -339 0 +-97 -340 0 +-98 -341 0 +-99 -342 0 +-100 -343 0 +-101 -344 0 +-102 -345 0 +-103 -346 0 +-104 -347 0 +-105 -348 0 +-106 -349 0 +-107 -350 0 +-108 -351 0 +-109 -352 0 +-110 -353 0 +-111 -354 0 +-112 -355 0 +-113 -356 0 +-114 -357 0 +-115 -358 0 +-116 -359 0 +-117 -360 0 +-118 -361 0 +-119 -362 0 +-120 -363 0 +-121 -364 0 +-122 -365 0 +-123 -366 0 +-124 -367 0 +-125 -368 0 +-126 -369 0 +-127 -370 0 +-128 -371 0 +-129 -372 0 +-130 -373 0 +-131 -374 0 +-132 -375 0 +-133 -376 0 +-134 -377 0 +-135 -378 0 +-136 -379 0 +-137 -380 0 +-138 -381 0 +-139 -382 0 +-140 -383 0 +-141 -384 0 +-142 -385 0 +-143 -386 0 +-144 -387 0 +-145 -388 0 +-146 -389 0 +-147 -390 0 +-148 -391 0 +-149 -392 0 +-150 -393 0 +-151 -394 0 +-152 -395 0 +-153 -396 0 +-154 -397 0 +-155 -398 0 +-156 -399 0 +-157 -400 0 +-158 -401 0 +-159 -402 0 +-160 -403 0 +-161 -404 0 +-162 -405 0 +-82 -406 0 +-83 -407 0 +-84 -408 0 +-85 -409 0 +-86 -410 0 +-87 -411 0 +-88 -412 0 +-89 -413 0 +-90 -414 0 +-91 -415 0 +-92 -416 0 +-93 -417 0 +-94 -418 0 +-95 -419 0 +-96 -420 0 +-97 -421 0 +-98 -422 0 +-99 -423 0 +-100 -424 0 +-101 -425 0 +-102 -426 0 +-103 -427 0 +-104 -428 0 +-105 -429 0 +-106 -430 0 +-107 -431 0 +-108 -432 0 +-109 -433 0 +-110 -434 0 +-111 -435 0 +-112 -436 0 +-113 -437 0 +-114 -438 0 +-115 -439 0 +-116 -440 0 +-117 -441 0 +-118 -442 0 +-119 -443 0 +-120 -444 0 +-121 -445 0 +-122 -446 0 +-123 -447 0 +-124 -448 0 +-125 -449 0 +-126 -450 0 +-127 -451 0 +-128 -452 0 +-129 -453 0 +-130 -454 0 +-131 -455 0 +-132 -456 0 +-133 -457 0 +-134 -458 0 +-135 -459 0 +-136 -460 0 +-137 -461 0 +-138 -462 0 +-139 -463 0 +-140 -464 0 +-141 -465 0 +-142 -466 0 +-143 -467 0 +-144 -468 0 +-145 -469 0 +-146 -470 0 +-147 -471 0 +-148 -472 0 +-149 -473 0 +-150 -474 0 +-151 -475 0 +-152 -476 0 +-153 -477 0 +-154 -478 0 +-155 -479 0 +-156 -480 0 +-157 -481 0 +-158 -482 0 +-159 -483 0 +-160 -484 0 +-161 -485 0 +-162 -486 0 +-82 -487 0 +-83 -488 0 +-84 -489 0 +-85 -490 0 +-86 -491 0 +-87 -492 0 +-88 -493 0 +-89 -494 0 +-90 -495 0 +-91 -496 0 +-92 -497 0 +-93 -498 0 +-94 -499 0 +-95 -500 0 +-96 -501 0 +-97 -502 0 +-98 -503 0 +-99 -504 0 +-100 -505 0 +-101 -506 0 +-102 -507 0 +-103 -508 0 +-104 -509 0 +-105 -510 0 +-106 -511 0 +-107 -512 0 +-108 -513 0 +-109 -514 0 +-110 -515 0 +-111 -516 0 +-112 -517 0 +-113 -518 0 +-114 -519 0 +-115 -520 0 +-116 -521 0 +-117 -522 0 +-118 -523 0 +-119 -524 0 +-120 -525 0 +-121 -526 0 +-122 -527 0 +-123 -528 0 +-124 -529 0 +-125 -530 0 +-126 -531 0 +-127 -532 0 +-128 -533 0 +-129 -534 0 +-130 -535 0 +-131 -536 0 +-132 -537 0 +-133 -538 0 +-134 -539 0 +-135 -540 0 +-136 -541 0 +-137 -542 0 +-138 -543 0 +-139 -544 0 +-140 -545 0 +-141 -546 0 +-142 -547 0 +-143 -548 0 +-144 -549 0 +-145 -550 0 +-146 -551 0 +-147 -552 0 +-148 -553 0 +-149 -554 0 +-150 -555 0 +-151 -556 0 +-152 -557 0 +-153 -558 0 +-154 -559 0 +-155 -560 0 +-156 -561 0 +-157 -562 0 +-158 -563 0 +-159 -564 0 +-160 -565 0 +-161 -566 0 +-162 -567 0 +-82 -568 0 +-83 -569 0 +-84 -570 0 +-85 -571 0 +-86 -572 0 +-87 -573 0 +-88 -574 0 +-89 -575 0 +-90 -576 0 +-91 -577 0 +-92 -578 0 +-93 -579 0 +-94 -580 0 +-95 -581 0 +-96 -582 0 +-97 -583 0 +-98 -584 0 +-99 -585 0 +-100 -586 0 +-101 -587 0 +-102 -588 0 +-103 -589 0 +-104 -590 0 +-105 -591 0 +-106 -592 0 +-107 -593 0 +-108 -594 0 +-109 -595 0 +-110 -596 0 +-111 -597 0 +-112 -598 0 +-113 -599 0 +-114 -600 0 +-115 -601 0 +-116 -602 0 +-117 -603 0 +-118 -604 0 +-119 -605 0 +-120 -606 0 +-121 -607 0 +-122 -608 0 +-123 -609 0 +-124 -610 0 +-125 -611 0 +-126 -612 0 +-127 -613 0 +-128 -614 0 +-129 -615 0 +-130 -616 0 +-131 -617 0 +-132 -618 0 +-133 -619 0 +-134 -620 0 +-135 -621 0 +-136 -622 0 +-137 -623 0 +-138 -624 0 +-139 -625 0 +-140 -626 0 +-141 -627 0 +-142 -628 0 +-143 -629 0 +-144 -630 0 +-145 -631 0 +-146 -632 0 +-147 -633 0 +-148 -634 0 +-149 -635 0 +-150 -636 0 +-151 -637 0 +-152 -638 0 +-153 -639 0 +-154 -640 0 +-155 -641 0 +-156 -642 0 +-157 -643 0 +-158 -644 0 +-159 -645 0 +-160 -646 0 +-161 -647 0 +-162 -648 0 +-82 -649 0 +-83 -650 0 +-84 -651 0 +-85 -652 0 +-86 -653 0 +-87 -654 0 +-88 -655 0 +-89 -656 0 +-90 -657 0 +-91 -658 0 +-92 -659 0 +-93 -660 0 +-94 -661 0 +-95 -662 0 +-96 -663 0 +-97 -664 0 +-98 -665 0 +-99 -666 0 +-100 -667 0 +-101 -668 0 +-102 -669 0 +-103 -670 0 +-104 -671 0 +-105 -672 0 +-106 -673 0 +-107 -674 0 +-108 -675 0 +-109 -676 0 +-110 -677 0 +-111 -678 0 +-112 -679 0 +-113 -680 0 +-114 -681 0 +-115 -682 0 +-116 -683 0 +-117 -684 0 +-118 -685 0 +-119 -686 0 +-120 -687 0 +-121 -688 0 +-122 -689 0 +-123 -690 0 +-124 -691 0 +-125 -692 0 +-126 -693 0 +-127 -694 0 +-128 -695 0 +-129 -696 0 +-130 -697 0 +-131 -698 0 +-132 -699 0 +-133 -700 0 +-134 -701 0 +-135 -702 0 +-136 -703 0 +-137 -704 0 +-138 -705 0 +-139 -706 0 +-140 -707 0 +-141 -708 0 +-142 -709 0 +-143 -710 0 +-144 -711 0 +-145 -712 0 +-146 -713 0 +-147 -714 0 +-148 -715 0 +-149 -716 0 +-150 -717 0 +-151 -718 0 +-152 -719 0 +-153 -720 0 +-154 -721 0 +-155 -722 0 +-156 -723 0 +-157 -724 0 +-158 -725 0 +-159 -726 0 +-160 -727 0 +-161 -728 0 +-162 -729 0 +-163 -1 0 +-164 -2 0 +-165 -3 0 +-166 -4 0 +-167 -5 0 +-168 -6 0 +-169 -7 0 +-170 -8 0 +-171 -9 0 +-172 -10 0 +-173 -11 0 +-174 -12 0 +-175 -13 0 +-176 -14 0 +-177 -15 0 +-178 -16 0 +-179 -17 0 +-180 -18 0 +-181 -19 0 +-182 -20 0 +-183 -21 0 +-184 -22 0 +-185 -23 0 +-186 -24 0 +-187 -25 0 +-188 -26 0 +-189 -27 0 +-190 -28 0 +-191 -29 0 +-192 -30 0 +-193 -31 0 +-194 -32 0 +-195 -33 0 +-196 -34 0 +-197 -35 0 +-198 -36 0 +-199 -37 0 +-200 -38 0 +-201 -39 0 +-202 -40 0 +-203 -41 0 +-204 -42 0 +-205 -43 0 +-206 -44 0 +-207 -45 0 +-208 -46 0 +-209 -47 0 +-210 -48 0 +-211 -49 0 +-212 -50 0 +-213 -51 0 +-214 -52 0 +-215 -53 0 +-216 -54 0 +-217 -55 0 +-218 -56 0 +-219 -57 0 +-220 -58 0 +-221 -59 0 +-222 -60 0 +-223 -61 0 +-224 -62 0 +-225 -63 0 +-226 -64 0 +-227 -65 0 +-228 -66 0 +-229 -67 0 +-230 -68 0 +-231 -69 0 +-232 -70 0 +-233 -71 0 +-234 -72 0 +-235 -73 0 +-236 -74 0 +-237 -75 0 +-238 -76 0 +-239 -77 0 +-240 -78 0 +-241 -79 0 +-242 -80 0 +-243 -81 0 +-163 -82 0 +-164 -83 0 +-165 -84 0 +-166 -85 0 +-167 -86 0 +-168 -87 0 +-169 -88 0 +-170 -89 0 +-171 -90 0 +-172 -91 0 +-173 -92 0 +-174 -93 0 +-175 -94 0 +-176 -95 0 +-177 -96 0 +-178 -97 0 +-179 -98 0 +-180 -99 0 +-181 -100 0 +-182 -101 0 +-183 -102 0 +-184 -103 0 +-185 -104 0 +-186 -105 0 +-187 -106 0 +-188 -107 0 +-189 -108 0 +-190 -109 0 +-191 -110 0 +-192 -111 0 +-193 -112 0 +-194 -113 0 +-195 -114 0 +-196 -115 0 +-197 -116 0 +-198 -117 0 +-199 -118 0 +-200 -119 0 +-201 -120 0 +-202 -121 0 +-203 -122 0 +-204 -123 0 +-205 -124 0 +-206 -125 0 +-207 -126 0 +-208 -127 0 +-209 -128 0 +-210 -129 0 +-211 -130 0 +-212 -131 0 +-213 -132 0 +-214 -133 0 +-215 -134 0 +-216 -135 0 +-217 -136 0 +-218 -137 0 +-219 -138 0 +-220 -139 0 +-221 -140 0 +-222 -141 0 +-223 -142 0 +-224 -143 0 +-225 -144 0 +-226 -145 0 +-227 -146 0 +-228 -147 0 +-229 -148 0 +-230 -149 0 +-231 -150 0 +-232 -151 0 +-233 -152 0 +-234 -153 0 +-235 -154 0 +-236 -155 0 +-237 -156 0 +-238 -157 0 +-239 -158 0 +-240 -159 0 +-241 -160 0 +-242 -161 0 +-243 -162 0 +-163 -244 0 +-164 -245 0 +-165 -246 0 +-166 -247 0 +-167 -248 0 +-168 -249 0 +-169 -250 0 +-170 -251 0 +-171 -252 0 +-172 -253 0 +-173 -254 0 +-174 -255 0 +-175 -256 0 +-176 -257 0 +-177 -258 0 +-178 -259 0 +-179 -260 0 +-180 -261 0 +-181 -262 0 +-182 -263 0 +-183 -264 0 +-184 -265 0 +-185 -266 0 +-186 -267 0 +-187 -268 0 +-188 -269 0 +-189 -270 0 +-190 -271 0 +-191 -272 0 +-192 -273 0 +-193 -274 0 +-194 -275 0 +-195 -276 0 +-196 -277 0 +-197 -278 0 +-198 -279 0 +-199 -280 0 +-200 -281 0 +-201 -282 0 +-202 -283 0 +-203 -284 0 +-204 -285 0 +-205 -286 0 +-206 -287 0 +-207 -288 0 +-208 -289 0 +-209 -290 0 +-210 -291 0 +-211 -292 0 +-212 -293 0 +-213 -294 0 +-214 -295 0 +-215 -296 0 +-216 -297 0 +-217 -298 0 +-218 -299 0 +-219 -300 0 +-220 -301 0 +-221 -302 0 +-222 -303 0 +-223 -304 0 +-224 -305 0 +-225 -306 0 +-226 -307 0 +-227 -308 0 +-228 -309 0 +-229 -310 0 +-230 -311 0 +-231 -312 0 +-232 -313 0 +-233 -314 0 +-234 -315 0 +-235 -316 0 +-236 -317 0 +-237 -318 0 +-238 -319 0 +-239 -320 0 +-240 -321 0 +-241 -322 0 +-242 -323 0 +-243 -324 0 +-163 -325 0 +-164 -326 0 +-165 -327 0 +-166 -328 0 +-167 -329 0 +-168 -330 0 +-169 -331 0 +-170 -332 0 +-171 -333 0 +-172 -334 0 +-173 -335 0 +-174 -336 0 +-175 -337 0 +-176 -338 0 +-177 -339 0 +-178 -340 0 +-179 -341 0 +-180 -342 0 +-181 -343 0 +-182 -344 0 +-183 -345 0 +-184 -346 0 +-185 -347 0 +-186 -348 0 +-187 -349 0 +-188 -350 0 +-189 -351 0 +-190 -352 0 +-191 -353 0 +-192 -354 0 +-193 -355 0 +-194 -356 0 +-195 -357 0 +-196 -358 0 +-197 -359 0 +-198 -360 0 +-199 -361 0 +-200 -362 0 +-201 -363 0 +-202 -364 0 +-203 -365 0 +-204 -366 0 +-205 -367 0 +-206 -368 0 +-207 -369 0 +-208 -370 0 +-209 -371 0 +-210 -372 0 +-211 -373 0 +-212 -374 0 +-213 -375 0 +-214 -376 0 +-215 -377 0 +-216 -378 0 +-217 -379 0 +-218 -380 0 +-219 -381 0 +-220 -382 0 +-221 -383 0 +-222 -384 0 +-223 -385 0 +-224 -386 0 +-225 -387 0 +-226 -388 0 +-227 -389 0 +-228 -390 0 +-229 -391 0 +-230 -392 0 +-231 -393 0 +-232 -394 0 +-233 -395 0 +-234 -396 0 +-235 -397 0 +-236 -398 0 +-237 -399 0 +-238 -400 0 +-239 -401 0 +-240 -402 0 +-241 -403 0 +-242 -404 0 +-243 -405 0 +-163 -406 0 +-164 -407 0 +-165 -408 0 +-166 -409 0 +-167 -410 0 +-168 -411 0 +-169 -412 0 +-170 -413 0 +-171 -414 0 +-172 -415 0 +-173 -416 0 +-174 -417 0 +-175 -418 0 +-176 -419 0 +-177 -420 0 +-178 -421 0 +-179 -422 0 +-180 -423 0 +-181 -424 0 +-182 -425 0 +-183 -426 0 +-184 -427 0 +-185 -428 0 +-186 -429 0 +-187 -430 0 +-188 -431 0 +-189 -432 0 +-190 -433 0 +-191 -434 0 +-192 -435 0 +-193 -436 0 +-194 -437 0 +-195 -438 0 +-196 -439 0 +-197 -440 0 +-198 -441 0 +-199 -442 0 +-200 -443 0 +-201 -444 0 +-202 -445 0 +-203 -446 0 +-204 -447 0 +-205 -448 0 +-206 -449 0 +-207 -450 0 +-208 -451 0 +-209 -452 0 +-210 -453 0 +-211 -454 0 +-212 -455 0 +-213 -456 0 +-214 -457 0 +-215 -458 0 +-216 -459 0 +-217 -460 0 +-218 -461 0 +-219 -462 0 +-220 -463 0 +-221 -464 0 +-222 -465 0 +-223 -466 0 +-224 -467 0 +-225 -468 0 +-226 -469 0 +-227 -470 0 +-228 -471 0 +-229 -472 0 +-230 -473 0 +-231 -474 0 +-232 -475 0 +-233 -476 0 +-234 -477 0 +-235 -478 0 +-236 -479 0 +-237 -480 0 +-238 -481 0 +-239 -482 0 +-240 -483 0 +-241 -484 0 +-242 -485 0 +-243 -486 0 +-163 -487 0 +-164 -488 0 +-165 -489 0 +-166 -490 0 +-167 -491 0 +-168 -492 0 +-169 -493 0 +-170 -494 0 +-171 -495 0 +-172 -496 0 +-173 -497 0 +-174 -498 0 +-175 -499 0 +-176 -500 0 +-177 -501 0 +-178 -502 0 +-179 -503 0 +-180 -504 0 +-181 -505 0 +-182 -506 0 +-183 -507 0 +-184 -508 0 +-185 -509 0 +-186 -510 0 +-187 -511 0 +-188 -512 0 +-189 -513 0 +-190 -514 0 +-191 -515 0 +-192 -516 0 +-193 -517 0 +-194 -518 0 +-195 -519 0 +-196 -520 0 +-197 -521 0 +-198 -522 0 +-199 -523 0 +-200 -524 0 +-201 -525 0 +-202 -526 0 +-203 -527 0 +-204 -528 0 +-205 -529 0 +-206 -530 0 +-207 -531 0 +-208 -532 0 +-209 -533 0 +-210 -534 0 +-211 -535 0 +-212 -536 0 +-213 -537 0 +-214 -538 0 +-215 -539 0 +-216 -540 0 +-217 -541 0 +-218 -542 0 +-219 -543 0 +-220 -544 0 +-221 -545 0 +-222 -546 0 +-223 -547 0 +-224 -548 0 +-225 -549 0 +-226 -550 0 +-227 -551 0 +-228 -552 0 +-229 -553 0 +-230 -554 0 +-231 -555 0 +-232 -556 0 +-233 -557 0 +-234 -558 0 +-235 -559 0 +-236 -560 0 +-237 -561 0 +-238 -562 0 +-239 -563 0 +-240 -564 0 +-241 -565 0 +-242 -566 0 +-243 -567 0 +-163 -568 0 +-164 -569 0 +-165 -570 0 +-166 -571 0 +-167 -572 0 +-168 -573 0 +-169 -574 0 +-170 -575 0 +-171 -576 0 +-172 -577 0 +-173 -578 0 +-174 -579 0 +-175 -580 0 +-176 -581 0 +-177 -582 0 +-178 -583 0 +-179 -584 0 +-180 -585 0 +-181 -586 0 +-182 -587 0 +-183 -588 0 +-184 -589 0 +-185 -590 0 +-186 -591 0 +-187 -592 0 +-188 -593 0 +-189 -594 0 +-190 -595 0 +-191 -596 0 +-192 -597 0 +-193 -598 0 +-194 -599 0 +-195 -600 0 +-196 -601 0 +-197 -602 0 +-198 -603 0 +-199 -604 0 +-200 -605 0 +-201 -606 0 +-202 -607 0 +-203 -608 0 +-204 -609 0 +-205 -610 0 +-206 -611 0 +-207 -612 0 +-208 -613 0 +-209 -614 0 +-210 -615 0 +-211 -616 0 +-212 -617 0 +-213 -618 0 +-214 -619 0 +-215 -620 0 +-216 -621 0 +-217 -622 0 +-218 -623 0 +-219 -624 0 +-220 -625 0 +-221 -626 0 +-222 -627 0 +-223 -628 0 +-224 -629 0 +-225 -630 0 +-226 -631 0 +-227 -632 0 +-228 -633 0 +-229 -634 0 +-230 -635 0 +-231 -636 0 +-232 -637 0 +-233 -638 0 +-234 -639 0 +-235 -640 0 +-236 -641 0 +-237 -642 0 +-238 -643 0 +-239 -644 0 +-240 -645 0 +-241 -646 0 +-242 -647 0 +-243 -648 0 +-163 -649 0 +-164 -650 0 +-165 -651 0 +-166 -652 0 +-167 -653 0 +-168 -654 0 +-169 -655 0 +-170 -656 0 +-171 -657 0 +-172 -658 0 +-173 -659 0 +-174 -660 0 +-175 -661 0 +-176 -662 0 +-177 -663 0 +-178 -664 0 +-179 -665 0 +-180 -666 0 +-181 -667 0 +-182 -668 0 +-183 -669 0 +-184 -670 0 +-185 -671 0 +-186 -672 0 +-187 -673 0 +-188 -674 0 +-189 -675 0 +-190 -676 0 +-191 -677 0 +-192 -678 0 +-193 -679 0 +-194 -680 0 +-195 -681 0 +-196 -682 0 +-197 -683 0 +-198 -684 0 +-199 -685 0 +-200 -686 0 +-201 -687 0 +-202 -688 0 +-203 -689 0 +-204 -690 0 +-205 -691 0 +-206 -692 0 +-207 -693 0 +-208 -694 0 +-209 -695 0 +-210 -696 0 +-211 -697 0 +-212 -698 0 +-213 -699 0 +-214 -700 0 +-215 -701 0 +-216 -702 0 +-217 -703 0 +-218 -704 0 +-219 -705 0 +-220 -706 0 +-221 -707 0 +-222 -708 0 +-223 -709 0 +-224 -710 0 +-225 -711 0 +-226 -712 0 +-227 -713 0 +-228 -714 0 +-229 -715 0 +-230 -716 0 +-231 -717 0 +-232 -718 0 +-233 -719 0 +-234 -720 0 +-235 -721 0 +-236 -722 0 +-237 -723 0 +-238 -724 0 +-239 -725 0 +-240 -726 0 +-241 -727 0 +-242 -728 0 +-243 -729 0 +-244 -1 0 +-245 -2 0 +-246 -3 0 +-247 -4 0 +-248 -5 0 +-249 -6 0 +-250 -7 0 +-251 -8 0 +-252 -9 0 +-253 -10 0 +-254 -11 0 +-255 -12 0 +-256 -13 0 +-257 -14 0 +-258 -15 0 +-259 -16 0 +-260 -17 0 +-261 -18 0 +-262 -19 0 +-263 -20 0 +-264 -21 0 +-265 -22 0 +-266 -23 0 +-267 -24 0 +-268 -25 0 +-269 -26 0 +-270 -27 0 +-271 -28 0 +-272 -29 0 +-273 -30 0 +-274 -31 0 +-275 -32 0 +-276 -33 0 +-277 -34 0 +-278 -35 0 +-279 -36 0 +-280 -37 0 +-281 -38 0 +-282 -39 0 +-283 -40 0 +-284 -41 0 +-285 -42 0 +-286 -43 0 +-287 -44 0 +-288 -45 0 +-289 -46 0 +-290 -47 0 +-291 -48 0 +-292 -49 0 +-293 -50 0 +-294 -51 0 +-295 -52 0 +-296 -53 0 +-297 -54 0 +-298 -55 0 +-299 -56 0 +-300 -57 0 +-301 -58 0 +-302 -59 0 +-303 -60 0 +-304 -61 0 +-305 -62 0 +-306 -63 0 +-307 -64 0 +-308 -65 0 +-309 -66 0 +-310 -67 0 +-311 -68 0 +-312 -69 0 +-313 -70 0 +-314 -71 0 +-315 -72 0 +-316 -73 0 +-317 -74 0 +-318 -75 0 +-319 -76 0 +-320 -77 0 +-321 -78 0 +-322 -79 0 +-323 -80 0 +-324 -81 0 +-244 -82 0 +-245 -83 0 +-246 -84 0 +-247 -85 0 +-248 -86 0 +-249 -87 0 +-250 -88 0 +-251 -89 0 +-252 -90 0 +-253 -91 0 +-254 -92 0 +-255 -93 0 +-256 -94 0 +-257 -95 0 +-258 -96 0 +-259 -97 0 +-260 -98 0 +-261 -99 0 +-262 -100 0 +-263 -101 0 +-264 -102 0 +-265 -103 0 +-266 -104 0 +-267 -105 0 +-268 -106 0 +-269 -107 0 +-270 -108 0 +-271 -109 0 +-272 -110 0 +-273 -111 0 +-274 -112 0 +-275 -113 0 +-276 -114 0 +-277 -115 0 +-278 -116 0 +-279 -117 0 +-280 -118 0 +-281 -119 0 +-282 -120 0 +-283 -121 0 +-284 -122 0 +-285 -123 0 +-286 -124 0 +-287 -125 0 +-288 -126 0 +-289 -127 0 +-290 -128 0 +-291 -129 0 +-292 -130 0 +-293 -131 0 +-294 -132 0 +-295 -133 0 +-296 -134 0 +-297 -135 0 +-298 -136 0 +-299 -137 0 +-300 -138 0 +-301 -139 0 +-302 -140 0 +-303 -141 0 +-304 -142 0 +-305 -143 0 +-306 -144 0 +-307 -145 0 +-308 -146 0 +-309 -147 0 +-310 -148 0 +-311 -149 0 +-312 -150 0 +-313 -151 0 +-314 -152 0 +-315 -153 0 +-316 -154 0 +-317 -155 0 +-318 -156 0 +-319 -157 0 +-320 -158 0 +-321 -159 0 +-322 -160 0 +-323 -161 0 +-324 -162 0 +-244 -163 0 +-245 -164 0 +-246 -165 0 +-247 -166 0 +-248 -167 0 +-249 -168 0 +-250 -169 0 +-251 -170 0 +-252 -171 0 +-253 -172 0 +-254 -173 0 +-255 -174 0 +-256 -175 0 +-257 -176 0 +-258 -177 0 +-259 -178 0 +-260 -179 0 +-261 -180 0 +-262 -181 0 +-263 -182 0 +-264 -183 0 +-265 -184 0 +-266 -185 0 +-267 -186 0 +-268 -187 0 +-269 -188 0 +-270 -189 0 +-271 -190 0 +-272 -191 0 +-273 -192 0 +-274 -193 0 +-275 -194 0 +-276 -195 0 +-277 -196 0 +-278 -197 0 +-279 -198 0 +-280 -199 0 +-281 -200 0 +-282 -201 0 +-283 -202 0 +-284 -203 0 +-285 -204 0 +-286 -205 0 +-287 -206 0 +-288 -207 0 +-289 -208 0 +-290 -209 0 +-291 -210 0 +-292 -211 0 +-293 -212 0 +-294 -213 0 +-295 -214 0 +-296 -215 0 +-297 -216 0 +-298 -217 0 +-299 -218 0 +-300 -219 0 +-301 -220 0 +-302 -221 0 +-303 -222 0 +-304 -223 0 +-305 -224 0 +-306 -225 0 +-307 -226 0 +-308 -227 0 +-309 -228 0 +-310 -229 0 +-311 -230 0 +-312 -231 0 +-313 -232 0 +-314 -233 0 +-315 -234 0 +-316 -235 0 +-317 -236 0 +-318 -237 0 +-319 -238 0 +-320 -239 0 +-321 -240 0 +-322 -241 0 +-323 -242 0 +-324 -243 0 +-244 -325 0 +-245 -326 0 +-246 -327 0 +-247 -328 0 +-248 -329 0 +-249 -330 0 +-250 -331 0 +-251 -332 0 +-252 -333 0 +-253 -334 0 +-254 -335 0 +-255 -336 0 +-256 -337 0 +-257 -338 0 +-258 -339 0 +-259 -340 0 +-260 -341 0 +-261 -342 0 +-262 -343 0 +-263 -344 0 +-264 -345 0 +-265 -346 0 +-266 -347 0 +-267 -348 0 +-268 -349 0 +-269 -350 0 +-270 -351 0 +-271 -352 0 +-272 -353 0 +-273 -354 0 +-274 -355 0 +-275 -356 0 +-276 -357 0 +-277 -358 0 +-278 -359 0 +-279 -360 0 +-280 -361 0 +-281 -362 0 +-282 -363 0 +-283 -364 0 +-284 -365 0 +-285 -366 0 +-286 -367 0 +-287 -368 0 +-288 -369 0 +-289 -370 0 +-290 -371 0 +-291 -372 0 +-292 -373 0 +-293 -374 0 +-294 -375 0 +-295 -376 0 +-296 -377 0 +-297 -378 0 +-298 -379 0 +-299 -380 0 +-300 -381 0 +-301 -382 0 +-302 -383 0 +-303 -384 0 +-304 -385 0 +-305 -386 0 +-306 -387 0 +-307 -388 0 +-308 -389 0 +-309 -390 0 +-310 -391 0 +-311 -392 0 +-312 -393 0 +-313 -394 0 +-314 -395 0 +-315 -396 0 +-316 -397 0 +-317 -398 0 +-318 -399 0 +-319 -400 0 +-320 -401 0 +-321 -402 0 +-322 -403 0 +-323 -404 0 +-324 -405 0 +-244 -406 0 +-245 -407 0 +-246 -408 0 +-247 -409 0 +-248 -410 0 +-249 -411 0 +-250 -412 0 +-251 -413 0 +-252 -414 0 +-253 -415 0 +-254 -416 0 +-255 -417 0 +-256 -418 0 +-257 -419 0 +-258 -420 0 +-259 -421 0 +-260 -422 0 +-261 -423 0 +-262 -424 0 +-263 -425 0 +-264 -426 0 +-265 -427 0 +-266 -428 0 +-267 -429 0 +-268 -430 0 +-269 -431 0 +-270 -432 0 +-271 -433 0 +-272 -434 0 +-273 -435 0 +-274 -436 0 +-275 -437 0 +-276 -438 0 +-277 -439 0 +-278 -440 0 +-279 -441 0 +-280 -442 0 +-281 -443 0 +-282 -444 0 +-283 -445 0 +-284 -446 0 +-285 -447 0 +-286 -448 0 +-287 -449 0 +-288 -450 0 +-289 -451 0 +-290 -452 0 +-291 -453 0 +-292 -454 0 +-293 -455 0 +-294 -456 0 +-295 -457 0 +-296 -458 0 +-297 -459 0 +-298 -460 0 +-299 -461 0 +-300 -462 0 +-301 -463 0 +-302 -464 0 +-303 -465 0 +-304 -466 0 +-305 -467 0 +-306 -468 0 +-307 -469 0 +-308 -470 0 +-309 -471 0 +-310 -472 0 +-311 -473 0 +-312 -474 0 +-313 -475 0 +-314 -476 0 +-315 -477 0 +-316 -478 0 +-317 -479 0 +-318 -480 0 +-319 -481 0 +-320 -482 0 +-321 -483 0 +-322 -484 0 +-323 -485 0 +-324 -486 0 +-244 -487 0 +-245 -488 0 +-246 -489 0 +-247 -490 0 +-248 -491 0 +-249 -492 0 +-250 -493 0 +-251 -494 0 +-252 -495 0 +-253 -496 0 +-254 -497 0 +-255 -498 0 +-256 -499 0 +-257 -500 0 +-258 -501 0 +-259 -502 0 +-260 -503 0 +-261 -504 0 +-262 -505 0 +-263 -506 0 +-264 -507 0 +-265 -508 0 +-266 -509 0 +-267 -510 0 +-268 -511 0 +-269 -512 0 +-270 -513 0 +-271 -514 0 +-272 -515 0 +-273 -516 0 +-274 -517 0 +-275 -518 0 +-276 -519 0 +-277 -520 0 +-278 -521 0 +-279 -522 0 +-280 -523 0 +-281 -524 0 +-282 -525 0 +-283 -526 0 +-284 -527 0 +-285 -528 0 +-286 -529 0 +-287 -530 0 +-288 -531 0 +-289 -532 0 +-290 -533 0 +-291 -534 0 +-292 -535 0 +-293 -536 0 +-294 -537 0 +-295 -538 0 +-296 -539 0 +-297 -540 0 +-298 -541 0 +-299 -542 0 +-300 -543 0 +-301 -544 0 +-302 -545 0 +-303 -546 0 +-304 -547 0 +-305 -548 0 +-306 -549 0 +-307 -550 0 +-308 -551 0 +-309 -552 0 +-310 -553 0 +-311 -554 0 +-312 -555 0 +-313 -556 0 +-314 -557 0 +-315 -558 0 +-316 -559 0 +-317 -560 0 +-318 -561 0 +-319 -562 0 +-320 -563 0 +-321 -564 0 +-322 -565 0 +-323 -566 0 +-324 -567 0 +-244 -568 0 +-245 -569 0 +-246 -570 0 +-247 -571 0 +-248 -572 0 +-249 -573 0 +-250 -574 0 +-251 -575 0 +-252 -576 0 +-253 -577 0 +-254 -578 0 +-255 -579 0 +-256 -580 0 +-257 -581 0 +-258 -582 0 +-259 -583 0 +-260 -584 0 +-261 -585 0 +-262 -586 0 +-263 -587 0 +-264 -588 0 +-265 -589 0 +-266 -590 0 +-267 -591 0 +-268 -592 0 +-269 -593 0 +-270 -594 0 +-271 -595 0 +-272 -596 0 +-273 -597 0 +-274 -598 0 +-275 -599 0 +-276 -600 0 +-277 -601 0 +-278 -602 0 +-279 -603 0 +-280 -604 0 +-281 -605 0 +-282 -606 0 +-283 -607 0 +-284 -608 0 +-285 -609 0 +-286 -610 0 +-287 -611 0 +-288 -612 0 +-289 -613 0 +-290 -614 0 +-291 -615 0 +-292 -616 0 +-293 -617 0 +-294 -618 0 +-295 -619 0 +-296 -620 0 +-297 -621 0 +-298 -622 0 +-299 -623 0 +-300 -624 0 +-301 -625 0 +-302 -626 0 +-303 -627 0 +-304 -628 0 +-305 -629 0 +-306 -630 0 +-307 -631 0 +-308 -632 0 +-309 -633 0 +-310 -634 0 +-311 -635 0 +-312 -636 0 +-313 -637 0 +-314 -638 0 +-315 -639 0 +-316 -640 0 +-317 -641 0 +-318 -642 0 +-319 -643 0 +-320 -644 0 +-321 -645 0 +-322 -646 0 +-323 -647 0 +-324 -648 0 +-244 -649 0 +-245 -650 0 +-246 -651 0 +-247 -652 0 +-248 -653 0 +-249 -654 0 +-250 -655 0 +-251 -656 0 +-252 -657 0 +-253 -658 0 +-254 -659 0 +-255 -660 0 +-256 -661 0 +-257 -662 0 +-258 -663 0 +-259 -664 0 +-260 -665 0 +-261 -666 0 +-262 -667 0 +-263 -668 0 +-264 -669 0 +-265 -670 0 +-266 -671 0 +-267 -672 0 +-268 -673 0 +-269 -674 0 +-270 -675 0 +-271 -676 0 +-272 -677 0 +-273 -678 0 +-274 -679 0 +-275 -680 0 +-276 -681 0 +-277 -682 0 +-278 -683 0 +-279 -684 0 +-280 -685 0 +-281 -686 0 +-282 -687 0 +-283 -688 0 +-284 -689 0 +-285 -690 0 +-286 -691 0 +-287 -692 0 +-288 -693 0 +-289 -694 0 +-290 -695 0 +-291 -696 0 +-292 -697 0 +-293 -698 0 +-294 -699 0 +-295 -700 0 +-296 -701 0 +-297 -702 0 +-298 -703 0 +-299 -704 0 +-300 -705 0 +-301 -706 0 +-302 -707 0 +-303 -708 0 +-304 -709 0 +-305 -710 0 +-306 -711 0 +-307 -712 0 +-308 -713 0 +-309 -714 0 +-310 -715 0 +-311 -716 0 +-312 -717 0 +-313 -718 0 +-314 -719 0 +-315 -720 0 +-316 -721 0 +-317 -722 0 +-318 -723 0 +-319 -724 0 +-320 -725 0 +-321 -726 0 +-322 -727 0 +-323 -728 0 +-324 -729 0 +-325 -1 0 +-326 -2 0 +-327 -3 0 +-328 -4 0 +-329 -5 0 +-330 -6 0 +-331 -7 0 +-332 -8 0 +-333 -9 0 +-334 -10 0 +-335 -11 0 +-336 -12 0 +-337 -13 0 +-338 -14 0 +-339 -15 0 +-340 -16 0 +-341 -17 0 +-342 -18 0 +-343 -19 0 +-344 -20 0 +-345 -21 0 +-346 -22 0 +-347 -23 0 +-348 -24 0 +-349 -25 0 +-350 -26 0 +-351 -27 0 +-352 -28 0 +-353 -29 0 +-354 -30 0 +-355 -31 0 +-356 -32 0 +-357 -33 0 +-358 -34 0 +-359 -35 0 +-360 -36 0 +-361 -37 0 +-362 -38 0 +-363 -39 0 +-364 -40 0 +-365 -41 0 +-366 -42 0 +-367 -43 0 +-368 -44 0 +-369 -45 0 +-370 -46 0 +-371 -47 0 +-372 -48 0 +-373 -49 0 +-374 -50 0 +-375 -51 0 +-376 -52 0 +-377 -53 0 +-378 -54 0 +-379 -55 0 +-380 -56 0 +-381 -57 0 +-382 -58 0 +-383 -59 0 +-384 -60 0 +-385 -61 0 +-386 -62 0 +-387 -63 0 +-388 -64 0 +-389 -65 0 +-390 -66 0 +-391 -67 0 +-392 -68 0 +-393 -69 0 +-394 -70 0 +-395 -71 0 +-396 -72 0 +-397 -73 0 +-398 -74 0 +-399 -75 0 +-400 -76 0 +-401 -77 0 +-402 -78 0 +-403 -79 0 +-404 -80 0 +-405 -81 0 +-325 -82 0 +-326 -83 0 +-327 -84 0 +-328 -85 0 +-329 -86 0 +-330 -87 0 +-331 -88 0 +-332 -89 0 +-333 -90 0 +-334 -91 0 +-335 -92 0 +-336 -93 0 +-337 -94 0 +-338 -95 0 +-339 -96 0 +-340 -97 0 +-341 -98 0 +-342 -99 0 +-343 -100 0 +-344 -101 0 +-345 -102 0 +-346 -103 0 +-347 -104 0 +-348 -105 0 +-349 -106 0 +-350 -107 0 +-351 -108 0 +-352 -109 0 +-353 -110 0 +-354 -111 0 +-355 -112 0 +-356 -113 0 +-357 -114 0 +-358 -115 0 +-359 -116 0 +-360 -117 0 +-361 -118 0 +-362 -119 0 +-363 -120 0 +-364 -121 0 +-365 -122 0 +-366 -123 0 +-367 -124 0 +-368 -125 0 +-369 -126 0 +-370 -127 0 +-371 -128 0 +-372 -129 0 +-373 -130 0 +-374 -131 0 +-375 -132 0 +-376 -133 0 +-377 -134 0 +-378 -135 0 +-379 -136 0 +-380 -137 0 +-381 -138 0 +-382 -139 0 +-383 -140 0 +-384 -141 0 +-385 -142 0 +-386 -143 0 +-387 -144 0 +-388 -145 0 +-389 -146 0 +-390 -147 0 +-391 -148 0 +-392 -149 0 +-393 -150 0 +-394 -151 0 +-395 -152 0 +-396 -153 0 +-397 -154 0 +-398 -155 0 +-399 -156 0 +-400 -157 0 +-401 -158 0 +-402 -159 0 +-403 -160 0 +-404 -161 0 +-405 -162 0 +-325 -163 0 +-326 -164 0 +-327 -165 0 +-328 -166 0 +-329 -167 0 +-330 -168 0 +-331 -169 0 +-332 -170 0 +-333 -171 0 +-334 -172 0 +-335 -173 0 +-336 -174 0 +-337 -175 0 +-338 -176 0 +-339 -177 0 +-340 -178 0 +-341 -179 0 +-342 -180 0 +-343 -181 0 +-344 -182 0 +-345 -183 0 +-346 -184 0 +-347 -185 0 +-348 -186 0 +-349 -187 0 +-350 -188 0 +-351 -189 0 +-352 -190 0 +-353 -191 0 +-354 -192 0 +-355 -193 0 +-356 -194 0 +-357 -195 0 +-358 -196 0 +-359 -197 0 +-360 -198 0 +-361 -199 0 +-362 -200 0 +-363 -201 0 +-364 -202 0 +-365 -203 0 +-366 -204 0 +-367 -205 0 +-368 -206 0 +-369 -207 0 +-370 -208 0 +-371 -209 0 +-372 -210 0 +-373 -211 0 +-374 -212 0 +-375 -213 0 +-376 -214 0 +-377 -215 0 +-378 -216 0 +-379 -217 0 +-380 -218 0 +-381 -219 0 +-382 -220 0 +-383 -221 0 +-384 -222 0 +-385 -223 0 +-386 -224 0 +-387 -225 0 +-388 -226 0 +-389 -227 0 +-390 -228 0 +-391 -229 0 +-392 -230 0 +-393 -231 0 +-394 -232 0 +-395 -233 0 +-396 -234 0 +-397 -235 0 +-398 -236 0 +-399 -237 0 +-400 -238 0 +-401 -239 0 +-402 -240 0 +-403 -241 0 +-404 -242 0 +-405 -243 0 +-325 -244 0 +-326 -245 0 +-327 -246 0 +-328 -247 0 +-329 -248 0 +-330 -249 0 +-331 -250 0 +-332 -251 0 +-333 -252 0 +-334 -253 0 +-335 -254 0 +-336 -255 0 +-337 -256 0 +-338 -257 0 +-339 -258 0 +-340 -259 0 +-341 -260 0 +-342 -261 0 +-343 -262 0 +-344 -263 0 +-345 -264 0 +-346 -265 0 +-347 -266 0 +-348 -267 0 +-349 -268 0 +-350 -269 0 +-351 -270 0 +-352 -271 0 +-353 -272 0 +-354 -273 0 +-355 -274 0 +-356 -275 0 +-357 -276 0 +-358 -277 0 +-359 -278 0 +-360 -279 0 +-361 -280 0 +-362 -281 0 +-363 -282 0 +-364 -283 0 +-365 -284 0 +-366 -285 0 +-367 -286 0 +-368 -287 0 +-369 -288 0 +-370 -289 0 +-371 -290 0 +-372 -291 0 +-373 -292 0 +-374 -293 0 +-375 -294 0 +-376 -295 0 +-377 -296 0 +-378 -297 0 +-379 -298 0 +-380 -299 0 +-381 -300 0 +-382 -301 0 +-383 -302 0 +-384 -303 0 +-385 -304 0 +-386 -305 0 +-387 -306 0 +-388 -307 0 +-389 -308 0 +-390 -309 0 +-391 -310 0 +-392 -311 0 +-393 -312 0 +-394 -313 0 +-395 -314 0 +-396 -315 0 +-397 -316 0 +-398 -317 0 +-399 -318 0 +-400 -319 0 +-401 -320 0 +-402 -321 0 +-403 -322 0 +-404 -323 0 +-405 -324 0 +-325 -406 0 +-326 -407 0 +-327 -408 0 +-328 -409 0 +-329 -410 0 +-330 -411 0 +-331 -412 0 +-332 -413 0 +-333 -414 0 +-334 -415 0 +-335 -416 0 +-336 -417 0 +-337 -418 0 +-338 -419 0 +-339 -420 0 +-340 -421 0 +-341 -422 0 +-342 -423 0 +-343 -424 0 +-344 -425 0 +-345 -426 0 +-346 -427 0 +-347 -428 0 +-348 -429 0 +-349 -430 0 +-350 -431 0 +-351 -432 0 +-352 -433 0 +-353 -434 0 +-354 -435 0 +-355 -436 0 +-356 -437 0 +-357 -438 0 +-358 -439 0 +-359 -440 0 +-360 -441 0 +-361 -442 0 +-362 -443 0 +-363 -444 0 +-364 -445 0 +-365 -446 0 +-366 -447 0 +-367 -448 0 +-368 -449 0 +-369 -450 0 +-370 -451 0 +-371 -452 0 +-372 -453 0 +-373 -454 0 +-374 -455 0 +-375 -456 0 +-376 -457 0 +-377 -458 0 +-378 -459 0 +-379 -460 0 +-380 -461 0 +-381 -462 0 +-382 -463 0 +-383 -464 0 +-384 -465 0 +-385 -466 0 +-386 -467 0 +-387 -468 0 +-388 -469 0 +-389 -470 0 +-390 -471 0 +-391 -472 0 +-392 -473 0 +-393 -474 0 +-394 -475 0 +-395 -476 0 +-396 -477 0 +-397 -478 0 +-398 -479 0 +-399 -480 0 +-400 -481 0 +-401 -482 0 +-402 -483 0 +-403 -484 0 +-404 -485 0 +-405 -486 0 +-325 -487 0 +-326 -488 0 +-327 -489 0 +-328 -490 0 +-329 -491 0 +-330 -492 0 +-331 -493 0 +-332 -494 0 +-333 -495 0 +-334 -496 0 +-335 -497 0 +-336 -498 0 +-337 -499 0 +-338 -500 0 +-339 -501 0 +-340 -502 0 +-341 -503 0 +-342 -504 0 +-343 -505 0 +-344 -506 0 +-345 -507 0 +-346 -508 0 +-347 -509 0 +-348 -510 0 +-349 -511 0 +-350 -512 0 +-351 -513 0 +-352 -514 0 +-353 -515 0 +-354 -516 0 +-355 -517 0 +-356 -518 0 +-357 -519 0 +-358 -520 0 +-359 -521 0 +-360 -522 0 +-361 -523 0 +-362 -524 0 +-363 -525 0 +-364 -526 0 +-365 -527 0 +-366 -528 0 +-367 -529 0 +-368 -530 0 +-369 -531 0 +-370 -532 0 +-371 -533 0 +-372 -534 0 +-373 -535 0 +-374 -536 0 +-375 -537 0 +-376 -538 0 +-377 -539 0 +-378 -540 0 +-379 -541 0 +-380 -542 0 +-381 -543 0 +-382 -544 0 +-383 -545 0 +-384 -546 0 +-385 -547 0 +-386 -548 0 +-387 -549 0 +-388 -550 0 +-389 -551 0 +-390 -552 0 +-391 -553 0 +-392 -554 0 +-393 -555 0 +-394 -556 0 +-395 -557 0 +-396 -558 0 +-397 -559 0 +-398 -560 0 +-399 -561 0 +-400 -562 0 +-401 -563 0 +-402 -564 0 +-403 -565 0 +-404 -566 0 +-405 -567 0 +-325 -568 0 +-326 -569 0 +-327 -570 0 +-328 -571 0 +-329 -572 0 +-330 -573 0 +-331 -574 0 +-332 -575 0 +-333 -576 0 +-334 -577 0 +-335 -578 0 +-336 -579 0 +-337 -580 0 +-338 -581 0 +-339 -582 0 +-340 -583 0 +-341 -584 0 +-342 -585 0 +-343 -586 0 +-344 -587 0 +-345 -588 0 +-346 -589 0 +-347 -590 0 +-348 -591 0 +-349 -592 0 +-350 -593 0 +-351 -594 0 +-352 -595 0 +-353 -596 0 +-354 -597 0 +-355 -598 0 +-356 -599 0 +-357 -600 0 +-358 -601 0 +-359 -602 0 +-360 -603 0 +-361 -604 0 +-362 -605 0 +-363 -606 0 +-364 -607 0 +-365 -608 0 +-366 -609 0 +-367 -610 0 +-368 -611 0 +-369 -612 0 +-370 -613 0 +-371 -614 0 +-372 -615 0 +-373 -616 0 +-374 -617 0 +-375 -618 0 +-376 -619 0 +-377 -620 0 +-378 -621 0 +-379 -622 0 +-380 -623 0 +-381 -624 0 +-382 -625 0 +-383 -626 0 +-384 -627 0 +-385 -628 0 +-386 -629 0 +-387 -630 0 +-388 -631 0 +-389 -632 0 +-390 -633 0 +-391 -634 0 +-392 -635 0 +-393 -636 0 +-394 -637 0 +-395 -638 0 +-396 -639 0 +-397 -640 0 +-398 -641 0 +-399 -642 0 +-400 -643 0 +-401 -644 0 +-402 -645 0 +-403 -646 0 +-404 -647 0 +-405 -648 0 +-325 -649 0 +-326 -650 0 +-327 -651 0 +-328 -652 0 +-329 -653 0 +-330 -654 0 +-331 -655 0 +-332 -656 0 +-333 -657 0 +-334 -658 0 +-335 -659 0 +-336 -660 0 +-337 -661 0 +-338 -662 0 +-339 -663 0 +-340 -664 0 +-341 -665 0 +-342 -666 0 +-343 -667 0 +-344 -668 0 +-345 -669 0 +-346 -670 0 +-347 -671 0 +-348 -672 0 +-349 -673 0 +-350 -674 0 +-351 -675 0 +-352 -676 0 +-353 -677 0 +-354 -678 0 +-355 -679 0 +-356 -680 0 +-357 -681 0 +-358 -682 0 +-359 -683 0 +-360 -684 0 +-361 -685 0 +-362 -686 0 +-363 -687 0 +-364 -688 0 +-365 -689 0 +-366 -690 0 +-367 -691 0 +-368 -692 0 +-369 -693 0 +-370 -694 0 +-371 -695 0 +-372 -696 0 +-373 -697 0 +-374 -698 0 +-375 -699 0 +-376 -700 0 +-377 -701 0 +-378 -702 0 +-379 -703 0 +-380 -704 0 +-381 -705 0 +-382 -706 0 +-383 -707 0 +-384 -708 0 +-385 -709 0 +-386 -710 0 +-387 -711 0 +-388 -712 0 +-389 -713 0 +-390 -714 0 +-391 -715 0 +-392 -716 0 +-393 -717 0 +-394 -718 0 +-395 -719 0 +-396 -720 0 +-397 -721 0 +-398 -722 0 +-399 -723 0 +-400 -724 0 +-401 -725 0 +-402 -726 0 +-403 -727 0 +-404 -728 0 +-405 -729 0 +-406 -1 0 +-407 -2 0 +-408 -3 0 +-409 -4 0 +-410 -5 0 +-411 -6 0 +-412 -7 0 +-413 -8 0 +-414 -9 0 +-415 -10 0 +-416 -11 0 +-417 -12 0 +-418 -13 0 +-419 -14 0 +-420 -15 0 +-421 -16 0 +-422 -17 0 +-423 -18 0 +-424 -19 0 +-425 -20 0 +-426 -21 0 +-427 -22 0 +-428 -23 0 +-429 -24 0 +-430 -25 0 +-431 -26 0 +-432 -27 0 +-433 -28 0 +-434 -29 0 +-435 -30 0 +-436 -31 0 +-437 -32 0 +-438 -33 0 +-439 -34 0 +-440 -35 0 +-441 -36 0 +-442 -37 0 +-443 -38 0 +-444 -39 0 +-445 -40 0 +-446 -41 0 +-447 -42 0 +-448 -43 0 +-449 -44 0 +-450 -45 0 +-451 -46 0 +-452 -47 0 +-453 -48 0 +-454 -49 0 +-455 -50 0 +-456 -51 0 +-457 -52 0 +-458 -53 0 +-459 -54 0 +-460 -55 0 +-461 -56 0 +-462 -57 0 +-463 -58 0 +-464 -59 0 +-465 -60 0 +-466 -61 0 +-467 -62 0 +-468 -63 0 +-469 -64 0 +-470 -65 0 +-471 -66 0 +-472 -67 0 +-473 -68 0 +-474 -69 0 +-475 -70 0 +-476 -71 0 +-477 -72 0 +-478 -73 0 +-479 -74 0 +-480 -75 0 +-481 -76 0 +-482 -77 0 +-483 -78 0 +-484 -79 0 +-485 -80 0 +-486 -81 0 +-406 -82 0 +-407 -83 0 +-408 -84 0 +-409 -85 0 +-410 -86 0 +-411 -87 0 +-412 -88 0 +-413 -89 0 +-414 -90 0 +-415 -91 0 +-416 -92 0 +-417 -93 0 +-418 -94 0 +-419 -95 0 +-420 -96 0 +-421 -97 0 +-422 -98 0 +-423 -99 0 +-424 -100 0 +-425 -101 0 +-426 -102 0 +-427 -103 0 +-428 -104 0 +-429 -105 0 +-430 -106 0 +-431 -107 0 +-432 -108 0 +-433 -109 0 +-434 -110 0 +-435 -111 0 +-436 -112 0 +-437 -113 0 +-438 -114 0 +-439 -115 0 +-440 -116 0 +-441 -117 0 +-442 -118 0 +-443 -119 0 +-444 -120 0 +-445 -121 0 +-446 -122 0 +-447 -123 0 +-448 -124 0 +-449 -125 0 +-450 -126 0 +-451 -127 0 +-452 -128 0 +-453 -129 0 +-454 -130 0 +-455 -131 0 +-456 -132 0 +-457 -133 0 +-458 -134 0 +-459 -135 0 +-460 -136 0 +-461 -137 0 +-462 -138 0 +-463 -139 0 +-464 -140 0 +-465 -141 0 +-466 -142 0 +-467 -143 0 +-468 -144 0 +-469 -145 0 +-470 -146 0 +-471 -147 0 +-472 -148 0 +-473 -149 0 +-474 -150 0 +-475 -151 0 +-476 -152 0 +-477 -153 0 +-478 -154 0 +-479 -155 0 +-480 -156 0 +-481 -157 0 +-482 -158 0 +-483 -159 0 +-484 -160 0 +-485 -161 0 +-486 -162 0 +-406 -163 0 +-407 -164 0 +-408 -165 0 +-409 -166 0 +-410 -167 0 +-411 -168 0 +-412 -169 0 +-413 -170 0 +-414 -171 0 +-415 -172 0 +-416 -173 0 +-417 -174 0 +-418 -175 0 +-419 -176 0 +-420 -177 0 +-421 -178 0 +-422 -179 0 +-423 -180 0 +-424 -181 0 +-425 -182 0 +-426 -183 0 +-427 -184 0 +-428 -185 0 +-429 -186 0 +-430 -187 0 +-431 -188 0 +-432 -189 0 +-433 -190 0 +-434 -191 0 +-435 -192 0 +-436 -193 0 +-437 -194 0 +-438 -195 0 +-439 -196 0 +-440 -197 0 +-441 -198 0 +-442 -199 0 +-443 -200 0 +-444 -201 0 +-445 -202 0 +-446 -203 0 +-447 -204 0 +-448 -205 0 +-449 -206 0 +-450 -207 0 +-451 -208 0 +-452 -209 0 +-453 -210 0 +-454 -211 0 +-455 -212 0 +-456 -213 0 +-457 -214 0 +-458 -215 0 +-459 -216 0 +-460 -217 0 +-461 -218 0 +-462 -219 0 +-463 -220 0 +-464 -221 0 +-465 -222 0 +-466 -223 0 +-467 -224 0 +-468 -225 0 +-469 -226 0 +-470 -227 0 +-471 -228 0 +-472 -229 0 +-473 -230 0 +-474 -231 0 +-475 -232 0 +-476 -233 0 +-477 -234 0 +-478 -235 0 +-479 -236 0 +-480 -237 0 +-481 -238 0 +-482 -239 0 +-483 -240 0 +-484 -241 0 +-485 -242 0 +-486 -243 0 +-406 -244 0 +-407 -245 0 +-408 -246 0 +-409 -247 0 +-410 -248 0 +-411 -249 0 +-412 -250 0 +-413 -251 0 +-414 -252 0 +-415 -253 0 +-416 -254 0 +-417 -255 0 +-418 -256 0 +-419 -257 0 +-420 -258 0 +-421 -259 0 +-422 -260 0 +-423 -261 0 +-424 -262 0 +-425 -263 0 +-426 -264 0 +-427 -265 0 +-428 -266 0 +-429 -267 0 +-430 -268 0 +-431 -269 0 +-432 -270 0 +-433 -271 0 +-434 -272 0 +-435 -273 0 +-436 -274 0 +-437 -275 0 +-438 -276 0 +-439 -277 0 +-440 -278 0 +-441 -279 0 +-442 -280 0 +-443 -281 0 +-444 -282 0 +-445 -283 0 +-446 -284 0 +-447 -285 0 +-448 -286 0 +-449 -287 0 +-450 -288 0 +-451 -289 0 +-452 -290 0 +-453 -291 0 +-454 -292 0 +-455 -293 0 +-456 -294 0 +-457 -295 0 +-458 -296 0 +-459 -297 0 +-460 -298 0 +-461 -299 0 +-462 -300 0 +-463 -301 0 +-464 -302 0 +-465 -303 0 +-466 -304 0 +-467 -305 0 +-468 -306 0 +-469 -307 0 +-470 -308 0 +-471 -309 0 +-472 -310 0 +-473 -311 0 +-474 -312 0 +-475 -313 0 +-476 -314 0 +-477 -315 0 +-478 -316 0 +-479 -317 0 +-480 -318 0 +-481 -319 0 +-482 -320 0 +-483 -321 0 +-484 -322 0 +-485 -323 0 +-486 -324 0 +-406 -325 0 +-407 -326 0 +-408 -327 0 +-409 -328 0 +-410 -329 0 +-411 -330 0 +-412 -331 0 +-413 -332 0 +-414 -333 0 +-415 -334 0 +-416 -335 0 +-417 -336 0 +-418 -337 0 +-419 -338 0 +-420 -339 0 +-421 -340 0 +-422 -341 0 +-423 -342 0 +-424 -343 0 +-425 -344 0 +-426 -345 0 +-427 -346 0 +-428 -347 0 +-429 -348 0 +-430 -349 0 +-431 -350 0 +-432 -351 0 +-433 -352 0 +-434 -353 0 +-435 -354 0 +-436 -355 0 +-437 -356 0 +-438 -357 0 +-439 -358 0 +-440 -359 0 +-441 -360 0 +-442 -361 0 +-443 -362 0 +-444 -363 0 +-445 -364 0 +-446 -365 0 +-447 -366 0 +-448 -367 0 +-449 -368 0 +-450 -369 0 +-451 -370 0 +-452 -371 0 +-453 -372 0 +-454 -373 0 +-455 -374 0 +-456 -375 0 +-457 -376 0 +-458 -377 0 +-459 -378 0 +-460 -379 0 +-461 -380 0 +-462 -381 0 +-463 -382 0 +-464 -383 0 +-465 -384 0 +-466 -385 0 +-467 -386 0 +-468 -387 0 +-469 -388 0 +-470 -389 0 +-471 -390 0 +-472 -391 0 +-473 -392 0 +-474 -393 0 +-475 -394 0 +-476 -395 0 +-477 -396 0 +-478 -397 0 +-479 -398 0 +-480 -399 0 +-481 -400 0 +-482 -401 0 +-483 -402 0 +-484 -403 0 +-485 -404 0 +-486 -405 0 +-406 -487 0 +-407 -488 0 +-408 -489 0 +-409 -490 0 +-410 -491 0 +-411 -492 0 +-412 -493 0 +-413 -494 0 +-414 -495 0 +-415 -496 0 +-416 -497 0 +-417 -498 0 +-418 -499 0 +-419 -500 0 +-420 -501 0 +-421 -502 0 +-422 -503 0 +-423 -504 0 +-424 -505 0 +-425 -506 0 +-426 -507 0 +-427 -508 0 +-428 -509 0 +-429 -510 0 +-430 -511 0 +-431 -512 0 +-432 -513 0 +-433 -514 0 +-434 -515 0 +-435 -516 0 +-436 -517 0 +-437 -518 0 +-438 -519 0 +-439 -520 0 +-440 -521 0 +-441 -522 0 +-442 -523 0 +-443 -524 0 +-444 -525 0 +-445 -526 0 +-446 -527 0 +-447 -528 0 +-448 -529 0 +-449 -530 0 +-450 -531 0 +-451 -532 0 +-452 -533 0 +-453 -534 0 +-454 -535 0 +-455 -536 0 +-456 -537 0 +-457 -538 0 +-458 -539 0 +-459 -540 0 +-460 -541 0 +-461 -542 0 +-462 -543 0 +-463 -544 0 +-464 -545 0 +-465 -546 0 +-466 -547 0 +-467 -548 0 +-468 -549 0 +-469 -550 0 +-470 -551 0 +-471 -552 0 +-472 -553 0 +-473 -554 0 +-474 -555 0 +-475 -556 0 +-476 -557 0 +-477 -558 0 +-478 -559 0 +-479 -560 0 +-480 -561 0 +-481 -562 0 +-482 -563 0 +-483 -564 0 +-484 -565 0 +-485 -566 0 +-486 -567 0 +-406 -568 0 +-407 -569 0 +-408 -570 0 +-409 -571 0 +-410 -572 0 +-411 -573 0 +-412 -574 0 +-413 -575 0 +-414 -576 0 +-415 -577 0 +-416 -578 0 +-417 -579 0 +-418 -580 0 +-419 -581 0 +-420 -582 0 +-421 -583 0 +-422 -584 0 +-423 -585 0 +-424 -586 0 +-425 -587 0 +-426 -588 0 +-427 -589 0 +-428 -590 0 +-429 -591 0 +-430 -592 0 +-431 -593 0 +-432 -594 0 +-433 -595 0 +-434 -596 0 +-435 -597 0 +-436 -598 0 +-437 -599 0 +-438 -600 0 +-439 -601 0 +-440 -602 0 +-441 -603 0 +-442 -604 0 +-443 -605 0 +-444 -606 0 +-445 -607 0 +-446 -608 0 +-447 -609 0 +-448 -610 0 +-449 -611 0 +-450 -612 0 +-451 -613 0 +-452 -614 0 +-453 -615 0 +-454 -616 0 +-455 -617 0 +-456 -618 0 +-457 -619 0 +-458 -620 0 +-459 -621 0 +-460 -622 0 +-461 -623 0 +-462 -624 0 +-463 -625 0 +-464 -626 0 +-465 -627 0 +-466 -628 0 +-467 -629 0 +-468 -630 0 +-469 -631 0 +-470 -632 0 +-471 -633 0 +-472 -634 0 +-473 -635 0 +-474 -636 0 +-475 -637 0 +-476 -638 0 +-477 -639 0 +-478 -640 0 +-479 -641 0 +-480 -642 0 +-481 -643 0 +-482 -644 0 +-483 -645 0 +-484 -646 0 +-485 -647 0 +-486 -648 0 +-406 -649 0 +-407 -650 0 +-408 -651 0 +-409 -652 0 +-410 -653 0 +-411 -654 0 +-412 -655 0 +-413 -656 0 +-414 -657 0 +-415 -658 0 +-416 -659 0 +-417 -660 0 +-418 -661 0 +-419 -662 0 +-420 -663 0 +-421 -664 0 +-422 -665 0 +-423 -666 0 +-424 -667 0 +-425 -668 0 +-426 -669 0 +-427 -670 0 +-428 -671 0 +-429 -672 0 +-430 -673 0 +-431 -674 0 +-432 -675 0 +-433 -676 0 +-434 -677 0 +-435 -678 0 +-436 -679 0 +-437 -680 0 +-438 -681 0 +-439 -682 0 +-440 -683 0 +-441 -684 0 +-442 -685 0 +-443 -686 0 +-444 -687 0 +-445 -688 0 +-446 -689 0 +-447 -690 0 +-448 -691 0 +-449 -692 0 +-450 -693 0 +-451 -694 0 +-452 -695 0 +-453 -696 0 +-454 -697 0 +-455 -698 0 +-456 -699 0 +-457 -700 0 +-458 -701 0 +-459 -702 0 +-460 -703 0 +-461 -704 0 +-462 -705 0 +-463 -706 0 +-464 -707 0 +-465 -708 0 +-466 -709 0 +-467 -710 0 +-468 -711 0 +-469 -712 0 +-470 -713 0 +-471 -714 0 +-472 -715 0 +-473 -716 0 +-474 -717 0 +-475 -718 0 +-476 -719 0 +-477 -720 0 +-478 -721 0 +-479 -722 0 +-480 -723 0 +-481 -724 0 +-482 -725 0 +-483 -726 0 +-484 -727 0 +-485 -728 0 +-486 -729 0 +-487 -1 0 +-488 -2 0 +-489 -3 0 +-490 -4 0 +-491 -5 0 +-492 -6 0 +-493 -7 0 +-494 -8 0 +-495 -9 0 +-496 -10 0 +-497 -11 0 +-498 -12 0 +-499 -13 0 +-500 -14 0 +-501 -15 0 +-502 -16 0 +-503 -17 0 +-504 -18 0 +-505 -19 0 +-506 -20 0 +-507 -21 0 +-508 -22 0 +-509 -23 0 +-510 -24 0 +-511 -25 0 +-512 -26 0 +-513 -27 0 +-514 -28 0 +-515 -29 0 +-516 -30 0 +-517 -31 0 +-518 -32 0 +-519 -33 0 +-520 -34 0 +-521 -35 0 +-522 -36 0 +-523 -37 0 +-524 -38 0 +-525 -39 0 +-526 -40 0 +-527 -41 0 +-528 -42 0 +-529 -43 0 +-530 -44 0 +-531 -45 0 +-532 -46 0 +-533 -47 0 +-534 -48 0 +-535 -49 0 +-536 -50 0 +-537 -51 0 +-538 -52 0 +-539 -53 0 +-540 -54 0 +-541 -55 0 +-542 -56 0 +-543 -57 0 +-544 -58 0 +-545 -59 0 +-546 -60 0 +-547 -61 0 +-548 -62 0 +-549 -63 0 +-550 -64 0 +-551 -65 0 +-552 -66 0 +-553 -67 0 +-554 -68 0 +-555 -69 0 +-556 -70 0 +-557 -71 0 +-558 -72 0 +-559 -73 0 +-560 -74 0 +-561 -75 0 +-562 -76 0 +-563 -77 0 +-564 -78 0 +-565 -79 0 +-566 -80 0 +-567 -81 0 +-487 -82 0 +-488 -83 0 +-489 -84 0 +-490 -85 0 +-491 -86 0 +-492 -87 0 +-493 -88 0 +-494 -89 0 +-495 -90 0 +-496 -91 0 +-497 -92 0 +-498 -93 0 +-499 -94 0 +-500 -95 0 +-501 -96 0 +-502 -97 0 +-503 -98 0 +-504 -99 0 +-505 -100 0 +-506 -101 0 +-507 -102 0 +-508 -103 0 +-509 -104 0 +-510 -105 0 +-511 -106 0 +-512 -107 0 +-513 -108 0 +-514 -109 0 +-515 -110 0 +-516 -111 0 +-517 -112 0 +-518 -113 0 +-519 -114 0 +-520 -115 0 +-521 -116 0 +-522 -117 0 +-523 -118 0 +-524 -119 0 +-525 -120 0 +-526 -121 0 +-527 -122 0 +-528 -123 0 +-529 -124 0 +-530 -125 0 +-531 -126 0 +-532 -127 0 +-533 -128 0 +-534 -129 0 +-535 -130 0 +-536 -131 0 +-537 -132 0 +-538 -133 0 +-539 -134 0 +-540 -135 0 +-541 -136 0 +-542 -137 0 +-543 -138 0 +-544 -139 0 +-545 -140 0 +-546 -141 0 +-547 -142 0 +-548 -143 0 +-549 -144 0 +-550 -145 0 +-551 -146 0 +-552 -147 0 +-553 -148 0 +-554 -149 0 +-555 -150 0 +-556 -151 0 +-557 -152 0 +-558 -153 0 +-559 -154 0 +-560 -155 0 +-561 -156 0 +-562 -157 0 +-563 -158 0 +-564 -159 0 +-565 -160 0 +-566 -161 0 +-567 -162 0 +-487 -163 0 +-488 -164 0 +-489 -165 0 +-490 -166 0 +-491 -167 0 +-492 -168 0 +-493 -169 0 +-494 -170 0 +-495 -171 0 +-496 -172 0 +-497 -173 0 +-498 -174 0 +-499 -175 0 +-500 -176 0 +-501 -177 0 +-502 -178 0 +-503 -179 0 +-504 -180 0 +-505 -181 0 +-506 -182 0 +-507 -183 0 +-508 -184 0 +-509 -185 0 +-510 -186 0 +-511 -187 0 +-512 -188 0 +-513 -189 0 +-514 -190 0 +-515 -191 0 +-516 -192 0 +-517 -193 0 +-518 -194 0 +-519 -195 0 +-520 -196 0 +-521 -197 0 +-522 -198 0 +-523 -199 0 +-524 -200 0 +-525 -201 0 +-526 -202 0 +-527 -203 0 +-528 -204 0 +-529 -205 0 +-530 -206 0 +-531 -207 0 +-532 -208 0 +-533 -209 0 +-534 -210 0 +-535 -211 0 +-536 -212 0 +-537 -213 0 +-538 -214 0 +-539 -215 0 +-540 -216 0 +-541 -217 0 +-542 -218 0 +-543 -219 0 +-544 -220 0 +-545 -221 0 +-546 -222 0 +-547 -223 0 +-548 -224 0 +-549 -225 0 +-550 -226 0 +-551 -227 0 +-552 -228 0 +-553 -229 0 +-554 -230 0 +-555 -231 0 +-556 -232 0 +-557 -233 0 +-558 -234 0 +-559 -235 0 +-560 -236 0 +-561 -237 0 +-562 -238 0 +-563 -239 0 +-564 -240 0 +-565 -241 0 +-566 -242 0 +-567 -243 0 +-487 -244 0 +-488 -245 0 +-489 -246 0 +-490 -247 0 +-491 -248 0 +-492 -249 0 +-493 -250 0 +-494 -251 0 +-495 -252 0 +-496 -253 0 +-497 -254 0 +-498 -255 0 +-499 -256 0 +-500 -257 0 +-501 -258 0 +-502 -259 0 +-503 -260 0 +-504 -261 0 +-505 -262 0 +-506 -263 0 +-507 -264 0 +-508 -265 0 +-509 -266 0 +-510 -267 0 +-511 -268 0 +-512 -269 0 +-513 -270 0 +-514 -271 0 +-515 -272 0 +-516 -273 0 +-517 -274 0 +-518 -275 0 +-519 -276 0 +-520 -277 0 +-521 -278 0 +-522 -279 0 +-523 -280 0 +-524 -281 0 +-525 -282 0 +-526 -283 0 +-527 -284 0 +-528 -285 0 +-529 -286 0 +-530 -287 0 +-531 -288 0 +-532 -289 0 +-533 -290 0 +-534 -291 0 +-535 -292 0 +-536 -293 0 +-537 -294 0 +-538 -295 0 +-539 -296 0 +-540 -297 0 +-541 -298 0 +-542 -299 0 +-543 -300 0 +-544 -301 0 +-545 -302 0 +-546 -303 0 +-547 -304 0 +-548 -305 0 +-549 -306 0 +-550 -307 0 +-551 -308 0 +-552 -309 0 +-553 -310 0 +-554 -311 0 +-555 -312 0 +-556 -313 0 +-557 -314 0 +-558 -315 0 +-559 -316 0 +-560 -317 0 +-561 -318 0 +-562 -319 0 +-563 -320 0 +-564 -321 0 +-565 -322 0 +-566 -323 0 +-567 -324 0 +-487 -325 0 +-488 -326 0 +-489 -327 0 +-490 -328 0 +-491 -329 0 +-492 -330 0 +-493 -331 0 +-494 -332 0 +-495 -333 0 +-496 -334 0 +-497 -335 0 +-498 -336 0 +-499 -337 0 +-500 -338 0 +-501 -339 0 +-502 -340 0 +-503 -341 0 +-504 -342 0 +-505 -343 0 +-506 -344 0 +-507 -345 0 +-508 -346 0 +-509 -347 0 +-510 -348 0 +-511 -349 0 +-512 -350 0 +-513 -351 0 +-514 -352 0 +-515 -353 0 +-516 -354 0 +-517 -355 0 +-518 -356 0 +-519 -357 0 +-520 -358 0 +-521 -359 0 +-522 -360 0 +-523 -361 0 +-524 -362 0 +-525 -363 0 +-526 -364 0 +-527 -365 0 +-528 -366 0 +-529 -367 0 +-530 -368 0 +-531 -369 0 +-532 -370 0 +-533 -371 0 +-534 -372 0 +-535 -373 0 +-536 -374 0 +-537 -375 0 +-538 -376 0 +-539 -377 0 +-540 -378 0 +-541 -379 0 +-542 -380 0 +-543 -381 0 +-544 -382 0 +-545 -383 0 +-546 -384 0 +-547 -385 0 +-548 -386 0 +-549 -387 0 +-550 -388 0 +-551 -389 0 +-552 -390 0 +-553 -391 0 +-554 -392 0 +-555 -393 0 +-556 -394 0 +-557 -395 0 +-558 -396 0 +-559 -397 0 +-560 -398 0 +-561 -399 0 +-562 -400 0 +-563 -401 0 +-564 -402 0 +-565 -403 0 +-566 -404 0 +-567 -405 0 +-487 -406 0 +-488 -407 0 +-489 -408 0 +-490 -409 0 +-491 -410 0 +-492 -411 0 +-493 -412 0 +-494 -413 0 +-495 -414 0 +-496 -415 0 +-497 -416 0 +-498 -417 0 +-499 -418 0 +-500 -419 0 +-501 -420 0 +-502 -421 0 +-503 -422 0 +-504 -423 0 +-505 -424 0 +-506 -425 0 +-507 -426 0 +-508 -427 0 +-509 -428 0 +-510 -429 0 +-511 -430 0 +-512 -431 0 +-513 -432 0 +-514 -433 0 +-515 -434 0 +-516 -435 0 +-517 -436 0 +-518 -437 0 +-519 -438 0 +-520 -439 0 +-521 -440 0 +-522 -441 0 +-523 -442 0 +-524 -443 0 +-525 -444 0 +-526 -445 0 +-527 -446 0 +-528 -447 0 +-529 -448 0 +-530 -449 0 +-531 -450 0 +-532 -451 0 +-533 -452 0 +-534 -453 0 +-535 -454 0 +-536 -455 0 +-537 -456 0 +-538 -457 0 +-539 -458 0 +-540 -459 0 +-541 -460 0 +-542 -461 0 +-543 -462 0 +-544 -463 0 +-545 -464 0 +-546 -465 0 +-547 -466 0 +-548 -467 0 +-549 -468 0 +-550 -469 0 +-551 -470 0 +-552 -471 0 +-553 -472 0 +-554 -473 0 +-555 -474 0 +-556 -475 0 +-557 -476 0 +-558 -477 0 +-559 -478 0 +-560 -479 0 +-561 -480 0 +-562 -481 0 +-563 -482 0 +-564 -483 0 +-565 -484 0 +-566 -485 0 +-567 -486 0 +-487 -568 0 +-488 -569 0 +-489 -570 0 +-490 -571 0 +-491 -572 0 +-492 -573 0 +-493 -574 0 +-494 -575 0 +-495 -576 0 +-496 -577 0 +-497 -578 0 +-498 -579 0 +-499 -580 0 +-500 -581 0 +-501 -582 0 +-502 -583 0 +-503 -584 0 +-504 -585 0 +-505 -586 0 +-506 -587 0 +-507 -588 0 +-508 -589 0 +-509 -590 0 +-510 -591 0 +-511 -592 0 +-512 -593 0 +-513 -594 0 +-514 -595 0 +-515 -596 0 +-516 -597 0 +-517 -598 0 +-518 -599 0 +-519 -600 0 +-520 -601 0 +-521 -602 0 +-522 -603 0 +-523 -604 0 +-524 -605 0 +-525 -606 0 +-526 -607 0 +-527 -608 0 +-528 -609 0 +-529 -610 0 +-530 -611 0 +-531 -612 0 +-532 -613 0 +-533 -614 0 +-534 -615 0 +-535 -616 0 +-536 -617 0 +-537 -618 0 +-538 -619 0 +-539 -620 0 +-540 -621 0 +-541 -622 0 +-542 -623 0 +-543 -624 0 +-544 -625 0 +-545 -626 0 +-546 -627 0 +-547 -628 0 +-548 -629 0 +-549 -630 0 +-550 -631 0 +-551 -632 0 +-552 -633 0 +-553 -634 0 +-554 -635 0 +-555 -636 0 +-556 -637 0 +-557 -638 0 +-558 -639 0 +-559 -640 0 +-560 -641 0 +-561 -642 0 +-562 -643 0 +-563 -644 0 +-564 -645 0 +-565 -646 0 +-566 -647 0 +-567 -648 0 +-487 -649 0 +-488 -650 0 +-489 -651 0 +-490 -652 0 +-491 -653 0 +-492 -654 0 +-493 -655 0 +-494 -656 0 +-495 -657 0 +-496 -658 0 +-497 -659 0 +-498 -660 0 +-499 -661 0 +-500 -662 0 +-501 -663 0 +-502 -664 0 +-503 -665 0 +-504 -666 0 +-505 -667 0 +-506 -668 0 +-507 -669 0 +-508 -670 0 +-509 -671 0 +-510 -672 0 +-511 -673 0 +-512 -674 0 +-513 -675 0 +-514 -676 0 +-515 -677 0 +-516 -678 0 +-517 -679 0 +-518 -680 0 +-519 -681 0 +-520 -682 0 +-521 -683 0 +-522 -684 0 +-523 -685 0 +-524 -686 0 +-525 -687 0 +-526 -688 0 +-527 -689 0 +-528 -690 0 +-529 -691 0 +-530 -692 0 +-531 -693 0 +-532 -694 0 +-533 -695 0 +-534 -696 0 +-535 -697 0 +-536 -698 0 +-537 -699 0 +-538 -700 0 +-539 -701 0 +-540 -702 0 +-541 -703 0 +-542 -704 0 +-543 -705 0 +-544 -706 0 +-545 -707 0 +-546 -708 0 +-547 -709 0 +-548 -710 0 +-549 -711 0 +-550 -712 0 +-551 -713 0 +-552 -714 0 +-553 -715 0 +-554 -716 0 +-555 -717 0 +-556 -718 0 +-557 -719 0 +-558 -720 0 +-559 -721 0 +-560 -722 0 +-561 -723 0 +-562 -724 0 +-563 -725 0 +-564 -726 0 +-565 -727 0 +-566 -728 0 +-567 -729 0 +-568 -1 0 +-569 -2 0 +-570 -3 0 +-571 -4 0 +-572 -5 0 +-573 -6 0 +-574 -7 0 +-575 -8 0 +-576 -9 0 +-577 -10 0 +-578 -11 0 +-579 -12 0 +-580 -13 0 +-581 -14 0 +-582 -15 0 +-583 -16 0 +-584 -17 0 +-585 -18 0 +-586 -19 0 +-587 -20 0 +-588 -21 0 +-589 -22 0 +-590 -23 0 +-591 -24 0 +-592 -25 0 +-593 -26 0 +-594 -27 0 +-595 -28 0 +-596 -29 0 +-597 -30 0 +-598 -31 0 +-599 -32 0 +-600 -33 0 +-601 -34 0 +-602 -35 0 +-603 -36 0 +-604 -37 0 +-605 -38 0 +-606 -39 0 +-607 -40 0 +-608 -41 0 +-609 -42 0 +-610 -43 0 +-611 -44 0 +-612 -45 0 +-613 -46 0 +-614 -47 0 +-615 -48 0 +-616 -49 0 +-617 -50 0 +-618 -51 0 +-619 -52 0 +-620 -53 0 +-621 -54 0 +-622 -55 0 +-623 -56 0 +-624 -57 0 +-625 -58 0 +-626 -59 0 +-627 -60 0 +-628 -61 0 +-629 -62 0 +-630 -63 0 +-631 -64 0 +-632 -65 0 +-633 -66 0 +-634 -67 0 +-635 -68 0 +-636 -69 0 +-637 -70 0 +-638 -71 0 +-639 -72 0 +-640 -73 0 +-641 -74 0 +-642 -75 0 +-643 -76 0 +-644 -77 0 +-645 -78 0 +-646 -79 0 +-647 -80 0 +-648 -81 0 +-568 -82 0 +-569 -83 0 +-570 -84 0 +-571 -85 0 +-572 -86 0 +-573 -87 0 +-574 -88 0 +-575 -89 0 +-576 -90 0 +-577 -91 0 +-578 -92 0 +-579 -93 0 +-580 -94 0 +-581 -95 0 +-582 -96 0 +-583 -97 0 +-584 -98 0 +-585 -99 0 +-586 -100 0 +-587 -101 0 +-588 -102 0 +-589 -103 0 +-590 -104 0 +-591 -105 0 +-592 -106 0 +-593 -107 0 +-594 -108 0 +-595 -109 0 +-596 -110 0 +-597 -111 0 +-598 -112 0 +-599 -113 0 +-600 -114 0 +-601 -115 0 +-602 -116 0 +-603 -117 0 +-604 -118 0 +-605 -119 0 +-606 -120 0 +-607 -121 0 +-608 -122 0 +-609 -123 0 +-610 -124 0 +-611 -125 0 +-612 -126 0 +-613 -127 0 +-614 -128 0 +-615 -129 0 +-616 -130 0 +-617 -131 0 +-618 -132 0 +-619 -133 0 +-620 -134 0 +-621 -135 0 +-622 -136 0 +-623 -137 0 +-624 -138 0 +-625 -139 0 +-626 -140 0 +-627 -141 0 +-628 -142 0 +-629 -143 0 +-630 -144 0 +-631 -145 0 +-632 -146 0 +-633 -147 0 +-634 -148 0 +-635 -149 0 +-636 -150 0 +-637 -151 0 +-638 -152 0 +-639 -153 0 +-640 -154 0 +-641 -155 0 +-642 -156 0 +-643 -157 0 +-644 -158 0 +-645 -159 0 +-646 -160 0 +-647 -161 0 +-648 -162 0 +-568 -163 0 +-569 -164 0 +-570 -165 0 +-571 -166 0 +-572 -167 0 +-573 -168 0 +-574 -169 0 +-575 -170 0 +-576 -171 0 +-577 -172 0 +-578 -173 0 +-579 -174 0 +-580 -175 0 +-581 -176 0 +-582 -177 0 +-583 -178 0 +-584 -179 0 +-585 -180 0 +-586 -181 0 +-587 -182 0 +-588 -183 0 +-589 -184 0 +-590 -185 0 +-591 -186 0 +-592 -187 0 +-593 -188 0 +-594 -189 0 +-595 -190 0 +-596 -191 0 +-597 -192 0 +-598 -193 0 +-599 -194 0 +-600 -195 0 +-601 -196 0 +-602 -197 0 +-603 -198 0 +-604 -199 0 +-605 -200 0 +-606 -201 0 +-607 -202 0 +-608 -203 0 +-609 -204 0 +-610 -205 0 +-611 -206 0 +-612 -207 0 +-613 -208 0 +-614 -209 0 +-615 -210 0 +-616 -211 0 +-617 -212 0 +-618 -213 0 +-619 -214 0 +-620 -215 0 +-621 -216 0 +-622 -217 0 +-623 -218 0 +-624 -219 0 +-625 -220 0 +-626 -221 0 +-627 -222 0 +-628 -223 0 +-629 -224 0 +-630 -225 0 +-631 -226 0 +-632 -227 0 +-633 -228 0 +-634 -229 0 +-635 -230 0 +-636 -231 0 +-637 -232 0 +-638 -233 0 +-639 -234 0 +-640 -235 0 +-641 -236 0 +-642 -237 0 +-643 -238 0 +-644 -239 0 +-645 -240 0 +-646 -241 0 +-647 -242 0 +-648 -243 0 +-568 -244 0 +-569 -245 0 +-570 -246 0 +-571 -247 0 +-572 -248 0 +-573 -249 0 +-574 -250 0 +-575 -251 0 +-576 -252 0 +-577 -253 0 +-578 -254 0 +-579 -255 0 +-580 -256 0 +-581 -257 0 +-582 -258 0 +-583 -259 0 +-584 -260 0 +-585 -261 0 +-586 -262 0 +-587 -263 0 +-588 -264 0 +-589 -265 0 +-590 -266 0 +-591 -267 0 +-592 -268 0 +-593 -269 0 +-594 -270 0 +-595 -271 0 +-596 -272 0 +-597 -273 0 +-598 -274 0 +-599 -275 0 +-600 -276 0 +-601 -277 0 +-602 -278 0 +-603 -279 0 +-604 -280 0 +-605 -281 0 +-606 -282 0 +-607 -283 0 +-608 -284 0 +-609 -285 0 +-610 -286 0 +-611 -287 0 +-612 -288 0 +-613 -289 0 +-614 -290 0 +-615 -291 0 +-616 -292 0 +-617 -293 0 +-618 -294 0 +-619 -295 0 +-620 -296 0 +-621 -297 0 +-622 -298 0 +-623 -299 0 +-624 -300 0 +-625 -301 0 +-626 -302 0 +-627 -303 0 +-628 -304 0 +-629 -305 0 +-630 -306 0 +-631 -307 0 +-632 -308 0 +-633 -309 0 +-634 -310 0 +-635 -311 0 +-636 -312 0 +-637 -313 0 +-638 -314 0 +-639 -315 0 +-640 -316 0 +-641 -317 0 +-642 -318 0 +-643 -319 0 +-644 -320 0 +-645 -321 0 +-646 -322 0 +-647 -323 0 +-648 -324 0 +-568 -325 0 +-569 -326 0 +-570 -327 0 +-571 -328 0 +-572 -329 0 +-573 -330 0 +-574 -331 0 +-575 -332 0 +-576 -333 0 +-577 -334 0 +-578 -335 0 +-579 -336 0 +-580 -337 0 +-581 -338 0 +-582 -339 0 +-583 -340 0 +-584 -341 0 +-585 -342 0 +-586 -343 0 +-587 -344 0 +-588 -345 0 +-589 -346 0 +-590 -347 0 +-591 -348 0 +-592 -349 0 +-593 -350 0 +-594 -351 0 +-595 -352 0 +-596 -353 0 +-597 -354 0 +-598 -355 0 +-599 -356 0 +-600 -357 0 +-601 -358 0 +-602 -359 0 +-603 -360 0 +-604 -361 0 +-605 -362 0 +-606 -363 0 +-607 -364 0 +-608 -365 0 +-609 -366 0 +-610 -367 0 +-611 -368 0 +-612 -369 0 +-613 -370 0 +-614 -371 0 +-615 -372 0 +-616 -373 0 +-617 -374 0 +-618 -375 0 +-619 -376 0 +-620 -377 0 +-621 -378 0 +-622 -379 0 +-623 -380 0 +-624 -381 0 +-625 -382 0 +-626 -383 0 +-627 -384 0 +-628 -385 0 +-629 -386 0 +-630 -387 0 +-631 -388 0 +-632 -389 0 +-633 -390 0 +-634 -391 0 +-635 -392 0 +-636 -393 0 +-637 -394 0 +-638 -395 0 +-639 -396 0 +-640 -397 0 +-641 -398 0 +-642 -399 0 +-643 -400 0 +-644 -401 0 +-645 -402 0 +-646 -403 0 +-647 -404 0 +-648 -405 0 +-568 -406 0 +-569 -407 0 +-570 -408 0 +-571 -409 0 +-572 -410 0 +-573 -411 0 +-574 -412 0 +-575 -413 0 +-576 -414 0 +-577 -415 0 +-578 -416 0 +-579 -417 0 +-580 -418 0 +-581 -419 0 +-582 -420 0 +-583 -421 0 +-584 -422 0 +-585 -423 0 +-586 -424 0 +-587 -425 0 +-588 -426 0 +-589 -427 0 +-590 -428 0 +-591 -429 0 +-592 -430 0 +-593 -431 0 +-594 -432 0 +-595 -433 0 +-596 -434 0 +-597 -435 0 +-598 -436 0 +-599 -437 0 +-600 -438 0 +-601 -439 0 +-602 -440 0 +-603 -441 0 +-604 -442 0 +-605 -443 0 +-606 -444 0 +-607 -445 0 +-608 -446 0 +-609 -447 0 +-610 -448 0 +-611 -449 0 +-612 -450 0 +-613 -451 0 +-614 -452 0 +-615 -453 0 +-616 -454 0 +-617 -455 0 +-618 -456 0 +-619 -457 0 +-620 -458 0 +-621 -459 0 +-622 -460 0 +-623 -461 0 +-624 -462 0 +-625 -463 0 +-626 -464 0 +-627 -465 0 +-628 -466 0 +-629 -467 0 +-630 -468 0 +-631 -469 0 +-632 -470 0 +-633 -471 0 +-634 -472 0 +-635 -473 0 +-636 -474 0 +-637 -475 0 +-638 -476 0 +-639 -477 0 +-640 -478 0 +-641 -479 0 +-642 -480 0 +-643 -481 0 +-644 -482 0 +-645 -483 0 +-646 -484 0 +-647 -485 0 +-648 -486 0 +-568 -487 0 +-569 -488 0 +-570 -489 0 +-571 -490 0 +-572 -491 0 +-573 -492 0 +-574 -493 0 +-575 -494 0 +-576 -495 0 +-577 -496 0 +-578 -497 0 +-579 -498 0 +-580 -499 0 +-581 -500 0 +-582 -501 0 +-583 -502 0 +-584 -503 0 +-585 -504 0 +-586 -505 0 +-587 -506 0 +-588 -507 0 +-589 -508 0 +-590 -509 0 +-591 -510 0 +-592 -511 0 +-593 -512 0 +-594 -513 0 +-595 -514 0 +-596 -515 0 +-597 -516 0 +-598 -517 0 +-599 -518 0 +-600 -519 0 +-601 -520 0 +-602 -521 0 +-603 -522 0 +-604 -523 0 +-605 -524 0 +-606 -525 0 +-607 -526 0 +-608 -527 0 +-609 -528 0 +-610 -529 0 +-611 -530 0 +-612 -531 0 +-613 -532 0 +-614 -533 0 +-615 -534 0 +-616 -535 0 +-617 -536 0 +-618 -537 0 +-619 -538 0 +-620 -539 0 +-621 -540 0 +-622 -541 0 +-623 -542 0 +-624 -543 0 +-625 -544 0 +-626 -545 0 +-627 -546 0 +-628 -547 0 +-629 -548 0 +-630 -549 0 +-631 -550 0 +-632 -551 0 +-633 -552 0 +-634 -553 0 +-635 -554 0 +-636 -555 0 +-637 -556 0 +-638 -557 0 +-639 -558 0 +-640 -559 0 +-641 -560 0 +-642 -561 0 +-643 -562 0 +-644 -563 0 +-645 -564 0 +-646 -565 0 +-647 -566 0 +-648 -567 0 +-568 -649 0 +-569 -650 0 +-570 -651 0 +-571 -652 0 +-572 -653 0 +-573 -654 0 +-574 -655 0 +-575 -656 0 +-576 -657 0 +-577 -658 0 +-578 -659 0 +-579 -660 0 +-580 -661 0 +-581 -662 0 +-582 -663 0 +-583 -664 0 +-584 -665 0 +-585 -666 0 +-586 -667 0 +-587 -668 0 +-588 -669 0 +-589 -670 0 +-590 -671 0 +-591 -672 0 +-592 -673 0 +-593 -674 0 +-594 -675 0 +-595 -676 0 +-596 -677 0 +-597 -678 0 +-598 -679 0 +-599 -680 0 +-600 -681 0 +-601 -682 0 +-602 -683 0 +-603 -684 0 +-604 -685 0 +-605 -686 0 +-606 -687 0 +-607 -688 0 +-608 -689 0 +-609 -690 0 +-610 -691 0 +-611 -692 0 +-612 -693 0 +-613 -694 0 +-614 -695 0 +-615 -696 0 +-616 -697 0 +-617 -698 0 +-618 -699 0 +-619 -700 0 +-620 -701 0 +-621 -702 0 +-622 -703 0 +-623 -704 0 +-624 -705 0 +-625 -706 0 +-626 -707 0 +-627 -708 0 +-628 -709 0 +-629 -710 0 +-630 -711 0 +-631 -712 0 +-632 -713 0 +-633 -714 0 +-634 -715 0 +-635 -716 0 +-636 -717 0 +-637 -718 0 +-638 -719 0 +-639 -720 0 +-640 -721 0 +-641 -722 0 +-642 -723 0 +-643 -724 0 +-644 -725 0 +-645 -726 0 +-646 -727 0 +-647 -728 0 +-648 -729 0 +-649 -1 0 +-650 -2 0 +-651 -3 0 +-652 -4 0 +-653 -5 0 +-654 -6 0 +-655 -7 0 +-656 -8 0 +-657 -9 0 +-658 -10 0 +-659 -11 0 +-660 -12 0 +-661 -13 0 +-662 -14 0 +-663 -15 0 +-664 -16 0 +-665 -17 0 +-666 -18 0 +-667 -19 0 +-668 -20 0 +-669 -21 0 +-670 -22 0 +-671 -23 0 +-672 -24 0 +-673 -25 0 +-674 -26 0 +-675 -27 0 +-676 -28 0 +-677 -29 0 +-678 -30 0 +-679 -31 0 +-680 -32 0 +-681 -33 0 +-682 -34 0 +-683 -35 0 +-684 -36 0 +-685 -37 0 +-686 -38 0 +-687 -39 0 +-688 -40 0 +-689 -41 0 +-690 -42 0 +-691 -43 0 +-692 -44 0 +-693 -45 0 +-694 -46 0 +-695 -47 0 +-696 -48 0 +-697 -49 0 +-698 -50 0 +-699 -51 0 +-700 -52 0 +-701 -53 0 +-702 -54 0 +-703 -55 0 +-704 -56 0 +-705 -57 0 +-706 -58 0 +-707 -59 0 +-708 -60 0 +-709 -61 0 +-710 -62 0 +-711 -63 0 +-712 -64 0 +-713 -65 0 +-714 -66 0 +-715 -67 0 +-716 -68 0 +-717 -69 0 +-718 -70 0 +-719 -71 0 +-720 -72 0 +-721 -73 0 +-722 -74 0 +-723 -75 0 +-724 -76 0 +-725 -77 0 +-726 -78 0 +-727 -79 0 +-728 -80 0 +-729 -81 0 +-649 -82 0 +-650 -83 0 +-651 -84 0 +-652 -85 0 +-653 -86 0 +-654 -87 0 +-655 -88 0 +-656 -89 0 +-657 -90 0 +-658 -91 0 +-659 -92 0 +-660 -93 0 +-661 -94 0 +-662 -95 0 +-663 -96 0 +-664 -97 0 +-665 -98 0 +-666 -99 0 +-667 -100 0 +-668 -101 0 +-669 -102 0 +-670 -103 0 +-671 -104 0 +-672 -105 0 +-673 -106 0 +-674 -107 0 +-675 -108 0 +-676 -109 0 +-677 -110 0 +-678 -111 0 +-679 -112 0 +-680 -113 0 +-681 -114 0 +-682 -115 0 +-683 -116 0 +-684 -117 0 +-685 -118 0 +-686 -119 0 +-687 -120 0 +-688 -121 0 +-689 -122 0 +-690 -123 0 +-691 -124 0 +-692 -125 0 +-693 -126 0 +-694 -127 0 +-695 -128 0 +-696 -129 0 +-697 -130 0 +-698 -131 0 +-699 -132 0 +-700 -133 0 +-701 -134 0 +-702 -135 0 +-703 -136 0 +-704 -137 0 +-705 -138 0 +-706 -139 0 +-707 -140 0 +-708 -141 0 +-709 -142 0 +-710 -143 0 +-711 -144 0 +-712 -145 0 +-713 -146 0 +-714 -147 0 +-715 -148 0 +-716 -149 0 +-717 -150 0 +-718 -151 0 +-719 -152 0 +-720 -153 0 +-721 -154 0 +-722 -155 0 +-723 -156 0 +-724 -157 0 +-725 -158 0 +-726 -159 0 +-727 -160 0 +-728 -161 0 +-729 -162 0 +-649 -163 0 +-650 -164 0 +-651 -165 0 +-652 -166 0 +-653 -167 0 +-654 -168 0 +-655 -169 0 +-656 -170 0 +-657 -171 0 +-658 -172 0 +-659 -173 0 +-660 -174 0 +-661 -175 0 +-662 -176 0 +-663 -177 0 +-664 -178 0 +-665 -179 0 +-666 -180 0 +-667 -181 0 +-668 -182 0 +-669 -183 0 +-670 -184 0 +-671 -185 0 +-672 -186 0 +-673 -187 0 +-674 -188 0 +-675 -189 0 +-676 -190 0 +-677 -191 0 +-678 -192 0 +-679 -193 0 +-680 -194 0 +-681 -195 0 +-682 -196 0 +-683 -197 0 +-684 -198 0 +-685 -199 0 +-686 -200 0 +-687 -201 0 +-688 -202 0 +-689 -203 0 +-690 -204 0 +-691 -205 0 +-692 -206 0 +-693 -207 0 +-694 -208 0 +-695 -209 0 +-696 -210 0 +-697 -211 0 +-698 -212 0 +-699 -213 0 +-700 -214 0 +-701 -215 0 +-702 -216 0 +-703 -217 0 +-704 -218 0 +-705 -219 0 +-706 -220 0 +-707 -221 0 +-708 -222 0 +-709 -223 0 +-710 -224 0 +-711 -225 0 +-712 -226 0 +-713 -227 0 +-714 -228 0 +-715 -229 0 +-716 -230 0 +-717 -231 0 +-718 -232 0 +-719 -233 0 +-720 -234 0 +-721 -235 0 +-722 -236 0 +-723 -237 0 +-724 -238 0 +-725 -239 0 +-726 -240 0 +-727 -241 0 +-728 -242 0 +-729 -243 0 +-649 -244 0 +-650 -245 0 +-651 -246 0 +-652 -247 0 +-653 -248 0 +-654 -249 0 +-655 -250 0 +-656 -251 0 +-657 -252 0 +-658 -253 0 +-659 -254 0 +-660 -255 0 +-661 -256 0 +-662 -257 0 +-663 -258 0 +-664 -259 0 +-665 -260 0 +-666 -261 0 +-667 -262 0 +-668 -263 0 +-669 -264 0 +-670 -265 0 +-671 -266 0 +-672 -267 0 +-673 -268 0 +-674 -269 0 +-675 -270 0 +-676 -271 0 +-677 -272 0 +-678 -273 0 +-679 -274 0 +-680 -275 0 +-681 -276 0 +-682 -277 0 +-683 -278 0 +-684 -279 0 +-685 -280 0 +-686 -281 0 +-687 -282 0 +-688 -283 0 +-689 -284 0 +-690 -285 0 +-691 -286 0 +-692 -287 0 +-693 -288 0 +-694 -289 0 +-695 -290 0 +-696 -291 0 +-697 -292 0 +-698 -293 0 +-699 -294 0 +-700 -295 0 +-701 -296 0 +-702 -297 0 +-703 -298 0 +-704 -299 0 +-705 -300 0 +-706 -301 0 +-707 -302 0 +-708 -303 0 +-709 -304 0 +-710 -305 0 +-711 -306 0 +-712 -307 0 +-713 -308 0 +-714 -309 0 +-715 -310 0 +-716 -311 0 +-717 -312 0 +-718 -313 0 +-719 -314 0 +-720 -315 0 +-721 -316 0 +-722 -317 0 +-723 -318 0 +-724 -319 0 +-725 -320 0 +-726 -321 0 +-727 -322 0 +-728 -323 0 +-729 -324 0 +-649 -325 0 +-650 -326 0 +-651 -327 0 +-652 -328 0 +-653 -329 0 +-654 -330 0 +-655 -331 0 +-656 -332 0 +-657 -333 0 +-658 -334 0 +-659 -335 0 +-660 -336 0 +-661 -337 0 +-662 -338 0 +-663 -339 0 +-664 -340 0 +-665 -341 0 +-666 -342 0 +-667 -343 0 +-668 -344 0 +-669 -345 0 +-670 -346 0 +-671 -347 0 +-672 -348 0 +-673 -349 0 +-674 -350 0 +-675 -351 0 +-676 -352 0 +-677 -353 0 +-678 -354 0 +-679 -355 0 +-680 -356 0 +-681 -357 0 +-682 -358 0 +-683 -359 0 +-684 -360 0 +-685 -361 0 +-686 -362 0 +-687 -363 0 +-688 -364 0 +-689 -365 0 +-690 -366 0 +-691 -367 0 +-692 -368 0 +-693 -369 0 +-694 -370 0 +-695 -371 0 +-696 -372 0 +-697 -373 0 +-698 -374 0 +-699 -375 0 +-700 -376 0 +-701 -377 0 +-702 -378 0 +-703 -379 0 +-704 -380 0 +-705 -381 0 +-706 -382 0 +-707 -383 0 +-708 -384 0 +-709 -385 0 +-710 -386 0 +-711 -387 0 +-712 -388 0 +-713 -389 0 +-714 -390 0 +-715 -391 0 +-716 -392 0 +-717 -393 0 +-718 -394 0 +-719 -395 0 +-720 -396 0 +-721 -397 0 +-722 -398 0 +-723 -399 0 +-724 -400 0 +-725 -401 0 +-726 -402 0 +-727 -403 0 +-728 -404 0 +-729 -405 0 +-649 -406 0 +-650 -407 0 +-651 -408 0 +-652 -409 0 +-653 -410 0 +-654 -411 0 +-655 -412 0 +-656 -413 0 +-657 -414 0 +-658 -415 0 +-659 -416 0 +-660 -417 0 +-661 -418 0 +-662 -419 0 +-663 -420 0 +-664 -421 0 +-665 -422 0 +-666 -423 0 +-667 -424 0 +-668 -425 0 +-669 -426 0 +-670 -427 0 +-671 -428 0 +-672 -429 0 +-673 -430 0 +-674 -431 0 +-675 -432 0 +-676 -433 0 +-677 -434 0 +-678 -435 0 +-679 -436 0 +-680 -437 0 +-681 -438 0 +-682 -439 0 +-683 -440 0 +-684 -441 0 +-685 -442 0 +-686 -443 0 +-687 -444 0 +-688 -445 0 +-689 -446 0 +-690 -447 0 +-691 -448 0 +-692 -449 0 +-693 -450 0 +-694 -451 0 +-695 -452 0 +-696 -453 0 +-697 -454 0 +-698 -455 0 +-699 -456 0 +-700 -457 0 +-701 -458 0 +-702 -459 0 +-703 -460 0 +-704 -461 0 +-705 -462 0 +-706 -463 0 +-707 -464 0 +-708 -465 0 +-709 -466 0 +-710 -467 0 +-711 -468 0 +-712 -469 0 +-713 -470 0 +-714 -471 0 +-715 -472 0 +-716 -473 0 +-717 -474 0 +-718 -475 0 +-719 -476 0 +-720 -477 0 +-721 -478 0 +-722 -479 0 +-723 -480 0 +-724 -481 0 +-725 -482 0 +-726 -483 0 +-727 -484 0 +-728 -485 0 +-729 -486 0 +-649 -487 0 +-650 -488 0 +-651 -489 0 +-652 -490 0 +-653 -491 0 +-654 -492 0 +-655 -493 0 +-656 -494 0 +-657 -495 0 +-658 -496 0 +-659 -497 0 +-660 -498 0 +-661 -499 0 +-662 -500 0 +-663 -501 0 +-664 -502 0 +-665 -503 0 +-666 -504 0 +-667 -505 0 +-668 -506 0 +-669 -507 0 +-670 -508 0 +-671 -509 0 +-672 -510 0 +-673 -511 0 +-674 -512 0 +-675 -513 0 +-676 -514 0 +-677 -515 0 +-678 -516 0 +-679 -517 0 +-680 -518 0 +-681 -519 0 +-682 -520 0 +-683 -521 0 +-684 -522 0 +-685 -523 0 +-686 -524 0 +-687 -525 0 +-688 -526 0 +-689 -527 0 +-690 -528 0 +-691 -529 0 +-692 -530 0 +-693 -531 0 +-694 -532 0 +-695 -533 0 +-696 -534 0 +-697 -535 0 +-698 -536 0 +-699 -537 0 +-700 -538 0 +-701 -539 0 +-702 -540 0 +-703 -541 0 +-704 -542 0 +-705 -543 0 +-706 -544 0 +-707 -545 0 +-708 -546 0 +-709 -547 0 +-710 -548 0 +-711 -549 0 +-712 -550 0 +-713 -551 0 +-714 -552 0 +-715 -553 0 +-716 -554 0 +-717 -555 0 +-718 -556 0 +-719 -557 0 +-720 -558 0 +-721 -559 0 +-722 -560 0 +-723 -561 0 +-724 -562 0 +-725 -563 0 +-726 -564 0 +-727 -565 0 +-728 -566 0 +-729 -567 0 +-649 -568 0 +-650 -569 0 +-651 -570 0 +-652 -571 0 +-653 -572 0 +-654 -573 0 +-655 -574 0 +-656 -575 0 +-657 -576 0 +-658 -577 0 +-659 -578 0 +-660 -579 0 +-661 -580 0 +-662 -581 0 +-663 -582 0 +-664 -583 0 +-665 -584 0 +-666 -585 0 +-667 -586 0 +-668 -587 0 +-669 -588 0 +-670 -589 0 +-671 -590 0 +-672 -591 0 +-673 -592 0 +-674 -593 0 +-675 -594 0 +-676 -595 0 +-677 -596 0 +-678 -597 0 +-679 -598 0 +-680 -599 0 +-681 -600 0 +-682 -601 0 +-683 -602 0 +-684 -603 0 +-685 -604 0 +-686 -605 0 +-687 -606 0 +-688 -607 0 +-689 -608 0 +-690 -609 0 +-691 -610 0 +-692 -611 0 +-693 -612 0 +-694 -613 0 +-695 -614 0 +-696 -615 0 +-697 -616 0 +-698 -617 0 +-699 -618 0 +-700 -619 0 +-701 -620 0 +-702 -621 0 +-703 -622 0 +-704 -623 0 +-705 -624 0 +-706 -625 0 +-707 -626 0 +-708 -627 0 +-709 -628 0 +-710 -629 0 +-711 -630 0 +-712 -631 0 +-713 -632 0 +-714 -633 0 +-715 -634 0 +-716 -635 0 +-717 -636 0 +-718 -637 0 +-719 -638 0 +-720 -639 0 +-721 -640 0 +-722 -641 0 +-723 -642 0 +-724 -643 0 +-725 -644 0 +-726 -645 0 +-727 -646 0 +-728 -647 0 +-729 -648 0 +-1 -91 0 +-2 -92 0 +-3 -93 0 +-4 -94 0 +-5 -95 0 +-6 -96 0 +-7 -97 0 +-8 -98 0 +-9 -99 0 +-1 -100 0 +-2 -101 0 +-3 -102 0 +-4 -103 0 +-5 -104 0 +-6 -105 0 +-7 -106 0 +-8 -107 0 +-9 -108 0 +-1 -172 0 +-2 -173 0 +-3 -174 0 +-4 -175 0 +-5 -176 0 +-6 -177 0 +-7 -178 0 +-8 -179 0 +-9 -180 0 +-1 -181 0 +-2 -182 0 +-3 -183 0 +-4 -184 0 +-5 -185 0 +-6 -186 0 +-7 -187 0 +-8 -188 0 +-9 -189 0 +-10 -82 0 +-11 -83 0 +-12 -84 0 +-13 -85 0 +-14 -86 0 +-15 -87 0 +-16 -88 0 +-17 -89 0 +-18 -90 0 +-10 -100 0 +-11 -101 0 +-12 -102 0 +-13 -103 0 +-14 -104 0 +-15 -105 0 +-16 -106 0 +-17 -107 0 +-18 -108 0 +-10 -163 0 +-11 -164 0 +-12 -165 0 +-13 -166 0 +-14 -167 0 +-15 -168 0 +-16 -169 0 +-17 -170 0 +-18 -171 0 +-10 -181 0 +-11 -182 0 +-12 -183 0 +-13 -184 0 +-14 -185 0 +-15 -186 0 +-16 -187 0 +-17 -188 0 +-18 -189 0 +-19 -82 0 +-20 -83 0 +-21 -84 0 +-22 -85 0 +-23 -86 0 +-24 -87 0 +-25 -88 0 +-26 -89 0 +-27 -90 0 +-19 -91 0 +-20 -92 0 +-21 -93 0 +-22 -94 0 +-23 -95 0 +-24 -96 0 +-25 -97 0 +-26 -98 0 +-27 -99 0 +-19 -163 0 +-20 -164 0 +-21 -165 0 +-22 -166 0 +-23 -167 0 +-24 -168 0 +-25 -169 0 +-26 -170 0 +-27 -171 0 +-19 -172 0 +-20 -173 0 +-21 -174 0 +-22 -175 0 +-23 -176 0 +-24 -177 0 +-25 -178 0 +-26 -179 0 +-27 -180 0 +-82 -10 0 +-83 -11 0 +-84 -12 0 +-85 -13 0 +-86 -14 0 +-87 -15 0 +-88 -16 0 +-89 -17 0 +-90 -18 0 +-82 -19 0 +-83 -20 0 +-84 -21 0 +-85 -22 0 +-86 -23 0 +-87 -24 0 +-88 -25 0 +-89 -26 0 +-90 -27 0 +-82 -172 0 +-83 -173 0 +-84 -174 0 +-85 -175 0 +-86 -176 0 +-87 -177 0 +-88 -178 0 +-89 -179 0 +-90 -180 0 +-82 -181 0 +-83 -182 0 +-84 -183 0 +-85 -184 0 +-86 -185 0 +-87 -186 0 +-88 -187 0 +-89 -188 0 +-90 -189 0 +-91 -1 0 +-92 -2 0 +-93 -3 0 +-94 -4 0 +-95 -5 0 +-96 -6 0 +-97 -7 0 +-98 -8 0 +-99 -9 0 +-91 -19 0 +-92 -20 0 +-93 -21 0 +-94 -22 0 +-95 -23 0 +-96 -24 0 +-97 -25 0 +-98 -26 0 +-99 -27 0 +-91 -163 0 +-92 -164 0 +-93 -165 0 +-94 -166 0 +-95 -167 0 +-96 -168 0 +-97 -169 0 +-98 -170 0 +-99 -171 0 +-91 -181 0 +-92 -182 0 +-93 -183 0 +-94 -184 0 +-95 -185 0 +-96 -186 0 +-97 -187 0 +-98 -188 0 +-99 -189 0 +-100 -1 0 +-101 -2 0 +-102 -3 0 +-103 -4 0 +-104 -5 0 +-105 -6 0 +-106 -7 0 +-107 -8 0 +-108 -9 0 +-100 -10 0 +-101 -11 0 +-102 -12 0 +-103 -13 0 +-104 -14 0 +-105 -15 0 +-106 -16 0 +-107 -17 0 +-108 -18 0 +-100 -163 0 +-101 -164 0 +-102 -165 0 +-103 -166 0 +-104 -167 0 +-105 -168 0 +-106 -169 0 +-107 -170 0 +-108 -171 0 +-100 -172 0 +-101 -173 0 +-102 -174 0 +-103 -175 0 +-104 -176 0 +-105 -177 0 +-106 -178 0 +-107 -179 0 +-108 -180 0 +-163 -10 0 +-164 -11 0 +-165 -12 0 +-166 -13 0 +-167 -14 0 +-168 -15 0 +-169 -16 0 +-170 -17 0 +-171 -18 0 +-163 -19 0 +-164 -20 0 +-165 -21 0 +-166 -22 0 +-167 -23 0 +-168 -24 0 +-169 -25 0 +-170 -26 0 +-171 -27 0 +-163 -91 0 +-164 -92 0 +-165 -93 0 +-166 -94 0 +-167 -95 0 +-168 -96 0 +-169 -97 0 +-170 -98 0 +-171 -99 0 +-163 -100 0 +-164 -101 0 +-165 -102 0 +-166 -103 0 +-167 -104 0 +-168 -105 0 +-169 -106 0 +-170 -107 0 +-171 -108 0 +-172 -1 0 +-173 -2 0 +-174 -3 0 +-175 -4 0 +-176 -5 0 +-177 -6 0 +-178 -7 0 +-179 -8 0 +-180 -9 0 +-172 -19 0 +-173 -20 0 +-174 -21 0 +-175 -22 0 +-176 -23 0 +-177 -24 0 +-178 -25 0 +-179 -26 0 +-180 -27 0 +-172 -82 0 +-173 -83 0 +-174 -84 0 +-175 -85 0 +-176 -86 0 +-177 -87 0 +-178 -88 0 +-179 -89 0 +-180 -90 0 +-172 -100 0 +-173 -101 0 +-174 -102 0 +-175 -103 0 +-176 -104 0 +-177 -105 0 +-178 -106 0 +-179 -107 0 +-180 -108 0 +-181 -1 0 +-182 -2 0 +-183 -3 0 +-184 -4 0 +-185 -5 0 +-186 -6 0 +-187 -7 0 +-188 -8 0 +-189 -9 0 +-181 -10 0 +-182 -11 0 +-183 -12 0 +-184 -13 0 +-185 -14 0 +-186 -15 0 +-187 -16 0 +-188 -17 0 +-189 -18 0 +-181 -82 0 +-182 -83 0 +-183 -84 0 +-184 -85 0 +-185 -86 0 +-186 -87 0 +-187 -88 0 +-188 -89 0 +-189 -90 0 +-181 -91 0 +-182 -92 0 +-183 -93 0 +-184 -94 0 +-185 -95 0 +-186 -96 0 +-187 -97 0 +-188 -98 0 +-189 -99 0 +-28 -118 0 +-29 -119 0 +-30 -120 0 +-31 -121 0 +-32 -122 0 +-33 -123 0 +-34 -124 0 +-35 -125 0 +-36 -126 0 +-28 -127 0 +-29 -128 0 +-30 -129 0 +-31 -130 0 +-32 -131 0 +-33 -132 0 +-34 -133 0 +-35 -134 0 +-36 -135 0 +-28 -199 0 +-29 -200 0 +-30 -201 0 +-31 -202 0 +-32 -203 0 +-33 -204 0 +-34 -205 0 +-35 -206 0 +-36 -207 0 +-28 -208 0 +-29 -209 0 +-30 -210 0 +-31 -211 0 +-32 -212 0 +-33 -213 0 +-34 -214 0 +-35 -215 0 +-36 -216 0 +-37 -109 0 +-38 -110 0 +-39 -111 0 +-40 -112 0 +-41 -113 0 +-42 -114 0 +-43 -115 0 +-44 -116 0 +-45 -117 0 +-37 -127 0 +-38 -128 0 +-39 -129 0 +-40 -130 0 +-41 -131 0 +-42 -132 0 +-43 -133 0 +-44 -134 0 +-45 -135 0 +-37 -190 0 +-38 -191 0 +-39 -192 0 +-40 -193 0 +-41 -194 0 +-42 -195 0 +-43 -196 0 +-44 -197 0 +-45 -198 0 +-37 -208 0 +-38 -209 0 +-39 -210 0 +-40 -211 0 +-41 -212 0 +-42 -213 0 +-43 -214 0 +-44 -215 0 +-45 -216 0 +-46 -109 0 +-47 -110 0 +-48 -111 0 +-49 -112 0 +-50 -113 0 +-51 -114 0 +-52 -115 0 +-53 -116 0 +-54 -117 0 +-46 -118 0 +-47 -119 0 +-48 -120 0 +-49 -121 0 +-50 -122 0 +-51 -123 0 +-52 -124 0 +-53 -125 0 +-54 -126 0 +-46 -190 0 +-47 -191 0 +-48 -192 0 +-49 -193 0 +-50 -194 0 +-51 -195 0 +-52 -196 0 +-53 -197 0 +-54 -198 0 +-46 -199 0 +-47 -200 0 +-48 -201 0 +-49 -202 0 +-50 -203 0 +-51 -204 0 +-52 -205 0 +-53 -206 0 +-54 -207 0 +-109 -37 0 +-110 -38 0 +-111 -39 0 +-112 -40 0 +-113 -41 0 +-114 -42 0 +-115 -43 0 +-116 -44 0 +-117 -45 0 +-109 -46 0 +-110 -47 0 +-111 -48 0 +-112 -49 0 +-113 -50 0 +-114 -51 0 +-115 -52 0 +-116 -53 0 +-117 -54 0 +-109 -199 0 +-110 -200 0 +-111 -201 0 +-112 -202 0 +-113 -203 0 +-114 -204 0 +-115 -205 0 +-116 -206 0 +-117 -207 0 +-109 -208 0 +-110 -209 0 +-111 -210 0 +-112 -211 0 +-113 -212 0 +-114 -213 0 +-115 -214 0 +-116 -215 0 +-117 -216 0 +-118 -28 0 +-119 -29 0 +-120 -30 0 +-121 -31 0 +-122 -32 0 +-123 -33 0 +-124 -34 0 +-125 -35 0 +-126 -36 0 +-118 -46 0 +-119 -47 0 +-120 -48 0 +-121 -49 0 +-122 -50 0 +-123 -51 0 +-124 -52 0 +-125 -53 0 +-126 -54 0 +-118 -190 0 +-119 -191 0 +-120 -192 0 +-121 -193 0 +-122 -194 0 +-123 -195 0 +-124 -196 0 +-125 -197 0 +-126 -198 0 +-118 -208 0 +-119 -209 0 +-120 -210 0 +-121 -211 0 +-122 -212 0 +-123 -213 0 +-124 -214 0 +-125 -215 0 +-126 -216 0 +-127 -28 0 +-128 -29 0 +-129 -30 0 +-130 -31 0 +-131 -32 0 +-132 -33 0 +-133 -34 0 +-134 -35 0 +-135 -36 0 +-127 -37 0 +-128 -38 0 +-129 -39 0 +-130 -40 0 +-131 -41 0 +-132 -42 0 +-133 -43 0 +-134 -44 0 +-135 -45 0 +-127 -190 0 +-128 -191 0 +-129 -192 0 +-130 -193 0 +-131 -194 0 +-132 -195 0 +-133 -196 0 +-134 -197 0 +-135 -198 0 +-127 -199 0 +-128 -200 0 +-129 -201 0 +-130 -202 0 +-131 -203 0 +-132 -204 0 +-133 -205 0 +-134 -206 0 +-135 -207 0 +-190 -37 0 +-191 -38 0 +-192 -39 0 +-193 -40 0 +-194 -41 0 +-195 -42 0 +-196 -43 0 +-197 -44 0 +-198 -45 0 +-190 -46 0 +-191 -47 0 +-192 -48 0 +-193 -49 0 +-194 -50 0 +-195 -51 0 +-196 -52 0 +-197 -53 0 +-198 -54 0 +-190 -118 0 +-191 -119 0 +-192 -120 0 +-193 -121 0 +-194 -122 0 +-195 -123 0 +-196 -124 0 +-197 -125 0 +-198 -126 0 +-190 -127 0 +-191 -128 0 +-192 -129 0 +-193 -130 0 +-194 -131 0 +-195 -132 0 +-196 -133 0 +-197 -134 0 +-198 -135 0 +-199 -28 0 +-200 -29 0 +-201 -30 0 +-202 -31 0 +-203 -32 0 +-204 -33 0 +-205 -34 0 +-206 -35 0 +-207 -36 0 +-199 -46 0 +-200 -47 0 +-201 -48 0 +-202 -49 0 +-203 -50 0 +-204 -51 0 +-205 -52 0 +-206 -53 0 +-207 -54 0 +-199 -109 0 +-200 -110 0 +-201 -111 0 +-202 -112 0 +-203 -113 0 +-204 -114 0 +-205 -115 0 +-206 -116 0 +-207 -117 0 +-199 -127 0 +-200 -128 0 +-201 -129 0 +-202 -130 0 +-203 -131 0 +-204 -132 0 +-205 -133 0 +-206 -134 0 +-207 -135 0 +-208 -28 0 +-209 -29 0 +-210 -30 0 +-211 -31 0 +-212 -32 0 +-213 -33 0 +-214 -34 0 +-215 -35 0 +-216 -36 0 +-208 -37 0 +-209 -38 0 +-210 -39 0 +-211 -40 0 +-212 -41 0 +-213 -42 0 +-214 -43 0 +-215 -44 0 +-216 -45 0 +-208 -109 0 +-209 -110 0 +-210 -111 0 +-211 -112 0 +-212 -113 0 +-213 -114 0 +-214 -115 0 +-215 -116 0 +-216 -117 0 +-208 -118 0 +-209 -119 0 +-210 -120 0 +-211 -121 0 +-212 -122 0 +-213 -123 0 +-214 -124 0 +-215 -125 0 +-216 -126 0 +-55 -145 0 +-56 -146 0 +-57 -147 0 +-58 -148 0 +-59 -149 0 +-60 -150 0 +-61 -151 0 +-62 -152 0 +-63 -153 0 +-55 -154 0 +-56 -155 0 +-57 -156 0 +-58 -157 0 +-59 -158 0 +-60 -159 0 +-61 -160 0 +-62 -161 0 +-63 -162 0 +-55 -226 0 +-56 -227 0 +-57 -228 0 +-58 -229 0 +-59 -230 0 +-60 -231 0 +-61 -232 0 +-62 -233 0 +-63 -234 0 +-55 -235 0 +-56 -236 0 +-57 -237 0 +-58 -238 0 +-59 -239 0 +-60 -240 0 +-61 -241 0 +-62 -242 0 +-63 -243 0 +-64 -136 0 +-65 -137 0 +-66 -138 0 +-67 -139 0 +-68 -140 0 +-69 -141 0 +-70 -142 0 +-71 -143 0 +-72 -144 0 +-64 -154 0 +-65 -155 0 +-66 -156 0 +-67 -157 0 +-68 -158 0 +-69 -159 0 +-70 -160 0 +-71 -161 0 +-72 -162 0 +-64 -217 0 +-65 -218 0 +-66 -219 0 +-67 -220 0 +-68 -221 0 +-69 -222 0 +-70 -223 0 +-71 -224 0 +-72 -225 0 +-64 -235 0 +-65 -236 0 +-66 -237 0 +-67 -238 0 +-68 -239 0 +-69 -240 0 +-70 -241 0 +-71 -242 0 +-72 -243 0 +-73 -136 0 +-74 -137 0 +-75 -138 0 +-76 -139 0 +-77 -140 0 +-78 -141 0 +-79 -142 0 +-80 -143 0 +-81 -144 0 +-73 -145 0 +-74 -146 0 +-75 -147 0 +-76 -148 0 +-77 -149 0 +-78 -150 0 +-79 -151 0 +-80 -152 0 +-81 -153 0 +-73 -217 0 +-74 -218 0 +-75 -219 0 +-76 -220 0 +-77 -221 0 +-78 -222 0 +-79 -223 0 +-80 -224 0 +-81 -225 0 +-73 -226 0 +-74 -227 0 +-75 -228 0 +-76 -229 0 +-77 -230 0 +-78 -231 0 +-79 -232 0 +-80 -233 0 +-81 -234 0 +-136 -64 0 +-137 -65 0 +-138 -66 0 +-139 -67 0 +-140 -68 0 +-141 -69 0 +-142 -70 0 +-143 -71 0 +-144 -72 0 +-136 -73 0 +-137 -74 0 +-138 -75 0 +-139 -76 0 +-140 -77 0 +-141 -78 0 +-142 -79 0 +-143 -80 0 +-144 -81 0 +-136 -226 0 +-137 -227 0 +-138 -228 0 +-139 -229 0 +-140 -230 0 +-141 -231 0 +-142 -232 0 +-143 -233 0 +-144 -234 0 +-136 -235 0 +-137 -236 0 +-138 -237 0 +-139 -238 0 +-140 -239 0 +-141 -240 0 +-142 -241 0 +-143 -242 0 +-144 -243 0 +-145 -55 0 +-146 -56 0 +-147 -57 0 +-148 -58 0 +-149 -59 0 +-150 -60 0 +-151 -61 0 +-152 -62 0 +-153 -63 0 +-145 -73 0 +-146 -74 0 +-147 -75 0 +-148 -76 0 +-149 -77 0 +-150 -78 0 +-151 -79 0 +-152 -80 0 +-153 -81 0 +-145 -217 0 +-146 -218 0 +-147 -219 0 +-148 -220 0 +-149 -221 0 +-150 -222 0 +-151 -223 0 +-152 -224 0 +-153 -225 0 +-145 -235 0 +-146 -236 0 +-147 -237 0 +-148 -238 0 +-149 -239 0 +-150 -240 0 +-151 -241 0 +-152 -242 0 +-153 -243 0 +-154 -55 0 +-155 -56 0 +-156 -57 0 +-157 -58 0 +-158 -59 0 +-159 -60 0 +-160 -61 0 +-161 -62 0 +-162 -63 0 +-154 -64 0 +-155 -65 0 +-156 -66 0 +-157 -67 0 +-158 -68 0 +-159 -69 0 +-160 -70 0 +-161 -71 0 +-162 -72 0 +-154 -217 0 +-155 -218 0 +-156 -219 0 +-157 -220 0 +-158 -221 0 +-159 -222 0 +-160 -223 0 +-161 -224 0 +-162 -225 0 +-154 -226 0 +-155 -227 0 +-156 -228 0 +-157 -229 0 +-158 -230 0 +-159 -231 0 +-160 -232 0 +-161 -233 0 +-162 -234 0 +-217 -64 0 +-218 -65 0 +-219 -66 0 +-220 -67 0 +-221 -68 0 +-222 -69 0 +-223 -70 0 +-224 -71 0 +-225 -72 0 +-217 -73 0 +-218 -74 0 +-219 -75 0 +-220 -76 0 +-221 -77 0 +-222 -78 0 +-223 -79 0 +-224 -80 0 +-225 -81 0 +-217 -145 0 +-218 -146 0 +-219 -147 0 +-220 -148 0 +-221 -149 0 +-222 -150 0 +-223 -151 0 +-224 -152 0 +-225 -153 0 +-217 -154 0 +-218 -155 0 +-219 -156 0 +-220 -157 0 +-221 -158 0 +-222 -159 0 +-223 -160 0 +-224 -161 0 +-225 -162 0 +-226 -55 0 +-227 -56 0 +-228 -57 0 +-229 -58 0 +-230 -59 0 +-231 -60 0 +-232 -61 0 +-233 -62 0 +-234 -63 0 +-226 -73 0 +-227 -74 0 +-228 -75 0 +-229 -76 0 +-230 -77 0 +-231 -78 0 +-232 -79 0 +-233 -80 0 +-234 -81 0 +-226 -136 0 +-227 -137 0 +-228 -138 0 +-229 -139 0 +-230 -140 0 +-231 -141 0 +-232 -142 0 +-233 -143 0 +-234 -144 0 +-226 -154 0 +-227 -155 0 +-228 -156 0 +-229 -157 0 +-230 -158 0 +-231 -159 0 +-232 -160 0 +-233 -161 0 +-234 -162 0 +-235 -55 0 +-236 -56 0 +-237 -57 0 +-238 -58 0 +-239 -59 0 +-240 -60 0 +-241 -61 0 +-242 -62 0 +-243 -63 0 +-235 -64 0 +-236 -65 0 +-237 -66 0 +-238 -67 0 +-239 -68 0 +-240 -69 0 +-241 -70 0 +-242 -71 0 +-243 -72 0 +-235 -136 0 +-236 -137 0 +-237 -138 0 +-238 -139 0 +-239 -140 0 +-240 -141 0 +-241 -142 0 +-242 -143 0 +-243 -144 0 +-235 -145 0 +-236 -146 0 +-237 -147 0 +-238 -148 0 +-239 -149 0 +-240 -150 0 +-241 -151 0 +-242 -152 0 +-243 -153 0 +-244 -334 0 +-245 -335 0 +-246 -336 0 +-247 -337 0 +-248 -338 0 +-249 -339 0 +-250 -340 0 +-251 -341 0 +-252 -342 0 +-244 -343 0 +-245 -344 0 +-246 -345 0 +-247 -346 0 +-248 -347 0 +-249 -348 0 +-250 -349 0 +-251 -350 0 +-252 -351 0 +-244 -415 0 +-245 -416 0 +-246 -417 0 +-247 -418 0 +-248 -419 0 +-249 -420 0 +-250 -421 0 +-251 -422 0 +-252 -423 0 +-244 -424 0 +-245 -425 0 +-246 -426 0 +-247 -427 0 +-248 -428 0 +-249 -429 0 +-250 -430 0 +-251 -431 0 +-252 -432 0 +-253 -325 0 +-254 -326 0 +-255 -327 0 +-256 -328 0 +-257 -329 0 +-258 -330 0 +-259 -331 0 +-260 -332 0 +-261 -333 0 +-253 -343 0 +-254 -344 0 +-255 -345 0 +-256 -346 0 +-257 -347 0 +-258 -348 0 +-259 -349 0 +-260 -350 0 +-261 -351 0 +-253 -406 0 +-254 -407 0 +-255 -408 0 +-256 -409 0 +-257 -410 0 +-258 -411 0 +-259 -412 0 +-260 -413 0 +-261 -414 0 +-253 -424 0 +-254 -425 0 +-255 -426 0 +-256 -427 0 +-257 -428 0 +-258 -429 0 +-259 -430 0 +-260 -431 0 +-261 -432 0 +-262 -325 0 +-263 -326 0 +-264 -327 0 +-265 -328 0 +-266 -329 0 +-267 -330 0 +-268 -331 0 +-269 -332 0 +-270 -333 0 +-262 -334 0 +-263 -335 0 +-264 -336 0 +-265 -337 0 +-266 -338 0 +-267 -339 0 +-268 -340 0 +-269 -341 0 +-270 -342 0 +-262 -406 0 +-263 -407 0 +-264 -408 0 +-265 -409 0 +-266 -410 0 +-267 -411 0 +-268 -412 0 +-269 -413 0 +-270 -414 0 +-262 -415 0 +-263 -416 0 +-264 -417 0 +-265 -418 0 +-266 -419 0 +-267 -420 0 +-268 -421 0 +-269 -422 0 +-270 -423 0 +-325 -253 0 +-326 -254 0 +-327 -255 0 +-328 -256 0 +-329 -257 0 +-330 -258 0 +-331 -259 0 +-332 -260 0 +-333 -261 0 +-325 -262 0 +-326 -263 0 +-327 -264 0 +-328 -265 0 +-329 -266 0 +-330 -267 0 +-331 -268 0 +-332 -269 0 +-333 -270 0 +-325 -415 0 +-326 -416 0 +-327 -417 0 +-328 -418 0 +-329 -419 0 +-330 -420 0 +-331 -421 0 +-332 -422 0 +-333 -423 0 +-325 -424 0 +-326 -425 0 +-327 -426 0 +-328 -427 0 +-329 -428 0 +-330 -429 0 +-331 -430 0 +-332 -431 0 +-333 -432 0 +-334 -244 0 +-335 -245 0 +-336 -246 0 +-337 -247 0 +-338 -248 0 +-339 -249 0 +-340 -250 0 +-341 -251 0 +-342 -252 0 +-334 -262 0 +-335 -263 0 +-336 -264 0 +-337 -265 0 +-338 -266 0 +-339 -267 0 +-340 -268 0 +-341 -269 0 +-342 -270 0 +-334 -406 0 +-335 -407 0 +-336 -408 0 +-337 -409 0 +-338 -410 0 +-339 -411 0 +-340 -412 0 +-341 -413 0 +-342 -414 0 +-334 -424 0 +-335 -425 0 +-336 -426 0 +-337 -427 0 +-338 -428 0 +-339 -429 0 +-340 -430 0 +-341 -431 0 +-342 -432 0 +-343 -244 0 +-344 -245 0 +-345 -246 0 +-346 -247 0 +-347 -248 0 +-348 -249 0 +-349 -250 0 +-350 -251 0 +-351 -252 0 +-343 -253 0 +-344 -254 0 +-345 -255 0 +-346 -256 0 +-347 -257 0 +-348 -258 0 +-349 -259 0 +-350 -260 0 +-351 -261 0 +-343 -406 0 +-344 -407 0 +-345 -408 0 +-346 -409 0 +-347 -410 0 +-348 -411 0 +-349 -412 0 +-350 -413 0 +-351 -414 0 +-343 -415 0 +-344 -416 0 +-345 -417 0 +-346 -418 0 +-347 -419 0 +-348 -420 0 +-349 -421 0 +-350 -422 0 +-351 -423 0 +-406 -253 0 +-407 -254 0 +-408 -255 0 +-409 -256 0 +-410 -257 0 +-411 -258 0 +-412 -259 0 +-413 -260 0 +-414 -261 0 +-406 -262 0 +-407 -263 0 +-408 -264 0 +-409 -265 0 +-410 -266 0 +-411 -267 0 +-412 -268 0 +-413 -269 0 +-414 -270 0 +-406 -334 0 +-407 -335 0 +-408 -336 0 +-409 -337 0 +-410 -338 0 +-411 -339 0 +-412 -340 0 +-413 -341 0 +-414 -342 0 +-406 -343 0 +-407 -344 0 +-408 -345 0 +-409 -346 0 +-410 -347 0 +-411 -348 0 +-412 -349 0 +-413 -350 0 +-414 -351 0 +-415 -244 0 +-416 -245 0 +-417 -246 0 +-418 -247 0 +-419 -248 0 +-420 -249 0 +-421 -250 0 +-422 -251 0 +-423 -252 0 +-415 -262 0 +-416 -263 0 +-417 -264 0 +-418 -265 0 +-419 -266 0 +-420 -267 0 +-421 -268 0 +-422 -269 0 +-423 -270 0 +-415 -325 0 +-416 -326 0 +-417 -327 0 +-418 -328 0 +-419 -329 0 +-420 -330 0 +-421 -331 0 +-422 -332 0 +-423 -333 0 +-415 -343 0 +-416 -344 0 +-417 -345 0 +-418 -346 0 +-419 -347 0 +-420 -348 0 +-421 -349 0 +-422 -350 0 +-423 -351 0 +-424 -244 0 +-425 -245 0 +-426 -246 0 +-427 -247 0 +-428 -248 0 +-429 -249 0 +-430 -250 0 +-431 -251 0 +-432 -252 0 +-424 -253 0 +-425 -254 0 +-426 -255 0 +-427 -256 0 +-428 -257 0 +-429 -258 0 +-430 -259 0 +-431 -260 0 +-432 -261 0 +-424 -325 0 +-425 -326 0 +-426 -327 0 +-427 -328 0 +-428 -329 0 +-429 -330 0 +-430 -331 0 +-431 -332 0 +-432 -333 0 +-424 -334 0 +-425 -335 0 +-426 -336 0 +-427 -337 0 +-428 -338 0 +-429 -339 0 +-430 -340 0 +-431 -341 0 +-432 -342 0 +-271 -361 0 +-272 -362 0 +-273 -363 0 +-274 -364 0 +-275 -365 0 +-276 -366 0 +-277 -367 0 +-278 -368 0 +-279 -369 0 +-271 -370 0 +-272 -371 0 +-273 -372 0 +-274 -373 0 +-275 -374 0 +-276 -375 0 +-277 -376 0 +-278 -377 0 +-279 -378 0 +-271 -442 0 +-272 -443 0 +-273 -444 0 +-274 -445 0 +-275 -446 0 +-276 -447 0 +-277 -448 0 +-278 -449 0 +-279 -450 0 +-271 -451 0 +-272 -452 0 +-273 -453 0 +-274 -454 0 +-275 -455 0 +-276 -456 0 +-277 -457 0 +-278 -458 0 +-279 -459 0 +-280 -352 0 +-281 -353 0 +-282 -354 0 +-283 -355 0 +-284 -356 0 +-285 -357 0 +-286 -358 0 +-287 -359 0 +-288 -360 0 +-280 -370 0 +-281 -371 0 +-282 -372 0 +-283 -373 0 +-284 -374 0 +-285 -375 0 +-286 -376 0 +-287 -377 0 +-288 -378 0 +-280 -433 0 +-281 -434 0 +-282 -435 0 +-283 -436 0 +-284 -437 0 +-285 -438 0 +-286 -439 0 +-287 -440 0 +-288 -441 0 +-280 -451 0 +-281 -452 0 +-282 -453 0 +-283 -454 0 +-284 -455 0 +-285 -456 0 +-286 -457 0 +-287 -458 0 +-288 -459 0 +-289 -352 0 +-290 -353 0 +-291 -354 0 +-292 -355 0 +-293 -356 0 +-294 -357 0 +-295 -358 0 +-296 -359 0 +-297 -360 0 +-289 -361 0 +-290 -362 0 +-291 -363 0 +-292 -364 0 +-293 -365 0 +-294 -366 0 +-295 -367 0 +-296 -368 0 +-297 -369 0 +-289 -433 0 +-290 -434 0 +-291 -435 0 +-292 -436 0 +-293 -437 0 +-294 -438 0 +-295 -439 0 +-296 -440 0 +-297 -441 0 +-289 -442 0 +-290 -443 0 +-291 -444 0 +-292 -445 0 +-293 -446 0 +-294 -447 0 +-295 -448 0 +-296 -449 0 +-297 -450 0 +-352 -280 0 +-353 -281 0 +-354 -282 0 +-355 -283 0 +-356 -284 0 +-357 -285 0 +-358 -286 0 +-359 -287 0 +-360 -288 0 +-352 -289 0 +-353 -290 0 +-354 -291 0 +-355 -292 0 +-356 -293 0 +-357 -294 0 +-358 -295 0 +-359 -296 0 +-360 -297 0 +-352 -442 0 +-353 -443 0 +-354 -444 0 +-355 -445 0 +-356 -446 0 +-357 -447 0 +-358 -448 0 +-359 -449 0 +-360 -450 0 +-352 -451 0 +-353 -452 0 +-354 -453 0 +-355 -454 0 +-356 -455 0 +-357 -456 0 +-358 -457 0 +-359 -458 0 +-360 -459 0 +-361 -271 0 +-362 -272 0 +-363 -273 0 +-364 -274 0 +-365 -275 0 +-366 -276 0 +-367 -277 0 +-368 -278 0 +-369 -279 0 +-361 -289 0 +-362 -290 0 +-363 -291 0 +-364 -292 0 +-365 -293 0 +-366 -294 0 +-367 -295 0 +-368 -296 0 +-369 -297 0 +-361 -433 0 +-362 -434 0 +-363 -435 0 +-364 -436 0 +-365 -437 0 +-366 -438 0 +-367 -439 0 +-368 -440 0 +-369 -441 0 +-361 -451 0 +-362 -452 0 +-363 -453 0 +-364 -454 0 +-365 -455 0 +-366 -456 0 +-367 -457 0 +-368 -458 0 +-369 -459 0 +-370 -271 0 +-371 -272 0 +-372 -273 0 +-373 -274 0 +-374 -275 0 +-375 -276 0 +-376 -277 0 +-377 -278 0 +-378 -279 0 +-370 -280 0 +-371 -281 0 +-372 -282 0 +-373 -283 0 +-374 -284 0 +-375 -285 0 +-376 -286 0 +-377 -287 0 +-378 -288 0 +-370 -433 0 +-371 -434 0 +-372 -435 0 +-373 -436 0 +-374 -437 0 +-375 -438 0 +-376 -439 0 +-377 -440 0 +-378 -441 0 +-370 -442 0 +-371 -443 0 +-372 -444 0 +-373 -445 0 +-374 -446 0 +-375 -447 0 +-376 -448 0 +-377 -449 0 +-378 -450 0 +-433 -280 0 +-434 -281 0 +-435 -282 0 +-436 -283 0 +-437 -284 0 +-438 -285 0 +-439 -286 0 +-440 -287 0 +-441 -288 0 +-433 -289 0 +-434 -290 0 +-435 -291 0 +-436 -292 0 +-437 -293 0 +-438 -294 0 +-439 -295 0 +-440 -296 0 +-441 -297 0 +-433 -361 0 +-434 -362 0 +-435 -363 0 +-436 -364 0 +-437 -365 0 +-438 -366 0 +-439 -367 0 +-440 -368 0 +-441 -369 0 +-433 -370 0 +-434 -371 0 +-435 -372 0 +-436 -373 0 +-437 -374 0 +-438 -375 0 +-439 -376 0 +-440 -377 0 +-441 -378 0 +-442 -271 0 +-443 -272 0 +-444 -273 0 +-445 -274 0 +-446 -275 0 +-447 -276 0 +-448 -277 0 +-449 -278 0 +-450 -279 0 +-442 -289 0 +-443 -290 0 +-444 -291 0 +-445 -292 0 +-446 -293 0 +-447 -294 0 +-448 -295 0 +-449 -296 0 +-450 -297 0 +-442 -352 0 +-443 -353 0 +-444 -354 0 +-445 -355 0 +-446 -356 0 +-447 -357 0 +-448 -358 0 +-449 -359 0 +-450 -360 0 +-442 -370 0 +-443 -371 0 +-444 -372 0 +-445 -373 0 +-446 -374 0 +-447 -375 0 +-448 -376 0 +-449 -377 0 +-450 -378 0 +-451 -271 0 +-452 -272 0 +-453 -273 0 +-454 -274 0 +-455 -275 0 +-456 -276 0 +-457 -277 0 +-458 -278 0 +-459 -279 0 +-451 -280 0 +-452 -281 0 +-453 -282 0 +-454 -283 0 +-455 -284 0 +-456 -285 0 +-457 -286 0 +-458 -287 0 +-459 -288 0 +-451 -352 0 +-452 -353 0 +-453 -354 0 +-454 -355 0 +-455 -356 0 +-456 -357 0 +-457 -358 0 +-458 -359 0 +-459 -360 0 +-451 -361 0 +-452 -362 0 +-453 -363 0 +-454 -364 0 +-455 -365 0 +-456 -366 0 +-457 -367 0 +-458 -368 0 +-459 -369 0 +-298 -388 0 +-299 -389 0 +-300 -390 0 +-301 -391 0 +-302 -392 0 +-303 -393 0 +-304 -394 0 +-305 -395 0 +-306 -396 0 +-298 -397 0 +-299 -398 0 +-300 -399 0 +-301 -400 0 +-302 -401 0 +-303 -402 0 +-304 -403 0 +-305 -404 0 +-306 -405 0 +-298 -469 0 +-299 -470 0 +-300 -471 0 +-301 -472 0 +-302 -473 0 +-303 -474 0 +-304 -475 0 +-305 -476 0 +-306 -477 0 +-298 -478 0 +-299 -479 0 +-300 -480 0 +-301 -481 0 +-302 -482 0 +-303 -483 0 +-304 -484 0 +-305 -485 0 +-306 -486 0 +-307 -379 0 +-308 -380 0 +-309 -381 0 +-310 -382 0 +-311 -383 0 +-312 -384 0 +-313 -385 0 +-314 -386 0 +-315 -387 0 +-307 -397 0 +-308 -398 0 +-309 -399 0 +-310 -400 0 +-311 -401 0 +-312 -402 0 +-313 -403 0 +-314 -404 0 +-315 -405 0 +-307 -460 0 +-308 -461 0 +-309 -462 0 +-310 -463 0 +-311 -464 0 +-312 -465 0 +-313 -466 0 +-314 -467 0 +-315 -468 0 +-307 -478 0 +-308 -479 0 +-309 -480 0 +-310 -481 0 +-311 -482 0 +-312 -483 0 +-313 -484 0 +-314 -485 0 +-315 -486 0 +-316 -379 0 +-317 -380 0 +-318 -381 0 +-319 -382 0 +-320 -383 0 +-321 -384 0 +-322 -385 0 +-323 -386 0 +-324 -387 0 +-316 -388 0 +-317 -389 0 +-318 -390 0 +-319 -391 0 +-320 -392 0 +-321 -393 0 +-322 -394 0 +-323 -395 0 +-324 -396 0 +-316 -460 0 +-317 -461 0 +-318 -462 0 +-319 -463 0 +-320 -464 0 +-321 -465 0 +-322 -466 0 +-323 -467 0 +-324 -468 0 +-316 -469 0 +-317 -470 0 +-318 -471 0 +-319 -472 0 +-320 -473 0 +-321 -474 0 +-322 -475 0 +-323 -476 0 +-324 -477 0 +-379 -307 0 +-380 -308 0 +-381 -309 0 +-382 -310 0 +-383 -311 0 +-384 -312 0 +-385 -313 0 +-386 -314 0 +-387 -315 0 +-379 -316 0 +-380 -317 0 +-381 -318 0 +-382 -319 0 +-383 -320 0 +-384 -321 0 +-385 -322 0 +-386 -323 0 +-387 -324 0 +-379 -469 0 +-380 -470 0 +-381 -471 0 +-382 -472 0 +-383 -473 0 +-384 -474 0 +-385 -475 0 +-386 -476 0 +-387 -477 0 +-379 -478 0 +-380 -479 0 +-381 -480 0 +-382 -481 0 +-383 -482 0 +-384 -483 0 +-385 -484 0 +-386 -485 0 +-387 -486 0 +-388 -298 0 +-389 -299 0 +-390 -300 0 +-391 -301 0 +-392 -302 0 +-393 -303 0 +-394 -304 0 +-395 -305 0 +-396 -306 0 +-388 -316 0 +-389 -317 0 +-390 -318 0 +-391 -319 0 +-392 -320 0 +-393 -321 0 +-394 -322 0 +-395 -323 0 +-396 -324 0 +-388 -460 0 +-389 -461 0 +-390 -462 0 +-391 -463 0 +-392 -464 0 +-393 -465 0 +-394 -466 0 +-395 -467 0 +-396 -468 0 +-388 -478 0 +-389 -479 0 +-390 -480 0 +-391 -481 0 +-392 -482 0 +-393 -483 0 +-394 -484 0 +-395 -485 0 +-396 -486 0 +-397 -298 0 +-398 -299 0 +-399 -300 0 +-400 -301 0 +-401 -302 0 +-402 -303 0 +-403 -304 0 +-404 -305 0 +-405 -306 0 +-397 -307 0 +-398 -308 0 +-399 -309 0 +-400 -310 0 +-401 -311 0 +-402 -312 0 +-403 -313 0 +-404 -314 0 +-405 -315 0 +-397 -460 0 +-398 -461 0 +-399 -462 0 +-400 -463 0 +-401 -464 0 +-402 -465 0 +-403 -466 0 +-404 -467 0 +-405 -468 0 +-397 -469 0 +-398 -470 0 +-399 -471 0 +-400 -472 0 +-401 -473 0 +-402 -474 0 +-403 -475 0 +-404 -476 0 +-405 -477 0 +-460 -307 0 +-461 -308 0 +-462 -309 0 +-463 -310 0 +-464 -311 0 +-465 -312 0 +-466 -313 0 +-467 -314 0 +-468 -315 0 +-460 -316 0 +-461 -317 0 +-462 -318 0 +-463 -319 0 +-464 -320 0 +-465 -321 0 +-466 -322 0 +-467 -323 0 +-468 -324 0 +-460 -388 0 +-461 -389 0 +-462 -390 0 +-463 -391 0 +-464 -392 0 +-465 -393 0 +-466 -394 0 +-467 -395 0 +-468 -396 0 +-460 -397 0 +-461 -398 0 +-462 -399 0 +-463 -400 0 +-464 -401 0 +-465 -402 0 +-466 -403 0 +-467 -404 0 +-468 -405 0 +-469 -298 0 +-470 -299 0 +-471 -300 0 +-472 -301 0 +-473 -302 0 +-474 -303 0 +-475 -304 0 +-476 -305 0 +-477 -306 0 +-469 -316 0 +-470 -317 0 +-471 -318 0 +-472 -319 0 +-473 -320 0 +-474 -321 0 +-475 -322 0 +-476 -323 0 +-477 -324 0 +-469 -379 0 +-470 -380 0 +-471 -381 0 +-472 -382 0 +-473 -383 0 +-474 -384 0 +-475 -385 0 +-476 -386 0 +-477 -387 0 +-469 -397 0 +-470 -398 0 +-471 -399 0 +-472 -400 0 +-473 -401 0 +-474 -402 0 +-475 -403 0 +-476 -404 0 +-477 -405 0 +-478 -298 0 +-479 -299 0 +-480 -300 0 +-481 -301 0 +-482 -302 0 +-483 -303 0 +-484 -304 0 +-485 -305 0 +-486 -306 0 +-478 -307 0 +-479 -308 0 +-480 -309 0 +-481 -310 0 +-482 -311 0 +-483 -312 0 +-484 -313 0 +-485 -314 0 +-486 -315 0 +-478 -379 0 +-479 -380 0 +-480 -381 0 +-481 -382 0 +-482 -383 0 +-483 -384 0 +-484 -385 0 +-485 -386 0 +-486 -387 0 +-478 -388 0 +-479 -389 0 +-480 -390 0 +-481 -391 0 +-482 -392 0 +-483 -393 0 +-484 -394 0 +-485 -395 0 +-486 -396 0 +-487 -577 0 +-488 -578 0 +-489 -579 0 +-490 -580 0 +-491 -581 0 +-492 -582 0 +-493 -583 0 +-494 -584 0 +-495 -585 0 +-487 -586 0 +-488 -587 0 +-489 -588 0 +-490 -589 0 +-491 -590 0 +-492 -591 0 +-493 -592 0 +-494 -593 0 +-495 -594 0 +-487 -658 0 +-488 -659 0 +-489 -660 0 +-490 -661 0 +-491 -662 0 +-492 -663 0 +-493 -664 0 +-494 -665 0 +-495 -666 0 +-487 -667 0 +-488 -668 0 +-489 -669 0 +-490 -670 0 +-491 -671 0 +-492 -672 0 +-493 -673 0 +-494 -674 0 +-495 -675 0 +-496 -568 0 +-497 -569 0 +-498 -570 0 +-499 -571 0 +-500 -572 0 +-501 -573 0 +-502 -574 0 +-503 -575 0 +-504 -576 0 +-496 -586 0 +-497 -587 0 +-498 -588 0 +-499 -589 0 +-500 -590 0 +-501 -591 0 +-502 -592 0 +-503 -593 0 +-504 -594 0 +-496 -649 0 +-497 -650 0 +-498 -651 0 +-499 -652 0 +-500 -653 0 +-501 -654 0 +-502 -655 0 +-503 -656 0 +-504 -657 0 +-496 -667 0 +-497 -668 0 +-498 -669 0 +-499 -670 0 +-500 -671 0 +-501 -672 0 +-502 -673 0 +-503 -674 0 +-504 -675 0 +-505 -568 0 +-506 -569 0 +-507 -570 0 +-508 -571 0 +-509 -572 0 +-510 -573 0 +-511 -574 0 +-512 -575 0 +-513 -576 0 +-505 -577 0 +-506 -578 0 +-507 -579 0 +-508 -580 0 +-509 -581 0 +-510 -582 0 +-511 -583 0 +-512 -584 0 +-513 -585 0 +-505 -649 0 +-506 -650 0 +-507 -651 0 +-508 -652 0 +-509 -653 0 +-510 -654 0 +-511 -655 0 +-512 -656 0 +-513 -657 0 +-505 -658 0 +-506 -659 0 +-507 -660 0 +-508 -661 0 +-509 -662 0 +-510 -663 0 +-511 -664 0 +-512 -665 0 +-513 -666 0 +-568 -496 0 +-569 -497 0 +-570 -498 0 +-571 -499 0 +-572 -500 0 +-573 -501 0 +-574 -502 0 +-575 -503 0 +-576 -504 0 +-568 -505 0 +-569 -506 0 +-570 -507 0 +-571 -508 0 +-572 -509 0 +-573 -510 0 +-574 -511 0 +-575 -512 0 +-576 -513 0 +-568 -658 0 +-569 -659 0 +-570 -660 0 +-571 -661 0 +-572 -662 0 +-573 -663 0 +-574 -664 0 +-575 -665 0 +-576 -666 0 +-568 -667 0 +-569 -668 0 +-570 -669 0 +-571 -670 0 +-572 -671 0 +-573 -672 0 +-574 -673 0 +-575 -674 0 +-576 -675 0 +-577 -487 0 +-578 -488 0 +-579 -489 0 +-580 -490 0 +-581 -491 0 +-582 -492 0 +-583 -493 0 +-584 -494 0 +-585 -495 0 +-577 -505 0 +-578 -506 0 +-579 -507 0 +-580 -508 0 +-581 -509 0 +-582 -510 0 +-583 -511 0 +-584 -512 0 +-585 -513 0 +-577 -649 0 +-578 -650 0 +-579 -651 0 +-580 -652 0 +-581 -653 0 +-582 -654 0 +-583 -655 0 +-584 -656 0 +-585 -657 0 +-577 -667 0 +-578 -668 0 +-579 -669 0 +-580 -670 0 +-581 -671 0 +-582 -672 0 +-583 -673 0 +-584 -674 0 +-585 -675 0 +-586 -487 0 +-587 -488 0 +-588 -489 0 +-589 -490 0 +-590 -491 0 +-591 -492 0 +-592 -493 0 +-593 -494 0 +-594 -495 0 +-586 -496 0 +-587 -497 0 +-588 -498 0 +-589 -499 0 +-590 -500 0 +-591 -501 0 +-592 -502 0 +-593 -503 0 +-594 -504 0 +-586 -649 0 +-587 -650 0 +-588 -651 0 +-589 -652 0 +-590 -653 0 +-591 -654 0 +-592 -655 0 +-593 -656 0 +-594 -657 0 +-586 -658 0 +-587 -659 0 +-588 -660 0 +-589 -661 0 +-590 -662 0 +-591 -663 0 +-592 -664 0 +-593 -665 0 +-594 -666 0 +-649 -496 0 +-650 -497 0 +-651 -498 0 +-652 -499 0 +-653 -500 0 +-654 -501 0 +-655 -502 0 +-656 -503 0 +-657 -504 0 +-649 -505 0 +-650 -506 0 +-651 -507 0 +-652 -508 0 +-653 -509 0 +-654 -510 0 +-655 -511 0 +-656 -512 0 +-657 -513 0 +-649 -577 0 +-650 -578 0 +-651 -579 0 +-652 -580 0 +-653 -581 0 +-654 -582 0 +-655 -583 0 +-656 -584 0 +-657 -585 0 +-649 -586 0 +-650 -587 0 +-651 -588 0 +-652 -589 0 +-653 -590 0 +-654 -591 0 +-655 -592 0 +-656 -593 0 +-657 -594 0 +-658 -487 0 +-659 -488 0 +-660 -489 0 +-661 -490 0 +-662 -491 0 +-663 -492 0 +-664 -493 0 +-665 -494 0 +-666 -495 0 +-658 -505 0 +-659 -506 0 +-660 -507 0 +-661 -508 0 +-662 -509 0 +-663 -510 0 +-664 -511 0 +-665 -512 0 +-666 -513 0 +-658 -568 0 +-659 -569 0 +-660 -570 0 +-661 -571 0 +-662 -572 0 +-663 -573 0 +-664 -574 0 +-665 -575 0 +-666 -576 0 +-658 -586 0 +-659 -587 0 +-660 -588 0 +-661 -589 0 +-662 -590 0 +-663 -591 0 +-664 -592 0 +-665 -593 0 +-666 -594 0 +-667 -487 0 +-668 -488 0 +-669 -489 0 +-670 -490 0 +-671 -491 0 +-672 -492 0 +-673 -493 0 +-674 -494 0 +-675 -495 0 +-667 -496 0 +-668 -497 0 +-669 -498 0 +-670 -499 0 +-671 -500 0 +-672 -501 0 +-673 -502 0 +-674 -503 0 +-675 -504 0 +-667 -568 0 +-668 -569 0 +-669 -570 0 +-670 -571 0 +-671 -572 0 +-672 -573 0 +-673 -574 0 +-674 -575 0 +-675 -576 0 +-667 -577 0 +-668 -578 0 +-669 -579 0 +-670 -580 0 +-671 -581 0 +-672 -582 0 +-673 -583 0 +-674 -584 0 +-675 -585 0 +-514 -604 0 +-515 -605 0 +-516 -606 0 +-517 -607 0 +-518 -608 0 +-519 -609 0 +-520 -610 0 +-521 -611 0 +-522 -612 0 +-514 -613 0 +-515 -614 0 +-516 -615 0 +-517 -616 0 +-518 -617 0 +-519 -618 0 +-520 -619 0 +-521 -620 0 +-522 -621 0 +-514 -685 0 +-515 -686 0 +-516 -687 0 +-517 -688 0 +-518 -689 0 +-519 -690 0 +-520 -691 0 +-521 -692 0 +-522 -693 0 +-514 -694 0 +-515 -695 0 +-516 -696 0 +-517 -697 0 +-518 -698 0 +-519 -699 0 +-520 -700 0 +-521 -701 0 +-522 -702 0 +-523 -595 0 +-524 -596 0 +-525 -597 0 +-526 -598 0 +-527 -599 0 +-528 -600 0 +-529 -601 0 +-530 -602 0 +-531 -603 0 +-523 -613 0 +-524 -614 0 +-525 -615 0 +-526 -616 0 +-527 -617 0 +-528 -618 0 +-529 -619 0 +-530 -620 0 +-531 -621 0 +-523 -676 0 +-524 -677 0 +-525 -678 0 +-526 -679 0 +-527 -680 0 +-528 -681 0 +-529 -682 0 +-530 -683 0 +-531 -684 0 +-523 -694 0 +-524 -695 0 +-525 -696 0 +-526 -697 0 +-527 -698 0 +-528 -699 0 +-529 -700 0 +-530 -701 0 +-531 -702 0 +-532 -595 0 +-533 -596 0 +-534 -597 0 +-535 -598 0 +-536 -599 0 +-537 -600 0 +-538 -601 0 +-539 -602 0 +-540 -603 0 +-532 -604 0 +-533 -605 0 +-534 -606 0 +-535 -607 0 +-536 -608 0 +-537 -609 0 +-538 -610 0 +-539 -611 0 +-540 -612 0 +-532 -676 0 +-533 -677 0 +-534 -678 0 +-535 -679 0 +-536 -680 0 +-537 -681 0 +-538 -682 0 +-539 -683 0 +-540 -684 0 +-532 -685 0 +-533 -686 0 +-534 -687 0 +-535 -688 0 +-536 -689 0 +-537 -690 0 +-538 -691 0 +-539 -692 0 +-540 -693 0 +-595 -523 0 +-596 -524 0 +-597 -525 0 +-598 -526 0 +-599 -527 0 +-600 -528 0 +-601 -529 0 +-602 -530 0 +-603 -531 0 +-595 -532 0 +-596 -533 0 +-597 -534 0 +-598 -535 0 +-599 -536 0 +-600 -537 0 +-601 -538 0 +-602 -539 0 +-603 -540 0 +-595 -685 0 +-596 -686 0 +-597 -687 0 +-598 -688 0 +-599 -689 0 +-600 -690 0 +-601 -691 0 +-602 -692 0 +-603 -693 0 +-595 -694 0 +-596 -695 0 +-597 -696 0 +-598 -697 0 +-599 -698 0 +-600 -699 0 +-601 -700 0 +-602 -701 0 +-603 -702 0 +-604 -514 0 +-605 -515 0 +-606 -516 0 +-607 -517 0 +-608 -518 0 +-609 -519 0 +-610 -520 0 +-611 -521 0 +-612 -522 0 +-604 -532 0 +-605 -533 0 +-606 -534 0 +-607 -535 0 +-608 -536 0 +-609 -537 0 +-610 -538 0 +-611 -539 0 +-612 -540 0 +-604 -676 0 +-605 -677 0 +-606 -678 0 +-607 -679 0 +-608 -680 0 +-609 -681 0 +-610 -682 0 +-611 -683 0 +-612 -684 0 +-604 -694 0 +-605 -695 0 +-606 -696 0 +-607 -697 0 +-608 -698 0 +-609 -699 0 +-610 -700 0 +-611 -701 0 +-612 -702 0 +-613 -514 0 +-614 -515 0 +-615 -516 0 +-616 -517 0 +-617 -518 0 +-618 -519 0 +-619 -520 0 +-620 -521 0 +-621 -522 0 +-613 -523 0 +-614 -524 0 +-615 -525 0 +-616 -526 0 +-617 -527 0 +-618 -528 0 +-619 -529 0 +-620 -530 0 +-621 -531 0 +-613 -676 0 +-614 -677 0 +-615 -678 0 +-616 -679 0 +-617 -680 0 +-618 -681 0 +-619 -682 0 +-620 -683 0 +-621 -684 0 +-613 -685 0 +-614 -686 0 +-615 -687 0 +-616 -688 0 +-617 -689 0 +-618 -690 0 +-619 -691 0 +-620 -692 0 +-621 -693 0 +-676 -523 0 +-677 -524 0 +-678 -525 0 +-679 -526 0 +-680 -527 0 +-681 -528 0 +-682 -529 0 +-683 -530 0 +-684 -531 0 +-676 -532 0 +-677 -533 0 +-678 -534 0 +-679 -535 0 +-680 -536 0 +-681 -537 0 +-682 -538 0 +-683 -539 0 +-684 -540 0 +-676 -604 0 +-677 -605 0 +-678 -606 0 +-679 -607 0 +-680 -608 0 +-681 -609 0 +-682 -610 0 +-683 -611 0 +-684 -612 0 +-676 -613 0 +-677 -614 0 +-678 -615 0 +-679 -616 0 +-680 -617 0 +-681 -618 0 +-682 -619 0 +-683 -620 0 +-684 -621 0 +-685 -514 0 +-686 -515 0 +-687 -516 0 +-688 -517 0 +-689 -518 0 +-690 -519 0 +-691 -520 0 +-692 -521 0 +-693 -522 0 +-685 -532 0 +-686 -533 0 +-687 -534 0 +-688 -535 0 +-689 -536 0 +-690 -537 0 +-691 -538 0 +-692 -539 0 +-693 -540 0 +-685 -595 0 +-686 -596 0 +-687 -597 0 +-688 -598 0 +-689 -599 0 +-690 -600 0 +-691 -601 0 +-692 -602 0 +-693 -603 0 +-685 -613 0 +-686 -614 0 +-687 -615 0 +-688 -616 0 +-689 -617 0 +-690 -618 0 +-691 -619 0 +-692 -620 0 +-693 -621 0 +-694 -514 0 +-695 -515 0 +-696 -516 0 +-697 -517 0 +-698 -518 0 +-699 -519 0 +-700 -520 0 +-701 -521 0 +-702 -522 0 +-694 -523 0 +-695 -524 0 +-696 -525 0 +-697 -526 0 +-698 -527 0 +-699 -528 0 +-700 -529 0 +-701 -530 0 +-702 -531 0 +-694 -595 0 +-695 -596 0 +-696 -597 0 +-697 -598 0 +-698 -599 0 +-699 -600 0 +-700 -601 0 +-701 -602 0 +-702 -603 0 +-694 -604 0 +-695 -605 0 +-696 -606 0 +-697 -607 0 +-698 -608 0 +-699 -609 0 +-700 -610 0 +-701 -611 0 +-702 -612 0 +-541 -631 0 +-542 -632 0 +-543 -633 0 +-544 -634 0 +-545 -635 0 +-546 -636 0 +-547 -637 0 +-548 -638 0 +-549 -639 0 +-541 -640 0 +-542 -641 0 +-543 -642 0 +-544 -643 0 +-545 -644 0 +-546 -645 0 +-547 -646 0 +-548 -647 0 +-549 -648 0 +-541 -712 0 +-542 -713 0 +-543 -714 0 +-544 -715 0 +-545 -716 0 +-546 -717 0 +-547 -718 0 +-548 -719 0 +-549 -720 0 +-541 -721 0 +-542 -722 0 +-543 -723 0 +-544 -724 0 +-545 -725 0 +-546 -726 0 +-547 -727 0 +-548 -728 0 +-549 -729 0 +-550 -622 0 +-551 -623 0 +-552 -624 0 +-553 -625 0 +-554 -626 0 +-555 -627 0 +-556 -628 0 +-557 -629 0 +-558 -630 0 +-550 -640 0 +-551 -641 0 +-552 -642 0 +-553 -643 0 +-554 -644 0 +-555 -645 0 +-556 -646 0 +-557 -647 0 +-558 -648 0 +-550 -703 0 +-551 -704 0 +-552 -705 0 +-553 -706 0 +-554 -707 0 +-555 -708 0 +-556 -709 0 +-557 -710 0 +-558 -711 0 +-550 -721 0 +-551 -722 0 +-552 -723 0 +-553 -724 0 +-554 -725 0 +-555 -726 0 +-556 -727 0 +-557 -728 0 +-558 -729 0 +-559 -622 0 +-560 -623 0 +-561 -624 0 +-562 -625 0 +-563 -626 0 +-564 -627 0 +-565 -628 0 +-566 -629 0 +-567 -630 0 +-559 -631 0 +-560 -632 0 +-561 -633 0 +-562 -634 0 +-563 -635 0 +-564 -636 0 +-565 -637 0 +-566 -638 0 +-567 -639 0 +-559 -703 0 +-560 -704 0 +-561 -705 0 +-562 -706 0 +-563 -707 0 +-564 -708 0 +-565 -709 0 +-566 -710 0 +-567 -711 0 +-559 -712 0 +-560 -713 0 +-561 -714 0 +-562 -715 0 +-563 -716 0 +-564 -717 0 +-565 -718 0 +-566 -719 0 +-567 -720 0 +-622 -550 0 +-623 -551 0 +-624 -552 0 +-625 -553 0 +-626 -554 0 +-627 -555 0 +-628 -556 0 +-629 -557 0 +-630 -558 0 +-622 -559 0 +-623 -560 0 +-624 -561 0 +-625 -562 0 +-626 -563 0 +-627 -564 0 +-628 -565 0 +-629 -566 0 +-630 -567 0 +-622 -712 0 +-623 -713 0 +-624 -714 0 +-625 -715 0 +-626 -716 0 +-627 -717 0 +-628 -718 0 +-629 -719 0 +-630 -720 0 +-622 -721 0 +-623 -722 0 +-624 -723 0 +-625 -724 0 +-626 -725 0 +-627 -726 0 +-628 -727 0 +-629 -728 0 +-630 -729 0 +-631 -541 0 +-632 -542 0 +-633 -543 0 +-634 -544 0 +-635 -545 0 +-636 -546 0 +-637 -547 0 +-638 -548 0 +-639 -549 0 +-631 -559 0 +-632 -560 0 +-633 -561 0 +-634 -562 0 +-635 -563 0 +-636 -564 0 +-637 -565 0 +-638 -566 0 +-639 -567 0 +-631 -703 0 +-632 -704 0 +-633 -705 0 +-634 -706 0 +-635 -707 0 +-636 -708 0 +-637 -709 0 +-638 -710 0 +-639 -711 0 +-631 -721 0 +-632 -722 0 +-633 -723 0 +-634 -724 0 +-635 -725 0 +-636 -726 0 +-637 -727 0 +-638 -728 0 +-639 -729 0 +-640 -541 0 +-641 -542 0 +-642 -543 0 +-643 -544 0 +-644 -545 0 +-645 -546 0 +-646 -547 0 +-647 -548 0 +-648 -549 0 +-640 -550 0 +-641 -551 0 +-642 -552 0 +-643 -553 0 +-644 -554 0 +-645 -555 0 +-646 -556 0 +-647 -557 0 +-648 -558 0 +-640 -703 0 +-641 -704 0 +-642 -705 0 +-643 -706 0 +-644 -707 0 +-645 -708 0 +-646 -709 0 +-647 -710 0 +-648 -711 0 +-640 -712 0 +-641 -713 0 +-642 -714 0 +-643 -715 0 +-644 -716 0 +-645 -717 0 +-646 -718 0 +-647 -719 0 +-648 -720 0 +-703 -550 0 +-704 -551 0 +-705 -552 0 +-706 -553 0 +-707 -554 0 +-708 -555 0 +-709 -556 0 +-710 -557 0 +-711 -558 0 +-703 -559 0 +-704 -560 0 +-705 -561 0 +-706 -562 0 +-707 -563 0 +-708 -564 0 +-709 -565 0 +-710 -566 0 +-711 -567 0 +-703 -631 0 +-704 -632 0 +-705 -633 0 +-706 -634 0 +-707 -635 0 +-708 -636 0 +-709 -637 0 +-710 -638 0 +-711 -639 0 +-703 -640 0 +-704 -641 0 +-705 -642 0 +-706 -643 0 +-707 -644 0 +-708 -645 0 +-709 -646 0 +-710 -647 0 +-711 -648 0 +-712 -541 0 +-713 -542 0 +-714 -543 0 +-715 -544 0 +-716 -545 0 +-717 -546 0 +-718 -547 0 +-719 -548 0 +-720 -549 0 +-712 -559 0 +-713 -560 0 +-714 -561 0 +-715 -562 0 +-716 -563 0 +-717 -564 0 +-718 -565 0 +-719 -566 0 +-720 -567 0 +-712 -622 0 +-713 -623 0 +-714 -624 0 +-715 -625 0 +-716 -626 0 +-717 -627 0 +-718 -628 0 +-719 -629 0 +-720 -630 0 +-712 -640 0 +-713 -641 0 +-714 -642 0 +-715 -643 0 +-716 -644 0 +-717 -645 0 +-718 -646 0 +-719 -647 0 +-720 -648 0 +-721 -541 0 +-722 -542 0 +-723 -543 0 +-724 -544 0 +-725 -545 0 +-726 -546 0 +-727 -547 0 +-728 -548 0 +-729 -549 0 +-721 -550 0 +-722 -551 0 +-723 -552 0 +-724 -553 0 +-725 -554 0 +-726 -555 0 +-727 -556 0 +-728 -557 0 +-729 -558 0 +-721 -622 0 +-722 -623 0 +-723 -624 0 +-724 -625 0 +-725 -626 0 +-726 -627 0 +-727 -628 0 +-728 -629 0 +-729 -630 0 +-721 -631 0 +-722 -632 0 +-723 -633 0 +-724 -634 0 +-725 -635 0 +-726 -636 0 +-727 -637 0 +-728 -638 0 +-729 -639 0 diff --git a/test/monniaux/picosat-965/version.c b/test/monniaux/picosat-965/version.c new file mode 100644 index 00000000..71c322bd --- /dev/null +++ b/test/monniaux/picosat-965/version.c @@ -0,0 +1,14 @@ +#include "config.h" + +const char * +picosat_version (void) +{ + return PICOSAT_VERSION; +} + +const char * +picosat_config (void) +{ + return PICOSAT_CC " " PICOSAT_CFLAGS; +} + |