1FC-SOLVE(6)                                                        FC-SOLVE(6)
2
3
4

NAME

6       fc-solve - automated solver for Freecell and related Solitiare variants
7

INTRODUCTION

9       This is Freecell Solver version 6.8.x, a program that automatically
10       solves most layouts of Freecell, and similar Solitaire variants as well
11       as those of Simple Simon.
12
13       Freecell Solver is distributed under the MIT/Expat License (
14       http://en.wikipedia.org/wiki/MIT_License ), a free, permissive,
15       open-source license.
16
17       Note that the Freecell Solver source and Win32 binary distributions do
18       not provide a graphical user-interface (GUI) and are primarily meant to
19       be used by Solitaire researchers and software developers. If you’re
20       looking for a suitable GUI based on Freecell Solver, see our links at:
21
22       http://fc-solve.shlomifish.org/links.html#front_ends
23
24       I hope you’ll enjoy using Freecell Solver, and make the best of it.
25
26        — Shlomi Fish ( http://www.shlomifish.org/ )
27

BUILDING

29       Read the file INSTALL.txt for information on how to do that.
30

USAGE

32       The program is called "fc-solve". You invoke it like this:
33
34           fc-solve board_file
35
36       board_file is the filename with a valid Freecell startup board. The
37       file is built as follows:
38
39       It has the 8 Freecell stacks.
40
41       Each stack contains its cards separated by a whitespace and terminated
42       with a newline character( it’s important that the last stack will also
43       be terminated with a newline !). The cards in the line are ordered from
44       the topmost card (= the card right on the virtual table and the one
45       with the most cards placed on it) in the left, to the bottommost card
46       in the right (= the card with no other cards placed on it).
47
48       A card string contains the rank of the card followed by its suit. The
49       card number is one of: A,1,2,3,4,5,6,7,8,9,T,J,Q,K. Alternatively, 10
50       can be used instead of T, but using that is discouraged and is only
51       supported for backward compatibility. The card suit is one of:  H,S,D,C
52       (standing for Hearts, Spades, Diamonds and Clubs respectively).
53
54       Here is an example board: (PySol/Microsoft board No. 24)
55
56           4C 2C 9C 8C QS 4S 2H
57           5H QH 3C AC 3H 4H QD
58           QC 9S 6H 9H 3S KS 3D
59           5D 2S JC 5C JH 6D AS
60           2D KD TH TC TD 8D
61           7H JS KH TS KC 7C
62           AH 5S 6S AD 8H JD
63           7S 6C 7D 4D 8S 9D
64
65       Visually, it appears as this:
66
67       [Freecell Deal No. 24]
68
69       As can be seen, the four of clubs (4C), five of hearts (5H), etc. are
70       at the bottom of the stacks and the start of the lines in the board
71       input.
72
73       And another one: (PySol board No. 198246790)
74
75           KD JH 5H 7D 9H KC 9D
76           3H JD 5D 8H QH 7H 2D
77           4D 3S QC 3C 6S QS KS
78           TC 9S 6D 9C QD 8S TD
79           TS 8C 7S TH 2C AS
80           8D AC AH 4H JC 4C
81           6H 7C 4S 5S 5C JS
82           AD KH 6C 2H 3D 2S
83
84       Starting from Freecell Solver 3.14.x, a stack can also start with a
85       leading colon (":"). This is to allow input from states as output by
86       Freecell Solver using the -p option.
87
88       You can specify the contents of the freecells by prefixing the line
89       with "FC:" or with "Freecells:". For example:
90
91           FC: 3H QC
92
93       will specify that the cards 3 of hearts and queen of clubs are present
94       in the freecells. To specify an empty freecell use a "-" as its
95       designator.
96
97       If there’s another "FC:" line, the previous line will be overridden.
98
99       You can specify the contents of the foundations by prefixing the line
100       with "Founds:" or with "Foundations:" and then using a format as
101       follows:
102
103           Founds: H-5 C-A S-0 D-K
104
105       Hence, the suit ID followed by a dash followed by the card number in
106       the foundation. A suit that is not present will be assumed to be 0.
107       Again, if there’s more than one line like that, then the previous lines
108       will be ignored and overridden.
109
110       The program will stop processing the input as soon as it read 8 lines
111       of standard stacks. Therefore, it is recommended that the foundations
112       and freecells lines will come at the beginning of the file.
113
114       The program will process the board and try to solve it. If it succeeds
115       it will output the states from the initial board to its final solution
116       to the standard output. If it fails, it will notify it.
117
118       For information about the various command-line switches that Freecell
119       Solver accepts, read the USAGE.txt file in this directory.
120
121       To solve Simple Simon boards append --game simple_simon right after the
122       "fc-solve" program name.
123

THE BOARD GENERATION PROGRAMS

125       Several programs which can generate the initial boards of various
126       Freecell implementations can be found in the "board_gen/"
127       sub-directory. Read the README.txt file there for details on how they
128       can be compiled and used.
129
130       In any case, they can save you the time of inputting the board
131       yourself.
132

SOME COMPLETE EXAMPLES FOR LAYOUTS

134       A layout in the middle of the MS Freecell deal No. 109 solution:
135
136           Foundations: H-6 C-9 D-2 S-0
137           Freecells:  QS  3S  2S  KD
138           : 8H 3D
139           : KS QD JC
140           : AS 8D TD 7D JH TS 9D
141           : 7S 6D
142           : 5S
143           : KH QC JD TC 9H 8S 7H 6S 5D 4S
144           : KC QH JS TH 9S
145           : 4D
146
147       Similar, but with an empty Freecell:
148
149           Foundations: H-6 C-9 D-2 S-0
150           Freecells:  QS  3S  -  KD
151           : 8H 3D 2S
152           : KS QD JC
153           : AS 8D TD 7D JH TS 9D
154           : 7S 6D
155           : 5S
156           : KH QC JD TC 9H 8S 7H 6S 5D 4S
157           : KC QH JS TH 9S
158           : 4D
159
160       Likewise, only without leading colons where unnecessary:
161
162           Foundations: H-6 C-9 D-2 S-0
163           Freecells:  QS  3S  -  KD
164           8H 3D 2S
165           KS QD JC
166           AS 8D TD 7D JH TS 9D
167           7S 6D
168           5S
169           KH QC JD TC 9H 8S 7H 6S 5D 4S
170           KC QH JS TH 9S
171           4D
172

HOW TO READ THE SOLUTIONS

174       The file USAGE.txt covers all of Freecell Solver’s command line
175       options, but it may be too exhaustive for casual users. As a result,
176       here is a shorter tutorial. First of all whenever invoking fc-solve one
177       should add the flags -p -t -sam -sel which will make the solution
178       easier to understand. Then, assuming the board could be successfully
179       solved, one will be given the layouts in the solution (in the format
180       given above) vis-a-vis with the moves as the string. Note that the
181       indexes of the resources given in the moves are 0-based rather than the
182       more natural 1-based notation.
183

THE PROGRAMS

185       Most command-line switches have two versions:
186
187       •   A short POSIX one which is a dash followed by a letter or a few.
188           This option must come standalone and not clustered:  -sam is not
189           equivalent to specifying -s, -a and -m.
190
191       •   A long switch which is two dashes followed by the command string.
192           For example: --prelude, --st-name.
193
194       If command line arguments have parameters, they are followed in
195       separate parameters - Freecell Solver won’t recognise a parameter
196       preceded by an equal sign. --st-name=myname is invalid, while --st-name
197       myname is OK.
198
199   The Scope of the Options
200       The scope of the options is mentioned along with them. Options can be:
201
202        1. Global - affects all the soft-threads.
203
204        2. Instance-specific - affects an instance (separated by the
205           --next-instance option below). Each instance consists of several
206           flares.
207
208        3. Flare-specific - affects the current flare (separated by the
209           --next-flare option below. Each flare consists of several hard
210           threads.
211
212        4. Hard-thread-specific - affects the current hard thread (separated
213           by the --next-hard-thread option below. Each hard thread consists
214           of several soft threads.
215
216        5. Soft-thread-specific - affects only the current soft thread.
217

GETTING HELP

219   -h , --help
220       Global
221
222       This option displays a help text on the screen. This help gives a help
223       display summarizing some ways to use the program and get more help.
224
225   --version
226       Global
227
228       This option displays the version number of the components that make the
229       executable (and then exits).
230
231   --help-configs
232       Global
233
234       Some help on the various configurations of Freecell Solver.
235
236   --help-options
237       Global
238
239       A help screen giving an overview of all available options.
240
241   --help-real-help
242       Global
243
244       Explains how to change the default help screen to a different one.
245
246   --help-short-sol
247       Global
248
249       How to generate shorter solutions.
250
251   --help-summary
252       Global
253
254       The default help screen.
255

OUTPUT OPTIONS

257   -p , --parseable-output
258       Global
259
260       This option will display the columns in a format that can be more
261       easily manipulated by text-processing programs such as grep or perl.
262       Namely, The freecells will be displayed in one line, and the
263       foundations in a separate line. Plus, Each column will be displayed
264       horizontally, in its own line, while beginning with a :.
265
266   -t , --display-10-as-t
267       Global
268
269       This option will display the 10 cards as a capital T instead of a 10.
270       Thus, the cards will be more properly aligned.
271
272       For example, here is a command line using -p and -t:
273
274           $ pi-make-microsoft-freecell-board 24 | fc-solve -p -t
275           -=-=-=-=-=-=-=-=-=-=-=-
276
277           Foundations: H-0 C-0 D-0 S-0
278           Freecells:
279           : 4C 2C 9C 8C QS 4S 2H
280           : 5H QH 3C AC 3H 4H QD
281           : QC 9S 6H 9H 3S KS 3D
282           : 5D 2S JC 5C JH 6D AS
283           : 2D KD TH TC TD 8D
284           : 7H JS KH TS KC 7C
285           : AH 5S 6S AD 8H JD
286           : 7S 6C 7D 4D 8S 9D
287
288
289           ====================
290
291           Foundations: H-0 C-0 D-0 S-A
292           Freecells:
293           : 4C 2C 9C 8C QS 4S 2H
294           : 5H QH 3C AC 3H 4H QD
295           : QC 9S 6H 9H 3S KS 3D
296           : 5D 2S JC 5C JH 6D
297           : 2D KD TH TC TD 8D
298           : 7H JS KH TS KC 7C
299           : AH 5S 6S AD 8H JD
300           : 7S 6C 7D 4D 8S 9D
301
302   -c , --canonized-order-output
303       Global
304
305       Freecell Solver re-arranges the stacks and freecells in a given state
306       according to their first card. It keeps their actual position in a
307       separate place, but internally it uses their canonized place. Use this
308       option, if you want Freecell Solver to display them in that order. One
309       should be warned that that way the place of a given stack in the board
310       will not be preserved throughout the solution.
311
312   -m , --display-moves
313       Global
314
315       This option will display the moves instead of the intermediate states.
316       Each move will be displayed in a separate line, in a format that is
317       human-readable, but that can also be parsed and analyzed by a computer
318       program with some effort on the programmer’s part.
319
320       For example:
321
322           $ pi-make-microsoft-freecell-board 24 | fc-solve -m | head -30
323           -=-=-=-=-=-=-=-=-=-=-=-
324
325           Move a card from stack 3 to the foundations
326
327           ====================
328
329           Move a card from stack 6 to freecell 0
330
331           ====================
332
333           Move a card from stack 6 to freecell 1
334
335   -sn , --standard-notation
336       Global
337
338       This option will display the moves in standard notation in which every
339       move consists of two characters and there are ten moves in a line.
340       Naturally, this option will only become apparent if the display moves
341       is specified. (it does not implicitly specify it, though).
342
343       For more information regarding standard notation refer to the following
344       web-page:
345
346       http://www.solitairelaboratory.com/solutioncatalog.html
347
348   -snx , --standard-notation-extended
349       Global
350
351       This option is similar to the previous one, except that when a sequence
352       move is made to an empty stack with more than one card in the sequence,
353       the move will be followed with "v" and the number of cards moved in
354       hexadecimal.
355
356   -sam , --display-states-and-moves
357       Global
358
359       This option will display both the intermediate states and the moves
360       that are needed to move from one to another. The standard notation
361       option applies to it to.
362
363           $ pi-make-microsoft-freecell-board 24 | fc-solve -sam -p -t | head -50
364           -=-=-=-=-=-=-=-=-=-=-=-
365
366           Foundations: H-0 C-0 D-0 S-0
367           Freecells:
368           : 4C 2C 9C 8C QS 4S 2H
369           : 5H QH 3C AC 3H 4H QD
370           : QC 9S 6H 9H 3S KS 3D
371           : 5D 2S JC 5C JH 6D AS
372           : 2D KD TH TC TD 8D
373           : 7H JS KH TS KC 7C
374           : AH 5S 6S AD 8H JD
375           : 7S 6C 7D 4D 8S 9D
376
377
378           ====================
379
380           Move a card from stack 3 to the foundations
381
382           Foundations: H-0 C-0 D-0 S-A
383           Freecells:
384           : 4C 2C 9C 8C QS 4S 2H
385           : 5H QH 3C AC 3H 4H QD
386           : QC 9S 6H 9H 3S KS 3D
387           : 5D 2S JC 5C JH 6D
388           : 2D KD TH TC TD 8D
389           : 7H JS KH TS KC 7C
390           : AH 5S 6S AD 8H JD
391           : 7S 6C 7D 4D 8S 9D
392
393
394           ====================
395
396           Move a card from stack 6 to freecell 0
397
398           Foundations: H-0 C-0 D-0 S-A
399           Freecells:  JD
400           : 4C 2C 9C 8C QS 4S 2H
401           : 5H QH 3C AC 3H 4H QD
402           : QC 9S 6H 9H 3S KS 3D
403           : 5D 2S JC 5C JH 6D
404           : 2D KD TH TC TD 8D
405           : 7H JS KH TS KC 7C
406           : AH 5S 6S AD 8H
407           : 7S 6C 7D 4D 8S 9D
408
409
410           ====================
411
412           Move a card from stack 6 to freecell 1
413
414   -pi , --display-parent-iter
415       Global
416
417       This option (assuming the -s and -i options are specified) will also
418       display the iteration index of the state from which the current state
419       was derived. This is especially useful for BeFS (so-called a-star) or
420       BFS scans.
421
422   -o [filename] , --output [filename]
423       Global
424
425       Outputs to a file instead of standard output. So for example:
426
427           $ fc-solve -o 2405.solution.txt 2405.board
428
429       Will put the solution to the file in 2405.board in the file
430       2405.solution.txt . This will also be done using:
431
432           $ fc-solve --output 2405.solution.txt 2405.board
433
434   -sel , --show-exceeded-limits
435       Global
436
437       This option will display a different status message ("Iterations count
438       exceeded.") instead of "I could not solve this game." in case the
439       iterations count was exceeded. This is recommended because the "I could
440       not solve this game." message can also mean that the entire game graph
441       was fully traversed (within the limitations of the specified moves'
442       types) and so no solution is possible.
443
444       This option is not the default, to retain compatibility with previous
445       versions of Freecell Solver, and was added in version 3.12.0 of
446       fc-solve.
447
448   -hoi , --hint-on-intractable
449       Global
450
451       Presents the moves to the intermediate reached state, if the maximal
452       number of iterations was reached without a conclusion (=
453       "intractable").
454
455       This option is not the default, to retain compatibility with previous
456       versions of Freecell Solver, and was added in version 4.20.0 of
457       fc-solve.
458

GAME VARIANTS OPTIONS

460   --freecells-num [Number of Freecells]
461       Global
462
463       This option specifies the number of freecells which are available to
464       the program. Freecell Solver can use any number of freecells as long as
465       it does not exceed its maximal number.
466
467       This maximum is hard-coded into the program, and can be specified at
468       compile-time by modifying the file config.h. See the file INSTALL (or
469       alternatively INSTALL.html) for details.
470
471   --stacks-num [Number of Stacks]
472       Global
473
474       This option specifies the number of stacks present in the board. Again,
475       this number cannot exceed the maximal number of stacks, which can be
476       specified in the file config.h during compile-time of Freecell Solver.
477
478   --decks-num [Number of Decks]
479       Global
480
481       This options specifies how many decks are found in the board. This
482       number cannot exceed the maximal number of decks, which can be
483       specified by the Freecell Solver build system.
484
485   --sequences-are-built-by {suit|alternate_color|rank}
486       Global
487
488       This option specifies whether a card sequence is built by suit or by
489       alternate colour or by rank regardless of suit.
490
491   --sequence-move {limited|unlimited}
492       Global
493
494       This option specifies whether the sequence move is limited by the
495       number of freecells or vacant stacks or not.
496
497   --empty-stacks-filled-by {kings|none|all}
498       Global
499
500       Specifies which cards can fill an empty stack.
501
502   --game [game] , --preset [game] , -g [game]
503       Global
504
505       Specifies the type of game. Each preset implies several of the settings
506       options above and sometimes even the moves’ order below. The default
507       configuration is for Freecell.
508
509       Available presets:
510
511       ┌───────────────────┬──────────────────────────┐
512       │                   │                          │
513       │bakers_dozen       │ Baker’s Dozen            │
514       ├───────────────────┼──────────────────────────┤
515       │                   │                          │
516       │bakers_game        │ Baker’s Game             │
517       ├───────────────────┼──────────────────────────┤
518       │                   │                          │
519       │beleaguered_castle │ Beleaguered Castle       │
520       ├───────────────────┼──────────────────────────┤
521       │                   │                          │
522       │citadel            │ Citadel                  │
523       ├───────────────────┼──────────────────────────┤
524       │                   │                          │
525       │cruel              │ Cruel                    │
526       ├───────────────────┼──────────────────────────┤
527       │                   │                          │
528       │der_katz           │ Der Katzenschwanz        │
529       ├───────────────────┼──────────────────────────┤
530       │                   │                          │
531       │die_schlange       │ Die Schlange             │
532       ├───────────────────┼──────────────────────────┤
533       │                   │                          │
534       │eight_off          │ Eight Off                │
535       ├───────────────────┼──────────────────────────┤
536       │                   │                          │
537       │fan                │ Fan                      │
538       ├───────────────────┼──────────────────────────┤
539       │                   │                          │
540       │forecell           │ Forecell                 │
541       ├───────────────────┼──────────────────────────┤
542       │                   │                          │
543       │freecell           │ Freecell (default)       │
544       ├───────────────────┼──────────────────────────┤
545       │                   │                          │
546       │good_measure       │ Good Measure             │
547       ├───────────────────┼──────────────────────────┤
548       │                   │                          │
549       │ko_bakers_game     │ Kings' Only Baker’s Game │
550       ├───────────────────┼──────────────────────────┤
551       │                   │                          │
552       │relaxed_freecell   │ Relaxed Freecell         │
553       ├───────────────────┼──────────────────────────┤
554       │                   │                          │
555       │relaxed_sehaven    │ Relaxed Seahaven Towers  │
556       ├───────────────────┼──────────────────────────┤
557       │                   │                          │
558       │seahaven           │ Seahaven Towers          │
559       ├───────────────────┼──────────────────────────┤
560       │                   │                          │
561       │simple_simon       │ Simple Simon             │
562       ├───────────────────┼──────────────────────────┤
563       │                   │                          │
564       │streets_and_alleys │ Streets and Alleys       │
565       └───────────────────┴──────────────────────────┘
566
567       Note: in order to solve Der Katzenschwanz and Die Schlange I recommend
568       you compile Freecell Solver with the INDIRECT_STACK_STATES option, or
569       else it will consume much more memory. For details consult the file
570       INSTALL.
571
572   Examples
573       To solve PySol Eight Off game No. 1,000 type:
574
575           $ make_pysol_freecell_board.py 1000 eight_off | fc-solve -g eight_off
576
577       To solve PySol Baker’s Game No. 50, type:
578
579           $ make_pysol_freecell_board.py 50 bakers_game | fc-solve -g bakers_game
580
581       If you want to solve a game similar to Freecell only with sequences
582       built by rank, and unlimited sequence move, do:
583
584           $ fc-solve -g freecell --sequences-are-built-by rank --sequence-move unlimited
585

SOLVING ALGORITHM OPTIONS

587   -mi [Iterations num] , --max-iters [Iterations num]
588       Global
589
590       This parameter limits the maximal number of states to check. This will
591       give a rough limit on the time spent to solve a given board.
592
593   -md [Maximal depth] , --max-depth [Maximal depth]
594       Not currently implemented
595
596       Freecell Solver recurses into the solution. This parameter specifies a
597       maximal recursion depth. Generally speaking, it’s not a good idea to
598       set it, because that way several important intermediate states may
599       become inaccessible.
600
601   -mss [num] , --max-stored-states [num]
602       Global
603
604       Limits the number of the states stored by the program in the computer’s
605       memory. This differs from the maximal number of iterations in the
606       sense, that it is possible that a stored state was not checked yet.
607
608   -tmss [num] , --trim-max-stored-states [num]
609       Instance-wide
610
611       This also limits the number of trimmed stored states, but this time
612       will try to trim them once the limit has been reached (which is time
613       consuming and may cause states to be traversed again in the future).
614
615   -to [Moves’ Order] , --tests-order [Moves Order]
616       Soft-thread-specific
617
618       This option specifies the order in which Freecell Solver will try the
619       different types of moves (formerly termed "tests") that it can perform.
620       Each move is specified by one character, and they are performed in the
621       order in which they appear in the parameter string. You can omit moves
622       by not including their corresponding characters in the string.
623
624       The moves along with their characters are:
625
626       ┌───────────────────────┬────────────────────────────┐
627       │                       │                            │
628       │Freecell Moves:        │                            │
629       ├───────────────────────┼────────────────────────────┤
630       │                       │                            │
6310                      │ put top stack cards in the │
632       │                       │ foundations.               │
633       ├───────────────────────┼────────────────────────────┤
634       │                       │                            │
6351                      │ put freecell cards in the  │
636       │                       │ foundations.               │
637       ├───────────────────────┼────────────────────────────┤
638       │                       │                            │
6392                      │ put freecell cards on top  │
640       │                       │ of stacks.                 │
641       ├───────────────────────┼────────────────────────────┤
642       │                       │                            │
6433                      │ put non-top stack cards in │
644       │                       │ the foundations.           │
645       ├───────────────────────┼────────────────────────────┤
646       │                       │                            │
6474                      │ move stack cards to        │
648       │                       │ different stacks.          │
649       ├───────────────────────┼────────────────────────────┤
650       │                       │                            │
6515                      │ move stack cards to a      │
652       │                       │ parent card on the same    │
653       │                       │ stack.                     │
654       ├───────────────────────┼────────────────────────────┤
655       │                       │                            │
6566                      │ move sequences of cards    │
657       │                       │ onto free stacks.          │
658       ├───────────────────────┼────────────────────────────┤
659       │                       │                            │
6607                      │ put freecell cards on      │
661       │                       │ empty stacks.              │
662       ├───────────────────────┼────────────────────────────┤
663       │                       │                            │
6648                      │ move cards to a different  │
665       │                       │ parent.                    │
666       ├───────────────────────┼────────────────────────────┤
667       │                       │                            │
6689                      │ empty an entire stack into │
669       │                       │ the freecells.             │
670       ├───────────────────────┼────────────────────────────┤
671       │                       │                            │
672j                      │ put freecell cards on      │
673       │                       │ empty stacks and right     │
674       │                       │ away put cards on top.     │
675       ├───────────────────────┼────────────────────────────┤
676       │                       │                            │
677       │Atomic Freecell Moves: │                            │
678       ├───────────────────────┼────────────────────────────┤
679       │                       │                            │
680A                      │ move a stack card to an    │
681       │                       │ empty stack.               │
682       ├───────────────────────┼────────────────────────────┤
683       │                       │                            │
684B                      │ move a stack card to a     │
685       │                       │ parent on a different      │
686       │                       │ stack.                     │
687       ├───────────────────────┼────────────────────────────┤
688       │                       │                            │
689C                      │ move a stack card to a     │
690       │                       │ freecell.                  │
691       ├───────────────────────┼────────────────────────────┤
692       │                       │                            │
693D                      │ move a freecell card to a  │
694       │                       │ parent.                    │
695       ├───────────────────────┼────────────────────────────┤
696       │                       │                            │
697E                      │ move a freecell card to an │
698       │                       │ empty stack.               │
699       ├───────────────────────┼────────────────────────────┤
700       │                       │                            │
701       │Simple Simon Moves:    │                            │
702       ├───────────────────────┼────────────────────────────┤
703       │                       │                            │
704a                      │ move a full sequence to    │
705       │                       │ the foundations.           │
706       ├───────────────────────┼────────────────────────────┤
707       │                       │                            │
708b                      │ move a sequence to a true  │
709       │                       │ parent of his.             │
710       ├───────────────────────┼────────────────────────────┤
711       │                       │                            │
712c                      │ move a whole stack         │
713       │                       │ sequence to a false parent │
714       │                       │ (in order to clear the     │
715       │                       │ stack)                     │
716       ├───────────────────────┼────────────────────────────┤
717       │                       │                            │
718d                      │ move a sequence to a true  │
719       │                       │ parent that has some cards │
720       │                       │ above it.                  │
721       ├───────────────────────┼────────────────────────────┤
722       │                       │                            │
723e                      │ move a sequence with some  │
724       │                       │ cards above it to a true   │
725       │                       │ parent.                    │
726       ├───────────────────────┼────────────────────────────┤
727       │                       │                            │
728f                      │ move a sequence with a     │
729       │                       │ junk sequence above it to  │
730       │                       │ a true parent that has     │
731       │                       │ some cards above it.       │
732       ├───────────────────────┼────────────────────────────┤
733       │                       │                            │
734g                      │ move a whole stack         │
735       │                       │ sequence to a false parent │
736       │                       │ which has some cards above │
737       │                       │ it.                        │
738       ├───────────────────────┼────────────────────────────┤
739       │                       │                            │
740h                      │ move a sequence to a       │
741       │                       │ parent on the same stack.  │
742       ├───────────────────────┼────────────────────────────┤
743       │                       │                            │
744i                      │ move any sequence to a     │
745       │                       │ false parent (using it may │
746       │                       │ make the solution much     │
747       │                       │ slower).                   │
748       └───────────────────────┴────────────────────────────┘
749
750       Manipulating the moves order can be very helpful to the quick solution
751       of a given board. If you found that a certain board cannot be solved in
752       after a long time or in a certain maximal number of iterations, you
753       should try different moves' orders. Usually, one can find a moves order
754       that solves a board very quickly.
755
756       Note that this moves order usually makes sense only for the Soft-DFS
757       and Random DFS scans (see the --method option below).
758
759       Also note that Freecell moves are not suitable for solving Simple Simon
760       games and Simple Simon moves are not suitable for solving anything
761       except Simple Simon.
762
763       Moves can be grouped together into groups using parenthesis (e.g:
764       "(0123)") or square brackets ("[012][3456789]"). Such grouping is only
765       relevant to the Random DFS scan (see below). A group may optionally be
766       followed by the equal sign "=" and by an ordering specifier. If one
767       specifies "=rand()", then the derived states will be randomised based
768       on the seed (which is what happens if no equal sign is specified). On
769       the other hand, if one specifies something like "=asw(5,0,5,0,0,5)",
770       then the numbers inside the parentheses will be treated as weights for
771       the same ordering function used by the -asw flag (see below).
772
773       If the order specifier is "=all()" then all the moves in the group will
774       be run, even if some derived states have been yielded by earlier moves
775       in the group. ( This was added in version 5.24.0. )
776
777   -dto2 [Min Depth],[Moves' Order] , --depth-tests-order2 [Min Depth],[Moves'
778       Order]
779       Soft-thread-specific
780
781       Sets the Moves' order starting from the minimal depth onwards. This
782       way, if a Soft-DFS scan recurses deeply into the game, it will use a
783       different moves' order.
784
785       Note that if you set the moves' order of a minimal depth of say 50,
786       then it will override all the moves' order of 50 and above. As a
787       result, it is recommended that you set the minimal depth moves order in
788       an increasing depth.
789
790       It should be noted that the -to or --tests-order option above is
791       equivalent to using this option with a minimal depth of 0.
792
793       Here are some examples:
794
795           -to 0123456789 -dto2 30,0138924567
796
797       This sets the moves' order to 0123456789 for all depths below 30 and to
798       0138924567 for all depths above it.
799
800           -to 0123457 -dto2 10,750123 -dto2 25,710235
801
802       This sets the moves' order to 0123457 for depths -9 (those below 10),
803       to 750123 for depths 10-24, and to 710235 for the depths 25 onwards.
804
805           -to 0123457 -dto2 "10,[012357]=asw(1)"
806
807       This sorts the moves starting from 10 onward based on the asw()
808       function.
809
810           -to 0123457 -dto2 "10,[012357]=rand()"
811
812       This randomises the moves from 10 onward.
813
814           -to 0123457 -dto2 "10,[012357]"
815
816       This does the same thing as the previous example.
817
818       Note : This option should be used instead of the older -dto option
819       given below which mutilates the moves order parameter and is still
820       provided for backward compatibility.
821
822   -dto [Min Depth],[Moves' Order] , --depth-tests-order [Min Depth],[Moves'
823       Order]
824       This is equivalent to specifying -dto2 [Min Depth],[Min Depth],[Moves'
825       Order] - i.e: the "[Min Depth]," string is prefixed to the given moves
826       order.
827
828       This option is provided for backward compatibility with older versions
829       of Freecell Solver.
830
831   -me [Solving Method] , --method [Solving Method]
832       Soft-thread-specific
833
834       This option specifies the solving method that will be used to solve the
835       board. Currently, the following methods are available:
836
837       •   a-star - A Best-First-Search scan (not "A*" as it was once thought
838           to be)
839
840       •   bfs - A Breadth-First Search (or BFS) scan
841
842       •   dfs - A Depth-First Search (or DFS) scan
843
844       •   random-dfs - A randomized DFS scan
845
846       •   patsolve - uses the scan of patsolve.
847
848       •   soft-dfs - A "soft" DFS scan
849
850       Starting from recent Freecell Solver versions there is no difference
851       between dfs and soft-dfs. In earlier versions, use of soft-dfs is
852       recommended. random-dfs is similar to soft-dfs only it determines to
853       which states to recurse into randomly. Its behaviour will differ
854       depending on the seed you supply to it. (see the "-seed" option below.)
855
856       BFS does not yield good results, and a-star has a mixed behaviour, so
857       for the time being I recommend using Soft-DFS or Random-DFS.
858
859       The Random-DFS scan processes every moves' random group, randomizes the
860       states that it found and recurses into them one by one. Standalone
861       moves that do not belong to any group, are processed in a non-random
862       manner.
863
864   -asw [BeFS Weights] , --a-star-weight [BeFS Weights]
865       Soft-thread-specific
866
867       Specify weights for the a-star (= "Best-First Search") scan, assuming
868       it is used. The parameter should be a comma-separated list of numbers,
869       each one is proportional to the weight of its corresponding test.
870
871       The numbers are, in order:
872
873        1. The number of cards out.
874
875        2. The maximal sequence move.
876
877        3. The number of cards under sequences.
878
879        4. The length of the sequences which are found over renegade cards.
880
881        5. The depth of the board in the solution.
882
883        6. The negative of the number of cards that are not placed above their
884           parents. To get the irreversibility depth, give equal weight to
885           this weight and to the number of cards out.
886
887       The default weights are respectively: {0.5, 0, 0.3, 0, 0.2, 0}
888
889   -seed [Seed Number]
890       Soft-thread-specific
891
892       Specifies a seed to be used by Freecell Solver’s internal random number
893       generator. This seed may alter the behaviour and speed of the
894       random-dfs scan.
895
896   --set-pruning [Pruning] , -sp [Pruning]
897       Soft-thread-specific
898
899       This option sets the pruning algorithm for the soft thread. Current
900       valid values are only the empty string ("") for no pruning and r:tf
901       (short for "Run: to foundations") for Horne’s rule. See:
902
903       https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/topics/214
904
905   -opt , --optimize-solution
906       Flare-wide
907
908       This option instructs Freecell Solver to try and optimize the solution
909       path so it will have a smaller number of moves.
910
911   -opt-to [moves order] , --optimization-tests-order [moves order]
912       Flare-wide
913
914       This argument specifies the moves order for the optimization scan, in
915       case it should be different than an order that contains all the moves
916       that were used in all the normal scans.
917
918   --reparent-states
919       Flare-wide
920
921       This option specifies that states that were encountered whose depth in
922       the states graph can be improved should be reparented to the new
923       parent. This option can possibly make solutions shorter.
924
925   --calc-real-depth
926       Flare-wide
927
928       This option becomes effective only if --reparent-states is specified.
929       What it does, is explicitly calculate the depth of the state by tracing
930       its path to the initial state. This may make depth consideration more
931       accurate.
932
933   --patsolve-x-param [pos],[value]
934       Soft-thread-specific
935
936       Sets the patsolve’s scan X param (an integer) in position "pos" into
937       "value".
938
939       Examples:
940
941           --patsolve-x-param 0,5
942           --patsolve-x-param 2,100
943
944   --patsolve-y-param [pos],[value]
945       Soft-thread-specific
946
947       Sets the patsolve Y param (a floating point number) in position "pos"
948       into "value".
949
950       Examples:
951
952           --patsolve-y-param 0,0.5
953           --patsolve-y-param 1,103.2
954

RUNNING SEVERAL SCANS IN PARALLEL

956       Starting from Version 2.4.0, Freecell Solver can run several scans in
957       parallel on the same state collection. Each scan resides in its own
958       "Soft Thread". By specifying several soft threads on the command line
959       one can create and run several task-switched scans. Once one of the
960       scans reaches a solution, the solution will be displayed.
961
962   -nst , --next-soft-thread
963       Hard-thread-specific
964
965       This option creates a new soft-thread and makes the following
966       scan-specific options initialize it. For example:
967
968           $ fc-solve --method a-star -nst --method soft-dfs -to 0123467 myboard.txt
969
970       will run an BeFS scan and a Soft-DFS scan with a moves order of 0123467
971       on myboard.txt.
972
973   -step [Step] , --soft-thread-step [Step]
974       Soft-thread-specific
975
976       This option will set the number of iterations with which to run the
977       soft thread before switching to the next one. By specifying a larger
978       step, one can give a certain scan a longer run-time and a higher
979       priority.
980
981       Note: after some experimentation, we have concluded that the --prelude
982       option normally yields better results, but -step can be used as a
983       fallback.
984
985   -nht , --next-hard-thread
986       Flare-wide
987
988       This argument lets one initialize the next hard thread. If Freecell
989       Solver was compiled with such support, then it is possible to run each
990       hard thread in its own system thread. Each hard-thread contains one or
991       more soft threads.
992
993   --st-name [soft thread name]
994       Soft-thread-specific
995
996       This argument sets the name used to identify the current soft thread.
997       This name can later be used to construct the prelude (see below).
998
999   --prelude [\i1@st1{,\i2@st2{,\i3@st3...}}]
1000       Hard-thread-specific
1001
1002       Sets the prelude for the hard thread. At the beginning of the search,
1003       the hard thread plays a static sequence of iterations at each of the
1004       soft threads specified in the prelude, for the number of iterations
1005       specified.
1006
1007       For example, if you had three soft threads named "foo", "bar" and
1008       "rin", then the following prelude:
1009
1010           --prelude 500@foo,1590@bar,100@foo,200@rin
1011
1012       Will run 500 iterations in "foo", then 1590 in "bar", then 100 in "foo"
1013       again, and then 200 in "rin". After the prelude finishes, the hard
1014       thread would run the scans one after the other in the sequence they
1015       were defined for their step number.
1016
1017   --scans-synergy {none|dead-end-marks}
1018       Flare-wide
1019
1020       Specifies the synergy between the various scans, or how much they
1021       cooperate between themselves. none means they do not cooperate and only
1022       share the same memory resources. dead-end-marks means they try to mark
1023       states that they have withdrawn from, and states whose all their
1024       derived states are such, as "dead ends". This may or may not improve
1025       the speed of the solution.
1026
1027   -ni , --next-instance
1028       Global
1029
1030       This option allows one to run two or more separate solvers one after
1031       the other. If the first one returned an unsolvable verdict, then the
1032       second one would run and so on. One use of it is to run an atomic moves
1033       scan after a meta-moves scan, so we will always get an accurate verdict
1034       and still enjoy some of the speed benefits of the meta-moves scan.
1035
1036   -nf , --next-flare
1037       Instance-wide
1038
1039       Each instance contains several flares. Flares are various alternative
1040       scans, that are ran one after another, as specified in the
1041       --flares-plan below or defaulting to running only the first flare
1042       (which isn’t very useful). Out of all the flares that are successful in
1043       solving a board, Freecell Solver picks the one with the shortest
1044       solution.
1045
1046   --flare-name [flare name]
1047       Flare-wide
1048
1049       This is a name that identifies the flare for use in the flares' plan.
1050
1051   --flares-plan [flare plan]
1052       Instance-wide
1053
1054       This instance-wide parameter gives a plan for the flares as a big
1055       string. Here are some examples:
1056
1057           --flares-plan "RunIndef:FlareyFlare"
1058
1059       This plan will run the flare with the name FlareyFlare indefinitely,
1060       until it terminates. Once a RunIndef action is encountered, the rest of
1061       the plan is ignored.
1062
1063           --flares-plan "Run:500@MyFlare,Run:2000@FooFlare"
1064
1065       Runs MyFlare for 500 iterations and FooFlare for 2,000 iterations. Note
1066       that both flares will be run and won’t share any resources between
1067       them, and then the minimal solution out of both flares (or only those
1068       that finished ). If no flares finished, then Freecell Solver will run
1069       them both again for the same number of iterations each, until at least
1070       one finishes (or it ran out of the iterations' limit).
1071
1072           --flares-plan "Run:500@dfs,Run:1500@befs,CP:,Run:10000@funky"
1073
1074       This runs the flares identified by dfs and befs and then see if a
1075       solution was reached ("CP:" stands for "checkpoint"), and if so yield
1076       it. If both flares did not reach a solution yet, or failed to solve the
1077       board, it will run the flare funky for 10,000 iterations and yield its
1078       solution. And like the previous case, this solution will loop after it
1079       ended for as long as the no flare solved the board or the program did
1080       not run out of iterations.
1081
1082       Using checkpoints one can yield a possibly sub-optimal (as far as
1083       solution length is concerned) solution that will still solve faster
1084       than letting all the flares run.
1085
1086   --flares-choice [choice]
1087       Global
1088
1089       This dictates how to choose the winning flare based on if more than one
1090       yielded a solution. Possible options are:
1091
1092        1. --flares-choice fc_solve - the default, which picks up the
1093           solutions based on the length of the solution in Freecell Solver’s
1094           moves.
1095
1096        2. --flares-choice fcpro - picks up the shortest solution based on the
1097           number of Freecell Pro moves, while not considering implicit moves
1098           to the foundations using Horne’s Prune / Raymond Prune.
1099
1100   -fif [factor] , --flares-iters-factor [factor]
1101       Global
1102
1103       Sets a global, floating-point number, factor to multiply all the
1104       iterations counts in the flares plans. The higher it is, the longer the
1105       scans will take, but there is a greater chance more of them will
1106       succeed, and, as a result, the solution may be shorter.
1107
1108       As an example, the following:
1109
1110           --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 2
1111
1112       Is equivalent to:
1113
1114           --flares-plan "Run:1000@MyFlare,Run:4000@FooFlare"
1115
1116       while:
1117
1118           --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 0.5
1119
1120       Is equivalent to:
1121
1122           --flares-plan "Run:250@MyFlare,Run:1000@FooFlare"
1123
1124   --cache-limit [cache limit]
1125       Global
1126
1127       This is a numeric limit to the LRU cache which only matters if Freecell
1128       Solver was compiled with FCS_RCS_STATES enabled. This value should be a
1129       positive integer and the higher it is, the more quickly it is likely
1130       that Freecell Solver will run, but it will also consume more memory.
1131       (The entire point of FCS_RCS_STATES is to conserve memory).
1132

META-OPTIONS

1134   --reset
1135       Global
1136
1137       This option resets the program to its initial state, losing all the
1138       configuration logic that was input to it up to that state. Afterwards,
1139       it can be set to a different configuration, again.
1140
1141   --read-from-file [num_skip,]filename
1142       Global (but context-specific).
1143
1144       This option will read the configuration options from a file. The format
1145       of the file is similar to that used by the UNIX Bourne Shell. (i.e:
1146       spaces denote separate arguments, double-quotes encompass arguments,
1147       backslash escapes characters).
1148
1149       The filename can be preceded by an optional number of the arguments to
1150       skip followed by a comma. (the default is 0)
1151
1152   -l [preset] , --load-config [preset]
1153       Global (but context-specific).
1154
1155       Reads the configuration specified by [preset] and configures the solver
1156       accordingly. A preset is a set of command line arguments to be analyzed
1157       in the place of this option. They are read from a set of presetrc files
1158       : one installed system-wide, the other at
1159       $HOME/.freecell-solver/presetrc and the third at the path specified by
1160       the FREECELL_SOLVER_PRESETRC environment variable. You can add more
1161       presets at any of these places. (refer to
1162       http://groups.yahoo.com/group/fc-solve-discuss/message/403 for
1163       information about their format)
1164
1165       Presets that are shipped with Freecell Solver:
1166
1167       ┌────────────────────────────┬─────────────────────────────────────────────────┐
1168       │                            │                                                 │
1169       │abra-kadabra                │ a meta-moves preset                             │
1170       ├────────────────────────────┼─────────────────────────────────────────────────┤
1171       │                            │                                                 │
1172       │amateur-star                │ a meta-moves preset that                        │
1173       │                            │ yields solutions faster on                      │
1174       │                            │ average than three-eighty.                      │
1175       ├────────────────────────────┼─────────────────────────────────────────────────┤
1176       │                            │                                                 │
1177       │blue-yonder                 │ a meta-moves preset                             │
1178       │                            │ generated by a quota                            │
1179       │                            │ optimization algorithm.                         │
1180       ├────────────────────────────┼─────────────────────────────────────────────────┤
1181       │                            │                                                 │
1182       │children-playing-ball       │ a meta-moves and                                │
1183       │                            │ flare-based preset that                         │
1184       │                            │ tends to yield very short                       │
1185       │                            │ solution, but is very slow                      │
1186       │                            │ (solves only 3 boards per                       │
1187       │                            │ second on a Pentium 4                           │
1188       │                            │ 2.4GHz).                                        │
1189       ├────────────────────────────┼─────────────────────────────────────────────────┤
1190       │                            │                                                 │
1191       │conspiracy-theory           │ a meta-moves preset that                        │
1192       │                            │ yields solutions faster on                      │
1193       │                            │ average than amateur-star.                      │
1194       ├────────────────────────────┼─────────────────────────────────────────────────┤
1195       │                            │                                                 │
1196       │cookie-monster              │ a meta-moves preset that                        │
1197       │                            │ yields solutions faster on                      │
1198       │                            │ average than                                    │
1199       │                            │ one-big-family.                                 │
1200       ├────────────────────────────┼─────────────────────────────────────────────────┤
1201       │                            │                                                 │
1202       │cool-jives                  │ a meta-moves preset                             │
1203       ├────────────────────────────┼─────────────────────────────────────────────────┤
1204       │                            │                                                 │
1205       │crooked-nose                │ an atomic-moves preset                          │
1206       │                            │ (guarantees an accurate                         │
1207       │                            │ verdict)                                        │
1208       ├────────────────────────────┼─────────────────────────────────────────────────┤
1209       │                            │                                                 │
1210       │enlightened-ostrich         │ a meta-moves preset (that                       │
1211       │                            │ depends on Freecell Solver                      │
1212       │                            │ 3.4.0 and above) that                           │
1213       │                            │ yields solutions faster on                      │
1214       │                            │ average than foss-nessy.                        │
1215       ├────────────────────────────┼─────────────────────────────────────────────────┤
1216       │                            │                                                 │
1217       │fools-gold                  │ an atomic-moves preset                          │
1218       ├────────────────────────────┼─────────────────────────────────────────────────┤
1219       │                            │                                                 │
1220       │foss-nessy                  │ a meta-moves preset (that                       │
1221       │                            │ depends on Freecell Solver                      │
1222       │                            │ 3.2.0 and above) that                           │
1223       │                            │ yields solutions faster on                      │
1224       │                            │ average than                                    │
1225       │                            │ the-iglu-cabal.                                 │
1226       ├────────────────────────────┼─────────────────────────────────────────────────┤
1227       │                            │                                                 │
1228       │good-intentions             │ runs "cool-jives" and then                      │
1229       │                            │ "fools-gold"                                    │
1230       ├────────────────────────────┼─────────────────────────────────────────────────┤
1231       │                            │                                                 │
1232       │gooey-unknown-thing         │ a meta-moves preset that                        │
1233       │                            │ aims to minimise the                            │
1234       │                            │ outcome solution’s length.                      │
1235       ├────────────────────────────┼─────────────────────────────────────────────────┤
1236       │                            │                                                 │
1237       │hello-world                 │ a meta-moves preset                             │
1238       ├────────────────────────────┼─────────────────────────────────────────────────┤
1239       │                            │                                                 │
1240       │john-galt-line              │ a meta-moves preset                             │
1241       ├────────────────────────────┼─────────────────────────────────────────────────┤
1242       │                            │                                                 │
1243       │looking-glass               │ a meta-moves preset that                        │
1244       │                            │ yields solutions faster on                      │
1245       │                            │ average than                                    │
1246       │                            │ cookie-monster.                                 │
1247       ├────────────────────────────┼─────────────────────────────────────────────────┤
1248       │                            │                                                 │
1249       │maliciously-obscure         │ a meta-moves and                                │
1250       │                            │ flare-based preset that                         │
1251       │                            │ tends to yield very short                       │
1252       │                            │ solutions (even in                              │
1253       │                            │ comparison to                                   │
1254       │                            │ children-playing-ball )                         │
1255       │                            │ but is slow.                                    │
1256       ├────────────────────────────┼─────────────────────────────────────────────────┤
1257       │                            │                                                 │
1258       │micro-finance               │ a meta-moves and                                │
1259       │                            │ flare-based preset that                         │
1260       │                            │ tends to yield very short                       │
1261       │                            │ solutions (even in                              │
1262       │                            │ comparison to                                   │
1263       │                            │ maliciously-obscure ) but                       │
1264       │                            │ is even slower.                                 │
1265       ├────────────────────────────┼─────────────────────────────────────────────────┤
1266       │                            │                                                 │
1267       │micro-finance-improved      │ a meta-moves and                                │
1268       │                            │ flare-based preset, based                       │
1269       │                            │ on micro-finance that                           │
1270       │                            │ yields somewhat shorter                         │
1271       │                            │ solutions on average, and                       │
1272       │                            │ should not be slower.                           │
1273       ├────────────────────────────┼─────────────────────────────────────────────────┤
1274       │                            │                                                 │
1275       │one-big-family              │ a meta-moves preset that                        │
1276       │                            │ yields solutions faster on                      │
1277       │                            │ average than                                    │
1278       │                            │ conspiracy-theory.                              │
1279       ├────────────────────────────┼─────────────────────────────────────────────────┤
1280       │                            │                                                 │
1281       │qualified-seed              │ a meta-moves and                                │
1282       │                            │ flare-based preset, based                       │
1283       │                            │ on micro-finance-improved                       │
1284       │                            │ that yields somewhat                            │
1285       │                            │ shorter solutions on                            │
1286       │                            │ average, and should not be                      │
1287       │                            │ slower.                                         │
1288       ├────────────────────────────┼─────────────────────────────────────────────────┤
1289       │                            │                                                 │
1290       │qualified-seed-improved     │ qualified-seed with -fif 5                      │
1291       │                            │ and --flares-choice fcpro                       │
1292       ├────────────────────────────┼─────────────────────────────────────────────────┤
1293       │                            │                                                 │
1294       │rin-tin-tin                 │ a meta-moves preset                             │
1295       ├────────────────────────────┼─────────────────────────────────────────────────┤
1296       │                            │                                                 │
1297       │sand-stone                  │ an atomic-moves preset                          │
1298       │                            │ that aims to minimise the                       │
1299       │                            │ outcome solution’s length.                      │
1300       ├────────────────────────────┼─────────────────────────────────────────────────┤
1301       │                            │                                                 │
1302       │slick-rock                  │ run "gooey-unknown-thing"                       │
1303       │                            │ and then "sand-stone"                           │
1304       ├────────────────────────────┼─────────────────────────────────────────────────┤
1305       │                            │                                                 │
1306       │sentient-pearls             │ a meta-moves and flares                         │
1307       │                            │ based preset with short                         │
1308       │                            │ solutions. Much faster                          │
1309       │                            │ than children-playing-ball                      │
1310       │                            │ but yields less optimal                         │
1311       │                            │ solutions.                                      │
1312       ├────────────────────────────┼─────────────────────────────────────────────────┤
1313       │                            │                                                 │
1314       │tea-for-two                 │ a meta-moves preset                             │
1315       │                            │ optimized for                                   │
1316       │                            │ two-freecells' Freecell                         │
1317       │                            │ games (although it can                          │
1318       │                            │ work on other                                   │
1319       │                            │ Freecell-like games as                          │
1320       │                            │ well).                                          │
1321       ├────────────────────────────┼─────────────────────────────────────────────────┤
1322       │                            │                                                 │
1323       │the-iglu-cabal              │ a meta-moves preset that                        │
1324       │                            │ yields faster solutions on                      │
1325       │                            │ average than blue-yonder.                       │
1326       ├────────────────────────────┼─────────────────────────────────────────────────┤
1327       │                            │                                                 │
1328       │the-last-mohican            │ a preset for solving                            │
1329       │                            │ Simple Simon. Yields less                       │
1330       │                            │ false negatives than the                        │
1331       │                            │ default one, but might be                       │
1332       │                            │ slower.                                         │
1333       ├────────────────────────────┼─────────────────────────────────────────────────┤
1334       │                            │                                                 │
1335       │three-eighty                │ a meta-moves preset (that                       │
1336       │                            │ depends on Freecell Solver                      │
1337       │                            │ 3.4.0 and above) that                           │
1338       │                            │ yields solutions faster on                      │
1339       │                            │ average than                                    │
1340       │                            │ enlightened-ostrich.                            │
1341       ├────────────────────────────┼─────────────────────────────────────────────────┤
1342       │                            │                                                 │
1343       │toons-for-twenty-somethings │ an atomic-moves preset                          │
1344       │                            │ that solves more boards                         │
1345       │                            │ efficiently than                                │
1346       │                            │ "fools-gold".                                   │
1347       ├────────────────────────────┼─────────────────────────────────────────────────┤
1348       │                            │                                                 │
1349       │video-editing               │ a meta-moves and                                │
1350       │                            │ flare-based preset, based                       │
1351       │                            │ on qualified-seed that                          │
1352       │                            │ yields shorter solutions                        │
1353       │                            │ on average, but may be                          │
1354       │                            │ somewhat slower. Named to                       │
1355       │                            │ commemorate the earlier                         │
1356       │                            │ work of Adrian Ettlinger                        │
1357       │                            │ (1925-2013)                                     │
1358       │                            │ <http://en.wikipedia.org/wiki/Adrian_Ettlinger> │
1359       │                            │ who later contributed to                        │
1360       │                            │ Freecell Solver and to                          │
1361       │                            │ Freecell research.                              │
1362       ├────────────────────────────┼─────────────────────────────────────────────────┤
1363       │                            │                                                 │
1364       │yellow-brick-road           │ a meta-moves preset                             │
1365       └────────────────────────────┴─────────────────────────────────────────────────┘
1366
1367       They can be abbreviated into their lowercase acronym (i.e: "ak" or
1368       "rtt").
1369

RUN-TIME DISPLAY OPTIONS

1371   -i , --iter-output
1372       Global
1373
1374       This option tells fc-solve to print the iteration number and the
1375       recursion depth of every state which is checked, to the standard
1376       output. It’s a good way to keep track of how it’s doing, but the output
1377       slows it down a bit.
1378
1379   --iter-output-step [step]
1380       Global
1381
1382       Prints the current iteration if -i is specified, only every [step]
1383       steps, where [step] is a positive integer. For example, if you do
1384       fc-solve -i --iter-output-step 100, you will see this:
1385
1386           Iteration: 0
1387           Iteration: 100
1388           Iteration: 200
1389           Iteration: 300
1390
1391       This option has been added in Freecell Solver 4.20.0 and is useful for
1392       speeding up the runtime process, by avoiding excessive output.
1393
1394   -s , --state-output
1395       Global
1396
1397       This option implies -i. If specified, this option outputs the cards and
1398       formation of the board itself, for every state that is checked.
1399       "fc-solve -s" yields a nice real-time display of the progress of
1400       Freecell Solver, but you usually cannot make what is going on because
1401       it is so fast.
1402

SIGNAL COMBINATIONS

1404       If you are working on a UNIX or a similar system, then you can set some
1405       run-time options in "fc-solve" by sending it some signal combinations.
1406
1407       If you send the fc-solve a single ABRT signal, then fc-solve will
1408       terminate the scan prematurely, and report that the iterations’s limit
1409       has been exceeded.
1410
1411       If you send the signal USR1, without sending any other signals before
1412       that, then fc-solve will output the present number of iterations. This
1413       method is a good way to monitor an instance that takes a long time to
1414       solve.
1415
1416       If you send it the signal USR2 and then USR1, then fc-solve will print
1417       the iteration number and depth on every state that it checks. It is the
1418       equivalent of specifying (or unspecifying) the option -i/--iter-output.
1419
1420       If you send it two USR2 signals and then USR1, then fc-solve will also
1421       print the board of every state. Again, this will only be done assuming
1422       the iteration output is turned on.
1423

AUTHOR

1425       Shlomi Fish
1426
1427
1428
1429                                  2022-10-20                       FC-SOLVE(6)
Impressum