1FC-SOLVE(6) FC-SOLVE(6)
2
6 fc-solve - automated solver for Freecell and related Solitiare variants
7
9 This is Freecell Solver version 5.16.x, a program that automatically
10 solves most layouts of Freecell, and similar Solitaire variants as well
11 as those of Simple Simon.
12 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 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 http://fc-solve.shlomifish.org/links.html#front_ends
23 I hope you’ll enjoy using Freecell Solver, and make the best of it.
25 — Shlomi Fish ( http://www.shlomifish.org/ )
27
29 Read the file INSTALL.txt for information on how to do that.
30
32 The program is called "fc-solve". You invoke it like this:
33 fc-solve board_file
35 board_file is the filename with a valid Freecell startup board. The
37 file is built as follows:
38 It has the 8 Freecell stacks.
40 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 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 Here is an example board: (PySol/Microsoft board No. 24)
55 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 Visually, it appears as this:
66 [Freecell Deal No. 24]
68 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 And another one: (PySol board No. 198246790)
74 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 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 You can specify the contents of the freecells by prefixing the line
89 with "FC:" or with "Freecells:". For example:
90 FC: 3H QC
92 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 If there’s another "FC:" line, the previous line will be overridden.
98 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 Founds: H-5 C-A S-0 D-K
104 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 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 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 For information about the various command-line switches that Freecell
119 Solver accepts, read the USAGE.txt file in this directory.
120 To solve Simple Simon boards append --game simple_simon right after the
122 "fc-solve" program name.
123
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 In any case, they can save you the time of inputting the board
131 yourself.
132
134 A layout in the middle of the MS Freecell deal No. 109 solution:
135 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 Similar, but with an empty Freecell:
148 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 Likewise, only without leading colons where unnecessary:
161 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
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
185 Most command-line switches have two versions:
186 · 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 · A long switch which is two dashes followed by the command string.
192 For example: --prelude, --st-name.
193 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 The Scope of the Options
200 The scope of the options is mentioned along with them. Options can be:
201 1. Global - affects all the soft-threads.
203 2. Instance-specific - affects an instance (separated by the
205 --next-instance option below). Each instance consists of several
206 flares.
207 3. Flare-specific - affects the current flare (separated by the
209 --next-flare option below. Each flare consists of several hard
210 threads.
211 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 5. Soft-thread-specific - affects only the current soft thread.
217
219 -h , --help
220 Global
221 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 --version
226 Global
227 This option displays the version number of the components that make the
229 executable (and then exits).
230 --help-configs
232 Global
233 Some help on the various configurations of Freecell Solver.
235 --help-options
237 Global
238 A help screen giving an overview of all available options.
240 --help-real-help
242 Global
243 Explains how to change the default help screen to a different one.
245 --help-short-sol
247 Global
248 How to generate shorter solutions.
250 --help-summary
252 Global
253 The default help screen.
255
257 -p , --parseable-output
258 Global
259 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 -t , --display-10-as-t
267 Global
268 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 For example, here is a command line using -p and -t:
273 $ pi-make-microsoft-freecell-board 24 | fc-solve -p -t
275 -=-=-=-=-=-=-=-=-=-=-=-
276 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 ====================
290 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 -c , --canonized-order-output
303 Global
304 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 -m , --display-moves
313 Global
314 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 For example:
321 $ pi-make-microsoft-freecell-board 24 | fc-solve -m | head -30
323 -=-=-=-=-=-=-=-=-=-=-=-
324 Move a card from stack 3 to the foundations
326 ====================
328 Move a card from stack 6 to freecell 0
330 ====================
332 Move a card from stack 6 to freecell 1
334 -sn , --standard-notation
336 Global
337 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 For more information regarding standard notation refer to the following
344 web-page:
345 http://home.earthlink.net/~fomalhaut/freecell.html
347 -snx , --standard-notation-extended
349 Global
350 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 -sam , --display-states-and-moves
357 Global
358 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 $ pi-make-microsoft-freecell-board 24 | fc-solve -sam -p -t | head -50
364 -=-=-=-=-=-=-=-=-=-=-=-
365 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 ====================
379 Move a card from stack 3 to the foundations
381 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 ====================
395 Move a card from stack 6 to freecell 0
397 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 ====================
411 Move a card from stack 6 to freecell 1
413 -pi , --display-parent-iter
415 Global
416 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 -o [filename] , --output [filename]
423 Global
424 Outputs to a file instead of standard output. So for example:
426 $ fc-solve -o 2405.solution.txt 2405.board
428 Will put the solution to the file in 2405.board in the file
430 2405.solution.txt . This will also be done using:
431 $ fc-solve --output 2405.solution.txt 2405.board
433 -sel , --show-exceeded-limits
435 Global
436 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 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 -hoi , --hint-on-intractable
449 Global
450 Presents the moves to the intermediate reached state, if the maximal
452 number of iterations was reached without a conclusion (=
453 "intractable").
454 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
460 --freecells-num [Number of Freecells]
461 Global
462 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 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 --stacks-num [Number of Stacks]
472 Global
473 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 --decks-num [Number of Decks]
479 Global
480 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 --sequences-are-built-by {suit|alternate_color|rank}
486 Global
487 This option specifies whether a card sequence is built by suit or by
489 alternate colour or by rank regardless of suit.
490 --sequence-move {limited|unlimited}
492 Global
493 This option specifies whether the sequence move is limited by the
495 number of freecells or vacant stacks or not.
496 --empty-stacks-filled-by {kings|none|all}
498 Global
499 Specifies which cards can fill an empty stack.
501 --game [game] , --preset [game] , -g [game]
503 Global
504 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 Available presets:
510 ┌───────────────────┬──────────────────────────┐
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 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 Examples
573 To solve PySol Eight Off game No. 1,000 type:
574 $ make_pysol_freecell_board.py 1000 eight_off | fc-solve -g eight_off
576 To solve PySol Baker’s Game No. 50, type:
578 $ make_pysol_freecell_board.py 50 bakers_game | fc-solve -g bakers_game
580 If you want to solve a game similar to Freecell only with sequences
582 built by rank, and unlimited sequence move, do:
583 $ fc-solve -g freecell --sequences-are-built-by rank --sequence-move unlimited
585
587 -mi [Iterations num] , --max-iters [Iterations num]
588 Global
589 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 -md [Maximal depth] , --max-depth [Maximal depth]
594 Not currently implemented
595 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 -mss [num] , --max-stored-states [num]
602 Global
603 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 -tmss [num] , --trim-max-stored-states [num]
609 Instance-wide
610 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 -to [Moves’ Order] , --tests-order [Moves Order]
616 Soft-thread-specific
617 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 The moves along with their characters are:
625 ┌───────────────────────┬────────────────────────────┐
627 │ │ │
628 │Freecell Moves: │ │
629 ├───────────────────────┼────────────────────────────┤
630 │ │ │
631 │0 │ put top stack cards in the │
632 │ │ foundations. │
633 ├───────────────────────┼────────────────────────────┤
634 │ │ │
635 │1 │ put freecell cards in the │
636 │ │ foundations. │
637 ├───────────────────────┼────────────────────────────┤
638 │ │ │
639 │2 │ put freecell cards on top │
640 │ │ of stacks. │
641 ├───────────────────────┼────────────────────────────┤
642 │ │ │
643 │3 │ put non-top stack cards in │
644 │ │ the foundations. │
645 ├───────────────────────┼────────────────────────────┤
646 │ │ │
647 │4 │ move stack cards to │
648 │ │ different stacks. │
649 ├───────────────────────┼────────────────────────────┤
650 │ │ │
651 │5 │ move stack cards to a │
652 │ │ parent card on the same │
653 │ │ stack. │
654 ├───────────────────────┼────────────────────────────┤
655 │ │ │
656 │6 │ move sequences of cards │
657 │ │ onto free stacks. │
658 ├───────────────────────┼────────────────────────────┤
659 │ │ │
660 │7 │ put freecell cards on │
661 │ │ empty stacks. │
662 ├───────────────────────┼────────────────────────────┤
663 │ │ │
664 │8 │ move cards to a different │
665 │ │ parent. │
666 ├───────────────────────┼────────────────────────────┤
667 │ │ │
668 │9 │ empty an entire stack into │
669 │ │ the freecells. │
670 ├───────────────────────┼────────────────────────────┤
671 │ │ │
672 │j │ put freecell cards on │
673 │ │ empty stacks and right │
674 │ │ away put cards on top. │
675 ├───────────────────────┼────────────────────────────┤
676 │ │ │
677 │Atomic Freecell Moves: │ │
678 ├───────────────────────┼────────────────────────────┤
679 │ │ │
680 │A │ move a stack card to an │
681 │ │ empty stack. │
682 ├───────────────────────┼────────────────────────────┤
683 │ │ │
684 │B │ move a stack card to a │
685 │ │ parent on a different │
686 │ │ stack. │
687 ├───────────────────────┼────────────────────────────┤
688 │ │ │
689 │C │ move a stack card to a │
690 │ │ freecell. │
691 ├───────────────────────┼────────────────────────────┤
692 │ │ │
693 │D │ move a freecell card to a │
694 │ │ parent. │
695 ├───────────────────────┼────────────────────────────┤
696 │ │ │
697 │E │ move a freecell card to an │
698 │ │ empty stack. │
699 ├───────────────────────┼────────────────────────────┤
700 │ │ │
701 │Simple Simon Moves: │ │
702 ├───────────────────────┼────────────────────────────┤
703 │ │ │
704 │a │ move a full sequence to │
705 │ │ the foundations. │
706 ├───────────────────────┼────────────────────────────┤
707 │ │ │
708 │b │ move a sequence to a true │
709 │ │ parent of his. │
710 ├───────────────────────┼────────────────────────────┤
711 │ │ │
712 │c │ move a whole stack │
713 │ │ sequence to a false parent │
714 │ │ (in order to clear the │
715 │ │ stack) │
716 ├───────────────────────┼────────────────────────────┤
717 │ │ │
718 │d │ move a sequence to a true │
719 │ │ parent that has some cards │
720 │ │ above it. │
721 ├───────────────────────┼────────────────────────────┤
722 │ │ │
723 │e │ move a sequence with some │
724 │ │ cards above it to a true │
725 │ │ parent. │
726 ├───────────────────────┼────────────────────────────┤
727 │ │ │
728 │f │ move a sequence with a │
729 │ │ junk sequence above it to │
730 │ │ a true parent that has │
731 │ │ some cards above it. │
732 ├───────────────────────┼────────────────────────────┤
733 │ │ │
734 │g │ move a whole stack │
735 │ │ sequence to a false parent │
736 │ │ which has some cards above │
737 │ │ it. │
738 ├───────────────────────┼────────────────────────────┤
739 │ │ │
740 │h │ move a sequence to a │
741 │ │ parent on the same stack. │
742 ├───────────────────────┼────────────────────────────┤
743 │ │ │
744 │i │ move any sequence to a │
745 │ │ false parent (using it may │
746 │ │ make the solution much │
747 │ │ slower). │
748 └───────────────────────┴────────────────────────────┘
749 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 Note that this moves order usually makes sense only for the Soft-DFS
757 and Random DFS scans (see the --method option below).
758 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 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 -dto2 [Min Depth],[Moves' Order] , --depth-tests-order2 [Min Depth],[Moves'
774 Order]
775 Soft-thread-specific
776 Sets the Moves' order starting from the minimal depth onwards. This
778 way, if a Soft-DFS scan recurses deeply into the game, it will use a
779 different moves' order.
780 Note that if you set the moves' order of a minimal depth of say 50,
782 then it will override all the moves' order of 50 and above. As a
783 result, it is recommended that you set the minimal depth moves order in
784 an increasing depth.
785 It should be noted that the -to or --tests-order option above is
787 equivalent to using this option with a minimal depth of 0.
788 Here are some examples:
790 -to 0123456789 -dto2 30,0138924567
792 This sets the moves' order to 0123456789 for all depths below 30 and to
794 0138924567 for all depths above it.
795 -to 0123457 -dto2 10,750123 -dto2 25,710235
797 This sets the moves' order to 0123457 for depths -9 (those below 10),
799 to 750123 for depths 10-24, and to 710235 for the depths 25 onwards.
800 -to 0123457 -dto2 "10,[012357]=asw(1)"
802 This sorts the moves starting from 10 onward based on the asw()
804 function.
805 -to 0123457 -dto2 "10,[012357]=rand()"
807 This randomises the moves from 10 onward.
809 -to 0123457 -dto2 "10,[012357]"
811 This does the same thing as the previous example.
813 Note : This option should be used instead of the older -dto option
815 given below which mutilates the moves order parameter and is still
816 provided for backward compatibility.
817 -dto [Min Depth],[Moves' Order] , --depth-tests-order [Min Depth],[Moves'
819 Order]
820 This is equivalent to specifying -dto2 [Min Depth],[Min Depth],[Moves'
821 Order] - i.e: the "[Min Depth]," string is prefixed to the given moves
822 order.
823 This option is provided for backward compatibility with older versions
825 of Freecell Solver.
826 -me [Solving Method] , --method [Solving Method]
828 Soft-thread-specific
829 This option specifies the solving method that will be used to solve the
831 board. Currently, the following methods are available:
832 · a-star - A Best-First-Search scan (not "A*" as it was once thought
834 to be)
835 · bfs - A Breadth-First Search (or BFS) scan
837 · dfs - A Depth-First Search (or DFS) scan
839 · random-dfs - A randomized DFS scan
841 · patsolve - uses the scan of patsolve.
843 · soft-dfs - A "soft" DFS scan
845 Starting from recent Freecell Solver versions there is no difference
847 between dfs and soft-dfs. In earlier versions, use of soft-dfs is
848 recommended. random-dfs is similar to soft-dfs only it determines to
849 which states to recurse into randomly. Its behaviour will differ
850 depending on the seed you supply to it. (see the "-seed" option below.)
851 BFS does not yield good results, and a-star has a mixed behaviour, so
853 for the time being I recommend using Soft-DFS or Random-DFS.
854 The Random-DFS scan processes every moves' random group, randomizes the
856 states that it found and recurses into them one by one. Standalone
857 moves that do not belong to any group, are processed in a non-random
858 manner.
859 -asw [BeFS Weights] , --a-star-weight [BeFS Weights]
861 Soft-thread-specific
862 Specify weights for the a-star (= "Best-First Search") scan, assuming
864 it is used. The parameter should be a comma-separated list of numbers,
865 each one is proportional to the weight of its corresponding test.
866 The numbers are, in order:
868 1. The number of cards out.
870 2. The maximal sequence move.
872 3. The number of cards under sequences.
874 4. The length of the sequences which are found over renegade cards.
876 5. The depth of the board in the solution.
878 6. The negative of the number of cards that are not placed above their
880 parents. To get the irreversibility depth, give equal weight to
881 this weight and to the number of cards out.
882 The default weights are respectively: {0.5, 0, 0.3, 0, 0.2, 0}
884 -seed [Seed Number]
886 Soft-thread-specific
887 Specifies a seed to be used by Freecell Solver’s internal random number
889 generator. This seed may alter the behaviour and speed of the
890 random-dfs scan.
891 --set-pruning [Pruning] , -sp [Pruning]
893 Soft-thread-specific
894 This option sets the pruning algorithm for the soft thread. Current
896 valid values are only the empty string ("") for no pruning and r:tf
897 (short for "Run: to foundations") for Horne’s rule. See:
898 https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/topics/214
900 -opt , --optimize-solution
902 Flare-wide
903 This option instructs Freecell Solver to try and optimize the solution
905 path so it will have a smaller number of moves.
906 -opt-to [moves order] , --optimization-tests-order [moves order]
908 Flare-wide
909 This argument specifies the moves order for the optimization scan, in
911 case it should be different than an order that contains all the moves
912 that were used in all the normal scans.
913 --reparent-states
915 Flare-wide
916 This option specifies that states that were encountered whose depth in
918 the states graph can be improved should be reparented to the new
919 parent. This option can possibly make solutions shorter.
920 --calc-real-depth
922 Flare-wide
923 This option becomes effective only if --reparent-states is specified.
925 What it does, is explicitly calculate the depth of the state by tracing
926 its path to the initial state. This may make depth consideration more
927 accurate.
928 --patsolve-x-param [pos],[value]
930 Soft-thread-specific
931 Sets the patsolve’s scan X param (an integer) in position "pos" into
933 "value".
934 Examples:
936 --patsolve-x-param 0,5
938 --patsolve-x-param 2,100
939 --patsolve-y-param [pos],[value]
941 Soft-thread-specific
942 Sets the patsolve Y param (a floating point number) in position "pos"
944 into "value".
945 Examples:
947 --patsolve-y-param 0,0.5
949 --patsolve-y-param 1,103.2
950
952 Starting from Version 2.4.0, Freecell Solver can run several scans in
953 parallel on the same state collection. Each scan resides in its own
954 "Soft Thread". By specifying several soft threads on the command line
955 one can create use several parallel scans. Once one of the scans
956 reaches a solution, the solution will be displayed.
957 -nst , --next-soft-thread
959 Hard-thread-specific
960 This option creates a new soft-thread and makes the following
962 scan-specific options initialize it. For example:
963 $ fc-solve --method a-star -nst --method soft-dfs -to 0123467 myboard.txt
965 will run an BeFS scan and a Soft-DFS scan with a moves order of 0123467
967 on myboard.txt.
968 -step [Step] , --soft-thread-step [Step]
970 Soft-thread-specific
971 This option will set the number of iterations with which to run the
973 soft thread before switching to the next one. By specifying a larger
974 step, one can give a certain scan a longer run-time and a higher
975 priority.
976 Note: after some experimentation, we have concluded that the --prelude
978 option normally yields better results, but -step can be used as a
979 fallback.
980 -nht , --next-hard-thread
982 Flare-wide
983 This argument lets one initialize the next hard thread. If Freecell
985 Solver was compiled with such support, then it is possible to run each
986 hard thread in its own system thread. Each hard-thread contains one or
987 more soft threads.
988 --st-name [soft thread name]
990 Soft-thread-specific
991 This argument sets the name used to identify the current soft thread.
993 This name can later be used to construct the prelude (see below).
994 --prelude [\i1@st1{,\i2@st2{,\i3@st3...}}]
996 Hard-thread-specific
997 Sets the prelude for the hard thread. At the beginning of the search,
999 the hard thread plays a static sequence of iterations at each of the
1000 soft threads specified in the prelude, for the number of iterations
1001 specified.
1002 For example, if you had three soft threads named "foo", "bar" and
1004 "rin", then the following prelude:
1005 --prelude 500@foo,1590@bar,100@foo,200@rin
1007 Will run 500 iterations in "foo", then 1590 in "bar", then 100 in "foo"
1009 again, and then 200 in "rin". After the prelude finishes, the hard
1010 thread would run the scans one after the other in the sequence they
1011 were defined for their step number.
1012 --scans-synergy {none|dead-end-marks}
1014 Flare-wide
1015 Specifies the synergy between the various scans, or how much they
1017 cooperate between themselves. none means they do not cooperate and only
1018 share the same memory resources. dead-end-marks means they try to mark
1019 states that they have withdrawn from, and states whose all their
1020 derived states are such, as "dead ends". This may or may not improve
1021 the speed of the solution.
1022 -ni , --next-instance
1024 Global
1025 This option allows one to run two or more separate solvers one after
1027 the other. If the first one returned an unsolvable verdict, then the
1028 second one would run and so on. One use of it is to run an atomic moves
1029 scan after a meta-moves scan, so we will always get an accurate verdict
1030 and still enjoy some of the speed benefits of the meta-moves scan.
1031 -nf , --next-flare
1033 Instance-wide
1034 Each instance contains several flares. Flares are various alternative
1036 scans, that are ran one after another, as specified in the
1037 --flares-plan below or defaulting to running only the first flare
1038 (which isn’t very useful). Out of all the flares that are successful in
1039 solving a board, Freecell Solver picks the one with the shortest
1040 solution.
1041 --flare-name [flare name]
1043 Flare-wide
1044 This is a name that identifies the flare for use in the flares' plan.
1046 --flares-plan [flare plan]
1048 Instance-wide
1049 This instance-wide parameter gives a plan for the flares as a big
1051 string. Here are some examples:
1052 --flares-plan "RunIndef:FlareyFlare"
1054 This plan will run the flare with the name FlareyFlare indefinitely,
1056 until it terminates. Once a RunIndef action is encountered, the rest of
1057 the plan is ignored.
1058 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare"
1060 Runs MyFlare for 500 iterations and FooFlare for 2,000 iterations. Note
1062 that both flares will be run and won’t share any resources between
1063 them, and then the minimal solution out of both flares (or only those
1064 that finished ). If no flares finished, then Freecell Solver will run
1065 them both again for the same number of iterations each, until at least
1066 one finishes (or it ran out of the iterations' limit).
1067 --flares-plan "Run:500@dfs,Run:1500@befs,CP:,Run:10000@funky"
1069 This runs the flares identified by dfs and befs and then see if a
1071 solution was reached ("CP:" stands for "checkpoint"), and if so yield
1072 it. If both flares did not reach a solution yet, or failed to solve the
1073 board, it will run the flare funky for 10,000 iterations and yield its
1074 solution. And like the previous case, this solution will loop after it
1075 ended for as long as the no flare solved the board or the program did
1076 not run out of iterations.
1077 Using checkpoints one can yield a possibly sub-optimal (as far as
1079 solution length is concerned) solution that will still solve faster
1080 than letting all the flares run.
1081 --flares-choice [choice]
1083 Global
1084 This dictates how to choose the winning flare based on if more than one
1086 yielded a solution. Possible options are:
1087 1. --flares-choice fc_solve - the default, which picks up the
1089 solutions based on the length of the solution in Freecell Solver’s
1090 moves.
1091 2. --flares-choice fcpro - picks up the shortest solution based on the
1093 number of Freecell Pro moves, while not considering implicit moves
1094 to the foundations using Horne’s Prune / Raymond Prune.
1095 -fif [factor] , --flares-iters-factor [factor]
1097 Global
1098 Sets a global, floating-point number, factor to multiply all the
1100 iterations counts in the flares plans. The higher it is, the longer the
1101 scans will take, but there is a greater chance more of them will
1102 succeed, and, as a result, the solution may be shorter.
1103 As an example, the following:
1105 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 2
1107 Is equivalent to:
1109 --flares-plan "Run:1000@MyFlare,Run:4000@FooFlare"
1111 while:
1113 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 0.5
1115 Is equivalent to:
1117 --flares-plan "Run:250@MyFlare,Run:1000@FooFlare"
1119 --cache-limit [cache limit]
1121 Global
1122 This is a numeric limit to the LRU cache which only matters if Freecell
1124 Solver was compiled with FCS_RCS_STATES enabled. This value should be a
1125 positive integer and the higher it is, the more quickly it is likely
1126 that Freecell Solver will run, but it will also consume more memory.
1127 (The entire point of FCS_RCS_STATES is to conserve memory).
1128
1130 --reset
1131 Global
1132 This option resets the program to its initial state, losing all the
1134 configuration logic that was input to it up to that state. Afterwards,
1135 it can be set to a different configuration, again.
1136 --read-from-file [num_skip,]filename
1138 Global (but context-specific).
1139 This option will read the configuration options from a file. The format
1141 of the file is similar to that used by the UNIX Bourne Shell. (i.e:
1142 spaces denote separate arguments, double-quotes encompass arguments,
1143 backslash escapes characters).
1144 The filename can be preceded by an optional number of the arguments to
1146 skip followed by a comma. (the default is 0)
1147 -l [preset] , --load-config [preset]
1149 Global (but context-specific).
1150 Reads the configuration specified by [preset] and configures the solver
1152 accordingly. A preset is a set of command line arguments to be analyzed
1153 in the place of this option. They are read from a set of presetrc files
1154 : one installed system-wide, the other at
1155 $HOME/.freecell-solver/presetrc and the third at the path specified by
1156 the FREECELL_SOLVER_PRESETRC environment variable. You can add more
1157 presets at any of these places. (refer to
1158 http://groups.yahoo.com/group/fc-solve-discuss/message/403 for
1159 information about their format)
1160 Presets that are shipped with Freecell Solver:
1162 ┌────────────────────────────┬─────────────────────────────────────────────────┐
1164 │ │ │
1165 │abra-kadabra │ a meta-moves preset │
1166 ├────────────────────────────┼─────────────────────────────────────────────────┤
1167 │ │ │
1168 │amateur-star │ a meta-moves preset that │
1169 │ │ yields solutions faster on │
1170 │ │ average than three-eighty. │
1171 ├────────────────────────────┼─────────────────────────────────────────────────┤
1172 │ │ │
1173 │blue-yonder │ a meta-moves preset │
1174 │ │ generated by a quota │
1175 │ │ optimization algorithm. │
1176 ├────────────────────────────┼─────────────────────────────────────────────────┤
1177 │ │ │
1178 │children-playing-ball │ a meta-moves and │
1179 │ │ flare-based preset that │
1180 │ │ tends to yield very short │
1181 │ │ solution, but is very slow │
1182 │ │ (solves only 3 boards per │
1183 │ │ second on a Pentium 4 │
1184 │ │ 2.4GHz). │
1185 ├────────────────────────────┼─────────────────────────────────────────────────┤
1186 │ │ │
1187 │conspiracy-theory │ a meta-moves preset that │
1188 │ │ yields solutions faster on │
1189 │ │ average than amateur-star. │
1190 ├────────────────────────────┼─────────────────────────────────────────────────┤
1191 │ │ │
1192 │cookie-monster │ a meta-moves preset that │
1193 │ │ yields solutions faster on │
1194 │ │ average than │
1195 │ │ one-big-family. │
1196 ├────────────────────────────┼─────────────────────────────────────────────────┤
1197 │ │ │
1198 │cool-jives │ a meta-moves preset │
1199 ├────────────────────────────┼─────────────────────────────────────────────────┤
1200 │ │ │
1201 │crooked-nose │ an atomic-moves preset │
1202 │ │ (guarantees an accurate │
1203 │ │ verdict) │
1204 ├────────────────────────────┼─────────────────────────────────────────────────┤
1205 │ │ │
1206 │enlightened-ostrich │ a meta-moves preset (that │
1207 │ │ depends on Freecell Solver │
1208 │ │ 3.4.0 and above) that │
1209 │ │ yields solutions faster on │
1210 │ │ average than foss-nessy. │
1211 ├────────────────────────────┼─────────────────────────────────────────────────┤
1212 │ │ │
1213 │fools-gold │ an atomic-moves preset │
1214 ├────────────────────────────┼─────────────────────────────────────────────────┤
1215 │ │ │
1216 │foss-nessy │ a meta-moves preset (that │
1217 │ │ depends on Freecell Solver │
1218 │ │ 3.2.0 and above) that │
1219 │ │ yields solutions faster on │
1220 │ │ average than │
1221 │ │ the-iglu-cabal. │
1222 ├────────────────────────────┼─────────────────────────────────────────────────┤
1223 │ │ │
1224 │good-intentions │ runs "cool-jives" and then │
1225 │ │ "fools-gold" │
1226 ├────────────────────────────┼─────────────────────────────────────────────────┤
1227 │ │ │
1228 │gooey-unknown-thing │ a meta-moves preset that │
1229 │ │ aims to minimise the │
1230 │ │ outcome solution’s length. │
1231 ├────────────────────────────┼─────────────────────────────────────────────────┤
1232 │ │ │
1233 │hello-world │ a meta-moves preset │
1234 ├────────────────────────────┼─────────────────────────────────────────────────┤
1235 │ │ │
1236 │john-galt-line │ a meta-moves preset │
1237 ├────────────────────────────┼─────────────────────────────────────────────────┤
1238 │ │ │
1239 │looking-glass │ a meta-moves preset that │
1240 │ │ yields solutions faster on │
1241 │ │ average than │
1242 │ │ cookie-monster. │
1243 ├────────────────────────────┼─────────────────────────────────────────────────┤
1244 │ │ │
1245 │maliciously-obscure │ a meta-moves and │
1246 │ │ flare-based preset that │
1247 │ │ tends to yield very short │
1248 │ │ solutions (even in │
1249 │ │ comparison to │
1250 │ │ children-playing-ball ) │
1251 │ │ but is slow. │
1252 ├────────────────────────────┼─────────────────────────────────────────────────┤
1253 │ │ │
1254 │micro-finance │ a meta-moves and │
1255 │ │ flare-based preset that │
1256 │ │ tends to yield very short │
1257 │ │ solutions (even in │
1258 │ │ comparison to │
1259 │ │ maliciously-obscure ) but │
1260 │ │ is even slower. │
1261 ├────────────────────────────┼─────────────────────────────────────────────────┤
1262 │ │ │
1263 │micro-finance-improved │ a meta-moves and │
1264 │ │ flare-based preset, based │
1265 │ │ on micro-finance that │
1266 │ │ yields somewhat shorter │
1267 │ │ solutions on average, and │
1268 │ │ should not be slower. │
1269 ├────────────────────────────┼─────────────────────────────────────────────────┤
1270 │ │ │
1271 │one-big-family │ a meta-moves preset that │
1272 │ │ yields solutions faster on │
1273 │ │ average than │
1274 │ │ conspiracy-theory. │
1275 ├────────────────────────────┼─────────────────────────────────────────────────┤
1276 │ │ │
1277 │qualified-seed │ a meta-moves and │
1278 │ │ flare-based preset, based │
1279 │ │ on micro-finance-improved │
1280 │ │ that yields somewhat │
1281 │ │ shorter solutions on │
1282 │ │ average, and should not be │
1283 │ │ slower. │
1284 ├────────────────────────────┼─────────────────────────────────────────────────┤
1285 │ │ │
1286 │qualified-seed-improved │ qualified-seed with -fif 5 │
1287 │ │ and --flares-choice fcpro │
1288 ├────────────────────────────┼─────────────────────────────────────────────────┤
1289 │ │ │
1290 │rin-tin-tin │ a meta-moves preset │
1291 ├────────────────────────────┼─────────────────────────────────────────────────┤
1292 │ │ │
1293 │sand-stone │ an atomic-moves preset │
1294 │ │ that aims to minimise the │
1295 │ │ outcome solution’s length. │
1296 ├────────────────────────────┼─────────────────────────────────────────────────┤
1297 │ │ │
1298 │slick-rock │ run "gooey-unknown-thing" │
1299 │ │ and then "sand-stone" │
1300 ├────────────────────────────┼─────────────────────────────────────────────────┤
1301 │ │ │
1302 │sentient-pearls │ a meta-moves and flares │
1303 │ │ based preset with short │
1304 │ │ solutions. Much faster │
1305 │ │ than children-playing-ball │
1306 │ │ but yields less optimal │
1307 │ │ solutions. │
1308 ├────────────────────────────┼─────────────────────────────────────────────────┤
1309 │ │ │
1310 │tea-for-two │ a meta-moves preset │
1311 │ │ optimized for │
1312 │ │ two-freecells' Freecell │
1313 │ │ games (although it can │
1314 │ │ work on other │
1315 │ │ Freecell-like games as │
1316 │ │ well). │
1317 ├────────────────────────────┼─────────────────────────────────────────────────┤
1318 │ │ │
1319 │the-iglu-cabal │ a meta-moves preset that │
1320 │ │ yields faster solutions on │
1321 │ │ average than blue-yonder. │
1322 ├────────────────────────────┼─────────────────────────────────────────────────┤
1323 │ │ │
1324 │the-last-mohican │ a preset for solving │
1325 │ │ Simple Simon. Yields less │
1326 │ │ false negatives than the │
1327 │ │ default one, but might be │
1328 │ │ slower. │
1329 ├────────────────────────────┼─────────────────────────────────────────────────┤
1330 │ │ │
1331 │three-eighty │ a meta-moves preset (that │
1332 │ │ depends on Freecell Solver │
1333 │ │ 3.4.0 and above) that │
1334 │ │ yields solutions faster on │
1335 │ │ average than │
1336 │ │ enlightened-ostrich. │
1337 ├────────────────────────────┼─────────────────────────────────────────────────┤
1338 │ │ │
1339 │toons-for-twenty-somethings │ an atomic-moves preset │
1340 │ │ that solves more boards │
1341 │ │ efficiently than │
1342 │ │ "fools-gold". │
1343 ├────────────────────────────┼─────────────────────────────────────────────────┤
1344 │ │ │
1345 │video-editing │ a meta-moves and │
1346 │ │ flare-based preset, based │
1347 │ │ on qualified-seed that │
1348 │ │ yields shorter solutions │
1349 │ │ on average, but may be │
1350 │ │ somewhat slower. Named to │
1351 │ │ commemorate the earlier │
1352 │ │ work of Adrian Ettlinger │
1353 │ │ (1925-2013) │
1354 │ │ <http://en.wikipedia.org/wiki/Adrian_Ettlinger> │
1355 │ │ who later contributed to │
1356 │ │ Freecell Solver and to │
1357 │ │ Freecell research. │
1358 ├────────────────────────────┼─────────────────────────────────────────────────┤
1359 │ │ │
1360 │yellow-brick-road │ a meta-moves preset │
1361 └────────────────────────────┴─────────────────────────────────────────────────┘
1362 They can be abbreviated into their lowercase acronym (i.e: "ak" or
1364 "rtt").
1365
1367 -i , --iter-output
1368 Global
1369 This option tells fc-solve to print the iteration number and the
1371 recursion depth of every state which is checked, to the standard
1372 output. It’s a good way to keep track of how it’s doing, but the output
1373 slows it down a bit.
1374 --iter-output-step [step]
1376 Global
1377 Prints the current iteration if -i is specified, only every [step]
1379 steps, where [step] is a positive integer. For example, if you do
1380 fc-solve -i --iter-output-step 100, you will see this:
1381 Iteration: 0
1383 Iteration: 100
1384 Iteration: 200
1385 Iteration: 300
1386 This option has been added in Freecell Solver 4.20.0 and is useful for
1388 speeding up the runtime process, by avoiding excessive output.
1389 -s , --state-output
1391 Global
1392 This option implies -i. If specified, this option outputs the cards and
1394 formation of the board itself, for every state that is checked.
1395 "fc-solve -s" yields a nice real-time display of the progress of
1396 Freecell Solver, but you usually cannot make what is going on because
1397 it is so fast.
1398
1400 If you are working on a UNIX or a similar system, then you can set some
1401 run-time options in "fc-solve" by sending it some signal combinations.
1402 If you send the fc-solve a single ABRT signal, then fc-solve will
1404 terminate the scan prematurely, and report that the iterations’s limit
1405 has been exceeded.
1406 If you send the signal USR1, without sending any other signals before
1408 that, then fc-solve will output the present number of iterations. This
1409 method is a good way to monitor an instance that takes a long time to
1410 solve.
1411 If you send it the signal USR2 and then USR1, then fc-solve will print
1413 the iteration number and depth on every state that it checks. It is the
1414 equivalent of specifying (or unspecifying) the option -i/--iter-output.
1415 If you send it two USR2 signals and then USR1, then fc-solve will also
1417 print the board of every state. Again, this will only be done assuming
1418 the iteration output is turned on.
1419
1421 Shlomi Fish
1422 2019-12-30 FC-SOLVE(6)