File: USAGE.html

package info (click to toggle)
freecell-solver 3.26.0-1
links: PTS, VCS
area: main
in suites: jessie, jessie-kfreebsd
size: 4,864 kB
ctags: 3,658
sloc: ansic: 34,721; perl: 12,320; xml: 5,999; python: 1,149; sh: 965; ruby: 347; cpp: 304; makefile: 151
file content (1990 lines) | stat: -rw-r--r-- 74,462 bytes
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="application/xhtml+xml; charset=UTF-8" />
<meta name="generator" content="AsciiDoc 8.6.9" />
<title>Freecell Solver&#8217;s Command-Line Syntax and Usage</title>
<style type="text/css">
/* Shared CSS for AsciiDoc xhtml11 and html5 backends */

/* Default font. */
body {
  font-family: Georgia,serif;
}

/* Title font. */
h1, h2, h3, h4, h5, h6,
div.title, caption.title,
thead, p.table.header,
#toctitle,
#author, #revnumber, #revdate, #revremark,
#footer {
  font-family: Arial,Helvetica,sans-serif;
}

body {
  margin: 1em 5% 1em 5%;
}

a {
  color: blue;
  text-decoration: underline;
}
a:visited {
  color: fuchsia;
}

em {
  font-style: italic;
  color: navy;
}

strong {
  font-weight: bold;
  color: #083194;
}

h1, h2, h3, h4, h5, h6 {
  color: #527bbd;
  margin-top: 1.2em;
  margin-bottom: 0.5em;
  line-height: 1.3;
}

h1, h2, h3 {
  border-bottom: 2px solid silver;
}
h2 {
  padding-top: 0.5em;
}
h3 {
  float: left;
}
h3 + * {
  clear: left;
}
h5 {
  font-size: 1.0em;
}

div.sectionbody {
  margin-left: 0;
}

hr {
  border: 1px solid silver;
}

p {
  margin-top: 0.5em;
  margin-bottom: 0.5em;
}

ul, ol, li > p {
  margin-top: 0;
}
ul > li     { color: #aaa; }
ul > li > * { color: black; }

.monospaced, code, pre {
  font-family: "Courier New", Courier, monospace;
  font-size: inherit;
  color: navy;
  padding: 0;
  margin: 0;
}
pre {
  white-space: pre-wrap;
}

#author {
  color: #527bbd;
  font-weight: bold;
  font-size: 1.1em;
}
#email {
}
#revnumber, #revdate, #revremark {
}

#footer {
  font-size: small;
  border-top: 2px solid silver;
  padding-top: 0.5em;
  margin-top: 4.0em;
}
#footer-text {
  float: left;
  padding-bottom: 0.5em;
}
#footer-badges {
  float: right;
  padding-bottom: 0.5em;
}

#preamble {
  margin-top: 1.5em;
  margin-bottom: 1.5em;
}
div.imageblock, div.exampleblock, div.verseblock,
div.quoteblock, div.literalblock, div.listingblock, div.sidebarblock,
div.admonitionblock {
  margin-top: 1.0em;
  margin-bottom: 1.5em;
}
div.admonitionblock {
  margin-top: 2.0em;
  margin-bottom: 2.0em;
  margin-right: 10%;
  color: #606060;
}

div.content { /* Block element content. */
  padding: 0;
}

/* Block element titles. */
div.title, caption.title {
  color: #527bbd;
  font-weight: bold;
  text-align: left;
  margin-top: 1.0em;
  margin-bottom: 0.5em;
}
div.title + * {
  margin-top: 0;
}

td div.title:first-child {
  margin-top: 0.0em;
}
div.content div.title:first-child {
  margin-top: 0.0em;
}
div.content + div.title {
  margin-top: 0.0em;
}

div.sidebarblock > div.content {
  background: #ffffee;
  border: 1px solid #dddddd;
  border-left: 4px solid #f0f0f0;
  padding: 0.5em;
}

div.listingblock > div.content {
  border: 1px solid #dddddd;
  border-left: 5px solid #f0f0f0;
  background: #f8f8f8;
  padding: 0.5em;
}

div.quoteblock, div.verseblock {
  padding-left: 1.0em;
  margin-left: 1.0em;
  margin-right: 10%;
  border-left: 5px solid #f0f0f0;
  color: #888;
}

div.quoteblock > div.attribution {
  padding-top: 0.5em;
  text-align: right;
}

div.verseblock > pre.content {
  font-family: inherit;
  font-size: inherit;
}
div.verseblock > div.attribution {
  padding-top: 0.75em;
  text-align: left;
}
/* DEPRECATED: Pre version 8.2.7 verse style literal block. */
div.verseblock + div.attribution {
  text-align: left;
}

div.admonitionblock .icon {
  vertical-align: top;
  font-size: 1.1em;
  font-weight: bold;
  text-decoration: underline;
  color: #527bbd;
  padding-right: 0.5em;
}
div.admonitionblock td.content {
  padding-left: 0.5em;
  border-left: 3px solid #dddddd;
}

div.exampleblock > div.content {
  border-left: 3px solid #dddddd;
  padding-left: 0.5em;
}

div.imageblock div.content { padding-left: 0; }
span.image img { border-style: none; vertical-align: text-bottom; }
a.image:visited { color: white; }

dl {
  margin-top: 0.8em;
  margin-bottom: 0.8em;
}
dt {
  margin-top: 0.5em;
  margin-bottom: 0;
  font-style: normal;
  color: navy;
}
dd > *:first-child {
  margin-top: 0.1em;
}

ul, ol {
    list-style-position: outside;
}
ol.arabic {
  list-style-type: decimal;
}
ol.loweralpha {
  list-style-type: lower-alpha;
}
ol.upperalpha {
  list-style-type: upper-alpha;
}
ol.lowerroman {
  list-style-type: lower-roman;
}
ol.upperroman {
  list-style-type: upper-roman;
}

div.compact ul, div.compact ol,
div.compact p, div.compact p,
div.compact div, div.compact div {
  margin-top: 0.1em;
  margin-bottom: 0.1em;
}

tfoot {
  font-weight: bold;
}
td > div.verse {
  white-space: pre;
}

div.hdlist {
  margin-top: 0.8em;
  margin-bottom: 0.8em;
}
div.hdlist tr {
  padding-bottom: 15px;
}
dt.hdlist1.strong, td.hdlist1.strong {
  font-weight: bold;
}
td.hdlist1 {
  vertical-align: top;
  font-style: normal;
  padding-right: 0.8em;
  color: navy;
}
td.hdlist2 {
  vertical-align: top;
}
div.hdlist.compact tr {
  margin: 0;
  padding-bottom: 0;
}

.comment {
  background: yellow;
}

.footnote, .footnoteref {
  font-size: 0.8em;
}

span.footnote, span.footnoteref {
  vertical-align: super;
}

#footnotes {
  margin: 20px 0 20px 0;
  padding: 7px 0 0 0;
}

#footnotes div.footnote {
  margin: 0 0 5px 0;
}

#footnotes hr {
  border: none;
  border-top: 1px solid silver;
  height: 1px;
  text-align: left;
  margin-left: 0;
  width: 20%;
  min-width: 100px;
}

div.colist td {
  padding-right: 0.5em;
  padding-bottom: 0.3em;
  vertical-align: top;
}
div.colist td img {
  margin-top: 0.3em;
}

@media print {
  #footer-badges { display: none; }
}

#toc {
  margin-bottom: 2.5em;
}

#toctitle {
  color: #527bbd;
  font-size: 1.1em;
  font-weight: bold;
  margin-top: 1.0em;
  margin-bottom: 0.1em;
}

div.toclevel0, div.toclevel1, div.toclevel2, div.toclevel3, div.toclevel4 {
  margin-top: 0;
  margin-bottom: 0;
}
div.toclevel2 {
  margin-left: 2em;
  font-size: 0.9em;
}
div.toclevel3 {
  margin-left: 4em;
  font-size: 0.9em;
}
div.toclevel4 {
  margin-left: 6em;
  font-size: 0.9em;
}

span.aqua { color: aqua; }
span.black { color: black; }
span.blue { color: blue; }
span.fuchsia { color: fuchsia; }
span.gray { color: gray; }
span.green { color: green; }
span.lime { color: lime; }
span.maroon { color: maroon; }
span.navy { color: navy; }
span.olive { color: olive; }
span.purple { color: purple; }
span.red { color: red; }
span.silver { color: silver; }
span.teal { color: teal; }
span.white { color: white; }
span.yellow { color: yellow; }

span.aqua-background { background: aqua; }
span.black-background { background: black; }
span.blue-background { background: blue; }
span.fuchsia-background { background: fuchsia; }
span.gray-background { background: gray; }
span.green-background { background: green; }
span.lime-background { background: lime; }
span.maroon-background { background: maroon; }
span.navy-background { background: navy; }
span.olive-background { background: olive; }
span.purple-background { background: purple; }
span.red-background { background: red; }
span.silver-background { background: silver; }
span.teal-background { background: teal; }
span.white-background { background: white; }
span.yellow-background { background: yellow; }

span.big { font-size: 2em; }
span.small { font-size: 0.6em; }

span.underline { text-decoration: underline; }
span.overline { text-decoration: overline; }
span.line-through { text-decoration: line-through; }

div.unbreakable { page-break-inside: avoid; }


/*
 * xhtml11 specific
 *
 * */

div.tableblock {
  margin-top: 1.0em;
  margin-bottom: 1.5em;
}
div.tableblock > table {
  border: 3px solid #527bbd;
}
thead, p.table.header {
  font-weight: bold;
  color: #527bbd;
}
p.table {
  margin-top: 0;
}
/* Because the table frame attribute is overriden by CSS in most browsers. */
div.tableblock > table[frame="void"] {
  border-style: none;
}
div.tableblock > table[frame="hsides"] {
  border-left-style: none;
  border-right-style: none;
}
div.tableblock > table[frame="vsides"] {
  border-top-style: none;
  border-bottom-style: none;
}


/*
 * html5 specific
 *
 * */

table.tableblock {
  margin-top: 1.0em;
  margin-bottom: 1.5em;
}
thead, p.tableblock.header {
  font-weight: bold;
  color: #527bbd;
}
p.tableblock {
  margin-top: 0;
}
table.tableblock {
  border-width: 3px;
  border-spacing: 0px;
  border-style: solid;
  border-color: #527bbd;
  border-collapse: collapse;
}
th.tableblock, td.tableblock {
  border-width: 1px;
  padding: 4px;
  border-style: solid;
  border-color: #527bbd;
}

table.tableblock.frame-topbot {
  border-left-style: hidden;
  border-right-style: hidden;
}
table.tableblock.frame-sides {
  border-top-style: hidden;
  border-bottom-style: hidden;
}
table.tableblock.frame-none {
  border-style: hidden;
}

th.tableblock.halign-left, td.tableblock.halign-left {
  text-align: left;
}
th.tableblock.halign-center, td.tableblock.halign-center {
  text-align: center;
}
th.tableblock.halign-right, td.tableblock.halign-right {
  text-align: right;
}

th.tableblock.valign-top, td.tableblock.valign-top {
  vertical-align: top;
}
th.tableblock.valign-middle, td.tableblock.valign-middle {
  vertical-align: middle;
}
th.tableblock.valign-bottom, td.tableblock.valign-bottom {
  vertical-align: bottom;
}


/*
 * manpage specific
 *
 * */

body.manpage h1 {
  padding-top: 0.5em;
  padding-bottom: 0.5em;
  border-top: 2px solid silver;
  border-bottom: 2px solid silver;
}
body.manpage h2 {
  border-style: none;
}
body.manpage div.sectionbody {
  margin-left: 3em;
}

@media print {
  body.manpage div#toc { display: none; }
}


</style>
<script type="text/javascript">
/*<![CDATA[*/
var asciidoc = {  // Namespace.

/////////////////////////////////////////////////////////////////////
// Table Of Contents generator
/////////////////////////////////////////////////////////////////////

/* Author: Mihai Bazon, September 2002
 * http://students.infoiasi.ro/~mishoo
 *
 * Table Of Content generator
 * Version: 0.4
 *
 * Feel free to use this script under the terms of the GNU General Public
 * License, as long as you do not remove or alter this notice.
 */

 /* modified by Troy D. Hanson, September 2006. License: GPL */
 /* modified by Stuart Rackham, 2006, 2009. License: GPL */

// toclevels = 1..4.
toc: function (toclevels) {

  function getText(el) {
    var text = "";
    for (var i = el.firstChild; i != null; i = i.nextSibling) {
      if (i.nodeType == 3 /* Node.TEXT_NODE */) // IE doesn't speak constants.
        text += i.data;
      else if (i.firstChild != null)
        text += getText(i);
    }
    return text;
  }

  function TocEntry(el, text, toclevel) {
    this.element = el;
    this.text = text;
    this.toclevel = toclevel;
  }

  function tocEntries(el, toclevels) {
    var result = new Array;
    var re = new RegExp('[hH]([1-'+(toclevels+1)+'])');
    // Function that scans the DOM tree for header elements (the DOM2
    // nodeIterator API would be a better technique but not supported by all
    // browsers).
    var iterate = function (el) {
      for (var i = el.firstChild; i != null; i = i.nextSibling) {
        if (i.nodeType == 1 /* Node.ELEMENT_NODE */) {
          var mo = re.exec(i.tagName);
          if (mo && (i.getAttribute("class") || i.getAttribute("className")) != "float") {
            result[result.length] = new TocEntry(i, getText(i), mo[1]-1);
          }
          iterate(i);
        }
      }
    }
    iterate(el);
    return result;
  }

  var toc = document.getElementById("toc");
  if (!toc) {
    return;
  }

  // Delete existing TOC entries in case we're reloading the TOC.
  var tocEntriesToRemove = [];
  var i;
  for (i = 0; i < toc.childNodes.length; i++) {
    var entry = toc.childNodes[i];
    if (entry.nodeName.toLowerCase() == 'div'
     && entry.getAttribute("class")
     && entry.getAttribute("class").match(/^toclevel/))
      tocEntriesToRemove.push(entry);
  }
  for (i = 0; i < tocEntriesToRemove.length; i++) {
    toc.removeChild(tocEntriesToRemove[i]);
  }

  // Rebuild TOC entries.
  var entries = tocEntries(document.getElementById("content"), toclevels);
  for (var i = 0; i < entries.length; ++i) {
    var entry = entries[i];
    if (entry.element.id == "")
      entry.element.id = "_toc_" + i;
    var a = document.createElement("a");
    a.href = "#" + entry.element.id;
    a.appendChild(document.createTextNode(entry.text));
    var div = document.createElement("div");
    div.appendChild(a);
    div.className = "toclevel" + entry.toclevel;
    toc.appendChild(div);
  }
  if (entries.length == 0)
    toc.parentNode.removeChild(toc);
},


/////////////////////////////////////////////////////////////////////
// Footnotes generator
/////////////////////////////////////////////////////////////////////

/* Based on footnote generation code from:
 * http://www.brandspankingnew.net/archive/2005/07/format_footnote.html
 */

footnotes: function () {
  // Delete existing footnote entries in case we're reloading the footnodes.
  var i;
  var noteholder = document.getElementById("footnotes");
  if (!noteholder) {
    return;
  }
  var entriesToRemove = [];
  for (i = 0; i < noteholder.childNodes.length; i++) {
    var entry = noteholder.childNodes[i];
    if (entry.nodeName.toLowerCase() == 'div' && entry.getAttribute("class") == "footnote")
      entriesToRemove.push(entry);
  }
  for (i = 0; i < entriesToRemove.length; i++) {
    noteholder.removeChild(entriesToRemove[i]);
  }

  // Rebuild footnote entries.
  var cont = document.getElementById("content");
  var spans = cont.getElementsByTagName("span");
  var refs = {};
  var n = 0;
  for (i=0; i<spans.length; i++) {
    if (spans[i].className == "footnote") {
      n++;
      var note = spans[i].getAttribute("data-note");
      if (!note) {
        // Use [\s\S] in place of . so multi-line matches work.
        // Because JavaScript has no s (dotall) regex flag.
        note = spans[i].innerHTML.match(/\s*\[([\s\S]*)]\s*/)[1];
        spans[i].innerHTML =
          "[<a id='_footnoteref_" + n + "' href='#_footnote_" + n +
          "' title='View footnote' class='footnote'>" + n + "</a>]";
        spans[i].setAttribute("data-note", note);
      }
      noteholder.innerHTML +=
        "<div class='footnote' id='_footnote_" + n + "'>" +
        "<a href='#_footnoteref_" + n + "' title='Return to text'>" +
        n + "</a>. " + note + "</div>";
      var id =spans[i].getAttribute("id");
      if (id != null) refs["#"+id] = n;
    }
  }
  if (n == 0)
    noteholder.parentNode.removeChild(noteholder);
  else {
    // Process footnoterefs.
    for (i=0; i<spans.length; i++) {
      if (spans[i].className == "footnoteref") {
        var href = spans[i].getElementsByTagName("a")[0].getAttribute("href");
        href = href.match(/#.*/)[0];  // Because IE return full URL.
        n = refs[href];
        spans[i].innerHTML =
          "[<a href='#_footnote_" + n +
          "' title='View footnote' class='footnote'>" + n + "</a>]";
      }
    }
  }
},

install: function(toclevels) {
  var timerId;

  function reinstall() {
    asciidoc.footnotes();
    if (toclevels) {
      asciidoc.toc(toclevels);
    }
  }

  function reinstallAndRemoveTimer() {
    clearInterval(timerId);
    reinstall();
  }

  timerId = setInterval(reinstall, 500);
  if (document.addEventListener)
    document.addEventListener("DOMContentLoaded", reinstallAndRemoveTimer, false);
  else
    window.onload = reinstallAndRemoveTimer;
}

}
asciidoc.install();
/*]]>*/
</script>
</head>
<body class="article">
<div id="header">
<h1>Freecell Solver&#8217;s Command-Line Syntax and Usage</h1>
<span id="author">Shlomi Fish</span><br />
<span id="email"><code>&lt;<a href="mailto:shlomif@cpan.org">shlomif@cpan.org</a>&gt;</code></span><br />
<span id="revnumber">version $Id$,</span>
<span id="revdate">2009-08-29</span>
</div>
<div id="content">
<div class="sect1">
<h2 id="_the_programs">The programs</h2>
<div class="sectionbody">
<div class="paragraph"><p>Most command-line switches have two versions:</p></div>
<div class="ulist"><ul>
<li>
<p>
A short POSIX one which is a dash followed by a letter or a few. This option
must come standalone and not clustered:  <code>-sam</code> is not equivalent to
specifying <code>-s</code>, <code>-a</code> and <code>-m</code>.
</p>
</li>
<li>
<p>
A long switch which is two dashes followed by the command string. For
example: <code>--prelude</code>, <code>--st-name</code>.
</p>
</li>
</ul></div>
<div class="paragraph"><p>If command line arguments have parameters, they are followed in separate
parameters - Freecell Solver won&#8217;t recognise a parameter preceded by an equal
sign. <code>--st-name=myname</code> is invalid, while <code>--st-name myname</code> is OK.</p></div>
<div class="sect2">
<h3 id="_the_scope_of_the_options">The Scope of the Options</h3>
<div class="paragraph"><p>The scope of the options is mentioned along with them. Options can be:</p></div>
<div class="olist arabic"><ol class="arabic">
<li>
<p>
Global - affects all the soft-threads.
</p>
</li>
<li>
<p>
Instance-specific - affects an instance (separated by the <code>--next-instance</code>
option below). Each instance consists of several flares.
</p>
</li>
<li>
<p>
Flare-specific - affects the current flare (separated by the <code>--next-flare</code>
option below. Each flare consists of several hard threads.
</p>
</li>
<li>
<p>
Hard-thread-specific - affects the current hard thread (separated by
the <code>--next-hard-thread</code> option below. Each hard thread consists of several
soft threads.
</p>
</li>
<li>
<p>
Soft-thread-specific - affects only the curent soft thread.
</p>
</li>
</ol></div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="_getting_help">Getting Help</h2>
<div class="sectionbody">
<div class="paragraph"><p>-h , --help</p></div>
<div class="listingblock">
<div class="content">
<pre><code>*Global*

This option displays a help text on the screen. This help gives a help
display summarizing some ways to use the program and get more help.

--version</code></pre>
</div></div>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option displays the version number of the components that make
the executable (and then exits).</p></div>
<div class="sect2">
<h3 id="_help_configs">--help-configs</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>Some help on the various configurations of Freecell Solver.</p></div>
</div>
<div class="sect2">
<h3 id="_help_options">--help-options</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>A help screen giving an overview of all available options.</p></div>
</div>
<div class="sect2">
<h3 id="_help_real_help">--help-real-help</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>Explains how to change the default help screen to a different one.</p></div>
</div>
<div class="sect2">
<h3 id="_help_short_sol">--help-short-sol</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>How to generate shorter solutions.</p></div>
</div>
<div class="sect2">
<h3 id="_help_summary">--help-summary</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>The default help screen.</p></div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="_output_options">Output Options</h2>
<div class="sectionbody">
<div class="sect2">
<h3 id="_p_parseable_output">-p , --parseable-output</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option will display the columns in a format that can be more easily
manipulated by text-processing programs such as grep or perl. Namely,
The freecells will be displayed in one line, and the foundations in a
separate line. Plus, Each column will be displayed horizontally, in its
own line, while beginning with a <code>:</code>.</p></div>
</div>
<div class="sect2">
<h3 id="_t_display_10_as_t">-t , --display-10-as-t</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option will display the 10 cards as a capital <code>T +instead of a +10</code>.
Thus, the cards will be more properly aligned.</p></div>
<div class="paragraph"><p>For example, here is a command line using <code>-p</code> and <code>-t</code>:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>$ pi-make-microsoft-freecell-board 24 | fc-solve -p -t
-=-=-=-=-=-=-=-=-=-=-=-

Foundations: H-0 C-0 D-0 S-0
Freecells:
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D AS
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H JD
: 7S 6C 7D 4D 8S 9D


====================

Foundations: H-0 C-0 D-0 S-A
Freecells:
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H JD
: 7S 6C 7D 4D 8S 9D</code></pre>
</div></div>
</div>
<div class="sect2">
<h3 id="_c_canonized_order_output">-c , --canonized-order-output</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>Freecell Solver re-arranges the stacks and freecells in a given state
according to their first card. It keeps their actual position in a
separate place, but internally it uses their canonized place. Use
this option, if you want Freecell Solver to display them in that order.
One should be warned that that way the place of a given stack in the
board will not be preserved throughout the solution.</p></div>
</div>
<div class="sect2">
<h3 id="_m_display_moves">-m , --display-moves</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option will display the moves instead of the intermediate states.
Each move will be displayed in a separate line, in a format that is
human-readable, but that can also be parsed and analyzed by a computer
program with some effort on the programmer&#8217;s part.</p></div>
<div class="paragraph"><p>For example:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>$ pi-make-microsoft-freecell-board 24 | fc-solve -m | head -30
-=-=-=-=-=-=-=-=-=-=-=-

Move a card from stack 3 to the foundations

====================

Move a card from stack 6 to freecell 0

====================

Move a card from stack 6 to freecell 1</code></pre>
</div></div>
</div>
<div class="sect2">
<h3 id="_sn_standard_notation">-sn , --standard-notation</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option will display the moves in standard notation in which every
move consists of two characters and there are ten moves in a line. Naturally,
this option will only become apparent if the display moves is specified.
(it does not implicitly specify it, though).</p></div>
<div class="paragraph"><p>For more information regarding standard notation refer to the following
web-page:</p></div>
<div class="paragraph"><p><a href="http://home.earthlink.net/~fomalhaut/freecell.html">http://home.earthlink.net/~fomalhaut/freecell.html</a></p></div>
</div>
<div class="sect2">
<h3 id="_snx_standard_notation_extended">-snx , --standard-notation-extended</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option is similar to the previous one, except that when a sequence
move is made to an empty stack with more than one card in the sequence,
the move will be followed with "v" and the number of cards moved in
hexadecimal.</p></div>
</div>
<div class="sect2">
<h3 id="_sam_display_states_and_moves">-sam , --display-states-and-moves</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option will display both the intermediate states and the moves that
are needed to move from one to another. The standard notation
option applies to it to.</p></div>
<div class="listingblock">
<div class="content">
<pre><code>$ pi-make-microsoft-freecell-board 24 | fc-solve -sam -p -t | head -50
-=-=-=-=-=-=-=-=-=-=-=-

Foundations: H-0 C-0 D-0 S-0
Freecells:
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D AS
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H JD
: 7S 6C 7D 4D 8S 9D


====================

Move a card from stack 3 to the foundations

Foundations: H-0 C-0 D-0 S-A
Freecells:
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H JD
: 7S 6C 7D 4D 8S 9D


====================

Move a card from stack 6 to freecell 0

Foundations: H-0 C-0 D-0 S-A
Freecells:  JD
: 4C 2C 9C 8C QS 4S 2H
: 5H QH 3C AC 3H 4H QD
: QC 9S 6H 9H 3S KS 3D
: 5D 2S JC 5C JH 6D
: 2D KD TH TC TD 8D
: 7H JS KH TS KC 7C
: AH 5S 6S AD 8H
: 7S 6C 7D 4D 8S 9D


====================

Move a card from stack 6 to freecell 1</code></pre>
</div></div>
</div>
<div class="sect2">
<h3 id="_pi_display_parent_iter">-pi , --display-parent-iter</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option (assuming the -s and -i options are specified) will also
display the iteration index of the state from which the current state
was derived. This is especially useful for BeFS (so-called <code>a-star</code>) or
BFS scans.</p></div>
</div>
<div class="sect2">
<h3 id="_o_filename_output_filename">-o [filename] , --output [filename]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>Outputs to a file instead of standard output. So for example:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>$ fc-solve -o 2405.solution.txt 2405.board</code></pre>
</div></div>
<div class="paragraph"><p>Will put the solution to the file in 2405.board in the file
<code>2405.solution.txt</code> . This will also be done using:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>$ fc-solve --output 2405.solution.txt 2405.board</code></pre>
</div></div>
</div>
<div class="sect2">
<h3 id="_sel_show_exceeded_limits">-sel , --show-exceeded-limits</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option will display a different status message ("Iterations count
exceeded.") instead of "I could not solve this game." in case the iterations
count was exceeded. This is recommended because the "I could not solve this
game." message can also mean that the entire game graph was fully traversed
(within the limitations of the specified moves' types) and so no solution
is possible.</p></div>
<div class="paragraph"><p>This option is not the default, to retain compatibility with previous versions
of Freecell Solver, and was added in version 3.12.0 of fc-solve.</p></div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="_game_variants_options">Game Variants Options</h2>
<div class="sectionbody">
<div class="sect2">
<h3 id="_freecells_num_number_of_freecells">--freecells-num [Number of Freecells]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option specifies the number of freecells which are available to
the program. Freecell Solver can use any number of freecells as long as
it does not exceed its maximal number.</p></div>
<div class="paragraph"><p>This maximum is hard-coded into the program, and can be specified at
compile-time by modifying the file <code>config.h</code>. See the file <code>INSTALL</code>
(or alternatively <code>INSTALL.html</code>) for details.</p></div>
</div>
<div class="sect2">
<h3 id="_stacks_num_number_of_stacks">--stacks-num [Number of Stacks]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option specifies the number of stacks present in the board. Again,
this number cannot exceed the maximal number of stacks, which can be
specified in the file <code>config.h</code> during compile-time of Freecell
Solver.</p></div>
</div>
<div class="sect2">
<h3 id="_decks_num_number_of_decks">--decks-num [Number of Decks]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This options specifies how many decks are found in the board. This number
cannot exceed the maximal number of decks, which can be specified by the
Freecell Solver build system.</p></div>
</div>
<div class="sect2">
<h3 id="_sequences_are_built_by_suit_alternate_color_rank">--sequences-are-built-by {suit|alternate_color|rank}</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option specifies whether a card sequence is built by suit or by
alternate colour or by rank regardless of suit.</p></div>
</div>
<div class="sect2">
<h3 id="_sequence_move_limited_unlimited">--sequence-move {limited|unlimited}</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option specifies whether the sequence move is limited by the
number of freecells or vacant stacks or not.</p></div>
</div>
<div class="sect2">
<h3 id="_empty_stacks_filled_by_kings_none_all">--empty-stacks-filled-by {kings|none|all}</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>Specifies which cards can fill an empty stack.</p></div>
</div>
<div class="sect2">
<h3 id="_game_game_preset_game_g_game">--game [game] , --preset [game] , -g [game]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>Specifies the type of game. Each preset implies several of the
settings options above and sometimes even the tests order below. The
default configuration is for Freecell.</p></div>
<div class="paragraph"><p>Available presets:</p></div>
<div class="tableblock">
<table rules="all"
width="50%"
frame="border"
cellspacing="0" cellpadding="4">
<col width="50%" />
<col width="50%" />
<tbody>
<tr>
<td align="left" valign="top"><p class="table"><code>bakers_dozen</code></p></td>
<td align="left" valign="top"><p class="table">Baker&#8217;s Dozen</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>bakers_game</code></p></td>
<td align="left" valign="top"><p class="table">Baker&#8217;s Game</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>beleaguered_castle</code></p></td>
<td align="left" valign="top"><p class="table">Beleaguered Castle</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>citadel</code></p></td>
<td align="left" valign="top"><p class="table">Citadel</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>cruel</code></p></td>
<td align="left" valign="top"><p class="table">Cruel</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>der_katz</code></p></td>
<td align="left" valign="top"><p class="table">Der Katzenschwanz</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>die_schlange</code></p></td>
<td align="left" valign="top"><p class="table">Die Schlange</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>eight_off</code></p></td>
<td align="left" valign="top"><p class="table">Eight Off</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>fan</code></p></td>
<td align="left" valign="top"><p class="table">Fan</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>forecell</code></p></td>
<td align="left" valign="top"><p class="table">Forecell</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>freecell</code></p></td>
<td align="left" valign="top"><p class="table">Freecell (default)</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>good_measure</code></p></td>
<td align="left" valign="top"><p class="table">Good Measure</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>ko_bakers_game</code></p></td>
<td align="left" valign="top"><p class="table">Kings' Only Baker&#8217;s Game</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>relaxed_freecell</code></p></td>
<td align="left" valign="top"><p class="table">Relaxed Freecell</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>relaxed_sehaven</code></p></td>
<td align="left" valign="top"><p class="table">Relaxed Seahaven Towers</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>seahaven</code></p></td>
<td align="left" valign="top"><p class="table">Seahaven Towers</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>simple_simon</code></p></td>
<td align="left" valign="top"><p class="table">Simple Simon</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>streets_and_alleys</code></p></td>
<td align="left" valign="top"><p class="table">Streets and Alleys</p></td>
</tr>
</tbody>
</table>
</div>
<div class="paragraph"><p>Note: in order to solve Der Katzenschwanz and Die Schlange I recommend you
compile Freecell Solver with the INDIRECT_STACK_STATES option, or else it will
consume much more memory. For details consult the file INSTALL.</p></div>
</div>
<div class="sect2">
<h3 id="_examples">Examples</h3>
<div class="paragraph"><p>To solve PySol Eight Off game No. 1,000 type:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>$ make_pysol_freecell_board.py 1000 eight_off | fc-solve -g eight_off</code></pre>
</div></div>
<div class="paragraph"><p>To solve PySol Baker&#8217;s Game No. 50, type:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>$ make_pysol_freecell_board.py 50 bakers_game | fc-solve -g bakers_game</code></pre>
</div></div>
<div class="paragraph"><p>If you want to solve a game similar to Freecell only with sequences built
by rank, and unlimited sequence move, do:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>$ fc-solve -g freecell --sequences-are-built-by rank --sequence-move unlimited</code></pre>
</div></div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="_solving_algorithm_options">Solving Algorithm Options</h2>
<div class="sectionbody">
<div class="sect2">
<h3 id="_mi_iterations_num_max_iters_iterations_num">-mi [Iterations num] , --max-iters [Iterations num]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This parameter limits the maximal number of states to check. This will
give a rough limit on the time spent to solve a given board.</p></div>
</div>
<div class="sect2">
<h3 id="_md_maximal_depth_max_depth_maximal_depth">-md [Maximal depth] , --max-depth [Maximal depth]</h3>
<div class="paragraph"><p><strong>Not currently implemented</strong></p></div>
<div class="paragraph"><p>Freecell Solver recurses into the solution. This parameter specifies a
maximal recursion depth. Generally speaking, it&#8217;s not a good idea to
set it, because that way several important intermediate states may become
inaccessible.</p></div>
</div>
<div class="sect2">
<h3 id="_mss_num_max_stored_states_num">-mss [num] , --max-stored-states [num]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>Limits the number of the states stored by the program in the computer&#8217;s
memory. This differs from the maximal number of iterations in the sense, that
it is possible that a stored state was not checked yet.</p></div>
</div>
<div class="sect2">
<h3 id="_tmss_num_trim_max_stored_states_num">-tmss [num] , --trim-max-stored-states [num]</h3>
<div class="paragraph"><p><strong>Instance-wide</strong></p></div>
<div class="paragraph"><p>This also limits the number of trimmed stored states, but this time will
try to trim them once the limit has been reached (which is time consuming
and may cause states to be traversed again in the future).</p></div>
</div>
<div class="sect2">
<h3 id="_to_test_8217_s_order_tests_order_test_8217_s_order">-to [Test&#8217;s Order] , --tests-order [Test&#8217;s Order]</h3>
<div class="paragraph"><p><strong>Soft-thread-specific</strong></p></div>
<div class="paragraph"><p>This option specifies the order in which Freecell Solver will try the
different types of moves that it can perform. Each move is specified by
one character, and they are performed in the order in which they appear
in the parameter string. You can omit tests by not including their
corresponding characters in the string.</p></div>
<div class="paragraph"><p>The tests along with their characters are:</p></div>
<div class="tableblock">
<table rules="all"
width="80%"
frame="border"
cellspacing="0" cellpadding="4">
<col width="9%" />
<col width="90%" />
<tbody>
<tr>
<td colspan="2" align="left" valign="top"><p class="table">Freecell Tests:</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>0</em></p></td>
<td align="left" valign="top"><p class="table">put top stack cards in the foundations.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>1</em></p></td>
<td align="left" valign="top"><p class="table">put freecell cards in the foundations.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>2</em></p></td>
<td align="left" valign="top"><p class="table">put freecell cards on top of stacks.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>3</em></p></td>
<td align="left" valign="top"><p class="table">put non-top stack cards in the foundations.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>4</em></p></td>
<td align="left" valign="top"><p class="table">move stack cards to different stacks.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>5</em></p></td>
<td align="left" valign="top"><p class="table">move stack cards to a parent card on the same stack.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>6</em></p></td>
<td align="left" valign="top"><p class="table">move sequences of cards onto free stacks.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>7</em></p></td>
<td align="left" valign="top"><p class="table">put freecell cards on empty stacks.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>8</em></p></td>
<td align="left" valign="top"><p class="table">move cards to a different parent.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>9</em></p></td>
<td align="left" valign="top"><p class="table">empty an entire stack into the freecells.</p></td>
</tr>
<tr>
<td colspan="2" align="left" valign="top"><p class="table">Atomic Freecell Tests:</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>A</em></p></td>
<td align="left" valign="top"><p class="table">move a stack card to an empty stack.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>B</em></p></td>
<td align="left" valign="top"><p class="table">move a stack card to a parent on a different stack.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>C</em></p></td>
<td align="left" valign="top"><p class="table">move a stack card to a freecell.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>D</em></p></td>
<td align="left" valign="top"><p class="table">move a freecell card to a parent.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>E</em></p></td>
<td align="left" valign="top"><p class="table">move a freecell card to an empty stack.</p></td>
</tr>
<tr>
<td colspan="2" align="left" valign="top"><p class="table">Simple Simon Tests:</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>a</em></p></td>
<td align="left" valign="top"><p class="table">move a full sequence to the foundations.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>b</em></p></td>
<td align="left" valign="top"><p class="table">move a sequence to a true parent of his.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>c</em></p></td>
<td align="left" valign="top"><p class="table">move a whole stack sequence to a false parent (in order to clear the stack)</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>d</em></p></td>
<td align="left" valign="top"><p class="table">move a sequence to a true parent that has some cards above it.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>e</em></p></td>
<td align="left" valign="top"><p class="table">move a sequence with some cards above it to a true parent.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>f</em></p></td>
<td align="left" valign="top"><p class="table">move a sequence with a junk sequence above it to a true parent that
has some cards above it.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>g</em></p></td>
<td align="left" valign="top"><p class="table">move a whole stack sequence to a false parent which has some
cards above it.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>h</em></p></td>
<td align="left" valign="top"><p class="table">move a sequence to a parent on the same stack.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><em>i</em></p></td>
<td align="left" valign="top"><p class="table">move any sequence to a false parent (using it may make the solution
much slower).</p></td>
</tr>
</tbody>
</table>
</div>
<div class="paragraph"><p>Manipulating the tests order can be very helpful to the quick solution
of a given board. If you found that a certain board cannot be solved in
after a long time or in a certain maximal number of iterations, you
should try different tests' orders. Usually, one can find a test order
that solves a board very quickly.</p></div>
<div class="paragraph"><p>Note that this test order usually makes sense only for the Soft-DFS
and Random DFS scans (see the <code>--method</code> option below).</p></div>
<div class="paragraph"><p>Also note that Freecell tests are not suitable for solving Simple Simon games
and Simple Simon tests are not suitable for solving anything except Simple
Simon.</p></div>
<div class="paragraph"><p>Tests can be grouped together into groups using parenthesis
(e.g: "(0123)") or square brackets ("[012][3456789]"). Such grouping is
only relevant to the Random DFS scan (see below). A group may optionally
be followed by the equal sign "=" and by an ordering specifier. If one
specifies "=rand()", then the derived states will be randomised based on the
seed (which is what happens if no equal sign is specified). On the other
hand, if one specifies something like "=asw(5,0,5,0,0,5)", then the numbers
inside the parentheses will be treated as weights for the same ordering
function used by the <code>-asw</code> flag (see below).</p></div>
</div>
<div class="sect2">
<h3 id="_dto_min_depth_tests_order_depth_tests_order_min_depth_tests_order">-dto [Min Depth],[Tests' Order] , --depth-tests-order [Min Depth],[Tests' Order]</h3>
<div class="paragraph"><p><strong>Soft-thread-specific</strong></p></div>
<div class="paragraph"><p>Sets the Tests' order starting from the minimal depth onwards. This way, if
a Soft-DFS scan recurses deeply into the game, it will use a different tests'
order.</p></div>
<div class="paragraph"><p>Note that if you set the tests' order of a minimal depth of say 50, then it
will override all the tests' order of 50 and above. As a result, it is
recommended that you set the minimal depth tests order in an increasing
depth.</p></div>
<div class="paragraph"><p>It should be noted that the <code>-to</code> or <code>--tests-order</code> option above is
equivalent to using this option with a minimal depth of 0.</p></div>
<div class="paragraph"><p>Here are some examples:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>-to 0123456789 -dto 30,0138924567</code></pre>
</div></div>
<div class="paragraph"><p>This sets the tests' order to <code>0123456789</code> for all depths below 30 and to
<code>0138924567</code> for all depths above it.</p></div>
<div class="listingblock">
<div class="content">
<pre><code>-to 0123457 -dto 10,750123 -dto 25,710235</code></pre>
</div></div>
<div class="paragraph"><p>This sets the tests' order to <code>0123457</code> for depths -9 (those below 10),
to <code>750123</code> for depths 10-24, and to <code>710235</code> for the depths 25 onwards.</p></div>
<div class="listingblock">
<div class="content">
<pre><code>-to 0123457 -dto "10,[012357]=asw(1)"</code></pre>
</div></div>
<div class="paragraph"><p>This sorts the tests starting from 10 onward based on the asw() function.</p></div>
<div class="listingblock">
<div class="content">
<pre><code>-to 0123457 -dto "10,[012357]=rand()"</code></pre>
</div></div>
<div class="paragraph"><p>This randomises the tests from 10 onward.</p></div>
<div class="listingblock">
<div class="content">
<pre><code>-to 0123457 -dto "10,[012357]"</code></pre>
</div></div>
<div class="paragraph"><p>This does the same thing as the previous example.</p></div>
</div>
<div class="sect2">
<h3 id="_me_solving_method_method_solving_method">-me [Solving Method] , --method [Solving Method]</h3>
<div class="paragraph"><p><strong>Soft-thread-specific</strong></p></div>
<div class="paragraph"><p>This option specifies the solving method that will be used to solve the
board. Currently, the following methods are available:</p></div>
<div class="ulist"><ul>
<li>
<p>
<code>a-star</code> - A Best-First-Search scan (not "A*" as it was once thought to be)
</p>
</li>
<li>
<p>
<code>bfs</code> - A Breadth-First Search (or BFS) scan
</p>
</li>
<li>
<p>
<code>dfs</code> - A Depth-First Search (or DFS) scan
</p>
</li>
<li>
<p>
<code>random-dfs</code> - A randomized DFS scan
</p>
</li>
<li>
<p>
<code>soft-dfs</code> - A "soft" DFS scan
</p>
</li>
</ul></div>
<div class="paragraph"><p>Starting from recent Freecell Solver versions there is no difference between
<code>dfs</code> and <code>soft-dfs</code>. In earlier versions, use of <code>soft-dfs</code> is recommended.
<code>random-dfs</code> is similar to <code>soft-dfs</code> only it determines to which states to
recurse into randomly. Its behaviour will differ depending on the seed you
supply to it.  (see the "-seed" option below.)</p></div>
<div class="paragraph"><p>BFS does not yield good results, and <code>a-star</code> has a mixed behaviour, so for
the time being I recommend using Soft-DFS or Andom-DFS.</p></div>
<div class="paragraph"><p>The Random-DFS scan processes every tests' random group, randomizes the
states that it found and recurses into them one by one. Standalone tests
that do not belong to any group, are processed in a non-random manner.</p></div>
</div>
<div class="sect2">
<h3 id="_asw_befs_weights_a_star_weight_befs_weights">-asw [BeFS Weights] , --a-star-weight [BeFS Weights]</h3>
<div class="paragraph"><p><strong>Soft-thread-specific</strong></p></div>
<div class="paragraph"><p>Specify weights for the <code>a-star</code> (= "Best-First Search") scan, assuming it is
used. The parameter should be a comma-separated list of numbers, each one is
proportional to the weight of its corresponding test.</p></div>
<div class="paragraph"><p>The numbers are, in order:</p></div>
<div class="olist arabic"><ol class="arabic">
<li>
<p>
The number of cards out.
</p>
</li>
<li>
<p>
The maximal sequence move.
</p>
</li>
<li>
<p>
The number of cards under sequences.
</p>
</li>
<li>
<p>
The length of the sequences which are found over renegade cards.
</p>
</li>
<li>
<p>
The depth of the board in the solution.
</p>
</li>
<li>
<p>
The negative of the number of cards that are not placed above their
parents. To get the irreversibility depth, give equal weight to this weight
and to the number of cards out.
</p>
</li>
</ol></div>
<div class="paragraph"><p>The default weights are respectively: {0.5, 0, 0.3, 0, 0.2, 0}</p></div>
</div>
<div class="sect2">
<h3 id="_seed_seed_number">-seed [Seed Number]</h3>
<div class="paragraph"><p><strong>Soft-thread-specific</strong></p></div>
<div class="paragraph"><p>Specifies a seed to be used by Freecell Solver&#8217;s internal random number
generator. This seed may alter the behaviour and speed of the <code>random-dfs</code>
scan.</p></div>
</div>
<div class="sect2">
<h3 id="_set_pruning_pruning_sp_pruning">--set-pruning [Pruning] , -sp [Pruning]</h3>
<div class="paragraph"><p><strong>Soft-thread-specific</strong></p></div>
<div class="paragraph"><p>This option sets the pruning algorithm for the soft thread. Current valid
values are only the empty string (<code>""</code>) for no pruning and <code>r:tf</code> (short
for "Run: to foundations") for Horne&#8217;s rule. See:</p></div>
<div class="paragraph"><p><a href="http://tech.groups.yahoo.com/group/fc-solve-discuss/message/214">http://tech.groups.yahoo.com/group/fc-solve-discuss/message/214</a></p></div>
</div>
<div class="sect2">
<h3 id="_opt_optimize_solution">-opt , --optimize-solution</h3>
<div class="paragraph"><p><strong>Flare-wide</strong></p></div>
<div class="paragraph"><p>This option instructs Freecell Solver to try and optimize the solution
path so it will have a smaller number of moves.</p></div>
</div>
<div class="sect2">
<h3 id="_opt_to_tests_order_optimization_tests_order_tests_order">-opt-to [tests order] , --optimization-tests-order [tests order]</h3>
<div class="paragraph"><p><strong>Flare-wide</strong></p></div>
<div class="paragraph"><p>This argument specifies the test order for the optimization scan, in case
it should be different than an order that contains all the tests that were
used in all the normal scans.</p></div>
</div>
<div class="sect2">
<h3 id="_reparent_states">--reparent-states</h3>
<div class="paragraph"><p><strong>Flare-wide</strong></p></div>
<div class="paragraph"><p>This option specifies that states that were encountered whose depth in the
states graph can be improved should be reparented to the new parent. This
option can possibly make solutions shorter.</p></div>
</div>
<div class="sect2">
<h3 id="_calc_real_depth">--calc-real-depth</h3>
<div class="paragraph"><p><strong>Flare-wide</strong></p></div>
<div class="paragraph"><p>This option becomes effective only if <code>--reparent-states</code> is specified. What
it does, is explicitly calculate the depth of the state by tracing its path
to the initial state. This may make depth consideration more accurate.</p></div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="_running_several_scans_in_parallel">Running Several Scans in Parallel</h2>
<div class="sectionbody">
<div class="paragraph"><p>Starting from Version 2.4.0, Freecell Solver can run several scans in
parallel on the same state collection. Each scan resides in its own
"Soft Thread". By specifying several soft threads on the command line
one can create use several parallel scans. Once one of the scans
reaches a solution, the solution will be displayed.</p></div>
<div class="sect2">
<h3 id="_nst_next_soft_thread">-nst , --next-soft-thread</h3>
<div class="paragraph"><p><strong>Hard-thread-specific</strong></p></div>
<div class="paragraph"><p>This option creates a new soft-thread and makes the following scan-specific
options initialize it. For example:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>$ fc-solve --method a-star -nst --method soft-dfs -to 0123467 myboard.txt</code></pre>
</div></div>
<div class="paragraph"><p>will run an BeFS scan and a Soft-DFS scan with a tests order of 0123467 on
myboard.txt.</p></div>
</div>
<div class="sect2">
<h3 id="_step_step_soft_thread_step_step">-step [Step] , --soft-thread-step [Step]</h3>
<div class="paragraph"><p><strong>Soft-thread-specific</strong></p></div>
<div class="paragraph"><p>This option will set the number of iterations with which to run the
soft thread before switching to the next one. By specifying a larger
step, one can give a certain scan a longer run-time and a higher priority.</p></div>
<div class="paragraph"><p><strong>Note:</strong> after some experimentation, we have concluded that the <code>--prelude</code>
option normally yields better results, but <code>-step</code> can be used as a fallback.</p></div>
</div>
<div class="sect2">
<h3 id="_nht_next_hard_thread">-nht , --next-hard-thread</h3>
<div class="paragraph"><p><strong>Flare-wide</strong></p></div>
<div class="paragraph"><p>This argument lets one initialize the next hard thread. If Freecell Solver was
compiled with such support, then it is possible to run each hard thread in its
own system thread. Each hard-thread contains one or more soft threads.</p></div>
</div>
<div class="sect2">
<h3 id="_st_name_soft_thread_name">--st-name [soft thread name]</h3>
<div class="paragraph"><p><strong>Soft-thread-specific</strong></p></div>
<div class="paragraph"><p>This argument sets the name used to identify the current soft thread. This name
can later be used to construct the prelude (see below).</p></div>
</div>
<div class="sect2">
<h3 id="_prelude_i1_st1_i2_st2_i3_st3_8230">--prelude [i1@st1{,i2@st2{,i3@st3&#8230;}}]</h3>
<div class="paragraph"><p><strong>Hard-thread-specific</strong></p></div>
<div class="paragraph"><p>Sets the prelude for the hard thread. At the beginning of the search, the
hard thread plays a static sequence of iterations at each of the soft threads
specified in the prelude, for the number of iterations specified.</p></div>
<div class="paragraph"><p>For example, if you had three soft threads named "foo", "bar" and "rin", then
the following prelude:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>--prelude 500@foo,1590@bar,100@foo,200@rin</code></pre>
</div></div>
<div class="paragraph"><p>Will run 500 iterations in "foo", then 1590 in "bar", then 100 in "foo" again,
and then 200 in "rin". After the prelude finishes, the hard thread would
run the scans one after the other in the sequence they were defined for their
step number.</p></div>
</div>
<div class="sect2">
<h3 id="_scans_synergy_none_dead_end_marks">--scans-synergy {none|dead-end-marks}</h3>
<div class="paragraph"><p><strong>Flare-wide</strong></p></div>
<div class="paragraph"><p>Specifies the synergy between the various scans, or how much they cooperate
between themselves. <code>none</code> means they do not cooperate and only share
the same memory resources. <code>dead-end-marks</code> means they try to mark states
that they have withdrawn from, and states whose all their derived states are
such, as "dead ends". This may or may not improve the speed of the solution.</p></div>
</div>
<div class="sect2">
<h3 id="_ni_next_instance">-ni , --next-instance</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option allows to run two or more separate solvers one after the
other. If the first one returned an unsolvable verdict, then the second
one would run and so on. One use of it is to run an atomic moves scan
after a meta-moves scan, so we will always get an accurate verdict and
still enjoy some of the speed of the meta-moves scan.</p></div>
</div>
<div class="sect2">
<h3 id="_nf_next_flare">-nf , --next-flare</h3>
<div class="paragraph"><p><strong>Instance-wide</strong></p></div>
<div class="paragraph"><p>Each instance contains several flares. Flares are various alternative scans,
that are ran one after another, as specified in the <code>--flares-plan</code> below
or defaulting to running only the first flare (which isn&#8217;t very useful). Out
of all the flares that are successful in solving a board, Freecell Solver
picks the one with the shortest solution.</p></div>
</div>
<div class="sect2">
<h3 id="_flare_name_flare_name">--flare-name [flare name]</h3>
<div class="paragraph"><p><strong>Flare-wide</strong></p></div>
<div class="paragraph"><p>This is a name that identifies the flare for use in the flares' plan.</p></div>
</div>
<div class="sect2">
<h3 id="_flares_plan_flare_plan">--flares-plan [flare plan]</h3>
<div class="paragraph"><p><strong>Instance-wide</strong></p></div>
<div class="paragraph"><p>This instance-wide parameter gives a plan for the flares as a big string. Here
are some examples:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>--flares-plan "RunIndef:FlareyFlare"</code></pre>
</div></div>
<div class="paragraph"><p>This plan will run the flare with the name <code>FlareyFlare</code> indefinetely, until it
terminates. Once a RunIndef action is encountered, the rest of the plan is
ignored.</p></div>
<div class="listingblock">
<div class="content">
<pre><code>--flares-plan "Run:500@MyFlare,Run:2000@FooFlare"</code></pre>
</div></div>
<div class="paragraph"><p>Runs <code>MyFlare</code> for 500 iterations and <code>FooFlare</code> for 2,000
iterations. Note that both flares will be run and won&#8217;t share any resources
between them, and then the minimal solution out of both flares (or only
those that finished ). If no flares finished, then Freecell Solver will run
them both again for the same number of iterations each, until at least one
finishes (or it ran out of the iterations' limit).</p></div>
<div class="listingblock">
<div class="content">
<pre><code>--flares-plan "Run:500@dfs,Run:1500@befs,CP:,Run:10000@funky"</code></pre>
</div></div>
<div class="paragraph"><p>This runs the flares identified by <code>dfs</code> and <code>befs</code> and then see if a solution
was reached ("CP:" stands for <strong>"checkpoint"</strong>), and if so yield it. If both
flares did not reach a solution yet, or failed to solve the board, it will run
the flare <code>funky</code> for 10,000 iterations and yield its solution. And like the
previous case, this solution will loop after it ended for as long as the
no flare solved the board or the program did not run out of iterations.</p></div>
<div class="paragraph"><p>Using checkpoints one can yield a possibly sub-optimal (as far as solution
length is concerned) solution that will still solve faster than letting all
the flares run.</p></div>
</div>
<div class="sect2">
<h3 id="_flares_choice_choice">--flares-choice [choice]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This dictates how to choose the winning flare based on if more than one yielded
a solution. Possible options are:</p></div>
<div class="olist arabic"><ol class="arabic">
<li>
<p>
<code>--flares-choice fc_solve</code> - the default, which picks up the solutions based
on the length of the solution in Freecell Solver&#8217;s moves.
</p>
</li>
<li>
<p>
<code>--flares-choice fcpro</code> - picks up the shortest solution based on the
number of Freecell Pro moves, while not considering implicit moves to the
foundations using Horne&#8217;s Prune / Raymond Prune.
</p>
</li>
</ol></div>
</div>
<div class="sect2">
<h3 id="_fif_factor_flares_iters_factor_factor">-fif [factor] , --flares-iters-factor [factor]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>Sets a global, floating-point number, factor to multiply all the iterations
counts in the flares plans. The higher it is, the longer the scans will take,
but there is a greater chance more of them will succeed, and, as a result,
the solution may be shorter.</p></div>
<div class="paragraph"><p>As an example, the following:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>--flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 2</code></pre>
</div></div>
<div class="paragraph"><p>Is equivalent to:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>--flares-plan "Run:1000@MyFlare,Run:4000@FooFlare"</code></pre>
</div></div>
<div class="paragraph"><p>while:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>--flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 0.5</code></pre>
</div></div>
<div class="paragraph"><p>Is equivalent to:</p></div>
<div class="listingblock">
<div class="content">
<pre><code>--flares-plan "Run:250@MyFlare,Run:1000@FooFlare"</code></pre>
</div></div>
</div>
<div class="sect2">
<h3 id="_cache_limit_cache_limit">--cache-limit [cache limit]</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This is a numeric limit to the LRU cache which only matters if Freecell
Solver was compiled with <code>FCS_RCS_STATES</code> enabled. This value should be
a positive integer and the higher it is, the more quickly it is likely
that Freecell Solver will run, but it will also consume more memory. (The
entire point of <code>FCS_RCS_STATES</code> is to conserve memory).</p></div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="_meta_options">Meta-Options</h2>
<div class="sectionbody">
<div class="sect2">
<h3 id="_reset">--reset</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option resets the program to its initial state, losing all the
configuration logic that was inputted to it up to that state. Afterwards,
it can be set to a different configuration, again.</p></div>
</div>
<div class="sect2">
<h3 id="_read_from_file_num_skip_filename">--read-from-file [num_skip,]filename</h3>
<div class="paragraph"><p><strong>Global</strong> (but context-specific).</p></div>
<div class="paragraph"><p>This option will read the configuration options from a file. The format
of the file is similar to that used by the UNIX Bourne Shell. (i.e:
spaces denote separate arguments, double-quotes encompass arguments,
backslash escapes characters).</p></div>
<div class="paragraph"><p>The filename can be preceeded by an optional number of the arguments to
skip followed by a comma. (the default is 0)</p></div>
</div>
<div class="sect2">
<h3 id="_l_preset_load_config_preset">-l [preset] , --load-config [preset]</h3>
<div class="paragraph"><p><strong>Global</strong> (but context-specific).</p></div>
<div class="paragraph"><p>Reads the configuration specified by [preset] and configures the solver
accordingly. A preset is a set of command line arguments to be analyzed
in the place of this option. They are read from a set of presetrc files
: one installed system-wide, the other at $HOME/.freecell-solver/presetrc
and the third at the path specified by the FREECELL_SOLVER_PRESETRC
environment variable. You can add more presets at any of these places.
(refer to <a href="http://groups.yahoo.com/group/fc-solve-discuss/message/403">http://groups.yahoo.com/group/fc-solve-discuss/message/403</a>
for information about their format)</p></div>
<div class="paragraph"><p>Presets that are shipped with Freecell Solver:</p></div>
<div class="tableblock">
<table rules="all"
width="100%"
frame="border"
cellspacing="0" cellpadding="4">
<col width="20%" />
<col width="80%" />
<tbody>
<tr>
<td align="left" valign="top"><p class="table"><code>abra-kadabra</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>amateur-star</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset that yields solutions
faster on average than <code>three-eighty</code>.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>blue-yonder</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset generated by a
quota optimization algorithm.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>children-playing-ball</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves and flare-based preset that tends
to yield very short solution, but is very slow (solves only 3 boards per
second on a Pentium 4 2.4GHz).</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>cool-jives</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>crooked-nose</code></p></td>
<td align="left" valign="top"><p class="table">an atomic-moves preset (guarantees an
            accurate verdict)</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>enlightened-ostrich</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset (that depends on Freecell
Solver 3.4.0 and above) that yields solutions faster on average than
<code>foss-nessy</code>.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>fools-gold</code></p></td>
<td align="left" valign="top"><p class="table">an atomic-moves preset</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>foss-nessy</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset (that depends on Freecell
Solver 3.2.0 and above) that yields solutions faster on average than
<code>the-iglu-cabal</code>.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>good-intentions</code></p></td>
<td align="left" valign="top"><p class="table">runs "cool-jives" and then "fools-gold"</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>gooey-unknown-thing</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset that aims to minimise
            the outcome solution&#8217;s length.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>hello-world</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>john-galt-line</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>maliciously-obscure</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves and flare-based preset that tends
to yield very short solutions (even in comparison to <code>children-playing-ball</code>
) but is slow.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>micro-finance</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves and flare-based preset that tends
to yield very short solutions (even in comparison to <code>maliciously-obscure</code>
) but is even slower.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>micro-finance-improved</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves and flare-based preset, based
on <code>micro-finance</code> that yields somewhat shorter solutions on average, and
should not be slower.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>qualified-seed</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves and flare-based preset, based
on <code>micro-finance-improved</code> that yields somewhat shorter solutions on average,
and should not be slower.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>qualified-seed-improved</code></p></td>
<td align="left" valign="top"><p class="table"><code>qualified-seed</code> with <code>-fif 5</code> and
<code>--flares-choice fcpro</code></p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>rin-tin-tin</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>sand-stone</code></p></td>
<td align="left" valign="top"><p class="table">an atomic-moves preset that aims to
            minimise the outcome solution&#8217;s length.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>slick-rock</code></p></td>
<td align="left" valign="top"><p class="table">run "gooey-unknown-thing" and then "sand-stone"</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>sentient-pearls</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves and flares based preset with
short solutions. Much faster than <code>children-playing-ball</code> but yields less
optimal solutions.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>tea-for-two</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset optimized for
two-freecells' Freecell games (although it can work on other Freecell-like
games as well).</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>the-iglu-cabal</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset that yields faster
solutions on average than <code>blue-yonder</code>.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>the-last-mohican</code></p></td>
<td align="left" valign="top"><p class="table">a preset for solving Simple Simon. Yields
            less false negatives than the default one, but might be slower.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>three-eighty</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset (that depends on Freecell
Solver 3.4.0 and above) that yields solutions faster on average than
<code>enlightened-ostrich</code>.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>toons-for-twenty-somethings</code></p></td>
<td align="left" valign="top"><p class="table">an atomic-moves preset that solves
            more boards efficiently than "fools-gold".</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>video-editing</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves and flare-based preset, based
on <code>qualified-seed</code> that yields shorter solutions on average, but may be
somewhat slower. Named to commemorate the earlier work of
<a href="http://en.wikipedia.org/wiki/Adrian_Ettlinger">Adrian Ettlinger (1925-2013)</a>
who later contributed to Freecell Solver and to Freecell research.</p></td>
</tr>
<tr>
<td align="left" valign="top"><p class="table"><code>yellow-brick-road</code></p></td>
<td align="left" valign="top"><p class="table">a meta-moves preset</p></td>
</tr>
</tbody>
</table>
</div>
<div class="paragraph"><p>They can be abbreviated into their lowercase acronym (i.e: "ak" or "rtt").</p></div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="_run_time_display_options">Run-time Display Options</h2>
<div class="sectionbody">
<div class="sect2">
<h3 id="_i_iter_output">-i , --iter-output</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option tells fc-solve to print the iteration number and the
recursion depth of every state which is checked, to the standard
output. It&#8217;s a good way to keep track of how it&#8217;s doing, but the output
slows it down a bit.</p></div>
</div>
<div class="sect2">
<h3 id="_s_state_output">-s , --state-output</h3>
<div class="paragraph"><p><strong>Global</strong></p></div>
<div class="paragraph"><p>This option implies -i. If specified, this option outputs the cards and
formation of the board itself, for every state that is checked.
"fc-solve -s" yields a nice real-time display of the progress of
Freecell Solver, but you usually cannot make what is going on because
it is so fast.</p></div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="_signal_combinations">Signal Combinations</h2>
<div class="sectionbody">
<div class="paragraph"><p>If you are working on a UNIX or a similar system then you can set some
run-time options in "fc-solve" by sending it some signal
combinations.</p></div>
<div class="paragraph"><p>If you send the fc-solve a single ABRT signal, then fc-solve will terminate
the scan prematurely, and report that the iterations’s limit has been
exceeded.</p></div>
<div class="paragraph"><p>If you send the signal USR1, without sending any other signals before
that, then <code>fc-solve</code> will output the present number of
iterations. This method is a good way to monitor an instance that takes
a long time to solve.</p></div>
<div class="paragraph"><p>If you send it the signal USR2 and then USR1, then <code>fc-solve</code>
will print the iteration number and depth on every state that it
checks. It is the equivalent of specifying (or unspecifying) the
option -i/--iter-output.</p></div>
<div class="paragraph"><p>If you send it two USR2 signals and then USR1, then <code>fc-solve</code>
will also print the board of every state. Again, this will only be done
assuming the iteration output is turned on.</p></div>
</div>
</div>
</div>
<div id="footnotes"><hr /></div>
<div id="footer">
<div id="footer-text">
Version $Id$<br />
Last updated 2014-03-05 08:18:42 IST
</div>
</div>
</body>
</html>