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.10.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,10,J,Q,K. Alternatively, T
50 can be used instead of 10. The card suit is one of: H,S,D,C (standing
51 for Hearts, Spades, Diamonds and Clubs respectively).
52 Here is an example board: (PySol/Microsoft board No. 24)
54 4C 2C 9C 8C QS 4S 2H
56 5H QH 3C AC 3H 4H QD
57 QC 9S 6H 9H 3S KS 3D
58 5D 2S JC 5C JH 6D AS
59 2D KD 10H 10C 10D 8D
60 7H JS KH 10S KC 7C
61 AH 5S 6S AD 8H JD
62 7S 6C 7D 4D 8S 9D
63 Visually, it appears as this:
65 [Freecell Deal No. 24]
67 As can be seen, the four of clubs (4C), five of hearts (5H), etc. are
69 at the bottom of the stacks and the start of the lines in the board
70 input.
71 And another one: (PySol board No. 198246790)
73 KD JH 5H 7D 9H KC 9D
75 3H JD 5D 8H QH 7H 2D
76 4D 3S QC 3C 6S QS KS
77 10C 9S 6D 9C QD 8S 10D
78 10S 8C 7S 10H 2C AS
79 8D AC AH 4H JC 4C
80 6H 7C 4S 5S 5C JS
81 AD KH 6C 2H 3D 2S
82 Starting from Freecell Solver 3.14.x, a stack can also start with a
84 leading colon (":"). This is to allow input from states as output by
85 Freecell Solver using the -p option.
86 You can specify the contents of the freecells by prefixing the line
88 with "FC:" or with "Freecells:". For example:
89 FC: 3H QC
91 will specify that the cards 3 of hearts and queen of clubs are present
93 in the freecells. To specify an empty freecell use a "-" as its
94 designator.
95 If there’s another "FC:" line, the previous line will be overridden.
97 You can specify the contents of the foundations by prefixing the line
99 with "Founds:" or with "Foundations:" and then using a format as
100 follows:
101 Founds: H-5 C-A S-0 D-K
103 Hence, the suit ID followed by a dash followed by the card number in
105 the foundation. A suit that is not present will be assumed to be 0.
106 Again, if there’s more than one line like that, then the previous lines
107 will be ignored and overridden.
108 The program will stop processing the input as soon as it read 8 lines
110 of standard stacks. Therefore, it is recommended that the foundations
111 and freecells lines will come at the beginning of the file.
112 The program will process the board and try to solve it. If it succeeds
114 it will output the states from the initial board to its final solution
115 to the standard output. If it fails, it will notify it.
116 For information about the various command-line switches that Freecell
118 Solver accepts, read the USAGE.txt file in this directory.
119 To solve Simple Simon boards append --game simple_simon right after the
121 "fc-solve" program name.
122
124 Several programs which can generate the initial boards of various
125 Freecell implementations can be found in the "board_gen/"
126 sub-directory. Read the README.txt file there for details on how they
127 can be compiled and used.
128 In any case, they can save you the time of inputting the board
130 yourself.
131
133 A layout in the middle of the MS Freecell deal No. 109 solution:
134 Foundations: H-6 C-9 D-2 S-0
136 Freecells: QS 3S 2S KD
137 : 8H 3D
138 : KS QD JC
139 : AS 8D TD 7D JH TS 9D
140 : 7S 6D
141 : 5S
142 : KH QC JD TC 9H 8S 7H 6S 5D 4S
143 : KC QH JS TH 9S
144 : 4D
145 Similar, but with an empty Freecell:
147 Foundations: H-6 C-9 D-2 S-0
149 Freecells: QS 3S - KD
150 : 8H 3D 2S
151 : KS QD JC
152 : AS 8D TD 7D JH TS 9D
153 : 7S 6D
154 : 5S
155 : KH QC JD TC 9H 8S 7H 6S 5D 4S
156 : KC QH JS TH 9S
157 : 4D
158 Likewise, only without leading colons where unnecessary:
160 Foundations: H-6 C-9 D-2 S-0
162 Freecells: QS 3S - KD
163 8H 3D 2S
164 KS QD JC
165 AS 8D TD 7D JH TS 9D
166 7S 6D
167 5S
168 KH QC JD TC 9H 8S 7H 6S 5D 4S
169 KC QH JS TH 9S
170 4D
171
173 The file USAGE.txt covers all of Freecell Solver’s command line
174 options, but it may be too exhaustive for casual users. As a result,
175 here is a shorter tutorial. First of all whenever invoking fc-solve one
176 should add the flags -p -t -sam -sel which will make the solution
177 easier to understand. Then, assuming the board could be successfully
178 solved, one will be given the layouts in the solution (in the format
179 given above) vis-a-vis with the moves as the string. Note that the
180 indexes of the resources given in the moves are 0-based rather than the
181 more natural 1-based notation.
182
184 Most command-line switches have two versions:
185 · A short POSIX one which is a dash followed by a letter or a few.
187 This option must come standalone and not clustered: -sam is not
188 equivalent to specifying -s, -a and -m.
189 · A long switch which is two dashes followed by the command string.
191 For example: --prelude, --st-name.
192 If command line arguments have parameters, they are followed in
194 separate parameters - Freecell Solver won’t recognise a parameter
195 preceded by an equal sign. --st-name=myname is invalid, while --st-name
196 myname is OK.
197 The Scope of the Options
199 The scope of the options is mentioned along with them. Options can be:
200 1. Global - affects all the soft-threads.
202 2. Instance-specific - affects an instance (separated by the
204 --next-instance option below). Each instance consists of several
205 flares.
206 3. Flare-specific - affects the current flare (separated by the
208 --next-flare option below. Each flare consists of several hard
209 threads.
210 4. Hard-thread-specific - affects the current hard thread (separated
212 by the --next-hard-thread option below. Each hard thread consists
213 of several soft threads.
214 5. Soft-thread-specific - affects only the current soft thread.
216
218 -h , --help
219 Global
220 This option displays a help text on the screen. This help gives a help
222 display summarizing some ways to use the program and get more help.
223 --version
225 Global
226 This option displays the version number of the components that make the
228 executable (and then exits).
229 --help-configs
231 Global
232 Some help on the various configurations of Freecell Solver.
234 --help-options
236 Global
237 A help screen giving an overview of all available options.
239 --help-real-help
241 Global
242 Explains how to change the default help screen to a different one.
244 --help-short-sol
246 Global
247 How to generate shorter solutions.
249 --help-summary
251 Global
252 The default help screen.
254
256 -p , --parseable-output
257 Global
258 This option will display the columns in a format that can be more
260 easily manipulated by text-processing programs such as grep or perl.
261 Namely, The freecells will be displayed in one line, and the
262 foundations in a separate line. Plus, Each column will be displayed
263 horizontally, in its own line, while beginning with a :.
264 -t , --display-10-as-t
266 Global
267 This option will display the 10 cards as a capital T +instead of a +10.
269 Thus, the cards will be more properly aligned.
270 For example, here is a command line using -p and -t:
272 $ pi-make-microsoft-freecell-board 24 | fc-solve -p -t
274 -=-=-=-=-=-=-=-=-=-=-=-
275 Foundations: H-0 C-0 D-0 S-0
277 Freecells:
278 : 4C 2C 9C 8C QS 4S 2H
279 : 5H QH 3C AC 3H 4H QD
280 : QC 9S 6H 9H 3S KS 3D
281 : 5D 2S JC 5C JH 6D AS
282 : 2D KD TH TC TD 8D
283 : 7H JS KH TS KC 7C
284 : AH 5S 6S AD 8H JD
285 : 7S 6C 7D 4D 8S 9D
286 ====================
289 Foundations: H-0 C-0 D-0 S-A
291 Freecells:
292 : 4C 2C 9C 8C QS 4S 2H
293 : 5H QH 3C AC 3H 4H QD
294 : QC 9S 6H 9H 3S KS 3D
295 : 5D 2S JC 5C JH 6D
296 : 2D KD TH TC TD 8D
297 : 7H JS KH TS KC 7C
298 : AH 5S 6S AD 8H JD
299 : 7S 6C 7D 4D 8S 9D
300 -c , --canonized-order-output
302 Global
303 Freecell Solver re-arranges the stacks and freecells in a given state
305 according to their first card. It keeps their actual position in a
306 separate place, but internally it uses their canonized place. Use this
307 option, if you want Freecell Solver to display them in that order. One
308 should be warned that that way the place of a given stack in the board
309 will not be preserved throughout the solution.
310 -m , --display-moves
312 Global
313 This option will display the moves instead of the intermediate states.
315 Each move will be displayed in a separate line, in a format that is
316 human-readable, but that can also be parsed and analyzed by a computer
317 program with some effort on the programmer’s part.
318 For example:
320 $ pi-make-microsoft-freecell-board 24 | fc-solve -m | head -30
322 -=-=-=-=-=-=-=-=-=-=-=-
323 Move a card from stack 3 to the foundations
325 ====================
327 Move a card from stack 6 to freecell 0
329 ====================
331 Move a card from stack 6 to freecell 1
333 -sn , --standard-notation
335 Global
336 This option will display the moves in standard notation in which every
338 move consists of two characters and there are ten moves in a line.
339 Naturally, this option will only become apparent if the display moves
340 is specified. (it does not implicitly specify it, though).
341 For more information regarding standard notation refer to the following
343 web-page:
344 http://home.earthlink.net/~fomalhaut/freecell.html
346 -snx , --standard-notation-extended
348 Global
349 This option is similar to the previous one, except that when a sequence
351 move is made to an empty stack with more than one card in the sequence,
352 the move will be followed with "v" and the number of cards moved in
353 hexadecimal.
354 -sam , --display-states-and-moves
356 Global
357 This option will display both the intermediate states and the moves
359 that are needed to move from one to another. The standard notation
360 option applies to it to.
361 $ pi-make-microsoft-freecell-board 24 | fc-solve -sam -p -t | head -50
363 -=-=-=-=-=-=-=-=-=-=-=-
364 Foundations: H-0 C-0 D-0 S-0
366 Freecells:
367 : 4C 2C 9C 8C QS 4S 2H
368 : 5H QH 3C AC 3H 4H QD
369 : QC 9S 6H 9H 3S KS 3D
370 : 5D 2S JC 5C JH 6D AS
371 : 2D KD TH TC TD 8D
372 : 7H JS KH TS KC 7C
373 : AH 5S 6S AD 8H JD
374 : 7S 6C 7D 4D 8S 9D
375 ====================
378 Move a card from stack 3 to the foundations
380 Foundations: H-0 C-0 D-0 S-A
382 Freecells:
383 : 4C 2C 9C 8C QS 4S 2H
384 : 5H QH 3C AC 3H 4H QD
385 : QC 9S 6H 9H 3S KS 3D
386 : 5D 2S JC 5C JH 6D
387 : 2D KD TH TC TD 8D
388 : 7H JS KH TS KC 7C
389 : AH 5S 6S AD 8H JD
390 : 7S 6C 7D 4D 8S 9D
391 ====================
394 Move a card from stack 6 to freecell 0
396 Foundations: H-0 C-0 D-0 S-A
398 Freecells: JD
399 : 4C 2C 9C 8C QS 4S 2H
400 : 5H QH 3C AC 3H 4H QD
401 : QC 9S 6H 9H 3S KS 3D
402 : 5D 2S JC 5C JH 6D
403 : 2D KD TH TC TD 8D
404 : 7H JS KH TS KC 7C
405 : AH 5S 6S AD 8H
406 : 7S 6C 7D 4D 8S 9D
407 ====================
410 Move a card from stack 6 to freecell 1
412 -pi , --display-parent-iter
414 Global
415 This option (assuming the -s and -i options are specified) will also
417 display the iteration index of the state from which the current state
418 was derived. This is especially useful for BeFS (so-called a-star) or
419 BFS scans.
420 -o [filename] , --output [filename]
422 Global
423 Outputs to a file instead of standard output. So for example:
425 $ fc-solve -o 2405.solution.txt 2405.board
427 Will put the solution to the file in 2405.board in the file
429 2405.solution.txt . This will also be done using:
430 $ fc-solve --output 2405.solution.txt 2405.board
432 -sel , --show-exceeded-limits
434 Global
435 This option will display a different status message ("Iterations count
437 exceeded.") instead of "I could not solve this game." in case the
438 iterations count was exceeded. This is recommended because the "I could
439 not solve this game." message can also mean that the entire game graph
440 was fully traversed (within the limitations of the specified moves'
441 types) and so no solution is possible.
442 This option is not the default, to retain compatibility with previous
444 versions of Freecell Solver, and was added in version 3.12.0 of
445 fc-solve.
446 -hoi , --hint-on-intractable
448 Global
449 Presents the moves to the intermediate reached state, if the maximal
451 number of iterations was reached without a conclusion (=
452 "intractable").
453 This option is not the default, to retain compatibility with previous
455 versions of Freecell Solver, and was added in version 4.20.0 of
456 fc-solve.
457
459 --freecells-num [Number of Freecells]
460 Global
461 This option specifies the number of freecells which are available to
463 the program. Freecell Solver can use any number of freecells as long as
464 it does not exceed its maximal number.
465 This maximum is hard-coded into the program, and can be specified at
467 compile-time by modifying the file config.h. See the file INSTALL (or
468 alternatively INSTALL.html) for details.
469 --stacks-num [Number of Stacks]
471 Global
472 This option specifies the number of stacks present in the board. Again,
474 this number cannot exceed the maximal number of stacks, which can be
475 specified in the file config.h during compile-time of Freecell Solver.
476 --decks-num [Number of Decks]
478 Global
479 This options specifies how many decks are found in the board. This
481 number cannot exceed the maximal number of decks, which can be
482 specified by the Freecell Solver build system.
483 --sequences-are-built-by {suit|alternate_color|rank}
485 Global
486 This option specifies whether a card sequence is built by suit or by
488 alternate colour or by rank regardless of suit.
489 --sequence-move {limited|unlimited}
491 Global
492 This option specifies whether the sequence move is limited by the
494 number of freecells or vacant stacks or not.
495 --empty-stacks-filled-by {kings|none|all}
497 Global
498 Specifies which cards can fill an empty stack.
500 --game [game] , --preset [game] , -g [game]
502 Global
503 Specifies the type of game. Each preset implies several of the settings
505 options above and sometimes even the moves’ order below. The default
506 configuration is for Freecell.
507 Available presets:
509 ┌───────────────────┬──────────────────────────┐
511 │ │ │
512 │bakers_dozen │ Baker’s Dozen │
513 ├───────────────────┼──────────────────────────┤
514 │ │ │
515 │bakers_game │ Baker’s Game │
516 ├───────────────────┼──────────────────────────┤
517 │ │ │
518 │beleaguered_castle │ Beleaguered Castle │
519 ├───────────────────┼──────────────────────────┤
520 │ │ │
521 │citadel │ Citadel │
522 ├───────────────────┼──────────────────────────┤
523 │ │ │
524 │cruel │ Cruel │
525 ├───────────────────┼──────────────────────────┤
526 │ │ │
527 │der_katz │ Der Katzenschwanz │
528 ├───────────────────┼──────────────────────────┤
529 │ │ │
530 │die_schlange │ Die Schlange │
531 ├───────────────────┼──────────────────────────┤
532 │ │ │
533 │eight_off │ Eight Off │
534 ├───────────────────┼──────────────────────────┤
535 │ │ │
536 │fan │ Fan │
537 ├───────────────────┼──────────────────────────┤
538 │ │ │
539 │forecell │ Forecell │
540 ├───────────────────┼──────────────────────────┤
541 │ │ │
542 │freecell │ Freecell (default) │
543 ├───────────────────┼──────────────────────────┤
544 │ │ │
545 │good_measure │ Good Measure │
546 ├───────────────────┼──────────────────────────┤
547 │ │ │
548 │ko_bakers_game │ Kings' Only Baker’s Game │
549 ├───────────────────┼──────────────────────────┤
550 │ │ │
551 │relaxed_freecell │ Relaxed Freecell │
552 ├───────────────────┼──────────────────────────┤
553 │ │ │
554 │relaxed_sehaven │ Relaxed Seahaven Towers │
555 ├───────────────────┼──────────────────────────┤
556 │ │ │
557 │seahaven │ Seahaven Towers │
558 ├───────────────────┼──────────────────────────┤
559 │ │ │
560 │simple_simon │ Simple Simon │
561 ├───────────────────┼──────────────────────────┤
562 │ │ │
563 │streets_and_alleys │ Streets and Alleys │
564 └───────────────────┴──────────────────────────┘
565 Note: in order to solve Der Katzenschwanz and Die Schlange I recommend
567 you compile Freecell Solver with the INDIRECT_STACK_STATES option, or
568 else it will consume much more memory. For details consult the file
569 INSTALL.
570 Examples
572 To solve PySol Eight Off game No. 1,000 type:
573 $ make_pysol_freecell_board.py 1000 eight_off | fc-solve -g eight_off
575 To solve PySol Baker’s Game No. 50, type:
577 $ make_pysol_freecell_board.py 50 bakers_game | fc-solve -g bakers_game
579 If you want to solve a game similar to Freecell only with sequences
581 built by rank, and unlimited sequence move, do:
582 $ fc-solve -g freecell --sequences-are-built-by rank --sequence-move unlimited
584
586 -mi [Iterations num] , --max-iters [Iterations num]
587 Global
588 This parameter limits the maximal number of states to check. This will
590 give a rough limit on the time spent to solve a given board.
591 -md [Maximal depth] , --max-depth [Maximal depth]
593 Not currently implemented
594 Freecell Solver recurses into the solution. This parameter specifies a
596 maximal recursion depth. Generally speaking, it’s not a good idea to
597 set it, because that way several important intermediate states may
598 become inaccessible.
599 -mss [num] , --max-stored-states [num]
601 Global
602 Limits the number of the states stored by the program in the computer’s
604 memory. This differs from the maximal number of iterations in the
605 sense, that it is possible that a stored state was not checked yet.
606 -tmss [num] , --trim-max-stored-states [num]
608 Instance-wide
609 This also limits the number of trimmed stored states, but this time
611 will try to trim them once the limit has been reached (which is time
612 consuming and may cause states to be traversed again in the future).
613 -to [Moves’ Order] , --tests-order [Moves Order]
615 Soft-thread-specific
616 This option specifies the order in which Freecell Solver will try the
618 different types of moves (formerly termed "tests") that it can perform.
619 Each move is specified by one character, and they are performed in the
620 order in which they appear in the parameter string. You can omit moves
621 by not including their corresponding characters in the string.
622 The moves along with their characters are:
624 ┌───────────────────────┬────────────────────────────┐
626 │ │ │
627 │Freecell Moves: │ │
628 ├───────────────────────┼────────────────────────────┤
629 │ │ │
630 │0 │ put top stack cards in the │
631 │ │ foundations. │
632 ├───────────────────────┼────────────────────────────┤
633 │ │ │
634 │1 │ put freecell cards in the │
635 │ │ foundations. │
636 ├───────────────────────┼────────────────────────────┤
637 │ │ │
638 │2 │ put freecell cards on top │
639 │ │ of stacks. │
640 ├───────────────────────┼────────────────────────────┤
641 │ │ │
642 │3 │ put non-top stack cards in │
643 │ │ the foundations. │
644 ├───────────────────────┼────────────────────────────┤
645 │ │ │
646 │4 │ move stack cards to │
647 │ │ different stacks. │
648 ├───────────────────────┼────────────────────────────┤
649 │ │ │
650 │5 │ move stack cards to a │
651 │ │ parent card on the same │
652 │ │ stack. │
653 ├───────────────────────┼────────────────────────────┤
654 │ │ │
655 │6 │ move sequences of cards │
656 │ │ onto free stacks. │
657 ├───────────────────────┼────────────────────────────┤
658 │ │ │
659 │7 │ put freecell cards on │
660 │ │ empty stacks. │
661 ├───────────────────────┼────────────────────────────┤
662 │ │ │
663 │8 │ move cards to a different │
664 │ │ parent. │
665 ├───────────────────────┼────────────────────────────┤
666 │ │ │
667 │9 │ empty an entire stack into │
668 │ │ the freecells. │
669 ├───────────────────────┼────────────────────────────┤
670 │ │ │
671 │j │ put freecell cards on │
672 │ │ empty stacks and right │
673 │ │ away put cards on top. │
674 ├───────────────────────┼────────────────────────────┤
675 │ │ │
676 │Atomic Freecell Moves: │ │
677 ├───────────────────────┼────────────────────────────┤
678 │ │ │
679 │A │ move a stack card to an │
680 │ │ empty stack. │
681 ├───────────────────────┼────────────────────────────┤
682 │ │ │
683 │B │ move a stack card to a │
684 │ │ parent on a different │
685 │ │ stack. │
686 ├───────────────────────┼────────────────────────────┤
687 │ │ │
688 │C │ move a stack card to a │
689 │ │ freecell. │
690 ├───────────────────────┼────────────────────────────┤
691 │ │ │
692 │D │ move a freecell card to a │
693 │ │ parent. │
694 ├───────────────────────┼────────────────────────────┤
695 │ │ │
696 │E │ move a freecell card to an │
697 │ │ empty stack. │
698 ├───────────────────────┼────────────────────────────┤
699 │ │ │
700 │Simple Simon Moves: │ │
701 ├───────────────────────┼────────────────────────────┤
702 │ │ │
703 │a │ move a full sequence to │
704 │ │ the foundations. │
705 ├───────────────────────┼────────────────────────────┤
706 │ │ │
707 │b │ move a sequence to a true │
708 │ │ parent of his. │
709 ├───────────────────────┼────────────────────────────┤
710 │ │ │
711 │c │ move a whole stack │
712 │ │ sequence to a false parent │
713 │ │ (in order to clear the │
714 │ │ stack) │
715 ├───────────────────────┼────────────────────────────┤
716 │ │ │
717 │d │ move a sequence to a true │
718 │ │ parent that has some cards │
719 │ │ above it. │
720 ├───────────────────────┼────────────────────────────┤
721 │ │ │
722 │e │ move a sequence with some │
723 │ │ cards above it to a true │
724 │ │ parent. │
725 ├───────────────────────┼────────────────────────────┤
726 │ │ │
727 │f │ move a sequence with a │
728 │ │ junk sequence above it to │
729 │ │ a true parent that has │
730 │ │ some cards above it. │
731 ├───────────────────────┼────────────────────────────┤
732 │ │ │
733 │g │ move a whole stack │
734 │ │ sequence to a false parent │
735 │ │ which has some cards above │
736 │ │ it. │
737 ├───────────────────────┼────────────────────────────┤
738 │ │ │
739 │h │ move a sequence to a │
740 │ │ parent on the same stack. │
741 ├───────────────────────┼────────────────────────────┤
742 │ │ │
743 │i │ move any sequence to a │
744 │ │ false parent (using it may │
745 │ │ make the solution much │
746 │ │ slower). │
747 └───────────────────────┴────────────────────────────┘
748 Manipulating the moves order can be very helpful to the quick solution
750 of a given board. If you found that a certain board cannot be solved in
751 after a long time or in a certain maximal number of iterations, you
752 should try different moves' orders. Usually, one can find a moves order
753 that solves a board very quickly.
754 Note that this moves order usually makes sense only for the Soft-DFS
756 and Random DFS scans (see the --method option below).
757 Also note that Freecell moves are not suitable for solving Simple Simon
759 games and Simple Simon moves are not suitable for solving anything
760 except Simple Simon.
761 Moves can be grouped together into groups using parenthesis (e.g:
763 "(0123)") or square brackets ("[012][3456789]"). Such grouping is only
764 relevant to the Random DFS scan (see below). A group may optionally be
765 followed by the equal sign "=" and by an ordering specifier. If one
766 specifies "=rand()", then the derived states will be randomised based
767 on the seed (which is what happens if no equal sign is specified). On
768 the other hand, if one specifies something like "=asw(5,0,5,0,0,5)",
769 then the numbers inside the parentheses will be treated as weights for
770 the same ordering function used by the -asw flag (see below).
771 -dto2 [Min Depth],[Moves' Order] , --depth-tests-order2 [Min Depth],[Moves'
773 Order]
774 Soft-thread-specific
775 Sets the Moves' order starting from the minimal depth onwards. This
777 way, if a Soft-DFS scan recurses deeply into the game, it will use a
778 different moves' order.
779 Note that if you set the moves' order of a minimal depth of say 50,
781 then it will override all the moves' order of 50 and above. As a
782 result, it is recommended that you set the minimal depth moves order in
783 an increasing depth.
784 It should be noted that the -to or --tests-order option above is
786 equivalent to using this option with a minimal depth of 0.
787 Here are some examples:
789 -to 0123456789 -dto2 30,0138924567
791 This sets the moves' order to 0123456789 for all depths below 30 and to
793 0138924567 for all depths above it.
794 -to 0123457 -dto2 10,750123 -dto2 25,710235
796 This sets the moves' order to 0123457 for depths -9 (those below 10),
798 to 750123 for depths 10-24, and to 710235 for the depths 25 onwards.
799 -to 0123457 -dto2 "10,[012357]=asw(1)"
801 This sorts the moves starting from 10 onward based on the asw()
803 function.
804 -to 0123457 -dto2 "10,[012357]=rand()"
806 This randomises the moves from 10 onward.
808 -to 0123457 -dto2 "10,[012357]"
810 This does the same thing as the previous example.
812 Note : This option should be used instead of the older -dto option
814 given below which mutilates the moves order parameter and is still
815 provided for backward compatibility.
816 -dto [Min Depth],[Moves' Order] , --depth-tests-order [Min Depth],[Moves'
818 Order]
819 This is equivalent to specifying -dto2 [Min Depth],[Min Depth],[Moves'
820 Order] - i.e: the "[Min Depth]," string is prefixed to the given moves
821 order.
822 This option is provided for backward compatibility with older versions
824 of Freecell Solver.
825 -me [Solving Method] , --method [Solving Method]
827 Soft-thread-specific
828 This option specifies the solving method that will be used to solve the
830 board. Currently, the following methods are available:
831 · a-star - A Best-First-Search scan (not "A*" as it was once thought
833 to be)
834 · bfs - A Breadth-First Search (or BFS) scan
836 · dfs - A Depth-First Search (or DFS) scan
838 · random-dfs - A randomized DFS scan
840 · patsolve - uses the scan of patsolve.
842 · soft-dfs - A "soft" DFS scan
844 Starting from recent Freecell Solver versions there is no difference
846 between dfs and soft-dfs. In earlier versions, use of soft-dfs is
847 recommended. random-dfs is similar to soft-dfs only it determines to
848 which states to recurse into randomly. Its behaviour will differ
849 depending on the seed you supply to it. (see the "-seed" option below.)
850 BFS does not yield good results, and a-star has a mixed behaviour, so
852 for the time being I recommend using Soft-DFS or Random-DFS.
853 The Random-DFS scan processes every moves' random group, randomizes the
855 states that it found and recurses into them one by one. Standalone
856 moves that do not belong to any group, are processed in a non-random
857 manner.
858 -asw [BeFS Weights] , --a-star-weight [BeFS Weights]
860 Soft-thread-specific
861 Specify weights for the a-star (= "Best-First Search") scan, assuming
863 it is used. The parameter should be a comma-separated list of numbers,
864 each one is proportional to the weight of its corresponding test.
865 The numbers are, in order:
867 1. The number of cards out.
869 2. The maximal sequence move.
871 3. The number of cards under sequences.
873 4. The length of the sequences which are found over renegade cards.
875 5. The depth of the board in the solution.
877 6. The negative of the number of cards that are not placed above their
879 parents. To get the irreversibility depth, give equal weight to
880 this weight and to the number of cards out.
881 The default weights are respectively: {0.5, 0, 0.3, 0, 0.2, 0}
883 -seed [Seed Number]
885 Soft-thread-specific
886 Specifies a seed to be used by Freecell Solver’s internal random number
888 generator. This seed may alter the behaviour and speed of the
889 random-dfs scan.
890 --set-pruning [Pruning] , -sp [Pruning]
892 Soft-thread-specific
893 This option sets the pruning algorithm for the soft thread. Current
895 valid values are only the empty string ("") for no pruning and r:tf
896 (short for "Run: to foundations") for Horne’s rule. See:
897 https://groups.yahoo.com/neo/groups/fc-solve-discuss/conversations/topics/214
899 -opt , --optimize-solution
901 Flare-wide
902 This option instructs Freecell Solver to try and optimize the solution
904 path so it will have a smaller number of moves.
905 -opt-to [moves order] , --optimization-tests-order [moves order]
907 Flare-wide
908 This argument specifies the moves order for the optimization scan, in
910 case it should be different than an order that contains all the moves
911 that were used in all the normal scans.
912 --reparent-states
914 Flare-wide
915 This option specifies that states that were encountered whose depth in
917 the states graph can be improved should be reparented to the new
918 parent. This option can possibly make solutions shorter.
919 --calc-real-depth
921 Flare-wide
922 This option becomes effective only if --reparent-states is specified.
924 What it does, is explicitly calculate the depth of the state by tracing
925 its path to the initial state. This may make depth consideration more
926 accurate.
927 --patsolve-x-param [pos],[value]
929 Soft-thread-specific
930 Sets the patsolve’s scan X param (an integer) in position "pos" into
932 "value".
933 Examples:
935 --patsolve-x-param 0,5
937 --patsolve-x-param 2,100
938 --patsolve-y-param [pos],[value]
940 Soft-thread-specific
941 Sets the patsolve Y param (a floating point number) in position "pos"
943 into "value".
944 Examples:
946 --patsolve-y-param 0,0.5
948 --patsolve-y-param 1,103.2
949
951 Starting from Version 2.4.0, Freecell Solver can run several scans in
952 parallel on the same state collection. Each scan resides in its own
953 "Soft Thread". By specifying several soft threads on the command line
954 one can create use several parallel scans. Once one of the scans
955 reaches a solution, the solution will be displayed.
956 -nst , --next-soft-thread
958 Hard-thread-specific
959 This option creates a new soft-thread and makes the following
961 scan-specific options initialize it. For example:
962 $ fc-solve --method a-star -nst --method soft-dfs -to 0123467 myboard.txt
964 will run an BeFS scan and a Soft-DFS scan with a moves order of 0123467
966 on myboard.txt.
967 -step [Step] , --soft-thread-step [Step]
969 Soft-thread-specific
970 This option will set the number of iterations with which to run the
972 soft thread before switching to the next one. By specifying a larger
973 step, one can give a certain scan a longer run-time and a higher
974 priority.
975 Note: after some experimentation, we have concluded that the --prelude
977 option normally yields better results, but -step can be used as a
978 fallback.
979 -nht , --next-hard-thread
981 Flare-wide
982 This argument lets one initialize the next hard thread. If Freecell
984 Solver was compiled with such support, then it is possible to run each
985 hard thread in its own system thread. Each hard-thread contains one or
986 more soft threads.
987 --st-name [soft thread name]
989 Soft-thread-specific
990 This argument sets the name used to identify the current soft thread.
992 This name can later be used to construct the prelude (see below).
993 --prelude [\i1@st1{,\i2@st2{,\i3@st3...}}]
995 Hard-thread-specific
996 Sets the prelude for the hard thread. At the beginning of the search,
998 the hard thread plays a static sequence of iterations at each of the
999 soft threads specified in the prelude, for the number of iterations
1000 specified.
1001 For example, if you had three soft threads named "foo", "bar" and
1003 "rin", then the following prelude:
1004 --prelude 500@foo,1590@bar,100@foo,200@rin
1006 Will run 500 iterations in "foo", then 1590 in "bar", then 100 in "foo"
1008 again, and then 200 in "rin". After the prelude finishes, the hard
1009 thread would run the scans one after the other in the sequence they
1010 were defined for their step number.
1011 --scans-synergy {none|dead-end-marks}
1013 Flare-wide
1014 Specifies the synergy between the various scans, or how much they
1016 cooperate between themselves. none means they do not cooperate and only
1017 share the same memory resources. dead-end-marks means they try to mark
1018 states that they have withdrawn from, and states whose all their
1019 derived states are such, as "dead ends". This may or may not improve
1020 the speed of the solution.
1021 -ni , --next-instance
1023 Global
1024 This option allows one to run two or more separate solvers one after
1026 the other. If the first one returned an unsolvable verdict, then the
1027 second one would run and so on. One use of it is to run an atomic moves
1028 scan after a meta-moves scan, so we will always get an accurate verdict
1029 and still enjoy some of the speed benefits of the meta-moves scan.
1030 -nf , --next-flare
1032 Instance-wide
1033 Each instance contains several flares. Flares are various alternative
1035 scans, that are ran one after another, as specified in the
1036 --flares-plan below or defaulting to running only the first flare
1037 (which isn’t very useful). Out of all the flares that are successful in
1038 solving a board, Freecell Solver picks the one with the shortest
1039 solution.
1040 --flare-name [flare name]
1042 Flare-wide
1043 This is a name that identifies the flare for use in the flares' plan.
1045 --flares-plan [flare plan]
1047 Instance-wide
1048 This instance-wide parameter gives a plan for the flares as a big
1050 string. Here are some examples:
1051 --flares-plan "RunIndef:FlareyFlare"
1053 This plan will run the flare with the name FlareyFlare indefinitely,
1055 until it terminates. Once a RunIndef action is encountered, the rest of
1056 the plan is ignored.
1057 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare"
1059 Runs MyFlare for 500 iterations and FooFlare for 2,000 iterations. Note
1061 that both flares will be run and won’t share any resources between
1062 them, and then the minimal solution out of both flares (or only those
1063 that finished ). If no flares finished, then Freecell Solver will run
1064 them both again for the same number of iterations each, until at least
1065 one finishes (or it ran out of the iterations' limit).
1066 --flares-plan "Run:500@dfs,Run:1500@befs,CP:,Run:10000@funky"
1068 This runs the flares identified by dfs and befs and then see if a
1070 solution was reached ("CP:" stands for "checkpoint"), and if so yield
1071 it. If both flares did not reach a solution yet, or failed to solve the
1072 board, it will run the flare funky for 10,000 iterations and yield its
1073 solution. And like the previous case, this solution will loop after it
1074 ended for as long as the no flare solved the board or the program did
1075 not run out of iterations.
1076 Using checkpoints one can yield a possibly sub-optimal (as far as
1078 solution length is concerned) solution that will still solve faster
1079 than letting all the flares run.
1080 --flares-choice [choice]
1082 Global
1083 This dictates how to choose the winning flare based on if more than one
1085 yielded a solution. Possible options are:
1086 1. --flares-choice fc_solve - the default, which picks up the
1088 solutions based on the length of the solution in Freecell Solver’s
1089 moves.
1090 2. --flares-choice fcpro - picks up the shortest solution based on the
1092 number of Freecell Pro moves, while not considering implicit moves
1093 to the foundations using Horne’s Prune / Raymond Prune.
1094 -fif [factor] , --flares-iters-factor [factor]
1096 Global
1097 Sets a global, floating-point number, factor to multiply all the
1099 iterations counts in the flares plans. The higher it is, the longer the
1100 scans will take, but there is a greater chance more of them will
1101 succeed, and, as a result, the solution may be shorter.
1102 As an example, the following:
1104 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 2
1106 Is equivalent to:
1108 --flares-plan "Run:1000@MyFlare,Run:4000@FooFlare"
1110 while:
1112 --flares-plan "Run:500@MyFlare,Run:2000@FooFlare" --flares-iters-factor 0.5
1114 Is equivalent to:
1116 --flares-plan "Run:250@MyFlare,Run:1000@FooFlare"
1118 --cache-limit [cache limit]
1120 Global
1121 This is a numeric limit to the LRU cache which only matters if Freecell
1123 Solver was compiled with FCS_RCS_STATES enabled. This value should be a
1124 positive integer and the higher it is, the more quickly it is likely
1125 that Freecell Solver will run, but it will also consume more memory.
1126 (The entire point of FCS_RCS_STATES is to conserve memory).
1127
1129 --reset
1130 Global
1131 This option resets the program to its initial state, losing all the
1133 configuration logic that was input to it up to that state. Afterwards,
1134 it can be set to a different configuration, again.
1135 --read-from-file [num_skip,]filename
1137 Global (but context-specific).
1138 This option will read the configuration options from a file. The format
1140 of the file is similar to that used by the UNIX Bourne Shell. (i.e:
1141 spaces denote separate arguments, double-quotes encompass arguments,
1142 backslash escapes characters).
1143 The filename can be preceded by an optional number of the arguments to
1145 skip followed by a comma. (the default is 0)
1146 -l [preset] , --load-config [preset]
1148 Global (but context-specific).
1149 Reads the configuration specified by [preset] and configures the solver
1151 accordingly. A preset is a set of command line arguments to be analyzed
1152 in the place of this option. They are read from a set of presetrc files
1153 : one installed system-wide, the other at
1154 $HOME/.freecell-solver/presetrc and the third at the path specified by
1155 the FREECELL_SOLVER_PRESETRC environment variable. You can add more
1156 presets at any of these places. (refer to
1157 http://groups.yahoo.com/group/fc-solve-discuss/message/403 for
1158 information about their format)
1159 Presets that are shipped with Freecell Solver:
1161 ┌────────────────────────────┬─────────────────────────────────────────────────┐
1163 │ │ │
1164 │abra-kadabra │ a meta-moves preset │
1165 ├────────────────────────────┼─────────────────────────────────────────────────┤
1166 │ │ │
1167 │amateur-star │ a meta-moves preset that │
1168 │ │ yields solutions faster on │
1169 │ │ average than three-eighty. │
1170 ├────────────────────────────┼─────────────────────────────────────────────────┤
1171 │ │ │
1172 │blue-yonder │ a meta-moves preset │
1173 │ │ generated by a quota │
1174 │ │ optimization algorithm. │
1175 ├────────────────────────────┼─────────────────────────────────────────────────┤
1176 │ │ │
1177 │children-playing-ball │ a meta-moves and │
1178 │ │ flare-based preset that │
1179 │ │ tends to yield very short │
1180 │ │ solution, but is very slow │
1181 │ │ (solves only 3 boards per │
1182 │ │ second on a Pentium 4 │
1183 │ │ 2.4GHz). │
1184 ├────────────────────────────┼─────────────────────────────────────────────────┤
1185 │ │ │
1186 │conspiracy-theory │ a meta-moves preset that │
1187 │ │ yields solutions faster on │
1188 │ │ average than amateur-star. │
1189 ├────────────────────────────┼─────────────────────────────────────────────────┤
1190 │ │ │
1191 │cookie-monster │ a meta-moves preset that │
1192 │ │ yields solutions faster on │
1193 │ │ average than │
1194 │ │ one-big-family. │
1195 ├────────────────────────────┼─────────────────────────────────────────────────┤
1196 │ │ │
1197 │cool-jives │ a meta-moves preset │
1198 ├────────────────────────────┼─────────────────────────────────────────────────┤
1199 │ │ │
1200 │crooked-nose │ an atomic-moves preset │
1201 │ │ (guarantees an accurate │
1202 │ │ verdict) │
1203 ├────────────────────────────┼─────────────────────────────────────────────────┤
1204 │ │ │
1205 │enlightened-ostrich │ a meta-moves preset (that │
1206 │ │ depends on Freecell Solver │
1207 │ │ 3.4.0 and above) that │
1208 │ │ yields solutions faster on │
1209 │ │ average than foss-nessy. │
1210 ├────────────────────────────┼─────────────────────────────────────────────────┤
1211 │ │ │
1212 │fools-gold │ an atomic-moves preset │
1213 ├────────────────────────────┼─────────────────────────────────────────────────┤
1214 │ │ │
1215 │foss-nessy │ a meta-moves preset (that │
1216 │ │ depends on Freecell Solver │
1217 │ │ 3.2.0 and above) that │
1218 │ │ yields solutions faster on │
1219 │ │ average than │
1220 │ │ the-iglu-cabal. │
1221 ├────────────────────────────┼─────────────────────────────────────────────────┤
1222 │ │ │
1223 │good-intentions │ runs "cool-jives" and then │
1224 │ │ "fools-gold" │
1225 ├────────────────────────────┼─────────────────────────────────────────────────┤
1226 │ │ │
1227 │gooey-unknown-thing │ a meta-moves preset that │
1228 │ │ aims to minimise the │
1229 │ │ outcome solution’s length. │
1230 ├────────────────────────────┼─────────────────────────────────────────────────┤
1231 │ │ │
1232 │hello-world │ a meta-moves preset │
1233 ├────────────────────────────┼─────────────────────────────────────────────────┤
1234 │ │ │
1235 │john-galt-line │ a meta-moves preset │
1236 ├────────────────────────────┼─────────────────────────────────────────────────┤
1237 │ │ │
1238 │looking-glass │ a meta-moves preset that │
1239 │ │ yields solutions faster on │
1240 │ │ average than │
1241 │ │ cookie-monster. │
1242 ├────────────────────────────┼─────────────────────────────────────────────────┤
1243 │ │ │
1244 │maliciously-obscure │ a meta-moves and │
1245 │ │ flare-based preset that │
1246 │ │ tends to yield very short │
1247 │ │ solutions (even in │
1248 │ │ comparison to │
1249 │ │ children-playing-ball ) │
1250 │ │ but is slow. │
1251 ├────────────────────────────┼─────────────────────────────────────────────────┤
1252 │ │ │
1253 │micro-finance │ a meta-moves and │
1254 │ │ flare-based preset that │
1255 │ │ tends to yield very short │
1256 │ │ solutions (even in │
1257 │ │ comparison to │
1258 │ │ maliciously-obscure ) but │
1259 │ │ is even slower. │
1260 ├────────────────────────────┼─────────────────────────────────────────────────┤
1261 │ │ │
1262 │micro-finance-improved │ a meta-moves and │
1263 │ │ flare-based preset, based │
1264 │ │ on micro-finance that │
1265 │ │ yields somewhat shorter │
1266 │ │ solutions on average, and │
1267 │ │ should not be slower. │
1268 ├────────────────────────────┼─────────────────────────────────────────────────┤
1269 │ │ │
1270 │one-big-family │ a meta-moves preset that │
1271 │ │ yields solutions faster on │
1272 │ │ average than │
1273 │ │ conspiracy-theory. │
1274 ├────────────────────────────┼─────────────────────────────────────────────────┤
1275 │ │ │
1276 │qualified-seed │ a meta-moves and │
1277 │ │ flare-based preset, based │
1278 │ │ on micro-finance-improved │
1279 │ │ that yields somewhat │
1280 │ │ shorter solutions on │
1281 │ │ average, and should not be │
1282 │ │ slower. │
1283 ├────────────────────────────┼─────────────────────────────────────────────────┤
1284 │ │ │
1285 │qualified-seed-improved │ qualified-seed with -fif 5 │
1286 │ │ and --flares-choice fcpro │
1287 ├────────────────────────────┼─────────────────────────────────────────────────┤
1288 │ │ │
1289 │rin-tin-tin │ a meta-moves preset │
1290 ├────────────────────────────┼─────────────────────────────────────────────────┤
1291 │ │ │
1292 │sand-stone │ an atomic-moves preset │
1293 │ │ that aims to minimise the │
1294 │ │ outcome solution’s length. │
1295 ├────────────────────────────┼─────────────────────────────────────────────────┤
1296 │ │ │
1297 │slick-rock │ run "gooey-unknown-thing" │
1298 │ │ and then "sand-stone" │
1299 ├────────────────────────────┼─────────────────────────────────────────────────┤
1300 │ │ │
1301 │sentient-pearls │ a meta-moves and flares │
1302 │ │ based preset with short │
1303 │ │ solutions. Much faster │
1304 │ │ than children-playing-ball │
1305 │ │ but yields less optimal │
1306 │ │ solutions. │
1307 ├────────────────────────────┼─────────────────────────────────────────────────┤
1308 │ │ │
1309 │tea-for-two │ a meta-moves preset │
1310 │ │ optimized for │
1311 │ │ two-freecells' Freecell │
1312 │ │ games (although it can │
1313 │ │ work on other │
1314 │ │ Freecell-like games as │
1315 │ │ well). │
1316 ├────────────────────────────┼─────────────────────────────────────────────────┤
1317 │ │ │
1318 │the-iglu-cabal │ a meta-moves preset that │
1319 │ │ yields faster solutions on │
1320 │ │ average than blue-yonder. │
1321 ├────────────────────────────┼─────────────────────────────────────────────────┤
1322 │ │ │
1323 │the-last-mohican │ a preset for solving │
1324 │ │ Simple Simon. Yields less │
1325 │ │ false negatives than the │
1326 │ │ default one, but might be │
1327 │ │ slower. │
1328 ├────────────────────────────┼─────────────────────────────────────────────────┤
1329 │ │ │
1330 │three-eighty │ a meta-moves preset (that │
1331 │ │ depends on Freecell Solver │
1332 │ │ 3.4.0 and above) that │
1333 │ │ yields solutions faster on │
1334 │ │ average than │
1335 │ │ enlightened-ostrich. │
1336 ├────────────────────────────┼─────────────────────────────────────────────────┤
1337 │ │ │
1338 │toons-for-twenty-somethings │ an atomic-moves preset │
1339 │ │ that solves more boards │
1340 │ │ efficiently than │
1341 │ │ "fools-gold". │
1342 ├────────────────────────────┼─────────────────────────────────────────────────┤
1343 │ │ │
1344 │video-editing │ a meta-moves and │
1345 │ │ flare-based preset, based │
1346 │ │ on qualified-seed that │
1347 │ │ yields shorter solutions │
1348 │ │ on average, but may be │
1349 │ │ somewhat slower. Named to │
1350 │ │ commemorate the earlier │
1351 │ │ work of Adrian Ettlinger │
1352 │ │ (1925-2013) │
1353 │ │ <http://en.wikipedia.org/wiki/Adrian_Ettlinger> │
1354 │ │ who later contributed to │
1355 │ │ Freecell Solver and to │
1356 │ │ Freecell research. │
1357 ├────────────────────────────┼─────────────────────────────────────────────────┤
1358 │ │ │
1359 │yellow-brick-road │ a meta-moves preset │
1360 └────────────────────────────┴─────────────────────────────────────────────────┘
1361 They can be abbreviated into their lowercase acronym (i.e: "ak" or
1363 "rtt").
1364
1366 -i , --iter-output
1367 Global
1368 This option tells fc-solve to print the iteration number and the
1370 recursion depth of every state which is checked, to the standard
1371 output. It’s a good way to keep track of how it’s doing, but the output
1372 slows it down a bit.
1373 --iter-output-step [step]
1375 Global
1376 Prints the current iteration if -i is specified, only every [step]
1378 steps, where [step] is a positive integer. For example, if you do
1379 fc-solve -i --iter-output-step 100, you will see this:
1380 Iteration: 0
1382 Iteration: 100
1383 Iteration: 200
1384 Iteration: 300
1385 This option has been added in Freecell Solver 4.20.0 and is useful for
1387 speeding up the runtime process, by avoiding excessive output.
1388 -s , --state-output
1390 Global
1391 This option implies -i. If specified, this option outputs the cards and
1393 formation of the board itself, for every state that is checked.
1394 "fc-solve -s" yields a nice real-time display of the progress of
1395 Freecell Solver, but you usually cannot make what is going on because
1396 it is so fast.
1397
1399 If you are working on a UNIX or a similar system, then you can set some
1400 run-time options in "fc-solve" by sending it some signal combinations.
1401 If you send the fc-solve a single ABRT signal, then fc-solve will
1403 terminate the scan prematurely, and report that the iterations’s limit
1404 has been exceeded.
1405 If you send the signal USR1, without sending any other signals before
1407 that, then fc-solve will output the present number of iterations. This
1408 method is a good way to monitor an instance that takes a long time to
1409 solve.
1410 If you send it the signal USR2 and then USR1, then fc-solve will print
1412 the iteration number and depth on every state that it checks. It is the
1413 equivalent of specifying (or unspecifying) the option -i/--iter-output.
1414 If you send it two USR2 signals and then USR1, then fc-solve will also
1416 print the board of every state. Again, this will only be done assuming
1417 the iteration output is turned on.
1418
1420 Shlomi Fish
1421 2019-07-28 FC-SOLVE(6)