;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301\302\303\304\305\306\307&\210\310\311\312\313\314DD\315\316\317%\210\310\320\312\313\321DD\322\316\317%\210\310\323\312\313\324DD\325\316\317%\210\310\326\312\313\327DD\330\316\331%\210\310\332\312\313\333DD\334\316\335%\210\310\336\312\313\337DD\340\316\341%\207" [custom-declare-group 5x5 nil "5x5 - Silly little puzzle game." :group games :prefix "5x5-" custom-declare-variable 5x5-grid-size funcall function #[0 "\300\207" [5] 1 #1=""] "Size of the playing area." :type integer 5x5-x-scale #[0 "\300\207" [4] 1 #1#] "X scaling factor for drawing the grid." 5x5-y-scale #[0 "\300\207" [3] 1 #1#] "Y scaling factor for drawing the grid." 5x5-animate-delay #[0 "\300\207" [0.01] 1 #1#] "Delay in seconds when animating a solution crack." number 5x5-hassle-me #[0 "\300\207" [t] 1 #1#] "Should 5x5 ask you when you want to do a destructive operation?" boolean 5x5-mode-hook #[0 "\300\207" [nil] 1 #1#] "Hook run on starting 5x5." hook] 8)
#@90 Define VAR to VALUE with documentation DOC and make it buffer local.

(fn VAR VALUE DOC)
(defalias '5x5-defvar-local '(macro . #[771 "\300\301F\302\303DDE\207" [progn defvar make-variable-buffer-local quote] 8 (#$ . 1044)]))
(make-obsolete '5x5-defvar-local 'defvar-local "28.1")
#@20 5x5 grid contents.
(defvar 5x5-grid nil (#$ . 1335))
(make-variable-buffer-local '5x5-grid)
#@23 X position of cursor.
(defvar 5x5-x-pos 2 (#$ . 1433))
(make-variable-buffer-local '5x5-x-pos)
#@23 Y position of cursor.
(defvar 5x5-y-pos 2 (#$ . 1534))
(make-variable-buffer-local '5x5-y-pos)
#@13 Moves made.
(defvar 5x5-moves 0 (#$ . 1635))
(make-variable-buffer-local '5x5-moves)
#@26 Are we in cracking mode?
(defvar 5x5-cracking nil (#$ . 1726))
(make-variable-buffer-local '5x5-cracking)
#@30 Name of the 5x5 play buffer.
(defvar 5x5-buffer-name "*5x5*" (#$ . 1838))
#@32 Local keymap for the 5x5 game.
(defvar 5x5-mode-map (byte-code "\300 \301
\302\"\210\303
\304\305#\210\303
\306\307#\210\303
\310\307#\210\303
\311\312#\210\303
\313\314#\210\303
\315\316#\210\303
\317\320#\210\303
\321\320#\210\303
\322\323#\210\303
\324\325#\210\303
\326\312#\210\303
\327\314#\210\303
\330\316#\210\303
\331\320#\210\303
\332\323#\210\303
\333\325#\210\303
\334\335#\210\303
\336\337#\210\303
\340\341#\210\303
\342\343#\210\303
\344\345#\210\303
\346\347#\210\303
\350\351#\210\303
\352\353#\210\303
\354\355#\210\303
\356\357#\210\303
\360\361#\210\303
\362\363#\210\207" [make-sparse-keymap suppress-keymap t define-key "?" describe-mode "
" 5x5-flip-current " " [up] 5x5-up [down] 5x5-down [left] 5x5-left [tab] 5x5-right [right] [(control a)] 5x5-bol [(control e)] 5x5-eol [(control p)] [(control n)] [(control b)] [(control f)] [home] [end] [prior] 5x5-first [next] 5x5-last "r" 5x5-randomize [(control c) (control r)] 5x5-crack-randomly [(control c) (control c)] 5x5-crack-mutating-current [(control c) (control b)] 5x5-crack-mutating-best [(control c) (control x)] 5x5-crack-xor-mutate "n" 5x5-new-game "s" 5x5-solve-suggest "<" 5x5-solve-rotate-left ">" 5x5-solve-rotate-right "q" 5x5-quit-game] 5) (#$ . 1918))
#@450 List that is the output of an arithmetic solver.

This list L is such that

L = (M S_1 S_2 ... S_N)

M is the move count when the solve output was stored.

S_1 ... S_N are all the solutions ordered from least to greatest
number of strokes.  S_1 is the solution to be displayed.

Each solution S_1, ..., S_N is a list (STROKE-COUNT GRID) where
STROKE-COUNT is the number of strokes to achieve the solution and
GRID is the grid of positions to click.
(defvar 5x5-solver-output nil (#$ . 3166))
(make-variable-buffer-local '5x5-solver-output)
#@11 5x5 menu.
(defvar 5x5-mode-menu nil (#$ . 3712))
(easy-menu-do-define '5x5-mode-menu 5x5-mode-map "5x5 menu." '("5x5" ["New game" 5x5-new-game t] ["Random game" 5x5-randomize t] ["Quit game" 5x5-quit-game t] "---" ["Use Calc solver" 5x5-solve-suggest t] ["Rotate left list of Calc solutions" 5x5-solve-rotate-left t] ["Rotate right list of Calc solutions" 5x5-solve-rotate-right t] "---" ["Crack randomly" 5x5-crack-randomly t] ["Crack mutating current" 5x5-crack-mutating-current t] ["Crack mutating best" 5x5-crack-mutating-best t] ["Crack with xor mutate" 5x5-crack-xor-mutate t]))
(defvar 5x5-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [5x5-mode-hook variable-documentation put "Hook run after entering 5x5 mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp 5x5-mode-map definition-name 5x5-mode] 4)
(defvar 5x5-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [5x5-mode-abbrev-table 5x5-mode-map variable-documentation put purecopy "Keymap for `5x5-mode'." boundp 5x5-mode-syntax-table definition-name 5x5-mode (lambda (#1=#:def-tmp-var) (defvar 5x5-mode-syntax-table #1#)) make-syntax-table "Syntax table for `5x5-mode'." (lambda (#1#) (defvar 5x5-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `5x5-mode'." derived-mode-parent special-mode] 5)
#@214 A mode for playing `5x5'.

In addition to any hooks its parent mode `special-mode' might have
run, this mode runs the hook `5x5-mode-hook', as the final or
penultimate step during initialization.

\{5x5-mode-map}
(defalias '5x5-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
=\204R\326
\325C#\210\327!\210\330\f!\210
\307\211\331 \210)\332\333!\207" [delay-mode-hooks major-mode mode-name 5x5-mode-map 5x5-mode-syntax-table 5x5-mode-abbrev-table make-local-variable t special-mode 5x5-mode "5x5" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table buffer-disable-undo run-mode-hooks 5x5-mode-hook local-abbrev-table buffer-read-only truncate-lines] 6 (#$ . 5400)])
#@894 Play 5x5.

The object of 5x5 is very simple, by moving around the grid and flipping
squares you must fill the grid.

5x5 keyboard bindings are:
\<5x5-mode-map>
Flip                        \[5x5-flip-current]
Move up                     \[5x5-up]
Move down                   \[5x5-down]
Move left                   \[5x5-left]
Move right                  \[5x5-right]
Start new game              \[5x5-new-game]
New game with random grid   \[5x5-randomize]
Random cracker              \[5x5-crack-randomly]
Mutate current cracker      \[5x5-crack-mutating-current]
Mutate best cracker         \[5x5-crack-mutating-best]
Mutate xor cracker          \[5x5-crack-xor-mutate]
Solve with Calc             \[5x5-solve-suggest]
Rotate left Calc Solutions  \[5x5-solve-rotate-left]
Rotate right Calc Solutions \[5x5-solve-rotate-right]
Quit current game           \[5x5-quit-game]

(fn &optional SIZE)
(defalias '5x5 #[256 "\304\305	!\210\306 \210\307
!\203\211\203\n\310HGU\204!\311 \210\312C!\210\313 \207" [5x5-cracking 5x5-buffer-name 5x5-grid-size 5x5-grid nil switch-to-buffer 5x5-mode natnump 0 5x5-new-game 5x5-draw-grid 5x5-position-cursor] 4 (#$ . 6387) "P"])
#@28 Start a new game of `5x5'.
(defalias '5x5-new-game #[0 "\306\307!\203\f\310\311!\202
\312\205*\313\245\313\245\314\315\316 \n	#\317\320\fC!\210\321 \207" [5x5-grid-size 5x5-x-pos 5x5-y-pos 5x5-moves 5x5-grid 5x5-solver-output called-interactively-p interactive 5x5-y-or-n-p "Start a new game? " t 2 0 5x5-make-move 5x5-make-new-grid nil 5x5-draw-grid 5x5-position-cursor] 4 (#$ . 7564) [nil (5x5-mode)]])
#@33 Quit the current game of `5x5'.
(defalias '5x5-quit-game #[0 "\301!\207" [5x5-buffer-name kill-buffer] 2 (#$ . 7985) [nil (5x5-mode)]])
#@47 Create and return a new `5x5' grid structure.
(defalias '5x5-make-new-grid #[0 "\301\302\"\303\211W\203
\301\302\"I\210\211T\262
\202\266\207" [5x5-grid-size make-vector nil 0] 8 (#$ . 8128)])
#@70 Return the value of the cell in GRID at location X,Y.

(fn GRID Y X)
(defalias '5x5-cell #[771 "H
H\207" [] 5 (#$ . 8337)])
#@66 Set the value of cell X,Y in GRID to VALUE.

(fn GRID Y X VALUE)
(defalias '5x5-set-cell #[1028 "HI\207" [] 7 (#$ . 8469)])
#@52 Flip the value of cell X,Y in GRID.

(fn GRID Y X)
(defalias '5x5-flip-cell #[771 "\300\301#?$\207" [5x5-set-cell 5x5-cell] 11 (#$ . 8603)])
#@37 Make a new copy of GRID.

(fn GRID)
(defalias '5x5-copy-grid #[257 "\301 \302\211W\2030\302\211W\203'\303\304\n#$\210\211T\262
\202\f\266\211T\262
\202\266\207" [5x5-grid-size 5x5-make-new-grid 0 5x5-set-cell 5x5-cell] 14 (#$ . 8759)])
#@67 Make a move on GRID at row ROW and column COL.

(fn GRID ROW COL)
(defalias '5x5-make-move #[771 "\301#\210
\302V\203\301S#\210
SW\203!\301T#\210\211\302V\203.\301S#\210\211SW\203<\301T#\210\207" [5x5-grid-size 5x5-flip-cell 0] 7 (#$ . 9020)])
#@48 Get the "on-value" for grid row ROW.

(fn ROW)
(defalias '5x5-row-value #[257 "\301S\301X\203 \211H\203\302\202\301\\\262
T\262\202\207" [5x5-grid-size 0 1] 7 (#$ . 9293)])
#@46 Get the "on-value" for grid GRID.

(fn GRID)
(defalias '5x5-grid-value #[257 "\301S\301X\203\211\302H!\\\262
T\262\202\207" [5x5-grid-size 0 5x5-row-value] 8 (#$ . 9486)])
#@34 Draw the top/bottom of the grid.
(defalias '5x5-draw-grid-end #[0 "\302c\210\303\211W\203\304\305\306	\307\"\261\266\211T\262
\202\266\310c\207" [5x5-grid-size 5x5-x-scale "+" 0 nil "-" make-string 45 "-+ "] 7 (#$ . 9675)])
#@59 Draw the grids GRIDS into the current buffer.

(fn GRIDS)
(defalias '5x5-draw-grid #[257 "\306\307
\310 \210\211\203\211@\210\307\311 \210
A\266\202\202\210\312c\210`\262
	\313\211W\203\213\n\313\211W\203\202\307\211\203v\211@	\313\211W\203j\211\313U\203L\314\202M\315\316\317\f#\203^\320\202_\321\"\261\210\211T\262
\202<\266\322c\210
A\266\202\2024\210\312c\266\211T\262
\202+\266\211T\262
\202#\266\f\203
\f@
U\203	
\212\211b\210\323\n\324\245T!\210\fA@A	\313\211W\203
\212T\324\245Tu\210	\313\211W\203\366\317#\203\353\325\324\"\313U\203\337\326c\210``\324\\|\210\327u\210\202\353\330\331\332\"\210\333\332!\210\334u\210Tu\210\211T\262
\202\271\266)\ny\210\211T\262
\202\251\266)\202
\307\211\203
\211@\210\307\311 \210
A\266\202\202\f
\210\312c\210\335\336\337@!
#c)\207" [inhibit-read-only 5x5-grid-size 5x5-y-scale 5x5-x-scale 5x5-solver-output 5x5-moves t nil erase-buffer 5x5-draw-grid-end "\n" 0 "| " " " make-string 5x5-cell 35 46 " | " beginning-of-line 2 mod "()" -2 insert-char 79 1 delete-char -1 format "On: %d  Moves: %d" 5x5-grid-value] 19 (#$ . 9914)])
#@34 Position the cursor on the grid.
(defalias '5x5-position-cursor #[0 "eb\210	_Ty\210\304`\n_\nT\305$b\207" [5x5-y-pos 5x5-y-scale 5x5-x-pos 5x5-x-scale + 1] 5 (#$ . 11049)])
#@46 Keep track of how many moves have been made.
(defalias '5x5-made-move #[0 "T\211\207" [5x5-moves] 2 (#$ . 11230)])
#@42 Make a random grid.

(fn &optional MOVE)
(defalias '5x5-make-random-grid #[256 "\211\206\301K\262
\302 \303\211W\2038\303\211W\203/\304\305!\303U\203(#\210\211T\262
\202\266\211T\262
\202\f\266\207" [5x5-grid-size 5x5-flip-cell 5x5-make-new-grid 0 random 2] 10 (#$ . 11353)])
#@46 Attempt to crack 5x5 using random solutions.
(defalias '5x5-crack-randomly #[0 "\300\301!\207" [5x5-crack 5x5-make-random-solution] 2 (#$ . 11653) nil])
#@56 Attempt to crack 5x5 by mutating the current solution.
(defalias '5x5-crack-mutating-current #[0 "\300\301!\207" [5x5-crack 5x5-make-mutate-current] 2 (#$ . 11812) nil])
#@53 Attempt to crack 5x5 by mutating the best solution.
(defalias '5x5-crack-mutating-best #[0 "\300\301!\207" [5x5-crack 5x5-make-mutate-best] 2 (#$ . 11988) nil])
#@82 Attempt to crack 5x5 by xoring the current and best solution.
Mutate the result.
(defalias '5x5-crack-xor-mutate #[0 "\300\301!\207" [5x5-crack 5x5-make-xor-with-mutation] 2 (#$ . 12155) nil])
#@335 Attempt to find a solution for 5x5.

`5x5-crack' takes the argument BREEDER which should be a function that takes
two parameters, the first will be a grid vector array that is the current
solution and the second will be the best solution so far.  The function
should return a grid vector array that is the new solution.

(fn BREEDER)
(defalias '5x5-crack #[257 "\302 \210\303\304 \211\305 \305 	\211_\306!
W\203A\307 \204A\310\"\262\306!\306!V\2033\262
\262\311!\311!\"\262\202\266\312\211\207" [5x5-cracking 5x5-grid-size 5x5 t 5x5-make-random-grid 5x5-make-new-grid 5x5-grid-value input-pending-p 5x5-play-solution 5x5-copy-grid nil] 10 (#$ . 12355) "aBreeder function: "])
#@44 Make a random solution.

(fn &rest IGNORE)
(defalias '5x5-make-random-solution #[128 "\300 \207" [5x5-make-random-grid] 2 (#$ . 13060)])
#@49 Mutate the current solution.

(fn CURRENT BEST)
(defalias '5x5-make-mutate-current #[514 "\300!\207" [5x5-mutate-solution] 4 (#$ . 13203)])
#@46 Mutate the best solution.

(fn CURRENT BEST)
(defalias '5x5-make-mutate-best #[514 "\300
!\207" [5x5-mutate-solution] 4 (#$ . 13350)])
#@74 Xor current and best solution then mutate the result.

(fn CURRENT BEST)
(defalias '5x5-make-xor-with-mutation #[514 "\301 \302\211W\203I\302\211W\203@\303\304#\304	#
\204/\262
\2027\211?\2055
\266\202$\210\211T\262
\202\f\266\211T\262
\202\266\305
!\207" [5x5-grid-size 5x5-make-new-grid 0 5x5-set-cell 5x5-cell 5x5-mutate-solution] 16 (#$ . 13491)])
#@52 Randomly flip bits in the solution.

(fn SOLUTION)
(defalias '5x5-mutate-solution #[257 "\301\211W\2038\301\211W\203/\302\211_\303\245!\211_\303\245\303\245U\203(\304#\210\211T\262
\202\n\266\211T\262
\202\266\207" [5x5-grid-size 0 random 2 5x5-flip-cell] 9 (#$ . 13877)])
#@133 Play a solution on an empty grid.
This destroys the current game in progress because it is an
animated attempt.

(fn SOLUTION BEST)
(defalias '5x5-play-solution #[514 "\306 \210\307	\310\211W\203E	\310\211W\203<\211\311#\203%\312 \210\313\fE!\210\314 \210\315
!\210\211T\262
\202\266\211T\262
\202\266)\f\207" [inhibit-quit 5x5-grid-size 5x5-y-pos 5x5-x-pos 5x5-grid 5x5-animate-delay 5x5-new-game t 0 5x5-cell 5x5-flip-current 5x5-draw-grid 5x5-position-cursor sit-for] 10 (#$ . 14174)])
#@142 Convert GRID to an equivalent Calc matrix of (mod X 2) forms
where X is 1 for setting a position, and 0 for unsetting a
position.

(fn GRID)
(defalias '5x5-grid-to-vec #[257 "\300\301\302\"B\207" [vec mapcar #[257 "\300\301\302\"B\207" [vec mapcar #[257 "\211\203\300\207\301\207" [(mod 1 2) (mod 0 2)] 2 "\n\n(fn X)"]] 5 "\n\n(fn Y)"]] 5 (#$ . 14693)])
#@125 Convert a grid matrix GRID-MATRIX in Calc format to a grid in 5x5 format.
See function `5x5-grid-to-vec'.

(fn GRID-MATRIX)
(defalias '5x5-vec-to-grid #[257 "\300\301\302\303A\"\"\207" [apply vector mapcar #[257 "\300\301\302\303A\"\"\207" [apply vector mapcar #[257 "\211A@\300U?\207" [0] 3 "\n\n(fn Y)"]] 6 "\n\n(fn X)"]] 6 (#$ . 15058)])
(byte-code "\300\301\302\"\210\303\301\304\305#\210\306\301\307\310#\210\300\311\312\"\210\303\311\304\305#\210\306\311\307\310#\207" [defalias 5x5-log-init #[0 "\300\207" [nil] 1] function-put speed -1 put byte-optimizer byte-compile-inline-expand 5x5-log #[514 "\207" [] 3 "\n\n(fn NAME VALUE)"]] 4)
#@476 Return a list of solutions for GRID.

Given some grid GRID, the returned a list of solution LIST is
sorted from least Hamming weight to greatest one.

   LIST = (SOLUTION-1 ... SOLUTION-N)

Each solution SOLUTION-I is a cons cell (HW . G) where HW is the
Hamming weight of the solution --- ie the number of strokes to
achieve it --- and G is the grid of positions to click in order
to complete the 5x5.

Solutions are sorted from least to greatest Hamming weight.

(fn GRID)
(defalias '5x5-solver #[257 "\305\306!\210\307\310	\211_\311\312\313!\314\"\315\316\314#\317
\"\266\202\262
\320\313\321 )	\322\211W\203\223	\322\211W\203\212\323_
\\\324\211\325$\210\322V\203R\324	Z\325$\210T	W\203c\324	\\\325$\210
\322V\203r\324S\325$\210
T	W\203\202\324T\325$\210\210\211T\262
\202/\266\211T\262
\202'\266\211\262
!\262
	\323U\203\245\326\202\250\327\330!\331\332\314\"!\333
T\"\334!A\241\210\335
!\262
\262
\336\337!\262
\340\341\341\"\"\262
\342\341\"\262
\343\314\n#\343\344\314	Z#\345\"\346\347\"\262
\345\"\341\337!\"\350\351\352\353
#\326\325\351\352\354\"\355\356\326\"\322\"\"+\"A\357\"\360\361!\210)\207" [calc-command-flags 5x5-grid-size calc-word-size calc-leading-zeros calc-number-radix require calc-ext #[257 "\300\301\"\207" [math-map-vec #[257 "\300\301\"\207" [math-map-vec #[257 "\300
\301BB\207" [mod (2)] 4 "\n\n(fn X)"]] 4 "\n\n(fn Y)"]] 4 "\n\n(fn A)"] nil "b" calcFunc-arrange 5x5-grid-to-vec 1 calcFunc-cvec (mod 1 2) math-sub "a" 5x5-make-new-grid 0 5 5x5-set-cell t 2 error "Transfer matrix rank not known for grid-size != 5" "p" calcFunc-diag last (vec (vec 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 1 0 1 0 1 0 1 1 1 0) (vec 1 1 0 1 1 0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 1 1 0 1 1)) calcFunc-trn "invp" calcFunc-inv "ca" math-mul "cb" math-make-intv 3 calcFunc-mrow "ca_2_1" calcFunc-mcol sort math-map-vec make-closure #[257 "\303\300\304\301\"\"\305\306\"\307\310\n\"!B\207" [V0 V1 5x5-grid-size math-mul calcFunc-vconcat math-reduce-vec #[514 "
\250\203	
\202
A@A@
A@A@\\\207" #1=[] 4 "\n\n(fn R X)"] 5x5-vec-to-grid calcFunc-arrange] 7 "\n\n(fn CX-2)"] #[257 "\301\302\303\304!\300[\305O\"B\207" [V0 vec mapcar #[257 "\300\301\302\303\"\304BBD\207" [vec mod logand 1 (2)] 6 "\n\n(fn X)"] math-format-number nil] 7 "\n\n(fn X)"] calcFunc-index math-pow #[514 "
@
@W\207" #1# 4 "\n\n(fn X Y)"] message "5x5 Solution computation done."] 25 (#$ . 15710)])
#@79 Suggest to the user where to click.

Argument N is ignored.

(fn &optional N)
(defalias '5x5-solve-suggest #[256 "\303!	
B\210\304C!\210\305 \207" [5x5-grid 5x5-moves 5x5-solver-output 5x5-solver 5x5-draw-grid 5x5-position-cursor] 4 (#$ . 18169) ["P" (5x5-mode)]])
#@733 Rotate left by N the list of solutions in 5x5-solver-output.

If N is not supplied rotate by 1, that is to say put the last
element first in the list.

The 5x5 game has in general several solutions.  For grid size=5,
there are 4 possible solutions.  When function
`5x5-solve-suggest' (press `\[5x5-solve-suggest]') is called the
solution that is presented is the one that needs least number of
strokes --- other solutions can be viewed by rotating through the
list.  The list of solution is ordered by number of strokes, so
rotating left just after calling `5x5-solve-suggest' will show
the solution with second least number of strokes, while rotating
right will show the solution with greatest number of strokes.

(fn &optional N)
(defalias '5x5-solve-rotate-left #[256 "G\211\302Y\205N
\250\203
\202\303\262\304S\"\262
\305=?\205N\211ZS\262\306T\"\211A\306
!\211A\241\210\241\210=\204E\307\241\210\266\310	C!\210\311 \207" [5x5-solver-output 5x5-grid 3 1 mod 0 last nil 5x5-draw-grid 5x5-position-cursor] 7 (#$ . 18444) ["P" (5x5-mode)]])
#@208 Rotate right by N the list of solutions in 5x5-solver-output.
If N is not supplied, rotate by 1.  Similar to function
`5x5-solve-rotate-left' except that rotation is right instead of
lest.

(fn &optional N)
(defalias '5x5-solve-rotate-right #[256 "\211\250\203\n\211[\202\300\262
\301
!\207" [-1 5x5-solve-rotate-left] 3 (#$ . 19515) ["P" (5x5-mode)]])
#@45 Make a move on the current cursor location.
(defalias '5x5-flip-current #[0 "\305	\n#\306 \210\204\307C!\210\310 \210\311!\f\211_U\205%\312 \210\313\314!\207" [5x5-grid 5x5-y-pos 5x5-x-pos 5x5-cracking 5x5-grid-size 5x5-make-move 5x5-made-move 5x5-draw-grid 5x5-position-cursor 5x5-grid-value beep message "You win!"] 4 (#$ . 19877) [nil (5x5-mode)]])
#@10 Move up.
(defalias '5x5-up #[0 "\301U?\205\fS\302 \207" [5x5-y-pos 0 5x5-position-cursor] 2 (#$ . 20243) [nil (5x5-mode)]])
#@12 Move down.
(defalias '5x5-down #[0 "	SU?\205
T\302 \207" [5x5-y-pos 5x5-grid-size 5x5-position-cursor] 2 (#$ . 20377) [nil (5x5-mode)]])
#@12 Move left.
(defalias '5x5-left #[0 "\301U?\205\fS\302 \207" [5x5-x-pos 0 5x5-position-cursor] 2 (#$ . 20524) [nil (5x5-mode)]])
#@13 Move right.
(defalias '5x5-right #[0 "	SU?\205
T\302 \207" [5x5-x-pos 5x5-grid-size 5x5-position-cursor] 2 (#$ . 20662) [nil (5x5-mode)]])
#@28 Move to beginning of line.
(defalias '5x5-bol #[0 "\301\302 \207" [5x5-x-pos 0 5x5-position-cursor] 1 (#$ . 20811) [nil (5x5-mode)]])
#@22 Move to end of line.
(defalias '5x5-eol #[0 "S\302 \207" [5x5-grid-size 5x5-x-pos 5x5-position-cursor] 1 (#$ . 20952) [nil (5x5-mode)]])
#@25 Move to the first cell.
(defalias '5x5-first #[0 "\302\211\303 \207" [5x5-x-pos 5x5-y-pos 0 5x5-position-cursor] 2 (#$ . 21097) [nil (5x5-mode)]])
#@24 Move to the last cell.
(defalias '5x5-last #[0 "SS\303 \207" [5x5-grid-size 5x5-x-pos 5x5-y-pos 5x5-position-cursor] 1 (#$ . 21252) [nil (5x5-mode)]])
#@21 Randomize the grid.
(defalias '5x5-randomize #[0 "\306\307!\205#\310\245\310\245\311\312\313K!\314\204!\315\fC!\210\316 \207" [5x5-grid-size 5x5-x-pos 5x5-y-pos 5x5-moves 5x5-grid 5x5-solver-output 5x5-y-or-n-p "Start a new game with a random grid? " 2 0 5x5-make-random-grid 5x5-make-move nil 5x5-draw-grid 5x5-position-cursor 5x5-cracking] 2 (#$ . 21413) [nil (5x5-mode)]])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias 5x5-xor xor nil make-obsolete "27.1"] 4)
#@85 5x5 wrapper for `y-or-n-p' which respects the `5x5-hassle-me' setting.

(fn PROMPT)
(defalias '5x5-y-or-n-p #[257 "\203\301
!\207\302\207" [5x5-hassle-me y-or-n-p t] 3 (#$ . 21913)])
(provide '5x5)