;ELC���
;;; Compiled
;;; in Emacs version 26.3
;;; with all optimizations.

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" #$))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\207" [require cl-lib time-date] 2)
#@80 Version of gnugo.el currently loaded.
This follows a MAJOR.MINOR.PATCH scheme.
(defconst gnugo-version "3.1.1" (#$ . 478))
#@250 Name of the GNU Go program (executable file).
\[gnugo] validates this using `executable-find'.
This program must accept command line args:
 --mode gtp --quiet
For more information on GTP and GNU Go, please visit:
<http://www.gnu.org/software/gnugo>
(defvar gnugo-program "gnugo" (#$ . 608))
#@155 Normal hook run immediately before the first move of the game.
To find out who is to move first, use `gnugo-current-player'.
See also `gnugo-board-mode'.
(defvar gnugo-start-game-hook nil (#$ . 906))
#@323 Normal hook run after a move and before the board is refreshed.
Initially, when `run-hooks' is called, the current buffer is the GNUGO
Board buffer of the game.  Hook functions that switch buffers must take
care not to call (directly or indirectly through some other function)
`gnugo-put' or `gnugo-get' after the switch.
(defvar gnugo-post-move-hook nil (#$ . 1113))
#@249 String whose individual characters are used for animation.
Specifically, the commands `gnugo-worm-stones' and `gnugo-dragon-stones'
render the stones in their respective result groups as the first character
in the string, then the next, and so on.
(defvar gnugo-animation-string (byte-code "\300\301\302\303\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\211\260\207" ["*#" " #" "-\\|/" "*-*!"] 29) (#$ . 1488))
#@507 A `mode-line-format'-compliant value for GNUGO Board mode.
If a single string, the following special escape sequences are
replaced with their associated information:
  ~b,~w  black,white captures (a number)
  ~p     current player (black or white)
  ~m     move number
  ~t     time waiting for the current move
  ~u     time taken for the Ultimate (most recent) move
The times are in seconds, or "-" if that information is not available.
For ~t, the value is a snapshot, use `gnugo-refresh' to update it.
(defvar gnugo-mode-line "~b ~w :~m :~u" (#$ . 1948))
#@43 Name of face to use for X (black) stones.
(defvar gnugo-X-face 'font-lock-string-face (#$ . 2513))
#@43 Name of face to use for O (white) stones.
(defvar gnugo-O-face 'font-lock-builtin-face (#$ . 2618))
#@57 Name of face to use for the grid (A B C ... 1 2 3 ...).
(defvar gnugo-grid-face 'default (#$ . 2724))
#@641 What to do if undo (or oops) leaves GNU Go to play.
After `gnugo-undo-one-move', `gnugo-undo-two-moves' or `gnugo-oops',
when GNU Go is to play, this can be a symbol:
 play     -- make GNU Go play (unless in Zombie mode)
 play!    -- make GNU Go play unconditionally (traditional behavior)
 zombie   -- enable Zombie mode (`gnugo-zombie-mode')
 one-shot -- like `zombie' but valid only for the next move
Any other value, or (as a special case) for `gnugo-undo-one-move',
any value other than `zombie', is taken as `one-shot'.  Note that
making GNU Go play will probably result in the recently-liberated
board position becoming re-occupied.
(defvar gnugo-undo-reaction 'play! (#$ . 2833))
#@798 List of 46 ((TYPE . LOCATION) . XPM-IMAGE) forms.
XPM-IMAGE is an image as returned by `create-image' with
inline data (i.e., property :data with string value).

TYPE is a symbol, one of:
 hoshi -- unoccupied position with dot
 empty -- unoccupied position sans dot
 bpmoku, bmoku -- black stone with and sans highlight point
 wpmoku, wmoku -- white stone with and sans highlight point

LOCATION is an integer encoding edge, corner, or center:
 1 2 3
 4 5 6
 7 8 9
For instance, 4 means "left edge", 9 means "bottom right".

There is only one location for hoshi: center.  The other five
types each have all possible locations.  So (+ 1 (* 9 5)) => 46.

The value can also be a function (satisfying `functionp') that
takes one arg, the size of the board, and returns the appropriate
list of forms.
(defvar gnugo-xpms nil (#$ . 3528))
#@44 Font lock keywords for `gnugo-board-mode'.
(defconst gnugo-font-lock-keywords '(("X" . gnugo-X-face) ("O" . gnugo-O-face)) (#$ . 4367))
#@49 History list of options for `gnugo' invocation.
(defvar gnugo-option-history nil (#$ . 4509))
(defvar gnugo-state nil)
(defvar gnugo-btw nil)
#@336 Essentially: (cdr (assq KEY ALIST))
This is like Scheme ‘assq-ref’ but with reversed arguments.
The name was chosen to occupy the same space as "cdr (assq":
  (cdr (assq KEY ALIST))
  (gnugo-aqr KEY ALIST)
to minimize reindentation noise.  [Surely Emacs must
provide something like this, somewhere, by now?  --ttn]

(fn KEY ALIST)
(defalias 'gnugo-aqr #[514 "\236A\207" [] 4 (#$ . 4658)])
(put 'gnugo-aqr 'byte-optimizer 'byte-compile-inline-expand)
#@18 

(fn &rest ETC)
(defalias 'gnugo--mkht #[128 "\300\301\302\303$\207" [apply make-hash-table :test eq] 6 (#$ . 5120)])
(put 'gnugo--mkht 'byte-optimizer 'byte-compile-inline-expand)
#@24 

(fn S1 BEG1 S2 BEG2)
(defalias 'gnugo--compare-strings #[1028 "\300\301\301&\207" [compare-strings nil] 11 (#$ . 5309)])
(put 'gnugo--compare-strings 'byte-optimizer 'byte-compile-inline-expand)
#@2542 Associate move/game/board-specific property KEY with VALUE.

There are many properties, each named by a keyword, that record and control
how gnugo.el manages each game.  Each GNUGO Board buffer has its own set
of properties, stored in the hash table `gnugo-state'.  Here we document
some of the more stable properties.  You may wish to use them as part of
a `gnugo-post-move-hook' function, for example.  Be careful to preserve
the current buffer as `gnugo-state' is made into a buffer-local variable.
NOTE: In the following, "see foo" actually means "see foo source or
you may never really understand to any degree of personal satisfaction".

 :proc -- subprocess named "gnugo", "gnugo<1>" and so forth

 :diamond -- the part of the subprocess name after "gnugo", may be ""

 :game-over -- nil until game over at which time its value is set to the
               alist ((live GROUP ...) (seki GROUP ...) (dead GROUP ...))

 :sgf-collection -- after a `loadsgf' command, entire parse tree of file,
                    a simple list of one or more gametrees, updated in
                    conjunction w/ :sgf-gametree and :monkey

 :sgf-gametree -- one of the gametrees in :sgf-collection

 :monkey -- vector of two elements:
            MEM, a pointer to one of the branches in the gametree;
            BIDX, the index of the "current branch"

 :gnugo-color -- either "black" or "white"
 :user-color
 :last-mover

 :last-waiting  -- seconds and time value, respectively; see `gnugo-push-move'
 :waiting-start

 :black-captures -- these are strings since gnugo.el doesn't do anything
 :white-captures    w/ the information besides display it in the mode line

 :display-using-images -- XPMs, to be precise; see functions `gnugo-yy',
                          `gnugo-image-display-mode' and `gnugo-refresh',
                          as well as gnugo-xpms.el (available elsewhere)

 :all-yy -- list of 46 symbols used as the `category' text property
            (so that their plists, typically w/ property `display' or
            `do-not-display') are consulted by the Emacs display engine;
            46 = 9 places * (4 moku + 1 empty) + 1 hoshi; see functions
            `gnugo-image-display-mode', `gnugo-yy' and `gnugo-yang'

 :paren-ov -- a pair (left and right) of overlays shuffled about to indicate
              the last move; only one is used when displaying using images

 :last-user-bpos -- board position; keep the hapless human happy

As things stabilize probably more info will be added to this docstring.

(fn KEY VALUE)
(defalias 'gnugo-put #[514 "\301#\207" [gnugo-state puthash] 6 (#$ . 5519)])
(byte-code "\300\301\302\303#\300\207" [function-put gnugo-put lisp-indent-function 1] 4)
#@79 Return the move/game/board-specific value for KEY.
See `gnugo-put'.

(fn KEY)
(defalias 'gnugo-get #[257 "\301\"\207" [gnugo-state gethash] 4 (#$ . 8236)])
#@19 

(fn &rest KEYS)
(defalias 'gnugo--forget #[128 "\211\211\205�\211@\301\"\210A\266\202\202�\207" [gnugo-state remhash] 6 (#$ . 8400)])
#@13 

(fn TREE)
(defalias 'gnugo--tree-mnum #[257 "\211\300H\207" [1] 3 (#$ . 8547)])
(put 'gnugo--tree-mnum 'byte-optimizer 'byte-compile-inline-expand)
#@13 

(fn TREE)
(defalias 'gnugo--tree-ends #[257 "\211\300H\207" [0] 3 (#$ . 8703)])
(put 'gnugo--tree-ends 'byte-optimizer 'byte-compile-inline-expand)
#@16 

(fn TREE LS)
(defalias 'gnugo--set-tree-ends #[514 "\300\301\302\"I\210\211\300H\207" [0 apply vector] 7 (#$ . 8859)])
(put 'gnugo--set-tree-ends 'byte-optimizer 'byte-compile-inline-expand)
#@23 

(fn &optional TREE)
(defalias 'gnugo--root-node #[256 "\211\206�\300\301!\302H\207" [gnugo-get :sgf-gametree 2] 3 (#$ . 9061)])
#@127 Pretty-print `gnugo-state' properties in another buffer.
Handle the big, slow-to-render, and/or uninteresting ones specially.
(defalias 'gnugo-describe-internal-properties #[0 "p\303\304!\305C\306\307\310\311\312\313!\314\"\315\316%\"\210\211\242\237\262\317\320\321\322\"!!\210\323 \210\324 \210\325\326\327\330G\"\261\210\212p\211\305\211:\203c�@\262\211A\262\242\262n\204T�\331 \210\332!\210\333!\210A\262\202<�)\266eb\210\321\334\335\230\203u�\336\202v�\335\"\337\305\325#\205\232�\340\341\342\343!!\344#\345\346\224\\`|\210\321\347\"c\266\202w�\262)\207" [gnugo-state truncate-lines standard-output gnugo-get :diamond nil maphash make-byte-code 514 "\300\301\302\"\203�\303\304\305!G#\202R�\306\307\"\203 �G\202R�\306\310\"\203<�\311\211\312H\262!\313!\211\314H\262E\202R�\306\315\"\203Q�\314H\312H@D\262\202R�B\300\242B\240\207" vconcat vector [memql (:xpms) format "hash: %X (%d images)" sxhash eql :sgf-collection :sgf-gametree hash-table-count 1 gnugo--root-node 0 :monkey] 9 "\n\n(fn KEY VAL)" switch-to-buffer get-buffer-create format "%s*GNUGO Board Properties*" erase-buffer emacs-lisp-mode t ";;; " message "%d properties" newline print pp "overlay from \\([0-9]+\\).+\n%s\\s-+" "" ".+\n" re-search-forward get-text-property string-to-number match-string 1 gnugo-position 2 0 " %S"] 10 (#$ . 9199) nil])
#@74 Return non-nil if BUFFER is a GNUGO Board buffer.

(fn &optional BUFFER)
(defalias 'gnugo-board-buffer-p #[256 "\300\301\206�p\"\302=\207" [buffer-local-value major-mode gnugo-board-mode] 4 (#$ . 10569)])
#@96 Return non-nil if BUFFER is a GNUGO Board buffer ready for a user move.

(fn &optional BUFFER)
(defalias 'gnugo-board-user-play-ok-p #[256 "r\211\206�pq\210\205�\301\302!?)\207" [gnugo-state gnugo-get :waiting] 3 (#$ . 10782)])
#@15 

(fn OBJECT)
(defalias 'gnugo--prop-blackp #[257 "\211\300=\207" [:B] 3 (#$ . 11019)])
(put 'gnugo--prop-blackp 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn STRING)
(defalias 'gnugo--blackp #[257 "\211\300\230\207" ["black"] 3 (#$ . 11183)])
(put 'gnugo--blackp 'byte-optimizer 'byte-compile-inline-expand)
#@69 If COLOR is "black", return "white", otherwise "black".

(fn COLOR)
(defalias 'gnugo-other #[257 "\211\211\300\230\262\203�\301\207\300\207" ["black" "white"] 4 (#$ . 11345)])
#@55 Return the current player, either "black" or "white".
(defalias 'gnugo-current-player #[0 "\300\301\302!!\207" [gnugo-other gnugo-get :last-mover] 3 (#$ . 11529)])
#@14 

(fn COLOR)
(defalias 'gnugo--prop<-color #[257 "\211\211\300\230\262\203�\301\207\302\207" ["black" :B :W] 4 (#$ . 11699)])
(put 'gnugo--prop<-color 'byte-optimizer 'byte-compile-inline-expand)
#@32 

(fn &optional IN-PROGRESS-P)
(defalias 'gnugo-gate #[256 "\300 \204	�\301\302!\210\303\304!\204�\301\305!\210\303\306!\211A\262\242\211\2034�\307\301\310\203-�\311D\2022�\312\313!D#\210\266\211\205C�\303\314!\205C�\301\315!\207" [gnugo-board-buffer-p user-error "Wrong buffer -- try M-x gnugo" gnugo-get :proc "No \"gnugo\" process!" :waiting apply "%s -- please wait for \"(%s to play)\"" "Still thinking" "Not your turn yet" gnugo-other :game-over "Sorry, game over"] 9 (#$ . 11903)])
#@20 

(fn PROC STRING)
(defalias 'gnugo-sentinel #[514 "\301!\211\302>\2050�\303!\304!\205.�r\211q\210\305\306\307!@\310\311#\312E\313\314!=\205-�\315\314!)\262\207" [mode-line-process process-status (exit signal) process-buffer buffer-live-p " [%s (" propertize split-string face font-lock-warning-face ")]" gnugo-get :proc gnugo--forget] 9 (#$ . 12405)])
#@25 

(fn PROC FILTER LINE)
(defalias 'gnugo--begin-exchange #[771 "\300\"\210\301\"\210\301\302\"\207" [set-process-filter process-send-string "\n"] 6 (#$ . 12771)])
(byte-code "\300\301\302\303#\300\207" [function-put gnugo--begin-exchange lisp-indent-function 2] 4)
#@201 Send formatted command "FMT ARGS..."; wait for / return response.
The response is a string whose first two characters indicate the
status of the command.  See also `gnugo-query'.

(fn FMT &rest ARGS)
(defalias 'gnugo--q #[385 "\300\301!\300\302!\203�\303\304@A\203�\305\202�\306#\210\307\310\311#\210\307\312\313#\210\314\315\2042�\2029�\316\317##\210\320\310\"\203J�\321\322\"\210\202;�\320\312\"\323\324O\307\312\313#\210\207" [gnugo-get :waiting :proc user-error "Sorry, still waiting for %s to %s" "receive a suggestion" "play" process-put :incomplete t :srs "" gnugo--begin-exchange #[514 "\300\301\"P\302\301#\210\211\303G\304Z]\305\306\307\306\306&\266\204\247?\205*�\302\310\306#\207" [process-get :srs process-put 0 2 "\n\n" nil compare-strings :incomplete] 14 "\n\n(fn PROC STRING)"] apply format process-get accept-process-output 30 0 -2] 11 (#$ . 13048)])
#@15 

(fn STRING)
(defalias 'gnugo--no-worries #[257 "\211\300H\301U\207" [0 61] 3 (#$ . 13953)])
(put 'gnugo--no-worries 'byte-optimizer 'byte-compile-inline-expand)
#@23 

(fn FMT &rest ARGS)
(defalias 'gnugo--q/ue #[385 "\300\301#\211\211\302H\303U\262\204�\304\305\"\210\211\306\307O\207" [apply gnugo--q 0 61 user-error "%s" 2 nil] 6 (#$ . 14122)])
#@274 Send GNU Go a command formatted with MESSAGE-FORMAT and ARGS.
Return a string that omits the first two characters (corresponding
to the status indicator in the Go Text Protocol).  Use this function
when you are sure the command cannot fail.

(fn MESSAGE-FORMAT &rest ARGS)
(defalias 'gnugo-query #[385 "\300\301#\302\303O\207" [apply gnugo--q 2 nil] 6 (#$ . 14316)])
#@12 

(fn CMD)
(defalias 'gnugo--nquery #[257 "\300\301!!\207" [string-to-number gnugo-query] 4 (#$ . 14691)])
#@101 Apply `gnugo-query' to args; split its rv (return list of strings).

(fn MESSAGE-FORMAT &rest ARGS)
(defalias 'gnugo-lsquery #[385 "\300\301\302#!\207" [split-string apply gnugo-query] 7 (#$ . 14806)])
#@23 

(fn FMT &rest ARGS)
(defalias 'gnugo--count-query #[385 "\300\301#G\207" [apply gnugo-lsquery] 6 (#$ . 15016)])
(put 'gnugo--count-query 'byte-optimizer 'byte-compile-inline-expand)
#@28 

(fn PROP &optional TREE)
(defalias 'gnugo--root-prop #[513 "\300!\236A\207" [gnugo--root-node] 6 (#$ . 15208)])
(put 'gnugo--root-prop 'byte-optimizer 'byte-compile-inline-expand)
#@34 

(fn PROP VALUE &optional TREE)
(defalias 'gnugo--set-root-prop #[770 "\300!\236\211\203�\211\241\202�B\301!\211AB\241\266\202\207" [gnugo--root-node last] 10 (#$ . 15400)])
#@113 Move point to board position POS, a letter-number string.
Return final buffer position (i.e., point).

(fn POS)
(defalias 'gnugo-goto-pos #[257 "eb\210\300\301!T\302\303\304O!Zy\210\303u\210g\305U\203�\303\202�\306\307H\310V\203+�\211\202-�\211S\262\311Z\306_\\u\210`\207" [gnugo-get :SZ string-to-number 1 nil 32 2 0 73 65] 6 (#$ . 15593)])
#@11 

(fn ID)
(defalias 'gnugo-f #[257 "\3009\203\f�\301!\202
�\302\303!\"\207" [intern symbol-name gnugo-get :obarray] 5 (#$ . 15947)])
#@629 Return the "image type information" corresponding to character C.
C is one of the four characters used in the ASCII representation
of a game board -- ?+ (U+2B PLUS SIGN), ?. (U+2E FULL STOP), ?X
and ?O (U+58 and U+4F, LATIN CAPITAL LETTER X and O, respectively).
For example, here is a 5x5 board with two stones placed:

  . . . . .
  . O . + .          (white at B4)
  . . + . .
  . + . + X          (black at E2)
  . . . . .

The image type information consists of a single symbol for ?. and ?+
and a pair (SANS-POINT . WITH-POINT) for ?X and ?O.  Both SANS-POINT
and WITH-POINT are symbols.  For other C, return nil.

(fn C)
(defalias 'gnugo-yang #[257 "\211\300\236A\207" [((43 . hoshi) (46 . empty) (88 bmoku . bpmoku) (79 wmoku . wpmoku))] 5 (#$ . 16090)])
#@331 Return a symbol made by formatting YIN (an integer) and YANG.
The returned symbol has the format N-SYMBOL.

If YANG is a symbol, use it directly.  Otherwise, YANG must be a pair.
If optional arg MOMENTARYP is non-nil, use the `cdr' of YANG.
Otherwise, use the `car' of YANG.  See `gnugo-yang'.

(fn YIN YANG &optional MOMENTARYP)
(defalias 'gnugo-yy #[770 "\300\301\3029\203
�\202�\203�A\202�@#!\207" [gnugo-f format "%d-%s"] 8 (#$ . 16862)])
#@64 If enabled, display grid around the board.

(fn &optional ARG)
(defalias 'gnugo-grid-mode #[256 "\301 \302=\203�\303>??\202�\304!\305V\211\203�\306\202�\307\303!\210\212\310 \210)\210\311\312\303>\2043�\313\2024�\314\"\210\315\316!\203Z�\301 \203H�\211\301 \232\203Z�\317\320\321\303>\204U�\322\202V�\323#\266\210\324 \210\303>?\207" [buffer-invisibility-spec current-message toggle :nogrid prefix-numeric-value 0 remove-from-invisibility-spec add-to-invisibility-spec gnugo-refresh run-hooks gnugo-grid-mode-hook gnugo-grid-mode-on-hook gnugo-grid-mode-off-hook called-interactively-p any " in current buffer" message "Gnugo-Grid mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 17320) (byte-code "\206�\301C\207" [current-prefix-arg toggle] 1)])
(defvar gnugo-grid-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\300\207" [gnugo-grid-mode-hook variable-documentation put "Hook run after entering or leaving `gnugo-grid-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)"] 4)
#@44 Text property that controls intangibility.
(defconst gnugo--intangible (byte-code "\300\301!\203�\302\207\303\207" [fboundp cursor-intangible-mode cursor-intangible intangible] 2) (#$ . 18427))
(defalias 'gnugo--propertize-board-buffer #[0 "\302 \210\303\304!\305\306Oc\210\307\310\311F\312\313!\312\314!\312\315!\312\316!\317\312\320!\321\322F\323\324!\325!eb\210\326``T\317\312\327!$\210\330\306w\210\326`S`\317\n$\210\326`\331 \317	$\210\332y\210\333eT`S\n#\210\334\335!\203\253\336\332!\337\225\340\341_\342#\340G\332#\230\343\230\344\332	G#S\345p\322$\333#\210\346\307\310#\210\346\317#\266\347W\204b\350\351\352\353Z\341\"H\n#USU\203\306�\203\306�\332\202
\203\323�\211\203\323�\305\202
\203\337�\203\337�\354\202
\203\353�\211\203\353�\355\202
\203\364�\341\202
\203\374�\356\202
\203\357\202
\211\203\f\360\202
\361\266\202\362f!\333\211T\363\364\362\317\365\f\f\"\366BBBBBBBB#\266SU\204M\333T\341\\
#\210\326\341\\	$\210\341\\\262\211\347=\203\\\367\202]\347\262\202\234�\266\333T#\210b\210\334\370!\203\233\371\332!\372\230\203\201\373\202\202\374\341\224\341\225\326\375ZB$\210\376\336\341!\"\266\326\331 \317
$\210\332y\266\202X�\333`Sd\n#\210\330\306w\210\326`S`\317\n$\210\326`\331 \317	$\207" [gnugo-grid-face gnugo--intangible erase-buffer gnugo--q "showboard" 3 nil invisible :nogrid font-lock-face gnugo-f gpad gspc lpad rpad category ispc rear-nonsticky t gnugo-get :SZ number-to-string put-text-property tpad " " line-end-position 1 add-text-properties looking-at "\\s-*\\([0-9]+\\)[ ]" match-string-no-properties 0 + 2 -1 "1" - make-overlay overlay-put even format "%c%s" "ABCDEFGHJKLMNOPQRST" truncate 7 9 8 4 6 5 gnugo-yang gnugo-position gnugo-yin gnugo-yy (front-sticky (gnugo-position gnugo-yin)) odd "\\s-+\\(WH\\|BL\\).*capt.* \\([0-9]+\\).*$" match-string "WH" :white-captures :black-captures :gnugo-cf gnugo-put] 32])
(defalias 'gnugo--merge-showboard-results #[0 "\302\303!\304\305O\306\307\310ed\"\311\211\211\211\305\211\211\211\211\211\312\n\n\n\313\305\305&\266\204\211\262\247\205B\305\262\211\311W\262\203D�T[\202F�S\262	\\\262	\\\262\314

\f#=\203g�\311\225\202j�T\262\n\314
\n#=\203\234�SH\315U\204\215�\211S\262\202}�\211T\211\262\262\203\234�\311\225\202\237�T\262\316	\203\263�\nZ\202\264�\311#\262b\210\203\317\320\"\211@A\321!\314\322	#O\262\323\320	GB#\210\324\"\210\325!\210\326\327#c\210GZ\\\262\266\202�
H\262\330\331!!\210\317\332\"\333!\334\211T\333\335\336\"F#\266\325\306!\210\317T	\"\211\262\203�\337\211T	$\210\202�)\207" [inhibit-read-only gnugo--intangible gnugo--q "showboard" 3 nil 1 "[0-9]* stones$" buffer-substring-no-properties 0 t compare-strings string-match 32 + get-text-property :gnugo-cf text-properties-at " " plist-put gnugo-put delete-char apply propertize insert-and-inherit char-to-string gnugo-yin gnugo-yang add-text-properties category gnugo-yy put-text-property] 25])
#@13 

(fn NODE)
(defalias 'gnugo--move-prop #[257 "\300\236\206	�\301\236\207" [:B :W] 3 (#$ . 21504)])
(put 'gnugo--move-prop 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'gnugo--as-pos-func #[0 "\300\301!\302\303\304\305\306!\307\"\310\311%\207" [gnugo-get :SZ make-byte-code 257 "\211\301\230\203�\302\207\211\303H\304\305\306\307V\203�\202�T\310Z\\\300\311H\310ZZ#\207" vconcat vector ["" "PASS" 0 format "%c%d" 65 105 97 1] 8 "\n\n(fn CC)"] 7])
#@15 

(fn STRING)
(defalias 'gnugo--resignp #[257 "\211\300\230\207" ["resign"] 3 (#$ . 21976)])
(put 'gnugo--resignp 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn STRING)
(defalias 'gnugo--passp #[257 "\211\300\230\207" ["PASS"] 3 (#$ . 22141)])
(put 'gnugo--passp 'byte-optimizer 'byte-compile-inline-expand)
#@657 Determine and return the game's move history.
Optional arg RSEL controls side effects and return value.
If nil, display the history in the echo area as "(N moves)"
followed by the space-separated list of moves.  When called
interactively with a prefix arg (i.e., RSEL is (4)), display
similarly, but suffix with the mover (either ":B" or ":W").
RSEL may also be a symbol that selects what to return:
 car  -- the most-recent move
 cadr -- the next-to-most-recent move
 two  -- the last two moves as a list, oldest last
 bpos -- the last stone on the board placed by COLOR
For all other values of RSEL, do nothing and return nil.

(fn &optional RSEL COLOR)
(defalias 'gnugo-move-history #[512 "\300\301!\211\302HC\303 \304C\304C\304C\304C\305\306\307\310\311	!\312\"\313\314%\305\302\315\310\311		#\316\"\313$\305\306\317\310\311\n				%\320\"\321\322%\323\305\302\324\310\311\f!\325\"\326$\327:\203x�@\211\313=\205s�A\211?\205q�\330$\262\262\202\204\207�\211\f\304$\202\331=\203\225�!@\202\332=\203\247�!\210!@\202\333=\203\274�!\210!\210	\242\202\334=\203
\211\211\335\230\262\203\324�\336\262\202\327�\337\262\330\304\242\203 \203\242@=\203	\242A\240\203	\242G\340U\203
\n\242!\262\304\211\262\202\330\204\331�\266\202\202\304\262\262\262\262\262\262\207" [gnugo-get :monkey 0 gnugo--as-pos-func nil make-byte-code 257 "\211\211\301\230\262\203\n�\207\300!\207" vconcat vector ["resign"] 4 "\n\n(fn X)" "\301\300\242\300\211\242A\240\210\242\240\210\302\301\242\303\236\206�\304\236\262\240\207" [:B :W] "\304 \205#�\302\303\301\242A!\240\210\300\203�\305\306\302\242\301\242@#\202�\302\242\300\242B\240\207" [format "%s%s"] 6 "\n\n(fn BYP)" #[257 "\211\300!\207" [nil] 3 "\n\n(fn --CL-NEXT--)"] "\301\302\300\242G\303\304\300\242\237\305##\207" [message "(%d moves) %s" mapconcat identity " "] 7 #[1028 "\242\203\f�!\210\202�� \207" [] 6 "\n\n(fn MEM --CL-NEXT-- --CL-TELL-- BYP)"] t car cadr two bpos "black" :B :W 2] 22 (#$ . 22301) "P"])
#@60 Do `bury-buffer' until the current one is not a GNU Board.
(defalias 'gnugo-boss-is-near #[0 "\300 \205�\301 \210\202��\207" [gnugo-board-buffer-p bury-buffer] 1 (#$ . 24364) nil])
#@20 

(fn MONKEY ENDS)
(defalias 'gnugo--no-regrets #[514 "\211\300HH\301H=\207" [1 0] 5 (#$ . 24552)])
(put 'gnugo--no-regrets 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'gnugo--as-cc-func #[0 "\300\301!\302\303\304\305\306!\307\"\310\311%\207" [gnugo-get :SZ make-byte-code 257 "\211\301H\302\303\304W\203�\305\202�\301\306#\\\302\300\307\305\310O!Z\\\311\312#\207" vconcat vector [0 97 - 72 1 65 string-to-number nil format "%c%c"] 9 "\n\n(fn POS)"] 7])
#@25 

(fn NODE &rest PLIST)
(defalias 'gnugo--decorate #[385 "\300!\301\203$�\211A\262\242\211A\262\242BC\262\211\241\266\211\262\202�\301\207" [last nil] 7 (#$ . 25033)])
#@24 

(fn END-TIME RESIGN)
(defalias 'gnugo-close-game #[514 "\300\301\"\210\206�\302 \300\303\304\305\306@\307\"\310\"A@\"\"\266\300\311\312\313=\2042�;\203F�\314\315\"\203F�\316\317\320\321\"\322\"\"\262B\323B\202\254�\324\325!\326\327!\330\331\211\211\314\332#\203\240�\333\334\"\333\335\"\324\336\"\"\314\337#\210\235\203\202�\211B\262\202\227�\333\335\"\203\222�\211B\262\202\227�\211B\262\330\225\262\266\202P�\316B\340B\341BE\266\206\262\"\207" [gnugo-put :game-end-time current-time :scoring-seed logior ash logand 255 16 :game-over #[514 "\211\204�\300\301!\210\211\211\302\230\262\203�\303\262\202�\304\262C\305\306\"B\207" [cl--assertion-failed positions "black" :B :W sort string<] 6 "\n\n(fn COLOR POSITIONS)"] t string-match "[BW][+][Rr]esign" live #[514 "\300\301\302\303\304\305\"\306\"\307\310%\311\312\313\"\314\"\"\207" [mapcar make-byte-code 257 "\300\301\302!\"\207" vconcat vector [split-string] 5 "\n\n(fn X)" split-string gnugo-query "worm_stones %s" "\n"] 10 "\n\n(fn --CL-GROUP-- COLOR)"] append "black" "white" ((seki) (dead)) gnugo-lsquery "final_status_list seki" gnugo-query "dragon_data" 0 nil "\\(.+\\):\n[^ ]+[ ]+\\(black\\|white\\)\n" match-string 1 2 "dragon_stones %s" "\nstatus[ ]+\\(\\(ALIVE\\)\\|[A-Z]+\\)\n" seki dead] 17 (#$ . 25219)])
(defalias 'gnugo--unclose-game #[0 "\300\301\302\303#\210\304 \305\236\211\205\"�\211@=\203�\306\307\310\311C$\210\312\"\207" [gnugo--forget :game-over :scoring-seed :game-end-time gnugo--root-node :RE cl--assertion-failed (not (eq cur (car root))) ":RE at head of root node: %S" nil delq] 7])
#@17 

(fn WHO MOVE)
(defalias 'gnugo-push-move #[514 "\300!\301\302!\203�\203�\211\202�\301\303!\202�\301\304!\305 \211\306\230\262\211\307\230\262\310\311!\211\2058�\211\211\307\230\262\206A�\211\205A�\204M�\312\313	
#\210\204T�\314 \210\315\316	\"\210	\203d�\202i�\230\203}�\315\317?\205{�?\205{�\f\"\210\211\211\320\230\262\203\216�\321\262\202\221�\322\262\211\203\234�\f\202\251�\203\244�\323\202\251�\324 
!B\211C\301\325!\211\326H\211@\301\327!\211\211\326H\262\211\330H\262G\331\"\330H\332\211\n\211\330HH\326H=\266\202\203\345�\330\202\346�\326\333\332W\203\205\334\\\n\"\262\332H\333\332:\203<\331@\211\262\"W\203<A=\2031\236\232\205(\262\332\211\262\2022\333\203<A\262\202?\205B\211\266\204\211\262\203zU\204m\nHHI\210\266\202I\266\211\262\262\332\211\262\202{\333\203\205T\262\202\351�\203\362\211\330HH\326H=\266\202\204\325\335\f\332\"\211\326X\203\265\233B\262\202\301\211S\233\233B\241\210\210\211\262\326\336\337\"I\210\211\326H\266\203\262\340\331
\"T\f#\210B\262\nI\210\266\211\326\nI\266\203\315\341\342\n\"A@\"\210\211\203\343\"\210\315\304?\205\"\"\210\207" [booleanp gnugo-get :user-color :gnugo-color :waiting-start current-time "resign" "PASS" gnugo-move-history car gnugo--q/ue "play %s %s" gnugo--merge-showboard-results gnugo-put :last-mover :last-user-bpos "black" :B :W "" gnugo--as-cc-func :monkey 0 :sgf-gametree 1 gethash nil t mod append apply vector puthash :last-waiting time-subtract gnugo-close-game] 41 (#$ . 26858)])
#@17 

(fn YIN YANG)
(defalias 'gnugo-venerate #[514 "\300\"\211\301N\206
�\211\302N\211A\303\304\"\303\305\"\300\306\307!\"\211\301N\206'�\211\302N\303A\304\"\310\311!G!!HW\203j�\211HU\204_�\312\313!\211\314V\262\203_�HI\210T\262T\262\202>�\315\316\317\320\321\322\205{�\305D&\207" [gnugo-yy display do-not-display plist-get :data :color-symbols gnugo-yang 46 #[257 "\300\301\302\"\205�\300\225\262\303\304\305\"!\211\211\300W\262\204.�\301\306#\203.�\300\225\262\211S\262\202�\301\307#\210\300\225\207" [0 string-match "\\([0-9]+\\)\\s-+[0-9]+\"," string-to-number match-string 1 ",\n" "\""] 7 "\n\n(fn S)"] copy-sequence random 4 0 apply create-image xpm t :ascent center] 25 (#$ . 28517)])
#@12 

(fn OVS)
(defalias 'gnugo--zonk-ovs #[257 "\300\301\"\207" [mapc delete-overlay] 4 (#$ . 29263)])
(put 'gnugo--zonk-ovs 'byte-optimizer 'byte-compile-inline-expand)
#@633 Update GNUGO Board buffer display.
While a game is in progress, parenthesize the last-played stone (no parens
for pass).  If the buffer is currently displayed in the selected window,
recenter the board (presuming there is extra space in the window).  Update
the mode line.  Lastly, move point to the last position played by the user,
if that move was not a pass.

Prefix arg NOCACHE requests complete reconstruction of the display, which may
be slow.  (This should normally be unnecessary; specify it only if the display
seems corrupted.)  NOCACHE is silently ignored when GNU Go is thinking about
its move.

(fn &optional NOCACHE)
(defalias 'gnugo-refresh #[256 "\304\305!\306\307!\306\310!\311\312\211\203>�\306\313!\204>�\314\315\316\317\"\"\211\203:�\211@\211@A\320\321\"\266\211@\312\241\210A\266\202\202�\210\322 \210\203\270�\306\323!\211\203R�\211A\262\242\202Y�\324\325\312GD\"\326\235\203l�\211D\320\321\"\266\202\266�\327!\306\330!\211@A@\\\3318\332\333\334!\203\221�	!\202\223�#\210\335\211T#\210\211\203\251�\211!\210\202\264�\335\331\\\336\\#\210\266\266\337\306\340!\203\330�\341\342\211\343\230\262\203\323�\344P\202\324�\345\"\202\352�\341\346\203\346�\347P\202\347�\345\350 #P!\210\203P\316\351\352\353\354\355	!\356\"\357\360%\361\"\211G\336U\203\211A\262\242\202\324\325\312GD\"\211A\262\242@\316\305\"\211\203=\211@\211A\320\321\"\266\211\312\241\210A\266\202\202$\210\362\211\363\364$\210\211\365\366$\266\367p!\211\262\203\243\370	>?\306\371!\211\372W\306\373!\374\375\376!A_\203y\331\202z\377#\331\"\203\205\377\202\210\201@�Z\201A�!\3318\211@Z@\201B�\201C�\201D�!!\375\n_\203\261\377\202\264S\331\203\311\f\203\303\331\202\312\201E�\202\312\377%\201F�\245\201G�\203\355\211\377V\262\203\355\333\201H�	\372\"D\202\360\201I�B\201J�\333\201K�\201L�\201M�\201N�	\203 \201O�_\203\201P�\202\201Q�\\\202,\203)\377\202,\201@�#EE\201R�\205P\333\201S�\201T� \201U�	_\\\245\262\201V�ZDDB\201W�\333\201K�\201L�ED\203r\201X�\314\201Y�\347#D\202s\211\262B\201Z�\333\201K�\201L�SEE\257\211\203\241\211@\201[�\201C�@!A\"\210A\266\202\202\207\266\f\306\201\\�!C\211\242\n\232\204\211\n\240\210\201]�\201\\�\242\"\210\201]�\201^�\242:\203\317\242\202\312C\312C\312C\201_�\211\201`�\201a�#\210\211\201b�\351\352\201c�\354\355#\201d�\"\201e�\201f�%#\266\201g�\242\341\242\242\237BBE\266\203\"\210\306\201^�!\211\205+\341\201h�\201i�!\"\210\201j� \266\306\201k�!\211\262\205A\327!)\207" [inhibit-read-only buffer-invisibility-spec gnugo-mode-line mode-line-process gnugo-move-history car gnugo-get :game-over :display-using-images t nil :waiting apply append mapcar cdr mapc delete-overlay gnugo--propertize-board-buffer :paren-ov signal wrong-number-of-arguments ("PASS" "resign") gnugo-goto-pos :highlight-last-move-spec 2 overlay-put display functionp move-overlay 3 rename-buffer :diamond format "%s(game over)" "resign" "ation " "" "%s(%s to play)" " " gnugo-current-player make-byte-code 257 "\211\300\236A\207" vconcat vector [] 5 "\n\n(fn SEL)" (live seki dead) #[1028 "\300\211:\203\213�@\262\211A\262\242\262\211A\204\204�\211@\211\301=\262\2034�\302\203/�\303\2020�\304!\202B�\305\203=�\306\202>�\307\310	#\311\312\"\300\211:\203~�@\262\313\211T\"\314\315\203l�
\316\317\"	\"\202n�#\210\211\262B\262A\262\202I�\211\237\266\205\241\210A\262\202�\300\207" [nil :B gnugo-yang 88 79 propertize "x" "o" face mapcar gnugo-goto-pos make-overlay overlay-put display get-text-property gnugo-yin] 21 "\n\n(fn USING-IMAGES GROUPS FACE RESPECT)"] font-lock-type-face #[514 "\300\301#\302N\207" [gnugo-yy t display] 6 "\n\n(fn YIN YANG)"] font-lock-warning-face gnugo-venerate get-buffer-window :nogrid :SZ 10 :mul truncate - window-height 0 1 window-edges symbol-plist gnugo-f ispc 4 2.0 tpad make-string (invisible :nogrid) gpad space :align-to + 2.0 0.5 -0.5 0.5 gspc space-width frame-char-width 1.0 1.0 lpad before-string propertize rpad setplist :mode-line gnugo-put :mode-line-form #[771 "\300\242\301\211%\240\207" [replace-regexp-in-string t] 10 "\n\n(fn CUR RE REP)"] "%" "%%" "~[bwpmtu]" "\303\301\300\304!\240\301\242B\240\210\302\305\300\242\306\300\242\307\"\203�\310\202U�\306\300\242\311\"\203(�\312\202U�\306\300\242\313\"\2034�\314\202U�\306\300\242\315\"\203@�\316\202U�\306\300\242\317\"\203L�\320\202U�\306\300\242\321\"\205U�\322D\302\242\323\324$\240\210\207" ["%s" intern cl-adjoin eql ~b (or (gnugo-get :black-captures) 0) ~w (or (gnugo-get :white-captures) 0) ~p (gnugo-current-player) ~t (let ((ws (gnugo-get :waiting-start))) (if ws (cadr (time-since ws)) "-")) ~u (or (gnugo-get :last-waiting) "-") ~m (let ((tree (gnugo-get :sgf-gametree)) (monkey (gnugo-get :monkey))) (gethash (car (aref monkey 0)) (gnugo--tree-mnum tree) "?")) :key car] 8 "\n\n(fn MATCH)" let " [%s]" eval force-mode-line-update :last-user-bpos] 27 (#$ . 29438) "P"])
#@22 

(fn &optional NOW)
(defalias 'gnugo--turn-the-wheel #[256 "\300\301!?\205.�\302 \300\303!\211\300\304!?\205+�A\235\205+�\305?\205\"�\306\307\310p&\240\266\202\207" [gnugo-get :waiting gnugo-current-player :wheel :game-over run-at-time 2 nil #[771 "\211\300\240\210rq\210\301!)\207" [nil gnugo-get-move] 5 "\n\n(fn BUF COLOR WHEEL)"]] 11 (#$ . 34453)])
#@22 

(fn &optional NOW)
(defalias 'gnugo--finish-move #[256 "p\300\301!\210\211q\266\302 \210\303!\207" [run-hooks gnugo-post-move-hook gnugo-refresh gnugo--turn-the-wheel] 4 (#$ . 34823)])
#@23 

(fn &optional BACK)
(defalias 'gnugo--rename-buffer-portion #[256 "\300\301\203\f�\211\262\262\302 \303\"\205�\304\305\306\211$!\262\207" ["to play" "waiting for suggestion" buffer-name string-match rename-buffer replace-match t] 10 (#$ . 35018)])
#@25 

(fn COLOR SUGGESTION)
(defalias 'gnugo--display-suggestion #[514 "\300\301\302\303!$\207" [message "%sSuggestion for %s: %s" gnugo-get :diamond] 7 (#$ . 35284)])
#@20 

(fn PROC STRING)
(defalias 'gnugo-get-move-insertion-filter #[514 "r\300!q\210\301\302!\303\302P\"\304\305\"\205c�\306\307\"\262\301\310!\211\203,�\211A\262\242\2023�\311\312\313GD\"\314\302\310\"\210\203Z�\315\316!\210\211\317\230\262\204S�\320=\204S�\321!\210\322\"\202a�\323\"\210\324 \266\202\266\202)\207" [process-buffer gnugo-get :get-move-string gnugo-put string-match "^= \\(.+\\)\n\n" match-string 1 :waiting signal wrong-number-of-arguments nil gnugo--forget gnugo--rename-buffer-portion t "PASS" nowarp gnugo-goto-pos gnugo--display-suggestion gnugo-push-move gnugo--finish-move] 9 (#$ . 35456)])
#@35 

(fn COLOR &optional SUGGESTION)
(defalias 'gnugo-get-move #[513 "\300\301B\"\210\302\303\304!\305\306P#\210\307 \207" [gnugo-put :waiting gnugo--begin-exchange gnugo-get :proc gnugo-get-move-insertion-filter "reg_genmove " accept-process-output] 7 (#$ . 36091)])
(defalias 'gnugo-cleanup #[0 "\301 \205�\302 \303U\204�\304\305!\210\306\211\207" [gnugo-state gnugo-board-buffer-p buffer-size 0 message "Thank you for playing GNU Go." nil] 2])
(defalias 'gnugo-position #[0 "\300`\301\"\206\n�\302\303!\207" [get-text-property gnugo-position user-error "Not a proper position point"] 3])
#@240 Request a move suggestion from GNU Go.
After some time (during which you can do other stuff),
Emacs displays the suggestion in the echo area and warps the
cursor to the suggested position.  Prefix arg inhibits warp.

(fn &optional NOWARP)
(defalias 'gnugo-request-suggestion #[256 "\300\301!\210\302 \210\303\304 \203�\305\202�\301\"\207" [gnugo-gate t gnugo--rename-buffer-portion gnugo-get-move gnugo-current-player nowarp] 4 (#$ . 36692) "P"])
#@14 

(fn COLOR)
(defalias 'gnugo--karma #[257 "\211\300\301!A\235\205\n�\302\207" [gnugo-get :wheel t] 4 (#$ . 37148)])
#@13 

(fn ROLE)
(defalias 'gnugo--:karma #[257 "\300\301!!\207" [gnugo--karma gnugo-get] 4 (#$ . 37271)])
(put 'gnugo--:karma 'byte-optimizer 'byte-compile-inline-expand)
#@23 

(fn &optional GATE)
(defalias 'gnugo--assist-state #[256 "\300\301\302!!\262\211\203�\203�\303\304!\202�\211\207" [:user-color gnugo--karma gnugo-get user-error "Sorry, Assist mode enabled"] 5 (#$ . 37445)])
#@20 

(fn POS-OR-PASS)
(defalias 'gnugo--user-play #[257 "\300\301!\210\302 \303!\203 �\211\304\305!\232\203�\306\305!\210\202 �\307\310\"\210\311\"\266\312\301!\207" [gnugo-gate t gnugo-current-player gnugo--karma gnugo-get :one-shot gnugo--forget user-error "Sorry, you cannot play for %s at this time" gnugo-push-move gnugo--finish-move] 5 (#$ . 37667)])
#@166 Make a move on the GNUGO Board buffer.
The position is computed from current point.
Signal error if done out-of-turn or if game-over.
To start a game try M-x gnugo.
(defalias 'gnugo-move #[0 "\300\301 !\207" [gnugo--user-play gnugo-position] 2 (#$ . 38034) nil])
#@44 Do `gnugo-move' at mouse location.

(fn E)
(defalias 'gnugo-mouse-move #[257 "\300!\210g\301>\205\f�\302 \207" [mouse-set-point (46 43) gnugo-move] 3 (#$ . 38303) "@e"])
#@121 Make a pass on the GNUGO Board buffer.
Signal error if done out-of-turn or if game-over.
To start a game try M-x gnugo.
(defalias 'gnugo-pass #[0 "\300\301!\207" [gnugo--user-play "PASS"] 2 (#$ . 38481) nil])
#@44 Do `gnugo-pass' at mouse location.

(fn E)
(defalias 'gnugo-mouse-pass #[257 "\300!\210\301 \207" [mouse-set-point gnugo-pass] 3 (#$ . 38696) "@e"])
(defalias 'gnugo-resign #[0 "\300\301!\210\302\303!\204�\304\305!\207\306\301\307\"\210\310 \207" [gnugo-gate t y-or-n-p "Resign? " message "(not resigning)" gnugo-push-move "resign" gnugo-refresh] 3 nil nil])
#@12 

(fn W/D)
(defalias 'gnugo-animate-group #[257 "\301 \210\302 \303 \304\211g\305>\204�\306\307\"\210\310\311\"\262\312\313#\262\310\314G#\210\315\316\317!\304\"\210\320\321!\203v�\322`\323\"\324g!\325\326#\327N\325\"\327N\330G\304W\203o�\331\332\"\330U\203c�\202d�B\262T\262\202P�\211\237\266\207\202{�\333\334\326#\211C\212\335\336\")\315\316\317!\327B\"\210A\203\247�\337\340!\203\247�A\211\262\240\210\341!\210\202\214�\337\342!\210\211\343\344\"\266\326\266\203\207" [gnugo-animation-string gnugo-gate gnugo-position buffer-modified-p nil (88 79) user-error "No stone at %s" message "Computing %s stones ..." gnugo-lsquery "%s_stones %s" "%s %s in group" setplist gnugo-f anim gnugo-get :display-using-images get-text-property gnugo-yin gnugo-yang gnugo-yy t display 0 logand 1 split-string "" mapcar #[257 "\301!\302\211T\"\303\304\305\306!#\210\303\307#\210\207" [most-positive-fixnum gnugo-goto-pos make-overlay overlay-put category gnugo-f anim priority] 8 "\n\n(fn POS)"] sit-for 0.08675309 set-buffer-modified-p 5 mapc delete-overlay] 15 (#$ . 39063)])
#@28 

(fn COMMAND BUFFER-NAME)
(defalias 'gnugo-display-group-data #[514 "\300 \210\301\302\"\210\303\304\305 #\306!\210\307 \210\211c\266\301\310\"\207" [gnugo-gate message "Computing %s ..." gnugo--q "%s %s" gnugo-position switch-to-buffer erase-buffer "Computing %s ... done"] 6 (#$ . 40175)])
#@171 In the GNUGO Board buffer, animate "worm" at current position.
Signal error if done out-of-turn or if game-over.
See variable `gnugo-animation-string' for customization.
(defalias 'gnugo-worm-stones #[0 "\300\301!\207" [gnugo-animate-group worm] 2 (#$ . 40480) nil])
#@115 Display in another buffer data from "worm" at current position.
Signal error if done out-of-turn or if game-over.
(defalias 'gnugo-worm-data #[0 "\300\301\302\"\207" [gnugo-display-group-data "worm_data" "*gnugo worm data*"] 3 (#$ . 40754) nil])
#@173 In the GNUGO Board buffer, animate "dragon" at current position.
Signal error if done out-of-turn or if game-over.
See variable `gnugo-animation-string' for customization.
(defalias 'gnugo-dragon-stones #[0 "\300\301!\207" [gnugo-animate-group dragon] 2 (#$ . 41007) nil])
#@117 Display in another buffer data from "dragon" at current position.
Signal error if done out-of-turn or if game-over.
(defalias 'gnugo-dragon-data #[0 "\300\301\302\"\207" [gnugo-display-group-data "dragon_data" "*gnugo dragon data*"] 3 (#$ . 41287) nil])
#@206 Display estimated score of a game of GNU Go.
Output includes number of stones on the board and number of stones
captured by each player, and the estimate of who has the advantage (and
by how many stones).
(defalias 'gnugo-estimate-score #[0 "\300\301!\210\302\303\304\305#G\266\202\306\303\304\305#G\266\202\307\310!\307\311!\307\312!\313\314\"\210\313\315\"\210\300\316&\207" [message "Est.score ..." "list_stones black" nil apply gnugo-lsquery "list_stones white" gnugo-query "captures black" "captures white" "estimate_score" gnugo-put :black-captures :white-captures "Est.score ... B %s %s | W %s %s | %s"] 12 (#$ . 41548) nil])
#@17 

(fn FILENAME)
(defalias 'gnugo--ok-file #[257 "\301\302!!\303\304!\207" [default-directory file-name-directory expand-file-name set-buffer-modified-p nil] 4 (#$ . 42203)])
#@146 Save the game history to FILENAME (even if unfinished).
If FILENAME already exists, Emacs confirms that you wish to overwrite it.

(fn FILENAME)
(defalias 'gnugo-write-sgf-file #[257 "\301!\203�\302\303!\204�\304\305\"\210\306 \203�\307\310\311B\"\210\312\313\314!\"\210\315!\207" [gnugo-version file-exists-p y-or-n-p "File exists. Continue? " user-error "Not writing %s" buffer-modified-p gnugo--set-root-prop :AP "gnugo.el" gnugo/sgf-write-file gnugo-get :sgf-collection gnugo--ok-file] 5 (#$ . 42386) "FWrite game as SGF file: "])
#@14 

(fn KARMA)
(defalias 'gnugo--dance-dance #[257 "\301\302\211\303\304#\305\306#\\\262H\211G\303U\203 �\211A\262\242\202'�\307\310\311GD\"@\312\313\"\210\211\211\207" [gnugo-btw [(moshpit " Zombie") (classic nil) (reverse " Zombie Assist") (stilted " Assist")] #[771 "\300!\235\203\n�\207\301\207" [gnugo-get 0] 5 "\n\n(fn KARMA N PROP)"] 2 :user-color 1 :gnugo-color signal wrong-number-of-arguments nil gnugo-put :dance] 8 (#$ . 42935)])
#@24 

(fn WAIT PLAY SAMEP)
(defalias 'gnugo--who-is-who #[771 "\211\204�\300\301!\211\203�\302\303\304A\"\241!\210\210\305\306\203 �\307\202!�\310\203+�\311\202,�\312%\207" [gnugo-get :wheel gnugo--dance-dance mapcar gnugo-other message "GNU Go %splays as %s, you as %s (%s)" "" "now " "as before" "NOTE: this is a switch!"] 9 (#$ . 43394)])
#@10 

(fn X)
(defalias 'gnugo--nodep #[257 "\300@@!\207" [keywordp] 3 (#$ . 43746)])
(put 'gnugo--nodep 'byte-optimizer 'byte-compile-inline-expand)
#@13 

(fn SIZE)
(defalias 'gnugo--SZ! #[257 "\300\301\"\210\300\302\303 \304\305\306\307T\310\"#\311\211\"\262!\"\207" [gnugo-put :SZ :center-position gnugo--as-pos-func + -1 97 truncate 2 string] 10 (#$ . 43898)])
#@33 

(fn COLLECTION &optional SEL)
(defalias 'gnugo--plant-and-climb #[513 "\300\301\"\210\211\206\n�\3028\300\303\"\210\300\304\305\211\302H\262\302H\302\"\"\210\211\207" [gnugo-put :sgf-collection 0 :sgf-gametree :monkey vector] 9 (#$ . 44120)])
#@78 Load the first game tree from FILENAME, a file in SGF format.

(fn FILENAME)
(defalias 'gnugo-read-sgf-file #[257 "\300!\203\n�\301\302!\210\303\211\211\211\211\211\304\305\306	!\"\262\307!\262\310\311!\230\262\312\313\"\210\204=�\312\314\"\210\312\311\"\210\315!\262\316\211G\211\317U\204Q�\320\321!\210\322\262\"\262\323\324\325!\236A\266\204!\210\326\325!\236A\266\204\206~�\327\330!\331\232\205~�\332\211\262\203\211�\333\303\"\210\312\334\327\335\310\311!\"\"\210\336\337!\210\340!\210\341#\207" [file-directory-p user-error "Cannot load a directory (try a filename with extension .sgf)" nil gnugo--q/ue "loadsgf %s" expand-file-name gnugo-other gnugo-get :user-color gnugo-put :last-mover :gnugo-color gnugo/sgf-create gnugo--plant-and-climb 1 message "(Selecting the first game)" 0 gnugo--SZ! :SZ gnugo--root-node :RE gnugo-move-history two ("PASS" "PASS") two-passes gnugo-close-game :last-user-bpos bpos gnugo-refresh t gnugo--ok-file gnugo--who-is-who] 14 (#$ . 44376) "fSGF file to load: "])
#@30 

(fn POS &optional NOERROR)
(defalias 'gnugo--mem-with-played-stone #[513 "g\300\301\"\203\f�\302\202�\300\303\"\205�\304\262\211\204&�?\205]�\305\306\"\202]�\211\307 !B\310\311!\312H\313\314:\203U�@@\232\203J�\262\314\211\262\202K�\313\203U�A\262\2023�?\205[�\211\266\204\207" [eql 88 :B 79 :W user-error "No stone at %s" gnugo--as-cc-func gnugo-get :monkey 0 t nil] 9 (#$ . 45426)])
#@37 

(fn SPEC &optional REACTION KEEP)
(defalias 'gnugo--climb-towards-root #[769 "\301 \210\302\303!\210\304\305!\304\306!\304\307!\211\211\310H\262\211\311HH\310H=\266\202?\247\203J�\310U\203A�\304\312!\230\203=�\311\202C�\313\202C�\310H\233\202Z�\314;\203V�\202X�\315 !A\304\316!\203c�\317 \210\211\310H=\204\227�\320\321!\211\310H\322U\262\203\227�\211\310H\211\310AI\210\266\323\312\324 \"\210\325 \210\326 \210\327 \210\202c�\304\312!\230\330\203\246�\331\202\247�\332!\323\333\203\273�\211\334\230\262\204\273�\202\276�\304\335!\"\210\326\303!\210\204\330�\204\330�\311H\310HI\210\2057\304\336!\337\206\346�\340\341\"\203\362� \2021\340\342\"\203 \304\343!\211ABA\344\310\345\346\347\"\350\"\313$\216\241\210 )\266\203\262\2021\340\351\"\203-\352\311!\2021\323\353\"\262\262\262\266\202\207" [gnugo-undo-reaction gnugo-gate gnugo--assist-state t gnugo-get :user-color :monkey :sgf-gametree 0 1 :last-mover 2 gnugo--mem-with-played-stone gnugo-position :game-over gnugo--unclose-game gnugo--q "undo" 61 gnugo-put gnugo-current-player gnugo--merge-showboard-results gnugo-refresh redisplay gnugo-move-history car cadr :last-user-bpos "PASS" :center-position :gnugo-color #[0 "\300\301!\207" [gnugo--turn-the-wheel t] 2] eql play play! :wheel make-byte-code "\300\301\241\207" vconcat vector [] zombie gnugo-zombie-mode :one-shot] 25 (#$ . 45835)])
#@456 Undo exactly one move (perhaps GNU Go's, perhaps yours).
Do not schedule a move by GNU Go even if it is GNU Go's turn to play.
Prefix arg ME-NEXT means to arrange for you to play
the color of the next move (and GNU Go the opposite).
This is useful after loading an SGF file whose last
move was done by the color you prefer to play:
 \[gnugo-read-sgf-file] FILENAME RET
 C-u \[gnugo-undo-one-move]

See also `gnugo-undo-two-moves'.

(fn &optional ME-NEXT)
(defalias 'gnugo-undo-one-move #[256 "\301 \210\211\203#�\302\303!\304!\302\305!\230\306\305\"\210\306\307\"\210\310#\266\311\312\313\314\"\2030�\2021�\315\"\207" [gnugo-undo-reaction gnugo-gate gnugo-get :last-mover gnugo-other :user-color gnugo-put :gnugo-color gnugo--who-is-who gnugo--climb-towards-root 1 eql zombie one-shot] 8 (#$ . 47259) "P"])
#@158 Undo a pair of moves (GNU Go's and yours).
However, if you are the last mover, undo only one move.
Regardless, after undoing, it is your turn to play again.
(defalias 'gnugo-undo-two-moves #[0 "\300\301!\207" [gnugo--climb-towards-root 0] 2 (#$ . 48083) nil])
#@283 Like `gnugo-undo-two-moves', but keep the undone moves.
The kept moves become a sub-gametree (variation) when play resumes.
Prefix arg means, instead, undo repeatedly up to and including
the move which placed the stone at point, like `\[gnugo-fancy-undo]'.

(fn &optional POSITION)
(defalias 'gnugo-oops #[256 "\300?\205�\301\302\303#\207" [gnugo--climb-towards-root 0 nil t] 5 (#$ . 48350) "P"])
#@98 Redo a pair of undone moves.
Prefix arg means to redo all the undone moves.

(fn &optional FULL)
(defalias 'gnugo-okay #[256 "\300 \210\301\302!\211\211\303H\262\301\304!\211\211\305HH\303H=\266\202\203%�\306\307!\202\344�\310 \211\305H\262\303H\305HH\301\311!\211\211\211\312\230\262\203I�\313\262\202L�\314\262\315\203[�\211@\"\202d�\316@\"\\\317\211\211\211:\203\260�\211@\262\313\236\206|�\314\236\262\262\203\241�
\"Y\203\241�@=\211A!DB\262\210\nA=\204\260�\211A\262\202i�\317\211\211:\203\333�@\262\211A\262\242\262\211@\262\320\"\210\321 \210\322 \210A\262\202\264�\266\317\266\205\262\266\207\207" [gnugo-gate gnugo-get :sgf-gametree 0 :monkey 1 message "Oop ack!" gnugo--as-pos-func :user-color "black" :B :W #[514 "\300\"\207" [gethash] 5 "\n\n(fn MNUM NODE)"] 2 nil gnugo-push-move gnugo-refresh redisplay] 24 (#$ . 48755) "P"])
#@619 Display final score and other info in another buffer (when game over).
If the game is still ongoing, Emacs asks if you wish to stop play (by
making sure two "pass" moves are played consecutively, if necessary).
Also, add the `RE' (Result) SGF property to the root node of the game tree.
Prefix arg means to attach to the last move the SGF properties:
 TB -- Black Territory
 TW -- White Territory
 MA -- Mark (to indicate seki stones)
 DD -- Dim Points (to indicate dead stones)
each of which is a non-empty list of positions, as well as the final
score text (slightly compacted) as a comment.

(fn &optional COMMENT)
(defalias 'gnugo-display-final-score #[256 "\300\301!\211\204�\300\302!\204�\303\304!\204�\305\306!\210\211\204.�\307\211\310!\204&�\211\311!\210\210\312 \210\313\314!\210\210\315\316\317\320!\211\321\230\262\205?�\300\322!\300\323!\311C\311\203w�\324\325\326H\327U\203Z�\202\\�\314\330O\"\331\324\332\"E\240\210\333!\326\334O\226\335P\262\202	\336\337!\210\300\301!\340\236A\266\202\341\236A\266\202\324\342\"\343\344\345C\346\347#G\266\202\350C\346\347#G\266\202\351\300\352!!\351\300\353!!\354\311\355!\236A\266\204\f\356C\240\210\357\360\"\262\f\361\311\355!\236A\266\204\362\230\203i	\211\203\211@\211@@\211\363=\262\203\375�AG\\\262\202AG\\\262A\266\202\202\341�\210\211\2038\211@\211@@\211\363=\262\203)AG\\\262\2021AG\\\262A\266\202\202\210\f\324\364\n%\242B\240\210\f\324\365\366	\\&\242B\240\210\202\326\211\203\231\211@\211@@\211\363=\262\203\210AG\367_\\\262\202\222AG\367_\\\262A\266\202\202k\210\f\324\370\f\f\\&\242B\240\210\f\324\371\f\366\372

#&	\242B\240\210\f\f\373\230\203\343\374\202\376\324\375\326H\376U\203\363\202\365\314\330O\367\311O#\242B\240\210\336\377!\266\f\300\201@�!\300\201A�!\211\2034\201B�\242B\240\210\201C�\211\201D�#\210\211\201E�#\266\266\346\201F�\242\237\"\240\210\201G�\201H�\"\210\203\300\201I�!\326H@\201J�\311\211:\203\234@\262\211A\262\242\262\347\201K�	#\201L�\236\"\210\211\203\224\201M�\201N�\201O� \"#\210\210A\262\202\\\266\201M�\201L�\201P�\236\"\201P�\201Q�\201R�!r\211q\210\201S�\326\201T�\201U�\201V�!\201W�\"\367$\216\242c\210\201X�\201Y�\311\310#\203\344`d|\210\201Z�\211\201[�\201\\�\"\210\211\343\201]�\"\210\211\344\201^�\"\210\211\201_�\201`�\"\266\201a� *\262#\266\201b�\324\201c�\300\201d�!\"!\210\201e� \210\242c\207" [gnugo-get :game-over :waiting y-or-n-p "Game still in play. Stop play now? " user-error "Sorry, game still in play" #[257 "\300\301\302\203�\303\202\f�\304!\"\210\305\306!\210\307\310\"\207" [message "Playing PASS for %s ..." gnugo-get :user-color :gnugo-color sit-for 1 gnugo-push-move "PASS"] 5 "\n\n(fn USERP)"] t nil gnugo-refresh sit-for 3 "   Black = " "   White = " gnugo-move-history car "resign" :last-mover :scoring-seed format "%s wins.\n" 0 98 8 "The game is over.\n" "Resignation by %s.\n" gnugo-other 1 "+Resign" message "Computing final score ..." live dead "final_status_list %%s_territory %d" "territory" "captures" "black" apply gnugo-lsquery "white" string-to-number :black-captures :white-captures :KM gnugo--root-node "The game is over.  Final score:\n" gnugo-query "final_score %d" :RU "Chinese" :B "%s%d %s = %3.1f\n" "%s%d %s + %3.1f %s = %3.1f\n" komi 2 "%s%d %s + %s %s = %3.1f\n" "%s%d %s + %s %s + %3.1f %s = %3.1f\n" + "0" "The game is a draw.\n" "%s wins by %s.\n" 66 "Computing final score ... done" :game-start-time :game-end-time "\n" #[771 "\300\301P\"\242B\240\207" [format-time-string ": %F %T %z\n"] 7 "\n\n(fn BLURB PRETTY MOMENT)"] "Game start" "       end" concat gnugo--set-root-prop :RE :monkey ((:TB . black_territory) (:TW . white_territory) (:MA . seki) (:DD . dead)) "final_status_list %s %s" delq gnugo--decorate mapcar gnugo--as-cc-func :C generate-new-buffer " *temp*" make-byte-code "\301\300!\205	�\302\300!\207" vconcat vector [buffer-name kill-buffer] search-backward "\n\nGame start:" #[514 "eb\210\300\301\302#\205�\303!\210\202�\207" [search-forward nil t replace-match] 6 "\n\n(fn OLD NEW)"] "The game is over.  " "" "T" "C" "komi" "K" buffer-string switch-to-buffer "%s*GNUGO Final Score*" :diamond erase-buffer] 32 (#$ . 49667) "P"])
#@121 Kill the current buffer, assumed to be in GNUGO Board mode, maybe.
If the game is not over, ask for confirmation first.
(defalias 'gnugo-quit #[0 "\300\301!\204\f�\302\303!\203�\304\305!\207\306\307!\207" [gnugo-get :game-over y-or-n-p "Quit? " kill-buffer nil message "(not quitting)"] 2 (#$ . 53994) nil])
#@42 Kill the current buffer unconditionally.
(defalias 'gnugo-leave-me-alone #[0 "\300\301!\207" [kill-buffer nil] 2 (#$ . 54309) nil])
#@188 Rewind the game tree in various ways.
Prefix arg COUNT means to undo that many moves.
Otherwise, undo repeatedly up to and including the move
which placed the stone at point.

(fn COUNT)
(defalias 'gnugo-fancy-undo #[257 "\300\247\203\n�\202\f�\242!\207" [gnugo--climb-towards-root] 3 (#$ . 54448) "P"])
#@124 If enabled, display the board using images.
See function `display-images-p' and variable `gnugo-xpms'.

(fn &optional ARG)
(defalias 'gnugo-image-display-mode #[256 "\301 \302=\203�\303\304!?\202�\305!\306V\211\303\304!=\204\273�\307 \204%�\310\311!\210\312!\2033�\303\313!!\2024�\211\204<�\310\314!\210\211\303\315!=\204M�\316\315\"\210\317\320!\210\210\321\203W�\322\202X�\323\324\325\326\327\330!\331\"\332\333%\262\303\320!\206\203�\316\320\334\335\303\315!\"\316\336\337\340\341\342\343!\"\344N!\"\210\"\"\210\345\346\347!\205\216�\350\"\210\316\351\203\234�\352\353B\202\237�\303\354!\"\210\316\355\203\255�\303\336!\202\256�\356\"\210\316\304\"\210\212\357\360!\210)\210\361\362\303\304!\203\310�\363\202\311�\364\"\210\365\366!\203\357�\301 \203\335�\211\301 \232\203\357�\367\370\371\303\304!\203\352�\372\202\353�\373#\266\210\374 \210\303\304!\207" [gnugo-xpms current-message toggle gnugo-get :display-using-images prefix-numeric-value 0 display-images-p user-error "Sorry, display does not support images" functionp :SZ "Sorry, `gnugo-xpms' unset" :xpms gnugo-put gnugo--forget :all-yy mapc display do-not-display make-byte-code 257 "\301!\300\240\207" vconcat vector [symbol-plist] 3 "\n\n(fn YY)" mapcar #[257 "\211@\300A@\"\301\302AD\"\210\207" [gnugo-yy setplist not-yet] 7 "\n\n(fn ENT)"] :imul image-size gnugo-yy 5 gnugo-yang 43 not-yet setplist gnugo-f ispc (display (space :width 0)) :highlight-last-move-spec #[257 "\300\301\302\"\301\303\"\304#\305N\207" [gnugo-yy get-text-property gnugo-yin gnugo-yang t display] 6 "\n\n(fn P)"] (0 delete-overlay) :default-highlight-last-move-spec :mul (1 . 1) gnugo-refresh t run-hooks gnugo-image-display-mode-hook gnugo-image-display-mode-on-hook gnugo-image-display-mode-off-hook called-interactively-p any " in current buffer" message "Gnugo-Image-Display mode %sabled%s" "en" "dis" force-mode-line-update] 15 (#$ . 54762) (byte-code "\206�\301C\207" [current-prefix-arg toggle] 1)])
(defvar gnugo-image-display-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\300\207" [gnugo-image-display-mode-hook variable-documentation put "Hook run after entering or leaving `gnugo-image-display-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)"] 4)
#@30 

(fn POS &optional NOERROR)
(defalias 'gnugo--node-with-played-stone #[513 "\300\"@\207" [gnugo--mem-with-played-stone] 5 (#$ . 57099)])
(put 'gnugo--node-with-played-stone 'byte-optimizer 'byte-compile-inline-expand)
#@124 Display the board position under cursor in the echo area.
If there a stone at that position, also display its move number.
(defalias 'gnugo-describe-position #[0 "\300 \211\301\302\"@\266\202\303\304\203)�\305\306!\211\211\307H\262\310\"\311\312\"\266\203\206*�\313#\207" [gnugo-position t gnugo--mem-with-played-stone message "%s%s" gnugo-get :sgf-gametree 1 gethash format " (move %d)" ""] 11 (#$ . 57327) nil])
#@48 Switch to another GNU Go game buffer (if any).
(defalias 'gnugo-switch-to-another #[0 "\300 A\301\302\301:\203/�@\262\303!\203$�\304 \210\305!\262\301\211\262\202%�\302\203/�A\262\202�\203;�\306\307!\210\301\202<�\211\207" [buffer-list nil t gnugo-board-buffer-p bury-buffer switch-to-buffer message "(only one)"] 6 (#$ . 57756) nil])
#@333 Add to NODE a COMMENT (string) property.
Interactively, NODE is the one corresponding to the stone at point,
or the root node if there is no played stone at point, and any
previous comment is inserted as the initial-input (see `read-string').

If COMMENT is nil or the empty string, remove the property entirely.

(fn NODE COMMENT)
(defalias 'gnugo-comment #[514 "\300\301\236\"\262\211G\302U?\205�\303\301#\207" [delq :C 0 gnugo--decorate] 6 (#$ . 58109) (byte-code "\300 \211\301\302\"@\266\202\206�\303 \211\304\305\306\303 =\203�\307\202!�\310 \"\311\236A\266\202\"D\207" [gnugo-position t gnugo--mem-with-played-stone gnugo--root-node read-string format "Comment for %s: " "root node" gnugo-describe-position :C] 9)])
#@18 

(fn PROP UPDN)
(defalias 'gnugo--struggle #[514 "\211\300\301!!\262=?\205\206�\301!\203�\302 \210\202P�\301\303!\211\203O�@\230\203O�\304 \210\211\3051<�\306 \307\310\"\2300\202@�\210\202C�\206D�\311\241\210\312\313\"\210\314\315!\210\210\301\316!\211@A\317!\203a�\320!\210\321\240\210\203s�B\211\262\202w�\322\"\211\262\241\210\323!\266\324\325!\262\207" [gnugo--karma gnugo-get gnugo-gate :waiting gnugo--rename-buffer-portion (error) gnugo-position gnugo-move-history bpos nowarp gnugo--display-suggestion "forthcoming" sit-for 2 :wheel timerp cancel-timer nil delete gnugo--dance-dance gnugo--turn-the-wheel t] 10 (#$ . 58852)])
#@272 If enabled ("Assist" in mode line), GNU Go plays for you.
When disabling, if GNU Go has already started thinking of
a move to play for you, the thinking is not cancelled but instead
transformed into a move suggestion (see `gnugo-request-suggestion').

(fn &optional ARG)
(defalias 'gnugo-assist-mode #[256 "\300 \301=\203�\302 ?\202�\303!\304V\305\306\"\266\307\310\302 \203$�\311\202%�\312\"\210\313\314!\203J�\300 \2039�\211\300 \232\203J�\315\316\317\302 \203E�\320\202F�\321#\266\210\322 \210\302 \207" [current-message toggle gnugo--assist-state prefix-numeric-value 0 gnugo--struggle :user-color run-hooks gnugo-assist-mode-hook gnugo-assist-mode-on-hook gnugo-assist-mode-off-hook called-interactively-p any " in current buffer" message "Gnugo-Assist mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 59519) (byte-code "\206�\301C\207" [current-prefix-arg toggle] 1)])
(defvar gnugo-assist-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\300\207" [gnugo-assist-mode-hook variable-documentation put "Hook run after entering or leaving `gnugo-assist-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)"] 4)
#@271 If enabled ("Zombie" in mode line), GNU Go lets you play for it.
When disabling, if GNU Go has already started thinking of
a move to play, the thinking is not cancelled but instead
transformed into a move suggestion (see `gnugo-request-suggestion').

(fn &optional ARG)
(defalias 'gnugo-zombie-mode #[256 "\300 \301=\203�\302\303\304!!\262??\202�\305!\306V\307\302?\"\266\310\311\302\303\304!!\262\2042�\312\2023�\313\"\210\314\315!\203^�\300 \203G�\211\300 \232\203^�\316\317\320\302\303\304!!\262\204Y�\321\202Z�\322#\266\210\323 \210\302\303\304!!\262?\207" [current-message toggle :gnugo-color gnugo--karma gnugo-get prefix-numeric-value 0 gnugo--struggle run-hooks gnugo-zombie-mode-hook gnugo-zombie-mode-on-hook gnugo-zombie-mode-off-hook called-interactively-p any " in current buffer" message "Gnugo-Zombie mode %sabled%s" "en" "dis" force-mode-line-update] 9 (#$ . 60756) (byte-code "\206�\301C\207" [current-prefix-arg toggle] 1)])
(defvar gnugo-zombie-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\300\207" [gnugo-zombie-mode-hook variable-documentation put "Hook run after entering or leaving `gnugo-zombie-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)"] 4)
#@581 Send the Go Text Protocol COMMAND (a string) to GNU Go.
Output and Emacs behavior depend on which command is given (some
commands are handled completely by Emacs w/o using the subprocess;
some commands have their output displayed in specially prepared
buffers or in the echo area; some commands are instrumented to do
gnugo.el-specific housekeeping).

For example, for the command "help", Emacs visits the
GTP command reference info page.

NOTE: At this time, GTP command handling specification is still
      incomplete.  Thus, some commands WILL confuse gnugo.el.

(fn COMMAND)
(defalias 'gnugo-command #[257 "\211\300\230\203\n�\301\302!\207\303!\304@!\211\305N\306\307\"\211\203#�\211A!\202\213�\301\310\"\210\311!\306\312\"\313\314\"\203>�\301\315\"\202\211�\316!\203K�\211!\210\202}�\211\317=\203X�\301\300!\210\202}�\211\320=\204e�\313\321\"\204m�\301\315\"\210\202}�\322\323!\210\324 \210c\210\301\325\"\210\306\326\"\211\205\207�\211 \262\266\202\207" ["" message "(no command given)" split-string intern :gnugo-gtp-command-spec plist-get :full "Doing %s ..." gnugo--q :output string-match "unknown.command" "%s" functionp :discard :message "\n" switch-to-buffer "*gnugo command output*" erase-buffer "Doing %s ... done" :post-thunk] 10 (#$ . 62059) "sCommand: "])
(defvar gnugo-board-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [gnugo-board-mode-hook variable-documentation put "Hook run after entering GNUGO Board mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp gnugo-board-mode-map definition-name gnugo-board-mode] 4)
(defvar gnugo-board-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204�\302\300\301\303\304!#\210\302\305\306\307#\207" [gnugo-board-mode-map variable-documentation put purecopy "Keymap for `gnugo-board-mode'." gnugo-board-mode derived-mode-parent special-mode] 5)
#@190 Major mode for playing GNU Go.
Entering this mode runs the normal hook `gnugo-board-mode-hook'.
In this mode, keys do not self insert (see `gnugo-board-mode-map').

\{gnugo-board-mode-map}
(defalias 'gnugo-board-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!\210\321 \210\322\307\323\324\325\326\307$\210\327\330!\203F�\330\331!\210\202M�\306\332!\210\326\306\333!\210\334\335D\336\337\340\341$\262\306\342!\210\326\"\343\344\345\"\210\346\347\346\350\351\"\"\210\346\352\353\331\211\"\353\331\211\"\354\355\356#\210\211\262B\"\210\346\357\360\"\210\346\361\362\363\326\"\"\210\364\365!\210)\366\367!\207" [delay-mode-hooks major-mode mode-name gnugo-board-mode-map font-lock-defaults truncate-lines make-local-variable t special-mode gnugo-board-mode "GNUGO Board" mode-class put keymap-parent set-keymap-parent current-local-map use-local-map buffer-disable-undo (gnugo-font-lock-keywords t) add-hook kill-buffer-hook gnugo-cleanup nil fboundp cursor-intangible-mode 1 inhibit-point-motion-hooks gnugo-state :size 41 apply make-hash-table :test eq gnugo-btw add-to-list minor-mode-alist (gnugo-btw gnugo-btw) gnugo-put :highlight-last-move-spec :default-highlight-last-move-spec ("(" -1 nil) :paren-ov make-overlay overlay-put display ")" :mul (1 . 1) :obarray make-vector 31 add-to-invisibility-spec :nogrid run-mode-hooks gnugo-board-mode-hook] 8 (#$ . 64047) nil])
#@701 Run gnugo in a buffer, or resume a game in progress.
If there is already a game in progress you may resume it instead
of starting a new one.  Prefix arg means skip the game-in-progress
check and start a new game straight away.

Before starting, Emacs queries you for additional command-line
options (Emacs supplies "--mode gtp --quiet" automatically).

Note that specifying "--infile FILENAME" (or, "-l FILENAME")
silently clobbers certain other options, such as "--color".
For details, see info node `(gnugo) Invoking GNU Go'.

\<gnugo-board-mode-map>
To play, use \[gnugo-move] to place a stone or \[gnugo-pass] to pass.
See `gnugo-board-mode' for a full list of commands.

(fn &optional NEW-GAME)
(defalias 'gnugo #[256 "\302\303 \211\203�\211@\304!\203�\305!BB\262A\266\202\202�\210\211\262\211G\204m�\211\211\306V\262\203m�\307\310\311\312U\203?�\313\202@�\314\"!\203m�\315\312U\203Q�@\202h�\316\317\302\320$\211\313\230\203b�@\202f�\321\"\262A!\202\250\322!\204x�\323\324\"\210\315\325\326!!\210\327 \210\302C\330\331\332\333	@\301#!\302\203\370�\211A\262\242\334\335\230\203\263�B\262\211A\262\242\211\262B\262\202\363�\336\230\203\311�\211\336\211A\262\242#\210\202\363�\337\340\"\203\356�\211\341\342GW\203\342�\342\302O\202\351�\211A\262\242#\210\202\363�B\262\266\202\215�\211\237\266\202\343\344\345p\346\347\350&\302C\302\211\211\351\352\"\210\351\353\"\210\354\355\"\210\356\302\"\210\351\357\360!\361\302O\"\210\351\362\363	!\"\210\242\203G\364\365	\242!!\210\202\366\367\370\371\372\373\320\"!!\240\210\374\375!\262\374\376!\262\374\377!\211\262!\210\201@�\235\306U\203\211\203\201A�A@!\262\210\211\201B�\201C�\201D�\201E�!\201F�\201G�\235\203\243\201H�\202\246\201I�\201J�\n&	\210\211\330\230\262\203\302\201K�\202\305\201L�\201M�\201N�\201O�!P\203\332\201L�\202\335\201K�\201P� %\266\306U\204\211\201Q�\201R�\201S�\201T� \201U�\201V�\"\"%\210\210\266\351\201W�\201X� \"\210\201Y�\320!\210\201Z�\201[�\201\\�!\206-\201[�\201]�!!\210\351\201^�\201X� \"\210\201[�\362!\201Q�\302\370!\236A\266\204\206P\306\201[�\352!\201[�\201_�!\204\210\351\201_�\211\330\230\262\203r\312W\204\201\211\330\230\262\203\205\342W\203\205\202\206\"\210C\351\201`�\302B\"\210\201a�!\266\201b�\201c�!\210\201d� \266\203\207" [gnugo-program gnugo-option-history nil buffer-list gnugo-board-buffer-p buffer-name 0 y-or-n-p format "GNU Go game%s in progress, resume play? " 1 "" "s" switch-to-buffer completing-read "Which one? " t assoc executable-find user-error "Invalid `gnugo-program': %S" generate-new-buffer "(Uninitialized GNUGO Board)" gnugo-board-mode "black" split-string read-string "GNU Go options: " #[771 "\242\203�\300\301#\207\240\207" [warn "%s %s ignored"] 7 "\n\n(fn FILENAME OPT FN)"] "--color" "--infile" string-match "^-l" "-l" 2 apply start-process "gnugo" "--mode" "gtp" "--quiet" gnugo-put :user-color :proc set-process-sentinel gnugo-sentinel set-process-query-on-exit-flag :diamond process-name 5 :gnugo-color gnugo-other gnugo-read-sgf-file expand-file-name #[385 "\300\301\242#\207" [apply gnugo--decorate] 6 "\n\n(fn &rest PLIST)"] gnugo--SZ! gnugo--root-node gnugo--plant-and-climb gnugo/sgf-create "(;FF[4]GM[1])" gnugo--nquery "get_komi" "get_handicap" "query_boardsize" "--handicap" string-to-number :SZ :DT format-time-string "%F" :RU "--chinese-rules" "Chinese" "Japanese" :KM :PW :PB "GNU Go " gnugo-query "version" user-full-name :HA :AB mapcar gnugo--as-cc-func gnugo-lsquery "fixed_handicap %d" :waiting-start current-time gnugo-refresh gnugo-goto-pos gnugo-get :last-user-bpos :center-position :game-start-time :last-mover :wheel gnugo--dance-dance run-hooks gnugo-start-game-hook gnugo--turn-the-wheel] 22 (#$ . 65511) "P"])
(byte-code "\301\302N\204H�\303\304\305\306\307\310!\311\"\312\313%\314\315\211\301\316\317$\210\211\320\316\321$\210\211\322\323\324\325\326&\210\211\327\316\330$\210\211\331\316\304\332\333\307\310\n!\334\"\335\336%$\266\337\340\"\341=\204}�\342\343\211\211:\203{�\262\211A\262\242\262\211A\262\242\262\344#\210AA\262\202U�\266\345\346!\207" [gnugo-board-mode-map help :gnugo-gtp-command-spec #[257 "\211\300N\207" [:gnugo-gtp-command-spec] 3 "\n\n(fn X)"] make-byte-code 771 "\301\302\303\300!##\207" vconcat vector [put :gnugo-gtp-command-spec plist-put] 10 "\n\n(fn CMD PROP VAL)" #[513 "\226\300\301!\302 !\303\304T\211\262GW\2034�H\262\211\305Z\303W\203*�V\2040�\306\307\"\210\210\202�\266\203>�\310!\210\211\207" [gnugo-get :SZ gnugo--as-cc-func -1 nil 97 user-error "Invalid position: %s" gnugo-goto-pos] 11 "\n\n(fn S &optional GO)"] #[642 "9\203\n�C\202�\211\205/�\211@\211\203'�@A@#\210\211AA\262\202�\210A\266\202\202�\207" [] 10 "\n\n(fn X &rest PROPS)"] :full #[257 "\301\302!\210\211\203�\303@!\262\304\211C\304\211\211\211\305eb\210\212\306\307\304\310#\203\227�\242\2044�\311\312\224\313\224Z\314\"\240\210\315\303\316\312!!\211\262\317N\211\262\320\"\203M�\211\321\"\210\315\322\"\211\262\203\203�\323!\203f�\211\324\"\210\202\203�\325\326\"\203v�\211\327\"\210\202\203�\325\330\"\203\203�\211\331\"\210=\203�\332 \262\313\224\304\223\210\202�)\210\211\203\247�\211b\210\211\304\211\223\202\262�?\206\262�\333\334\")\207" [buffer-read-only info "(gnugo)GTP command reference" intern nil #[514 "\242\300\301\261\207" ["[NOTE: gnugo.el " ".]\n"] 6 "\n\n(fn PAD S)"] re-search-forward "^ *[*] \\([a-zA-Z_]+\\)\\(:.*\\)*\n" t make-string 1 0 32 plist-get match-string :gnugo-gtp-command-spec :full "handles this command completely" :output functionp "handles the output specially" eql :discard "discards the output" :message "displays the output in the echo area" make-marker message "(no such command: %s)"] 12 "\n\n(fn SEL)"] final_score #[257 "\300 \207" [gnugo-display-final-score] 2 "\n\n(fn SEL)"] (boardsize clear_board fixed_handicap) :output :discard :post-thunk #[0 "\300 \210\301\302!\210\303\304\305!!\210\306\307!\207" [gnugo--unclose-game gnugo--forget :last-mover gnugo--SZ! gnugo--nquery "query_boardsize" gnugo-refresh t] 3] loadsgf #[257 "\300@!\207" [gnugo-read-sgf-file] 3 "\n\n(fn SEL)"] (undo gg-undo) 257 "\301\302\204\n�\303\202\"�\304@!\211\262\211\305V\262\203�\211\202\"�\300@\306\"\262!\207" [gnugo--climb-towards-root nil 1 string-to-number 0 t] 6 "\n\n(fn SEL)" lookup-key "?" describe-mode ("?" describe-mode "S" gnugo-request-suggestion "
" gnugo-move " " gnugo-move "P" gnugo-pass "R" gnugo-resign "q" gnugo-quit "Q" gnugo-leave-me-alone "U" gnugo-fancy-undo "\365" gnugo-undo-one-move "u" gnugo-undo-two-moves "" gnugo-undo-two-moves "o" gnugo-oops "O" gnugo-okay "\f" gnugo-refresh "\337" gnugo-boss-is-near "_" gnugo-boss-is-near "h" gnugo-move-history "L" gnugo-frolic-in-the-leaves "\f" gnugo-frolic-in-the-leaves "i" gnugo-image-display-mode "w" gnugo-worm-stones "W" gnugo-worm-data "d" gnugo-dragon-stones "D" gnugo-dragon-data "g" gnugo-grid-mode "!" gnugo-estimate-score ":" gnugo-command ";" gnugo-command "=" gnugo-describe-position "s" gnugo-write-sgf-file "" gnugo-write-sgf-file "" gnugo-write-sgf-file "l" gnugo-read-sgf-file "F" gnugo-display-final-score "A" gnugo-switch-to-another "C" gnugo-comment "" gnugo-assist-mode "" gnugo-zombie-mode [(down-mouse-1)] gnugo-mouse-move [(down-mouse-2)] gnugo-mouse-move [(down-mouse-3)] gnugo-mouse-pass "" gnugo-describe-internal-properties) nil define-key provide gnugo] 14)
#@74 List of SGF[4] properties, each of the form (PROP NAME CONTEXT SPEC...).
(defconst gnugo/sgf-*r4-properties* '((AB "Add Black" setup list stone) (AE "Add Empty" game list point) (AN "Annotation" game simpletext) (AP "Application" root (simpletext . simpletext)) (AR "Arrow" - list (point . point)) (AS "Who adds stones" - simpletext) (AW "Add White" setup list stone) (B "Black" move move) (BL "Black time left" move real) (BM "Bad move" move double) (BR "Black rank" game simpletext) (BT "Black team" game simpletext) (C "Comment" - text) (CA "Charset" root simpletext) (CP "Copyright" game simpletext) (CR "Circle" - list point) (DD "Dim points" - elist point) (DM "Even position" - double) (DO "Doubtful" move none) (DT "Date" game simpletext) (EV "Event" game simpletext) (FF "Fileformat" root [number (1 . 4)]) (FG "Figure" - (or none (number . simpletext))) (GB "Good for Black" - double) (GC "Game comment" game text) (GM "Game" root [number (1 . 20)]) (GN "Game name" game simpletext) (GW "Good for White" - double) (HA "Handicap" game number) (HO "Hotspot" - double) (IP "Initial pos." game simpletext) (IT "Interesting" move none) (IY "Invert Y-axis" game simpletext) (KM "Komi" game real) (KO "Ko" move none) (LB "Label" - list (point . simpletext)) (LN "Line" - list (point . point)) (MA "Mark" - list point) (MN "set move number" move number) (N "Nodename" - simpletext) (OB "OtStones Black" move number) (ON "Opening" game text) (OT "Overtime" game simpletext) (OW "OtStones White" move number) (PB "Player Black" game simpletext) (PC "Place" game simpletext) (PL "Player to play" setup color) (PM "Print move mode" - number) (PW "Player White" game simpletext) (RE "Result" game simpletext) (RO "Round" game simpletext) (RU "Rules" game simpletext) (SE "Markup" - point) (SL "Selected" - list point) (SO "Source" game simpletext) (SQ "Square" - list point) (ST "Style" root [number (0 . 3)]) (SU "Setup type" game simpletext) (SZ "Size" root (or number (number . number))) (TB "Territory Black" - elist point) (TE "Tesuji" move double) (TM "Timelimit" game real) (TR "Triangle" - list point) (TW "Territory White" - elist point) (UC "Unclear pos" - double) (US "User" game simpletext) (V "Value" - real) (VW "View" - elist point) (W "White" move move) (WL "White time left" move real) (WR "White rank" game simpletext) (WT "White team" game simpletext) (LT "Lose on time" setup simpletext)) (#$ . 73022))
#@548 Return the SGF[4] collection parsed from FILE-OR-DATA.
FILE-OR-DATA is a file name or SGF[4] data.
Optional arg DATA-P non-nil means FILE-OR-DATA is
a string containing SGF[4] data.
A collection is a list of gametrees, each a vector of four elements:

 ENDS -- a vector of node lists, with shared tails
         (last element of all the lists is the root node)

 MNUM -- `eq' hash: node to move numbers; non-"move" nodes
         have a move number of the previous "move" node (or zero)

 ROOT -- the root node

(fn FILE-OR-DATA &optional DATA-P)
(defalias 'gnugo/sgf-create #[513 "\300\301N\206�\302\300\301\303\304\"#\300\305N\206�\302\300\305\303\306\"#\307C\307C\307C\307C\307C\307C\307C\307C\307C\307C\307C\307C\307C\310\240\210\n\311\240\210	\312\313\314\315\316\"\317\"\320\321%\240\210\312\322\323\315\316!\324\"\320\325%\240\210\326\240\210\327\240\210\312\330\331\315\316&\332\"\333$\240\210\312\330\334\315\316!\335\"\336$\240\210\312\322\337\315\316\n!\335\"\340\341%\240\210\312\322\342\315\316	!\343\"\340\341%\240\210\312\330\344\315\316\f\n#\345\"\346$\240\210\211\312\313\347\315\316				$\350\"\351\352%\240\210\353\354!r\211q\210\312\330\355\315\316!\356\"\357$\216\204�\360!\210\202c\210eb\210\307\242 \2035\361\362D\363\364\365\366$\262\242\307\"\367@!@\316\363\316\"#\266\203B\262\202\211\237\262*\262\266\214\207" [gnugo/sgf-*r4-properties* :keywords put mapcar #[257 "\211@\300\301\302@\"!B\207" [intern format ":%s"] 6 "\n\n(fn FULL)"] :specs #[257 "\211@AAAB\207" #1=[] 3 "\n\n(fn FULL)"] nil #[0 "\300\301w\207" [" 	\n" nil] 2] #[514 "`\300\301\"\203\f�\302\202�\300\303\"\203�\304\202�\305\306g\211\262!\204X�\211\307U\203=�\310\311!\210l\2037�\312\311!\210\202�\311u\210\202�\204R�\313\314!\203R�`\315\225|\210\316c\210\202�\311u\210\202�\317`\"\207" [eql :end #[257 "\211\300U\207" [93] 3 "\n\n(fn CHAR)"] :mid #[257 "\211\300U\207" [58] 3 "\n\n(fn CHAR)"] #[257 "\211\300U\206	�\211\301U\207" [58 93] 3 "\n\n(fn CHAR)"] nil 92 delete-char 1 kill-line looking-at "\\s-+" 0 " " buffer-substring-no-properties] 8 "\n\n(fn END PRESERVE-WHITESPACE)"] make-byte-code 514 "\302u\210\301\242\303=\"\304\305\"\203+�\211\306\230\203'�\300\242\203'�\307\300\242Y\203'�\310\202]�\211\202]�\304\311\"\2036�\211\202]�\304\312\"\203C�\313!\202]�\304\314\"\203N�\211\202]�\304\315\"\203Y�\310\202]�\316\317\"\207" vconcat vector [1 text memql (stone point move) "tt" 19 "" (simpletext color) (number real double) string-to-number (text) (none) error "Unhandled type: %S"] 6 "\n\n(fn TYPE END)" 257 "\2119\203�\300\242\301\"\207\302!\203�\300\242\303H\301\"\207\211@\304=\203@�\300\242A@\305\"g\306U\2031�\211\202?�\307u\210\211\300\242AA@A\301\"B\207\300\242@\310\"\300\242A\301\"B\207" [:end vectorp 0 or t 93 1 :mid] "\n\n(fn SPEC)" #[257 "m\205�\300\301\"\207" [error "Unexpected EOF while reading %s"] 4 "\n\n(fn WHO)"] #[0 "g\300U\207" [91] 2] 0 "\306\211\211\302\242 \210\304\242\307!\210\310\311!\205\220�\312p!\262\301\236A\266\202\262\302\242 \210\300\236A\266\202G\313U\203<�\303\242@!\202\214�@\211\262\314>\204K�\315\316\"\210\317=\205[�\302\242 \205[�\305\242 ??\205\214�A@\306\211\302\242 \203\205�\305\242 \203\205�\303\242!\211\262\203\205�B\262\313u\210\202d�\320u\210\211\237\266\203\313u\210B\207" [nil property looking-at "[A-Z]" read 1 (elist list) error "Bad spec: %S" elist -1] 9 "\300\242 \205�m?\207" #1# 1 "\300\242 \205	�\211gU\207" 3 "\n\n(fn C)" "\300\242!\205�\301u\210\302\207" [1 t] "\302\242\303!\205*�\304\211\301\242 \211\262\203&�@\305=\203�\300A\240\210B\262\202	�\211\237\266\202\207" [59 nil :SZ] 4 "\304\211\301\242\305!\210\300\242\306!\203A�@\262\302\242 \262\307\211\310\236\206$�\311\236\262\203-�\312\202.�\313\314\313#\\#\210\211B\262\202�\300\242\305!\204M�C\202h�\304\300\242\305!\203d�\315\303\242\"!\244\262\202N�\211\237\262\301\242\316!\210\207" [nil 40 59 puthash :B :W 1 0 gethash reverse 41] 12 "\n\n(fn PARENT MNUM)" generate-new-buffer " *temp*" "\301\300!\205	�\302\300!\207" [buffer-name kill-buffer] 2 insert-file-contents :weakness key apply make-hash-table :test eq last] 29 (#$ . 75449)])
#@28 

(fn COLLECTION FILENAME)
(defalias 'gnugo/sgf-write-file #[514 "\301\302\303\"\304C\304C\304C\304C\304C\304C\304C\304C\304C\304C\304C\305\240\210\306\307\310\311\312\f!\313\"\314\315%\240\210\306\307\316\311\312\f!\317\"\320\315%\240\210\306\321\322\311\312#\323\"\324$\240\210\306\307\325\311\312&\326\"\327\330%\240\210\306\307\331\311\312!\332\"\314\333%\240\210\211\306\307\334\311\312\"\335\"\327\336%\240\210\337\340!r\211q\210\306\321\341\311\312!\342\"\324$\216\211\203\353�\211@\304\343\344\345\346$\262\347\211\321H\262\304\"\306\307\350\311\312!\351\"\352\353%\211\211A\262\242!\262\354\"\210\242!\266A\266\202\202\251�\210\355 \210\356!*\262\266\207\207" [gnugo/sgf-*r4-properties* (:AP :GN :PB :PW :HA :KM :RU :RE) mapcar #[257 "\300\301\302@\"!AAAB\207" [intern format ":%s"] 5 "\n\n(fn FULL)"] nil #[514 "\300\301\302\303\304\305!\306\"\307\310%;\203�\202�\311\312\"\313#\207" [mapconcat make-byte-code 257 "\301\302\"\203\f�\303\304\"\207\305\306\"\203�\300\203�\307\202�\310\311P\207\312!\207" vconcat vector [memql (91 93 92) format "\\%c" eql 58 "\\" #1="" ":" string] 4 "\n\n(fn C)" format "%s" #1#] 9 "\n\n(fn COMPOSED VAL)"] make-byte-code 257 "\301\300\242\302\"\303\261\207" vconcat vector ["[" nil "]"] 5 "\n\n(fn V)" "\301\300\242\302@\"\303\300\242\302A\"\304\261\207" ["[" t ":" "]"] 7 0 "\302\242\300>\203\n�\303c\207\304iW\205�\212\301\242b\210\303c)\207" ["\n" 60] 2 "\301`\240\210\302@\240\210\303A\240\210\310\302\242!\311\312Oc\210\303\242?\206\203�\303\242:\203j�\304\302\242\300\236A\266\202\240\203j�\304\242@\313>\203j�\307\242 \210\304\242A@:\203J�\306\242\202L�\305\242\303\242\211\205g�\211@\301`\240\210!\210\307\242 \210A\266\202\202N�\262\207\303\242:\203z�\306\242\303\242!\210\307\242 \207\305\242\303\242!\210\307\242 \207" [symbol-name 1 nil (list elist)] 6 "\n\n(fn PROP)" "\211\301\302c\210:\203�@\262\300\242!\210A\262\202�\301\207" [nil ";"] "\n\n(fn NODE)" "i\302U\204	�\303 \210\304c\210\211\211\203/�\211@\211\305@@!\262\203#�\300\242\202%�\301\242!\210A\266\202\202
�\210\306c\207" [0 newline "(" keywordp ")"] "\n\n(fn TREE)" generate-new-buffer " *temp*" "\301\300!\205	�\302\300!\207" [buffer-name kill-buffer] apply make-hash-table :test eq append "\301\211\301:\203*�@\262\302\300\"\211\262\204*�\303\211B\211\262\300#\210A\262\202�\2042�\202M�\211A\211@\304@@!\262\203F�\211C\202G�\211\262C\244\241\207" [nil gethash puthash keywordp] 10 "\n\n(fn STACK)" mapc newline write-file] 29 (#$ . 79686)])