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 6.2.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://www.solitairelaboratory.com/solutioncatalog.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 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 -dto2 [Min Depth],[Moves' Order] , --depth-tests-order2 [Min Depth],[Moves'
778 Order]
779 Soft-thread-specific
780 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 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 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 Here are some examples:
794 -to 0123456789 -dto2 30,0138924567
796 This sets the moves' order to 0123456789 for all depths below 30 and to
798 0138924567 for all depths above it.
799 -to 0123457 -dto2 10,750123 -dto2 25,710235
801 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 -to 0123457 -dto2 "10,[012357]=asw(1)"
806 This sorts the moves starting from 10 onward based on the asw()
808 function.
809 -to 0123457 -dto2 "10,[012357]=rand()"
811 This randomises the moves from 10 onward.
813 -to 0123457 -dto2 "10,[012357]"
815 This does the same thing as the previous example.
817 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 -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 This option is provided for backward compatibility with older versions
829 of Freecell Solver.
830 -me [Solving Method] , --method [Solving Method]
832 Soft-thread-specific
833 This option specifies the solving method that will be used to solve the
835 board. Currently, the following methods are available:
836 • a-star - A Best-First-Search scan (not "A*" as it was once thought
838 to be)
839 • bfs - A Breadth-First Search (or BFS) scan
841 • dfs - A Depth-First Search (or DFS) scan
843 • random-dfs - A randomized DFS scan
845 • patsolve - uses the scan of patsolve.
847 • soft-dfs - A "soft" DFS scan
849 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 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 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 -asw [BeFS Weights] , --a-star-weight [BeFS Weights]
865 Soft-thread-specific
866 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 The numbers are, in order:
872 1. The number of cards out.
874 2. The maximal sequence move.
876 3. The number of cards under sequences.
878 4. The length of the sequences which are found over renegade cards.
880 5. The depth of the board in the solution.
882 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 The default weights are respectively: {0.5, 0, 0.3, 0, 0.2, 0}
888 -seed [Seed Number]
890 Soft-thread-specific
891 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 --set-pruning [Pruning] , -sp [Pruning]
897 Soft-thread-specific
898 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 https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/topics/214
904 -opt , --optimize-solution
906 Flare-wide
907 This option instructs Freecell Solver to try and optimize the solution
909 path so it will have a smaller number of moves.
910 -opt-to [moves order] , --optimization-tests-order [moves order]
912 Flare-wide
913 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 --reparent-states
919 Flare-wide
920 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 --calc-real-depth
926 Flare-wide
927 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 --patsolve-x-param [pos],[value]
934 Soft-thread-specific
935 Sets the patsolve’s scan X param (an integer) in position "pos" into
937 "value".
938 Examples:
940 --patsolve-x-param 0,5
942 --patsolve-x-param 2,100
943 --patsolve-y-param [pos],[value]
945 Soft-thread-specific
946 Sets the patsolve Y param (a floating point number) in position "pos"
948 into "value".
949 Examples:
951 --patsolve-y-param 0,0.5
953 --patsolve-y-param 1,103.2
954
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 -nst , --next-soft-thread
963 Hard-thread-specific
964 This option creates a new soft-thread and makes the following
966 scan-specific options initialize it. For example:
967 $ fc-solve --method a-star -nst --method soft-dfs -to 0123467 myboard.txt
969 will run an BeFS scan and a Soft-DFS scan with a moves order of 0123467
971 on myboard.txt.
972 -step [Step] , --soft-thread-step [Step]
974 Soft-thread-specific
975 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 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 -nht , --next-hard-thread
986 Flare-wide
987 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 --st-name [soft thread name]
994 Soft-thread-specific
995 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 --prelude [\i1@st1{,\i2@st2{,\i3@st3...}}]
1000 Hard-thread-specific
1001 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 For example, if you had three soft threads named "foo", "bar" and
1008 "rin", then the following prelude:
1009 --prelude 500@foo,1590@bar,100@foo,200@rin
1011 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 --scans-synergy {none|dead-end-marks}
1018 Flare-wide
1019 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 -ni , --next-instance
1028 Global
1029 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 -nf , --next-flare
1037 Instance-wide
1038 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 --flare-name [flare name]
1047 Flare-wide
1048 This is a name that identifies the flare for use in the flares' plan.
1050 --flares-plan [flare plan]
1052 Instance-wide
1053 This instance-wide parameter gives a plan for the flares as a big
1055 string. Here are some examples:
1056 --flares-plan "RunIndef:FlareyFlare"
1058 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 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare"
1064 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 --flares-plan "Run:500@dfs,Run:1500@befs,CP:,Run:10000@funky"
1073 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 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 --flares-choice [choice]
1087 Global
1088 This dictates how to choose the winning flare based on if more than one
1090 yielded a solution. Possible options are:
1091 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 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 -fif [factor] , --flares-iters-factor [factor]
1101 Global
1102 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 As an example, the following:
1109 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 2
1111 Is equivalent to:
1113 --flares-plan "Run:1000@MyFlare,Run:4000@FooFlare"
1115 while:
1117 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 0.5
1119 Is equivalent to:
1121 --flares-plan "Run:250@MyFlare,Run:1000@FooFlare"
1123 --cache-limit [cache limit]
1125 Global
1126 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
1134 --reset
1135 Global
1136 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 --read-from-file [num_skip,]filename
1142 Global (but context-specific).
1143 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 The filename can be preceded by an optional number of the arguments to
1150 skip followed by a comma. (the default is 0)
1151 -l [preset] , --load-config [preset]
1153 Global (but context-specific).
1154 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 Presets that are shipped with Freecell Solver:
1166 ┌────────────────────────────┬─────────────────────────────────────────────────┐
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 They can be abbreviated into their lowercase acronym (i.e: "ak" or
1368 "rtt").
1369
1371 -i , --iter-output
1372 Global
1373 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 --iter-output-step [step]
1380 Global
1381 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 Iteration: 0
1387 Iteration: 100
1388 Iteration: 200
1389 Iteration: 300
1390 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 -s , --state-output
1395 Global
1396 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
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 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 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 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 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
1425 Shlomi Fish
1426 2020-10-10 FC-SOLVE(6)