<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd">
<?asciidoc-toc?>
<?asciidoc-numbered?>
<refentry lang="en">
<refentryinfo>
    <title>fc-solve(6)</title>
    <date>2009-08-29</date>
    <author>
        <firstname>Shlomi</firstname>
        <surname>Fish</surname>
        <email>shlomif@cpan.org</email>
    </author>
    <authorinitials>SF</authorinitials>
<revhistory><revision><revnumber>$Id$</revnumber><date>2009-08-29</date><authorinitials>SF</authorinitials></revision></revhistory>
</refentryinfo>
<refmeta>
<refentrytitle>fc-solve</refentrytitle>
<manvolnum>6</manvolnum>
<refmiscinfo class="source">&#160;</refmiscinfo>
<refmiscinfo class="manual">&#160;</refmiscinfo>
<refmiscinfo class="version">$Id$</refmiscinfo>
</refmeta>
<refnamediv>
    <refname>fc-solve</refname>
    <refpurpose>automated solver for Freecell and related Solitiare variants</refpurpose>
</refnamediv>
<refsect1 id="_introduction">
<title>Introduction</title>
<simpara>This is Freecell Solver version 3.12.x, a program that automatically
solves most layouts of Freecell, and similar Solitaire variants as
well as those of Simple Simon.</simpara>
<simpara>Freecell Solver is distributed under the MIT/X11 License
( <ulink url="http://en.wikipedia.org/wiki/MIT_License">http://en.wikipedia.org/wiki/MIT_License</ulink> ), a free, permissive,
public-domain like, open-source license.</simpara>
<simpara>Note that the Freecell Solver source and Win32 binary distributions <emphasis role="strong">do not</emphasis>
provide a graphical user-interface (GUI) and are primarily meant to be used
by Solitaire researchers and software developers. If you&#8217;re looking for a
suitable GUI based on Freecell Solver, see our links at:</simpara>
<simpara><ulink url="http://fc-solve.shlomifish.org/links.html#front_ends">http://fc-solve.shlomifish.org/links.html#front_ends</ulink></simpara>
<simpara>I hope you&#8217;ll enjoy using Freecell Solver, and make the best of it.</simpara>
<simpara>&#8212;&#8201;Shlomi Fish ( <ulink url="http://www.shlomifish.org/">http://www.shlomifish.org/</ulink> )</simpara>
</refsect1>
<refsect1 id="_building">
<title>Building</title>
<simpara>Read the file <literal>INSTALL.txt</literal> for information on how to do that.</simpara>
</refsect1>
<refsect1 id="_usage">
<title>Usage</title>
<simpara>The program is called "fc-solve". You invoke it like this:</simpara>
<literallayout class="monospaced">fc-solve board_file</literallayout>
<simpara>board_file is the filename with a valid Freecell startup board. The file is
built as follows:</simpara>
<simpara>It has the 8 Freecell stacks.
Each stack contain its number of cards separated by a whitespace
and terminated with a newline character( it&#8217;s important that the last stack
will also be terminated with a newline !). The cards in the line are ordered
from the bottom-most card in the left to the topmost card in the right.</simpara>
<simpara>A card string contains the card number (or rank) followed by the card deck.
The card number is one of: <literal>A,1,2,3,4,5,6,7,8,9,10,J,Q,K</literal>. Alterantively
<literal>T</literal> can be used instead of <literal>10</literal>. The card deck is one of:  <literal>H,S,D,C</literal> (standing
for Hearts, Spades, Diamonds and Clubs respectively).</simpara>
<simpara>Here is an example board: (PySol/Microsoft board No. 24)</simpara>
<screen>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 10H 10C 10D 8D
7H JS KH 10S KC 7C
AH 5S 6S AD 8H JD
7S 6C 7D 4D 8S 9D</screen>
<simpara>And another one: (PySol board No. 198246790)</simpara>
<screen>KD JH 5H 7D 9H KC 9D
3H JD 5D 8H QH 7H 2D
4D 3S QC 3C 6S QS KS
10C 9S 6D 9C QD 8S 10D
10S 8C 7S 10H 2C AS
8D AC AH 4H JC 4C
6H 7C 4S 5S 5C JS
AD KH 6C 2H 3D 2S</screen>
<simpara>You can specify the contents of the freecells by prefixing the line with
"FC:". For example:</simpara>
<screen>FC: 3H QC</screen>
<simpara>will specify that the cards 3 of hearts and queen of clubs are present in
the freecells. To specify an empty freecell use a "-" as its designator.</simpara>
<simpara>If there&#8217;s another "FC:" line, the previous line will be overriden.</simpara>
<simpara>You can specify the contents of the foundations by prefixing the line with
"Founds:" and then using a format as follows:</simpara>
<screen>Founds: H-5 C-A S-0 D-K</screen>
<simpara>Hence, the deck ID followed by a dash followed by the card number in the
foundation. A suit that is not present will be assumed to be 0. Again, if
there&#8217;s more than one then the previous lines will be overriden.</simpara>
<simpara>The program will stop processing the input as soon as it read 8 lines of
standard stacks. Therefore, it is recommended that the foundations and
freecells lines will come at the beginning of the file.</simpara>
<simpara>The program will process the board and try to solve it. If it succeeds it
will output the states from the initial board to its final solution to the
standard output. If it fails, it will notify it.</simpara>
<simpara>For information about the various command-line switches that Freecell
Solver accepts, read the <literal>USAGE.txt</literal> file in this directory.</simpara>
<simpara>To solve Simple Simon boards append <literal>--game simple_simon</literal> right after
the "fc-solve" program name.</simpara>
</refsect1>
<refsect1 id="_the_board_generation_programs">
<title>The board generation programs</title>
<simpara>Several programs which can generate the initial boards of various Freecell
implementations can be found in the "board_gen/" sub-directory. Read the
<literal>README.txt</literal> file there for details on how they can be compiled and used.</simpara>
<simpara>In any case, they can save you the time of inputting the board yourself.</simpara>
</refsect1>
<refsect1 id="_the_programs">
<title>The programs</title>
<simpara>Most command-line switches have two versions:</simpara>
<itemizedlist>
<listitem>
<simpara>
A short POSIX one which is a dash followed by a letter or a few. This option
must come standalone and not clustered:  <literal>-sam</literal> is not equivalent to
specifying <literal>-s</literal>, <literal>-a</literal> and <literal>-m</literal>.
</simpara>
</listitem>
<listitem>
<simpara>
A long switch which is two dashes followed by the command string. For
example: <literal>--prelude</literal>, <literal>--st-name</literal>.
</simpara>
</listitem>
</itemizedlist>
<simpara>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. <literal>--st-name=myname</literal> is invalid, while <literal>--st-name myname</literal> is OK.</simpara>
</refsect1>
<refsect1 id="_getting_help">
<title>Getting Help</title>
<simpara>-h , --help</simpara>
<screen>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</screen>
<simpara>This option displays the version number of the components that make
the executable (and then exits).</simpara>
<refsect2 id="_help_configs">
<title>--help-configs</title>
<simpara>Some help on the various configurations of Freecell Solver.</simpara>
</refsect2>
<refsect2 id="_help_options">
<title>--help-options</title>
<simpara>A help screen giving an overview of all available options.</simpara>
</refsect2>
<refsect2 id="_help_real_help">
<title>--help-real-help</title>
<simpara>Explains how to change the default help screen to a different one.</simpara>
</refsect2>
<refsect2 id="_help_short_sol">
<title>--help-short-sol</title>
<simpara>How to generate shorter solutions.</simpara>
</refsect2>
<refsect2 id="_help_summary">
<title>--help-summary</title>
<simpara>The default help screen.</simpara>
</refsect2>
</refsect1>
<refsect1 id="_output_options">
<title>Output Options</title>
<refsect2 id="_p_parseable_output">
<title>-p , --parseable-output</title>
<simpara>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 <literal>:</literal>.</simpara>
</refsect2>
<refsect2 id="_t_display_10_as_t">
<title>-t , --display-10-as-t</title>
<simpara>This option will display the 10 cards as a capital <literal>T +instead of a +10</literal>.
Thus, the cards will be more properly aligned.</simpara>
<simpara>For example, here is a command line using <literal>-p</literal> and <literal>-t</literal>:</simpara>
<screen>$ 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</screen>
</refsect2>
<refsect2 id="_c_canonized_order_output">
<title>-c , --canonized-order-output</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_m_display_moves">
<title>-m , --display-moves</title>
<simpara>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.</simpara>
<simpara>For example:</simpara>
<screen>$ 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</screen>
</refsect2>
<refsect2 id="_sn_standard_notation">
<title>-sn , --standard-notation</title>
<simpara>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).</simpara>
<simpara>For more information regarding standard notation refer to the following
web-page:</simpara>
<simpara><ulink url="http://home.earthlink.net/~fomalhaut/freecell.html">http://home.earthlink.net/~fomalhaut/freecell.html</ulink></simpara>
</refsect2>
<refsect2 id="_snx_standard_notation_extended">
<title>-snx , --standard-notation-extended</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_sam_display_states_and_moves">
<title>-sam , --display-states-and-moves</title>
<simpara>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.</simpara>
<screen>$ 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</screen>
</refsect2>
<refsect2 id="_pi_display_parent_iter">
<title>-pi , --display-parent-iter</title>
<simpara>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 <literal>a-star</literal>) or
BFS scans.</simpara>
</refsect2>
<refsect2 id="_o_filename_output_filename">
<title>-o [filename] , --output [filename]</title>
<simpara>Outputs to a file instead of standard output. So for example:</simpara>
<screen>$ fc-solve -o 2405.solution.txt 2405.board</screen>
<simpara>Will put the solution to the file in 2405.board in the file
<literal>2405.solution.txt</literal> . This will also be done using:</simpara>
<screen>$ fc-solve --output 2405.solution.txt 2405.board</screen>
</refsect2>
<refsect2 id="_sel_show_exceeded_limits">
<title>-sel , --show-exceeded-limits</title>
<simpara>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.</simpara>
<simpara>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.</simpara>
</refsect2>
</refsect1>
<refsect1 id="_game_variants_options">
<title>Game Variants Options</title>
<refsect2 id="_freecells_num_number_of_freecells">
<title>--freecells-num [Number of Freecells]</title>
<simpara>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.</simpara>
<simpara>This maximum is hard-coded into the program, and can be specified at
compile-time by modifying the file <literal>config.h</literal>. See the file <literal>INSTALL</literal>
(or alternatively <literal>INSTALL.html</literal>) for details.</simpara>
</refsect2>
<refsect2 id="_stacks_num_number_of_stacks">
<title>--stacks-num [Number of Stacks]</title>
<simpara>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 <literal>config.h</literal> during compile-time of Freecell
Solver.</simpara>
</refsect2>
<refsect2 id="_decks_num_number_of_decks">
<title>--decks-num [Number of Decks]</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_sequences_are_built_by_suit_alternate_color_rank">
<title>--sequences-are-built-by {suit|alternate_color|rank}</title>
<simpara>This option specifies whether a card sequence is built by suit or by
alternate colour or by rank regardless of suit.</simpara>
</refsect2>
<refsect2 id="_sequence_move_limited_unlimited">
<title>--sequence-move {limited|unlimited}</title>
<simpara>This option specifies whether the sequence move is limited by the
number of freecells or vacant stacks or not.</simpara>
</refsect2>
<refsect2 id="_empty_stacks_filled_by_kings_none_all">
<title>--empty-stacks-filled-by {kings|none|all}</title>
<simpara>Specifies which cards can fill an empty stack.</simpara>
</refsect2>
<refsect2 id="_game_game_preset_game_g_game">
<title>--game [game] , --preset [game] , -g [game]</title>
<simpara>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.</simpara>
<simpara>Available presets:</simpara>
<informaltable
frame="all"
rowsep="1" colsep="1"
>
<?dbhtml table-width="50%"?>
<?dbfo table-width="50%"?>
<?dblatex table-width="50%"?>
<tgroup cols="2">
<colspec colname="col_1" colwidth="106*"/>
<colspec colname="col_2" colwidth="106*"/>
<tbody>
<row>
<entry align="left" valign="top"><simpara><literal>bakers_dozen</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Baker&#8217;s Dozen</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>bakers_game</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Baker&#8217;s Game</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>beleaguered_castle</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Beleaguered Castle</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>citadel</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Citadel</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>cruel</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Cruel</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>der_katz</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Der Katzenschwanz</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>die_schlange</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Die Schlange</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>eight_off</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Eight Off</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>fan</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Fan</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>forecell</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Forecell</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>freecell</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Freecell (default)</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>good_measure</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Good Measure</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>ko_bakers_game</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Kings' Only Baker&#8217;s Game</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>relaxed_freecell</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Relaxed Freecell</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>relaxed_sehaven</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Relaxed Seahaven Towers</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>seahaven</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Seahaven Towers</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>simple_simon</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Simple Simon</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>streets_and_alleys</literal></simpara></entry>
<entry align="left" valign="top"><simpara>Streets and Alleys</simpara></entry>
</row>
</tbody>
</tgroup>
</informaltable>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_examples">
<title>Examples</title>
<simpara>To solve PySol Eight Off game No. 1,000 type:</simpara>
<screen>$ make_pysol_freecell_board.py 1000 eight_off | fc-solve -g eight_off</screen>
<simpara>To solve PySol Baker&#8217;s Game No. 50, type:</simpara>
<screen>$ make_pysol_freecell_board.py 50 bakers_game | fc-solve -g bakers_game</screen>
<simpara>If you want to solve a game similar to Freecell only with sequences built
by rank, and unlimited sequence move, do:</simpara>
<screen>$ fc-solve -g freecell --sequences-are-built-by rank --sequence-move unlimited</screen>
</refsect2>
</refsect1>
<refsect1 id="_5_solving_algorithm_options">
<title>5. Solving Algorithm Options</title>
<refsect2 id="_mi_iterations_num_max_iters_iterations_num">
<title>-mi [Iterations num] , --max-iters [Iterations num]</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_md_maximal_depth_max_depth_maximal_depth">
<title>-md [Maximal depth] , --max-depth [Maximal depth]</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_mss_num_max_stored_states_num">
<title>-mss [num] , --max-stored-states [num]</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_tmss_num_trim_max_stored_states_num">
<title>-tmss [num] , --trim-max-stored-states [num]</title>
<simpara>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).</simpara>
</refsect2>
<refsect2 id="_to_test_8217_s_order_tests_order_test_8217_s_order">
<title>-to [Test&#8217;s Order] , --tests-order [Test&#8217;s Order]</title>
<simpara>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.</simpara>
<simpara>The tests along with their characters are:</simpara>
<informaltable
frame="all"
rowsep="1" colsep="1"
>
<?dbhtml table-width="80%"?>
<?dbfo table-width="80%"?>
<?dblatex table-width="80%"?>
<tgroup cols="2">
<colspec colname="col_1" colwidth="31*"/>
<colspec colname="col_2" colwidth="309*"/>
<tbody>
<row>
<entry align="left" valign="top" namest="col_1" nameend="col_2"><simpara>Freecell Tests:</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>0</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>put top stack cards in the foundations.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>1</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>put freecell cards in the foundations.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>2</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>put freecell cards on top of stacks.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>3</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>put non-top stack cards in the foundations.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>4</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move stack cards to different stacks.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>5</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move stack cards to a parent card on the same stack.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>6</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move sequences of cards onto free stacks.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>7</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>put freecell cards on empty stacks.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>8</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move cards to a different parent.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>9</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>empty an entire stack into the freecells.</simpara></entry>
</row>
<row>
<entry align="left" valign="top" namest="col_1" nameend="col_2"><simpara>Atomic Freecell Tests:</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>A</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a stack card to an empty stack.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>B</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a stack card to a parent on a different stack.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>C</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a stack card to a freecell.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>D</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a freecell card to a parent.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>E</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a freecell card to an empty stack.</simpara></entry>
</row>
<row>
<entry align="left" valign="top" namest="col_1" nameend="col_2"><simpara>Simple Simon Tests:</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>a</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a full sequence to the foundations.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>b</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a sequence to a true parent of his.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>c</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a whole stack sequence to a false parent (in order to clear the stack)</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>d</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a sequence to a true parent that has some cards above it.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>e</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a sequence with some cards above it to a true parent.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>f</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a sequence with a junk sequence above it to a true parent that
has some cards above it.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>g</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a whole stack sequence to a false parent which has some
cards above it.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>h</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move a sequence to a parent on the same stack.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><emphasis>i</emphasis></simpara></entry>
<entry align="left" valign="top"><simpara>move any sequence to a false parent (using it may make the solution
much slower).</simpara></entry>
</row>
</tbody>
</tgroup>
</informaltable>
<simpara>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.</simpara>
<simpara>Note that this test order usually makes sense only for the Soft-DFS
and Random DFS scans (see the <literal>--method</literal> option below).</simpara>
<simpara>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.</simpara>
<simpara>Tests can be grouped together into random groups using parenthesis
(e.g: "(0123)") or square brackets ("[012][3456789]"). Such grouping is
only relevant to the Random DFS scan (see below).</simpara>
</refsect2>
<refsect2 id="_dto_min_depth_tests_order_depth_tests_order_min_depth_tests_order">
<title>-dto [Min Depth],[Tests' Order] , --depth-tests-order [Min Depth],[Tests' Order]</title>
<simpara>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.</simpara>
<simpara>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.</simpara>
<simpara>It should be noted that the <literal>-to</literal> or <literal>--tests-order</literal> option above is
equivalent to using this option with a minimal depth of 0.</simpara>
<simpara>Here are some examples:</simpara>
<screen>-to 0123456789 -dto 30,0138924567</screen>
<simpara>This sets the tests' order to <literal>0123456789</literal> for all depths below 30 and to
<literal>0138924567</literal> for all depths above it.</simpara>
<screen>-to 0123457 -dto 10,750123 -dto 25,710235</screen>
<simpara>This sets the tests' order to <literal>0123457</literal> for depths -9 (those below 10),
to <literal>750123</literal> for depths 10-24, and to <literal>710235</literal> for the depths 25 onwards.</simpara>
</refsect2>
<refsect2 id="_me_solving_method_method_solving_method">
<title>-me [Solving Method] , --method [Solving Method]</title>
<simpara>This option specifies the solving method that will be used to solve the
board. Currently, the following methods are available:</simpara>
<itemizedlist>
<listitem>
<simpara>
<literal>a-star</literal> - A Best-First-Search scan (not "A*" as it was once thought to be)
</simpara>
</listitem>
<listitem>
<simpara>
<literal>bfs</literal> - A Breadth-First Search (or BFS) scan
</simpara>
</listitem>
<listitem>
<simpara>
<literal>dfs</literal> - A Depth-First Search (or DFS) scan
</simpara>
</listitem>
<listitem>
<simpara>
<literal>random-dfs</literal> - A randomized DFS scan
</simpara>
</listitem>
<listitem>
<simpara>
<literal>soft-dfs</literal> - A "soft" DFS scan
</simpara>
</listitem>
</itemizedlist>
<simpara>Starting from recent Freecell Solver versions there is no difference between
<literal>dfs</literal> and <literal>soft-dfs</literal>. In earlier versions, use of <literal>soft-dfs</literal> is recommended.
<literal>random-dfs</literal> is similar to <literal>soft-dfs</literal> 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.)</simpara>
<simpara>BFS does not yield good results, and <literal>a-star</literal> has a mixed behaviour, so for
the time being I recommend using Soft-DFS or Andom-DFS.</simpara>
<simpara>The Random-DFS scan processes every tests' random group, randomizes the
states that it found and recurses into them one by one. Renegade tests
that do not belong to any group, are processed in a non-random manner.</simpara>
</refsect2>
<refsect2 id="_asw_befs_weights_a_star_weight_befs_weights">
<title>-asw [BeFS Weights] , --a-star-weight [BeFS Weights]</title>
<simpara>Specify weights for the <literal>a-star</literal> (= "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.</simpara>
<simpara>The numbers are, in order:</simpara>
<orderedlist numeration="arabic">
<listitem>
<simpara>
The number of cards out.
</simpara>
</listitem>
<listitem>
<simpara>
The maximal sequence move.
</simpara>
</listitem>
<listitem>
<simpara>
The number of cards under sequences.
</simpara>
</listitem>
<listitem>
<simpara>
The length of the sequences which are found over renegade cards.
</simpara>
</listitem>
<listitem>
<simpara>
The depth of the board in the solution.
</simpara>
</listitem>
</orderedlist>
<simpara>The default weights are respectively: 0.5,0,0.3,0,0.2</simpara>
</refsect2>
<refsect2 id="_seed_seed_number">
<title>-seed [Seed Number]</title>
<simpara>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 <literal>random-dfs</literal>
scan.</simpara>
</refsect2>
<refsect2 id="_set_pruning_pruning_sp_pruning">
<title>--set-pruning [Pruning] , -sp [Pruning]</title>
<simpara>This option sets the pruning algorithm for the soft thread. Current valid
values are only the empty string (<literal>""</literal>) for no pruning and <literal>r:tf</literal> (short
for "Run: to foundations") for Horne&#8217;s rule. See:</simpara>
<simpara><ulink url="http://tech.groups.yahoo.com/group/fc-solve-discuss/message/214">http://tech.groups.yahoo.com/group/fc-solve-discuss/message/214</ulink></simpara>
</refsect2>
<refsect2 id="_opt_optimize_solution">
<title>-opt , --optimize-solution</title>
<simpara>This option instructs Freecell Solver to try and optimize the solution
path so it will have a smaller number of moves.</simpara>
</refsect2>
<refsect2 id="_opt_to_tests_order_optimization_tests_order_tests_order">
<title>-opt-to [tests order] , --optimization-tests-order [tests order]</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_reparent_states">
<title>--reparent-states</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_calc_real_depth">
<title>--calc-real-depth</title>
<simpara>This option becomes effective only if <literal>--reparent-states</literal> 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.</simpara>
</refsect2>
</refsect1>
<refsect1 id="_running_several_scans_in_parallel">
<title>Running Several Scans in Parallel</title>
<simpara>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.</simpara>
<refsect2 id="_nst_next_soft_thread">
<title>-nst , --next-soft-thread</title>
<simpara>This option creates a new soft-thread and makes the following scan-specific
options initialize it. For example:</simpara>
<screen>$ fc-solve --method a-star -nst --method soft-dfs -to 0123467 myboard.txt</screen>
<simpara>will run an BeFS scan and a Soft-DFS scan with a tests order of 0123467 on
myboard.txt.</simpara>
</refsect2>
<refsect2 id="_step_step_soft_thread_step_step">
<title>-step [Step] , --soft-thread-step [Step]</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_nht_next_hard_thread">
<title>-nht , --next-hard-thread</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_st_name_soft_thread_name">
<title>--st-name [soft thread name]</title>
<simpara>This argument sets the name used to identify the current soft thread. This name
can later be used to construct the prelude (see below).</simpara>
</refsect2>
<refsect2 id="_prelude_i1_st1_i2_st2_i3_st3_8230">
<title>--prelude [i1@st1{,i2@st2{,i3@st3&#8230;}}]</title>
<simpara>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.</simpara>
<simpara>For example, if you had three soft threads named "foo", "bar" and "rin", then
the following prelude:</simpara>
<screen>--prelude 500@foo,1590@bar,100@foo,200@rin</screen>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_scans_synergy_none_dead_end_marks">
<title>--scans-synergy {none|dead-end-marks}</title>
<simpara>Specifies the synergy between the various scans, or how much they cooperate
between themselves. <literal>none</literal> means they do not cooperate and only share
the same memory resources. <literal>dead-end-marks</literal> 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.</simpara>
</refsect2>
<refsect2 id="_ni_next_instance">
<title>-ni , --next-instance</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_nf_next_flare">
<title>-nf , --next-flare</title>
<simpara>Each instance contains several flares. Flares are various alternative scans,
that are ran one after another, as specified in the <literal>--flares-plan</literal> 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.</simpara>
</refsect2>
<refsect2 id="_flare_name_flare_name">
<title>--flare-name [flare name]</title>
<simpara>This is a name that identifies the flare for use in the flares' plan.</simpara>
</refsect2>
<refsect2 id="_flares_plan_flare_plan">
<title>--flares-plan [flare plan]</title>
<simpara>This instance-wide parameter gives a plan for the flares as a big string. Here
are some examples:</simpara>
<screen>--flares-plan "RunIndef:FlareyFlare"</screen>
<simpara>This plan will run the flare with the name <literal>FlareyFlare</literal> indefinetely, until it
terminates. Once a RunIndef action is encountered, the rest of the plan is
ignored.</simpara>
<screen>--flares-plan "Run:500@MyFlare,Run:2000@FooFlare"</screen>
<simpara>Runs <literal>MyFlare</literal> for 500 iterations and <literal>FooFlare</literal> 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).</simpara>
<screen>--flares-plan "Run:500@dfs,Run:1500@befs,CP:,Run:10000@funky"</screen>
<simpara>This runs the flares identified by <literal>dfs</literal> and <literal>befs</literal> and then see if a solution
was reached ("CP:" stands for <emphasis role="strong">"checkpoint"</emphasis>), 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 <literal>funky</literal> 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.</simpara>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_cache_limit_cache_limit">
<title>--cache-limit [cache limit]</title>
<simpara>This is a numeric limit to the LRU cache which only matters if Freecell
Solver was compiled with <literal>FCS_RCS_STATES</literal> 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 <literal>FCS_RCS_STATES</literal> is to conserve memory).</simpara>
</refsect2>
</refsect1>
<refsect1 id="_meta_options">
<title>Meta-Options</title>
<refsect2 id="_reset">
<title>--reset</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_read_from_file_num_skip_filename">
<title>--read-from-file [num_skip,]filename</title>
<simpara>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).</simpara>
<simpara>The filename can be preceeded by an optional number of the arguments to
skip followed by a comma. (the default is 0)</simpara>
</refsect2>
<refsect2 id="_l_preset_load_config_preset">
<title>-l [preset] , --load-config [preset]</title>
<simpara>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 <ulink url="http://groups.yahoo.com/group/fc-solve-discuss/message/403">http://groups.yahoo.com/group/fc-solve-discuss/message/403</ulink>
for information about their format)</simpara>
<simpara>Presets that are shipped with Freecell Solver:</simpara>
<informaltable
frame="all"
rowsep="1" colsep="1"
>
<tgroup cols="2">
<colspec colname="col_1" colwidth="20*"/>
<colspec colname="col_2" colwidth="80*"/>
<tbody>
<row>
<entry align="left" valign="top"><simpara><literal>abra-kadabra</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>blue-yonder</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset generated by a
quota optimization algorithm.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>children-playing-ball</literal></simpara></entry>
<entry align="left" valign="top"><simpara>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).</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>cool-jives</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>crooked-nose</literal></simpara></entry>
<entry align="left" valign="top"><simpara>an atomic-moves preset (guarantees an
            accurate verdict)</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>enlightened-ostrich</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset (that depends on Freecell
Solver 3.4.0 and above) that yields solutions faster on average than
<literal>foss-nessy</literal>.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>fools-gold</literal></simpara></entry>
<entry align="left" valign="top"><simpara>an atomic-moves preset</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>foss-nessy</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset (that depends on Freecell
Solver 3.2.0 and above) that yields solutions faster on average than
<literal>the-iglu-cabal</literal>.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>good-intentions</literal></simpara></entry>
<entry align="left" valign="top"><simpara>runs "cool-jives" and then "fools-gold"</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>gooey-unknown-thing</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset that aims to minimise
            the outcome solution&#8217;s length.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>hello-world</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>john-galt-line</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>maliciously-obscure</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves and flare-based preset that tends
to yield very short solutions (even in comparison to <literal>children-playing-ball</literal>
) but is slow.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>rin-tin-tin</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>sand-stone</literal></simpara></entry>
<entry align="left" valign="top"><simpara>an atomic-moves preset that aims to
            minimise the outcome solution&#8217;s length.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>slick-rock</literal></simpara></entry>
<entry align="left" valign="top"><simpara>run "gooey-unknown-thing" and then "sand-stone"</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>sentient-pearls</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves and flares based preset with
short solutions. Much faster than <literal>children-playing-ball</literal> but yields less
optimal solutions.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>tea-for-two</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset optimized for
two-freecells' Freecell games (although it can work on other Freecell-like
games as well).</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>the-iglu-cabal</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset that yields faster
solutions on average than <literal>blue-yonder</literal>.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>the-last-mohican</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a preset for solving Simple Simon. Yields
            less false negatives than the default one, but might be slower.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>three-eighty</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset (that depends on Freecell
Solver 3.4.0 and above) that yields solutions faster on average than
<literal>enlightened-ostrich</literal>.</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>toons-for-twenty-somethings</literal></simpara></entry>
<entry align="left" valign="top"><simpara>an atomic-moves preset that solves
            more boards efficiently than "fools-gold".</simpara></entry>
</row>
<row>
<entry align="left" valign="top"><simpara><literal>yellow-brick-road</literal></simpara></entry>
<entry align="left" valign="top"><simpara>a meta-moves preset</simpara></entry>
</row>
</tbody>
</tgroup>
</informaltable>
<simpara>They can be abbreviated into their lowercase acronym (i.e: "ak" or "rtt").</simpara>
</refsect2>
</refsect1>
<refsect1 id="_run_time_display_options">
<title>Run-time Display Options</title>
<refsect2 id="_i_iter_output">
<title>-i , --iter-output</title>
<simpara>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.</simpara>
</refsect2>
<refsect2 id="_s_state_output">
<title>-s , --state-output</title>
<simpara>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.</simpara>
</refsect2>
</refsect1>
<refsect1 id="_signal_combinations">
<title>Signal Combinations</title>
<simpara>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.</simpara>
<simpara>If you send the signal USR1, without sending any other signals before
that, then <literal>fc-solve</literal> will output the present number of
iterations. This method is a good way to monitor an instance that takes
a long time to solve.</simpara>
<simpara>If you send it the signal USR2 and then USR1, then <literal>fc-solve</literal>
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.</simpara>
<simpara>If you send it two USR2 signals and then USR1, then <literal>fc-solve</literal>
will also print the board of every state. Again, this will only be done
assuming the iteration output is turned on.</simpara>
</refsect1>
</refentry>