;ELC   
;;; compiled by jimb@geech.gnu.ai.mit.edu on Mon Jul  5 22:10:28 1993
;;; from file /gd/gnu/emacs/19.0/lisp/allout.el
;;; emacs version 19.15.16.
;;; bytecomp version FSF 2.10
;;; optimization is on.
;;; this file uses opcodes which do not exist in Emacs 18.

(if (and (boundp 'emacs-version)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19")))
    (error "This file was compiled for Emacs 19"))

(provide (quote outline))
(defvar outline-header-prefix "." "\
*   Leading string for greater than level 0 topic headers.")
(make-variable-buffer-local (quote outline-header-prefix))
(defvar outline-header-subtraction (byte-code "GS‡" [outline-header-prefix] 1) "\
*   Leading string for greater than level 0 topic headers.")
(byte-code "ÀÁ!ˆÂÃ!„ ÄÀÃ!‡" [make-variable-buffer-local outline-header-subtraction boundp outline-primary-bullet "*"] 2)
(defvar outline-plain-bullets-string "" "\
*   The bullets normally used in outline topic prefixes.  See
   'outline-distinctive-bullets-string' for the other kind of
   bullets.

   DO NOT include the close-square-bracket, ']', among any bullets.

   You must run 'set-outline-regexp' in order for changes to the
   value of this var to effect outline-mode operation.")
(byte-code "ÁPÃÂ!‡" [outline-primary-bullet "+-:.;," outline-plain-bullets-string make-variable-buffer-local] 2)
(defvar outline-distinctive-bullets-string "" "\
*   The bullets used for distinguishing outline topics.  These
   bullets are not offered among the regular rotation, and are not
   changed when automatically rebulleting, as when shifting the
   level of a topic.  See 'outline-plain-bullets-string' for the
   other kind of bullets.

   DO NOT include the close-square-bracket, ']', among any bullets.

   You must run 'set-outline-regexp' in order for changes
   to the value of this var to effect outline-mode operation.")
(byte-code "ÀÂÁ!‡" ["=>([{}&!?#%\"X@$~" outline-distinctive-bullets-string make-variable-buffer-local] 2)
(defvar outline-numbered-bullet nil "\
*   Bullet signifying outline prefixes which are to be numbered.
   Leave it nil if you don't want any numbering, or set it to a
   string with the bullet you want to be used.")
(byte-code "ÀÂÁ!‡" ["#" outline-numbered-bullet make-variable-buffer-local] 2)
(defvar outline-file-xref-bullet "@" "\
*  Set this var to the bullet you want to use for file cross-references.
   Set it 'nil' if you want to inhibit this capability.")
(defvar outline-stylish-prefixes t "\
*A true value for this var makes the topic-prefix creation and modification
   functions vary the prefix bullet char according to level.  Otherwise, only
   asterisks ('*') and distinctive bullets are used.

   This is how an outline can look with stylish prefixes:

   * Top level
   .* A topic
   . + One level 3 subtopic
   .  . One level 4 subtopic
   . + Another level 3 subtopic
   .  . A level 4 subtopic
   .  #2 A distinguished, numbered level 4 subtopic
   .  ! A distinguished ('!') level 4 subtopic
   .  #4 Another numbered level 4 subtopic
   
   This would be an outline with stylish prefixes inhibited:

   * Top level
   .* A topic
   .! A distinctive (but measly) subtopic
   . * A sub-subtopic - no bullets from outline-plain-bullets-string but '*'

   Stylish and constant prefixes (as well as old-style prefixes) are
   always respected by the topic maneuvering functions, regardless of
   this variable setting.

   The setting of this var is not relevant when outline-old-style-prefixes
   is t.")
(make-variable-buffer-local (quote outline-stylish-prefixes))
(defvar outline-old-style-prefixes nil "\
*Setting this var causes the topic-prefix creation and modification
   functions to make only asterix-padded prefixes, so they look exactly
   like the old style prefixes.

   Both old and new style prefixes are always respected by the topic
   maneuvering functions.")
(make-variable-buffer-local (quote outline-old-style-prefixes))
(defvar outline-enwrap-isearch-mode "isearch-mode.el" "\
*  Set this var to the name of the (non-compiled) elisp code for
   isearch-mode, if you have Dan LaLiberte's 'isearch-mode'
   stuff and want isearches to reveal hidden stuff encountered in the
   course of a search, and reconceal it if you go past.  Set it nil if
   you don't have the package, or don't want to use this feature.")
(defvar outline-use-hanging-indents t "\
*  Set this var non-nil if you have Kyle E Jones' filladapt stuff,
  and you want outline to fill topics as hanging indents to the
  bullets.")
(make-variable-buffer-local (quote outline-use-hanging-indents))
(defvar outline-reindent-bodies t "\
*  Set this var non-nil if you want topic depth adjustments to
  reindent hanging bodies (ie, bodies lines indented to beginning of
  heading text).  The performance hit is small.

  Avoid this strenuously when using outline mode on program code.
  It's great for text, though.")
(make-variable-buffer-local (quote outline-reindent-bodies))
(defvar outline-mode-keys nil "\
Assoc list of outline-mode-keybindings, for common reference in setting 
up major and minor-mode keybindings.")
(byte-code "ÀÂ‡" [(("" outline-next-visible-heading) ("" outline-previous-visible-heading) ("" outline-up-current-level) ("" outline-forward-current-level) ("" outline-backward-current-level) ("" outline-beginning-of-current-entry) ("" outline-end-of-current-entry) ("	" outline-show-current-children) ("" outline-show-current-subtree) ("" outline-hide-current-subtree) ("" outline-show-current-entry) ("!" outline-show-all) (" " open-sibtopic) ("." open-subtopic) ("," open-supertopic) ("'" outline-shift-in) (">" outline-shift-in) ("<" outline-shift-out) ("" outline-rebullet-topic) ("b" outline-rebullet-current-heading) ("#" outline-number-siblings) ("" outline-kill-line) ("" outline-yank) ("ù" outline-yank-pop) ("" outline-kill-topic) ("@" outline-resolve-xref) ("c" outline-copy-exposed)) outline-mode-keys nil] 1)
(defvar outline-regexp "" "\
*   Regular expression to match the beginning of a heading line.
   Any line whose beginning matches this regexp is considered a
   heading.  This var is set according to the user configuration vars
   by set-outline-regexp.")
(make-variable-buffer-local (quote outline-regexp))
(defvar outline-bullets-string "" "\
   A string dictating the valid set of outline topic bullets.  This
   var should *not* be set by the user - it is set by 'set-outline-regexp',
   and is composed from the elements of 'outline-plain-bullets-string'
   and 'outline-distinctive-bullets-string'.")
(make-variable-buffer-local (quote outline-bullets-string))
(defvar outline-line-boundary-regexp nil "\
   outline-regexp with outline-style beginning of line anchor (ie,
   C-j, *or* C-m, for prefixes of hidden topics).  This is properly
   set when outline-regexp is produced by 'set-outline-regexp', so
   that (match-beginning 2) and (match-end 2) delimit the prefix.")
(make-variable-buffer-local (quote outline-line-boundary-regexp))
(defvar outline-bob-regexp nil "\
 Like outline-line-boundary-regexp, this is an outline-regexp for
  outline headers at the beginning of the buffer.  (match-beginning 2)
  and (match-end 2)
   delimit the prefix.")
(make-variable-buffer-local (quote outline-line-bob-regexp))
(defalias 'outline-reset-header-lead #[(header-lead) "‰GSÃ ‡" [header-lead outline-header-prefix outline-header-subtraction set-outline-regexp] 2 "\
*  Reset the leading string used to identify topic headers." "sNew lead string: "])
(defalias 'outline-lead-with-comment-string #[(&optional header-lead) ";„	 ÁÂ!ÃÅ!ˆ‡" [header-lead read-string "String prefix for topic headers: " nil outline-reindent-bodies outline-reset-header-lead] 2 "\
* Set the topic-header leading string to specified string.  Useful
  when for encapsulating outline structure in programming language
  comments.  Returns the leading string." "P"])
(defalias 'set-outline-regexp #[nil "ÀÂÃDÄ‰‰‰‰	‰\nƒh ÀË\n@J‰	GWƒ_ 	H	Í=ƒC Î‚T Ï=ƒN À‚T ÐÑ!!PT‰‚* \nA‰\n„ .\nGGSÕÖ	×Ù°ÛÜQÞÜQ‰‡" ["" outline-bullets-string outline-plain-bullets-string outline-distinctive-bullets-string nil new-string index cur-char-string cur-len cur-string strings 0 cur-char 45 "--" 93 regexp-quote char-to-string outline-plain-bullets-string-len outline-header-prefix outline-header-subtraction "\\(\\" "[ 	]*[" "]\\)\\|\\" outline-primary-bullet "+\\|" outline-regexp "\\([\n]\\)\\(" "\\)" outline-line-boundary-regexp "\\(\\`\\)\\(" outline-bob-regexp] 8 "\
   Generate proper topic-header regexp form for outline functions, from
   outline-plain-bullets-string and outline-distinctive-bullets-string." nil])
(defvar outline-mode-map nil "\
")
(byte-code "„9 Á \n¤ÃÄÅ#ˆÃÆÇ#ˆÃÈÉ#ˆÃÊË#ˆÃÌÍ#ˆÃÎÏ#ˆÃÐÑ#ˆÃÒÓ#ˆÁ‡" [outline-mode-map make-sparse-keymap text-mode-map define-key "" outline-next-visible-heading "" outline-previous-visible-heading "	" show-children "" show-subtree "" hide-subtree "" outline-up-heading "" outline-forward-same-level "" outline-backward-same-level] 4)
(defvar outline-minor-mode nil "\
Non-nil if using Outline mode as a minor mode of some other mode.")
(byte-code "ÀÁ!ˆÂÁÃÄ#ˆÅÇC\"ÈÉ!„ Ê		„/ Ë 	Ì	ÍÎÍ\"#ˆÁž„? Á	BBÊ‡" [make-variable-buffer-local outline-minor-mode put permanent-local t append minor-mode-alist (outline-minor-mode " Outl") boundp outline-minor-mode-map nil make-sparse-keymap define-key "" lookup-key outline-mode-map minor-mode-map-alist] 6)
(defalias 'outline-minor-mode #[(&optional arg) "„	 	?‚ Â!ÃV‰ƒ ÄÆÇ!‡È‰‡" [arg outline-minor-mode prefix-numeric-value 0 t selective-display run-hooks outline-minor-mode-hook nil] 3 "\
Toggle Outline minor mode.
With arg, turn Outline minor mode on if arg is positive, off otherwise.
See the command `outline-mode' for more information on this mode." "P"])
(defalias 'minor-bind-keys #[(keys-assoc) "À † Á Â‰‰‰ƒK @@	@A@Ê	!‰9„/ Â	Ê	!EBË	#ˆA‰„ Ì!ˆ-‡" [current-local-map make-sparse-keymap nil prevailing-func unbinding-registry new-func key local-map keys-assoc curr-key local-key-binding define-key use-local-map] 6 "\
   Establish BINDINGS assoc list in current buffer, returning a list
   for subsequent use by minor-unbind-keys to resume overloaded local
   bindings." nil])
(defalias 'minor-relinquish-keys #[(unbinding-registry) "À‰‰‰‰ƒG @‰@A@AA@Ç!	šƒ: \nƒ3 È\n\"ˆ‚> É!ˆ‚> BA‰„ -‡" [nil curr-relinquish curr-resume curr-key curr-item residue unbinding-registry local-key-binding local-set-key local-unset-key] 6 "\
   Given registry of MODAL-BINDINGS, as produced by minor-bind-keys,
   resume the former local keybindings of those keys that retain the
   local bindings set by minor-bind-keys.  Changed local bindings are
   left alone, so other minor (user or modal) bindings are not disrupted.

   Returns a list of those registrations which were not, because of
   tampering subsequent to the registration by minor-bind-keys, resumed." nil])
(defvar outline-minor-prior-keys nil "\
Former key bindings assoc-list, for resumption from  outline minor-mode.")
(make-variable-buffer-local (quote outline-minor-prior-keys))
(defalias 'outline-minor-bind-keys #[nil "À	!‰‡" [minor-bind-keys outline-mode-keys outline-minor-prior-keys] 2 "\
   Establish outline-mode keybindings as MINOR modality of current buffer."])
(defalias 'outline-minor-relinquish-keys #[nil "À	!‡" [minor-relinquish-keys outline-minor-prior-keys] 2 "\
   Resurrect local keybindings as they were before outline-minor-bind-keys."])
(defvar outline-mode-prior-settings nil "\
For internal use by outline mode, registers settings to be resumed
on mode deactivation.")
(make-variable-buffer-local (quote outline-mode-prior-settings))
(defalias 'outline-resumptions #[(name &optional value) "	žÂƒ# „ Æ!… JCD	B@L‚^ ??…^ A@‰ƒ9 @Lˆ‚= Ç!ˆÂ	ƒY 	@=„R 	@B	A‰„D ‰)*‡" [name outline-mode-prior-settings nil prior-capsule on-list value boundp makunbound rebuild] 4 "\
 Registers information for later reference, or performs resumption of
  outline-mode specific values.  First arg is NAME of variable affected.
  optional second arg is list containing outline-mode-specific VALUE to
  be impose on named variable, and to be registered.  (It's a list so you
  can specify registrations of null values.)  If no value is specified,
  the registered value is returned (encapsulated in the list, so the
  caller can distinguish nil vs no value), and the registration is popped
  from the list."])
(defvar outline-mode nil "\
Allout outline mode minor-mode flag.")
(make-variable-buffer-local (quote outline-mode))
(defalias 'outline-mode #[(&optional toggle) "ÀÁ!… 	… <ƒ @† ‰…+ 9†+ Ä!…+ ÅU?‰„R \n„9 ƒR Ç ˆÈÉ!ˆÈÊ!ˆÈË!ˆÈÌ!ˆÍ‰‚Á \n?…Á Î ˆÈÉÏ\"ˆÈÊÐ\"ˆÁž„q ÒBÓ ˆÔË!ˆÈËÕ×RC\"ˆÔÌ!ˆÈÌÕ×RC\"ˆƒœ Ù ˆƒº ÀÛ!ƒº ÜÝQÞBBBàá!ˆâ‰+‡" [boundp outline-mode active toggle natnump 0 explicit-activation outline-minor-relinquish-keys outline-resumptions selective-display indent-tabs-mode paragraph-start paragraph-separate nil outline-minor-bind-keys (t) (nil) minor-mode-alist (outline-mode " Outline") set-outline-regexp make-local-variable "\\|^\\(" outline-regexp "\\)" outline-enwrap-isearch-mode outline-enwrap-isearch outline-use-hanging-indents filladapt-prefix-table "\\(" "\\) " filladapt-hanging-list filladapt-hanging-list-prefixes run-hooks outline-mode-hook t] 7 "\
  Set minor mode for editing outlines with selective display.

   Look below the description of the bindings for explanation of the
   terminology use in outline-mode commands.

   (Note - this is not a proper minor mode, because it does affect key
   bindings.  It's not too improper, however, because it does resurrect
   any bindings which have not been tampered with since it changed them.)

Exposure Commands		      Movement Commands
C-c C-h	outline-hide-current-subtree  C-c C-n outline-next-visible-heading
C-c C-i	outline-show-current-children C-c C-p outline-previous-visible-heading
C-c C-s	outline-show-current-subtree  C-c C-u outline-up-current-level
C-c C-o	outline-show-current-entry    C-c C-f outline-forward-current-level
C-c !   outline-show-all              C-c C-b outline-backward-current-level
	outline-hide-current-leaves   C-c C-e outline-end-of-current-entry
                                     C-c C-a outline-beginning-of-current-entry


Topic Header Generation Commands
C-c<SP>	open-sibtopic		Create a new sibling after current topic
C-c .	open-subtopic		... an offspring of current topic
C-c ,	open-supertopic		... a sibling of the current topic's parent

Level and Prefix Adjustment Commands
C-c >	outline-shift-in	Shift current topic and all offspring deeper
C-c <	outline-shift-out	... less deep
C-c<CR>	outline-rebullet-topic	Reconcile bullets of topic and its offspring
                                - distinctive bullets are not changed, all
                                  others set suitable according to depth
C-c b	outline-rebullet-current-heading Prompt for alternate bullet for
					 current topic
C-c #	outline-number-siblings	Number bullets of topic and siblings - the
				offspring are not affected.  With repeat
				count, revoke numbering.

Killing and Yanking - all keep siblings numbering reconciled as appropriate
C-k	outline-kill-line	Regular kill line, but respects numbering ,etc
C-c C-k	outline-kill-topic	Kill current topic, including offspring
C-y	outline-yank		Yank, adjusting depth of yanked topic to
				depth of heading if yanking into bare topic
                                heading (ie, prefix sans text)
M-y	outline-yank-pop	Is to outline-yank as yank-pop is to yank

Misc commands
C-c @   outline-resolve-xref    pop-to-buffer named by xref (cf
                                outline-file-xref-bullet)
C-c c	outline-copy-exposed	Copy outline sans all hidden stuff to
				another buffer whose name is derived
				from the current one - \"XXX exposed\"
M-x outlinify-sticky            Activate outline mode for current buffer
                                and establish -*- outline -*- mode specifier
                                as well as file local vars to automatically
                                set exposure.  Try it.

                             Terminology

Topic: A basic cohesive component of an emacs outline, which can
       be closed (made hidden), opened (revealed), generated,
       traversed, and shifted as units, using outline-mode functions.
       A topic is composed of a HEADER, a BODY, and SUBTOPICs (see below).

Exposure: Hidden (~closed~) topics are represented by ellipses ('...')
          at the end of the visible SUPERTOPIC which contains them,
          rather than by their actual text.  Hidden topics are still
          susceptible to editing and regular movement functions, they
          just are not displayed normally, effectively collapsed into
          the ellipses which represent them.  Outline mode provides
          the means to selectively expose topics based on their
          NESTING.

          SUBTOPICS of a topic can be hidden and subsequently revealed
          based on their DEPTH relative to the supertopic from which
          the exposure is being done.

          The BODIES of a topic do not generally become visible except
          during exposure of entire subtrees (see documentation for
          '-current-subtree'), or when the entry is explicitly exposed
          with the 'outline-show-entry' function, or (if you have a
          special version of isearch installed) when encountered by
          incremental searches.

          The CURRENT topic is the more recent visible one before or
          including the text cursor.

Header: The initial portion of an outline topic.  It is composed of a
        topic header PREFIX at the beginning of the line, followed by
        text to the end of the EFFECTIVE LINE.

Body: Any subsequent lines of text following a topic header and preceding
      the next one.  This is also referred to as the entry for a topic.

Prefix: The text which distinguishes topic headers from normal text
        lines.  There are two forms, both of which start at the beginning
        of the topic header (EFFECTIVE) line.  The length of the prefix
        represents the DEPTH of the topic.  The fundamental sort begins
        either with solely an asterisk ('*') or else dot ('.') followed
        by zero or more spaces and then an outline BULLET.  [Note - you
        can now designate your own, arbitrary HEADER-LEAD string, by
        setting the variable 'outline-header-prefix'.]  The second form
        is for backwards compatibility with the original emacs outline
        mode, and consists solely of asterisks.  Both sorts are
        recognized by all outline commands.  The first sort is generated
        by outline topic production commands if the emacs variable
        outline-old-style-prefixes is nil, otherwise the second style is
        used.

Bullet: An outline prefix bullet is one of the characters on either
        of the outline bullet string vars, 'outline-plain-bullets-string'
        and 'outline-distinctive-bullets-string'.  (See their
        documentation for more details.)  The default choice of bullet
        for any prefix depends on the DEPTH of the topic.

Depth and Nesting:
       The length of a topic header prefix, from the initial
       character to the bullet (inclusive), represents the depth of
       the topic.  A topic is considered to contain the subsequent
       topics of greater depth up to the next topic of the same
       depth, and the contained topics are recursively considered to
       be nested within all containing topics.  Contained topics are
       called subtopics.  Immediate subtopics are called 'children'.
       Containing topics are supertopicsimmediate supertopics are
       'parents'.  Contained topics of the same depth are called
       siblings.

Effective line: The regular ascii text in which form outlines are
                saved are manipulated in outline-mode to engage emacs'
                selective-display faculty.  The upshot is that the
                effective end of an outline line can be terminated by
                either a normal Unix newline char, 
, or the special
                outline-mode eol, ^M.  This only matters at the user
                level when you're doing searches which key on the end of
                line character." "P"])
(defvar outline-recent-prefix-beginning 0 "\
   Buffer point of the start of the last topic prefix encountered.")
(make-variable-buffer-local (quote outline-recent-prefix-beginning))
(defvar outline-recent-prefix-end 0 "\
   Buffer point of the end of the last topic prefix encountered.")
(make-variable-buffer-local (quote outline-recent-prefix-end))
(defalias 'outline-flag-region #[(from to flag) "ÀÂÆUƒ Ç‚ ÆÈ%)‡" [nil buffer-read-only subst-char-in-region from to flag 10 13 t] 6 "\
   Hides or shows lines from FROM to TO, according to FLAG.
   Uses emacs selective-display, where text is show if FLAG put at
   beginning of line is `\\n' (newline character), while text is
   hidden if FLAG is `\\^M' (control-M).

   returns nil iff no changes were effected."])
(defalias (quote outline-flag-current-subtree) #[(flag) "ŠÀ ˆÁ`Â ˆ`#)‡" [outline-back-to-current-heading outline-flag-region outline-end-of-current-subtree flag] 4])
(defalias 'outline-hide-current-entry #[nil "À ˆŠÁ`Â ˆ`Ã#)‡" [outline-back-to-current-heading outline-flag-region outline-end-of-current-entry 13] 4 "\
Hide the body directly following this heading." nil])
(defalias 'outline-show-current-entry #[(&optional arg) "ƒ Á ‡ŠÂ`Ã ˆ`Ä#)‡" [arg outline-hide-current-entry outline-flag-region outline-end-of-current-entry 10] 4 "\
Show body directly following this heading, or hide it if repeat count." "P"])
(defalias 'outline-show-entry #[nil "ŠÀ ˆÁo„ `S‚ `Â ˆ`Ã#)‡" [outline-goto-prefix outline-flag-region outline-pre-next-preface 10] 4 "\
   Like outline-show-current-entry, but reveals an entry that is nested
   within hidden topics." nil])
(defalias 'outline-hide-current-entry-completely #[nil "ŠÀ ˆÁo„ `S‚ `Â ˆÃÄ!ƒ `‚ `SÅ#)‡" [outline-goto-prefix outline-flag-region outline-pre-next-preface looking-at "" 13] 4 "\
Like outline-hide-current-entry, but conceal topic completely." nil])
(defalias 'outline-show-current-subtree #[nil "ÀÁ!‡" [outline-flag-current-subtree 10] 2 "\
Show everything after this heading at deeper levels." nil])
(defalias 'outline-hide-current-subtree #[(&optional just-close) "ŠÀˆÁ ˆÀˆ`)ÃÄ!ˆ\nŠ\nbˆÀˆ`)U…- ?…- ÆÇÈ\"…- É )‡" [nil outline-goto-prefix orig-eol outline-flag-current-subtree 13 just-close outline-up-current-level 1 t outline-hide-current-subtree] 3 "\
   Hide everything after this heading at deeper levels, or if it's
  already closed, and optional arg JUST-CLOSE is nil, hide the current
  level." nil])
(defalias 'outline-show-current-branches #[nil "ÀÁ!‡" [outline-show-current-children 1000] 2 "\
Show all subheadings of this heading, but not their bodies." nil])
(defalias 'outline-hide-current-leaves #[nil "À ˆÁ`Â ˆ`\"‡" [outline-back-to-current-heading outline-hide-region-body outline-end-of-current-subtree] 3 "\
Hide all body after this heading at deeper levels." nil])
(defalias 'outline-show-current-children #[(&optional level) "„ ÁŠŒÂyˆÃ ˆÄ \\`Å ˆ`T}ˆebˆm?…K Æ …K Ä Xƒ Š`TÈuˆhÉ>ƒ@ ÈuˆÊ`Ë#ˆ*‚ *‡" [level 1 0 outline-back-to-current-heading outline-recent-depth outline-end-of-current-subtree outline-next-heading end -1 (10 13) outline-flag-region 10] 4 "\
  Show all direct subheadings of this heading.  Optional LEVEL specifies
   how many levels below the current level should be shown." "p"])
(defalias 'outline-show-all #[nil "ÀedÁ#‡" [outline-flag-region 10] 4 "\
Show all of the text in the buffer." nil])
(defalias 'outline-hide-bodies #[nil "Àed\"‡" [outline-hide-region-body] 3 "\
Hide all of buffer except headings." nil])
(defalias 'outline-hide-region-body #[(start end) "ŠŒ	}ˆebˆm?…+ Â`Ã ˆ`Ä#ˆm„	 ÅÆ!ƒ% Ç‚& Èuˆ‚	 *‡" [start end outline-flag-region outline-pre-next-preface 13 looking-at "[\n][\n]" 2 1] 4 "\
Hide all body lines in the region, but not headings."])
(defalias 'outline-expose #[(spec &rest followers) "ŠÀ ˆ`Áƒz 9ƒ& Å=ƒ Æ ˆÇ=ƒz È ˆ‚z §ƒK ÉUƒ8 ÊË!ˆ‚z ÉVƒD Ê ˆ[Ì!ˆ‚z <ƒz Í@!ˆÎÏ Ð\\!ƒz Ñ „z A‰ƒz \n„z Í@!ˆÒ ?‚c +…• Ò …• Í@!ˆA‰„€ Á‡" [outline-goto-prefix nil done start-point spec * outline-show-current-subtree + outline-show-current-branches 0 outline-hide-current-subtree t outline-show-current-children outline-expose outline-descend-to-depth outline-current-depth 1 outline-hidden-p outline-next-sibling followers] 4 "\
Dictate wholesale exposure scheme for current topic, according to SPEC.

SPEC is either a number or a list of specs.  Optional successive args
dictate exposure for subsequent siblings of current topic.

Numbers, the symbols '*' and '+', and the null list dictate different
exposure depths for the corresponding topic.  Numbers indicate the
depth to open, with negative numbers first forcing a close, and then
opening to their absolute value.  Positive numbers jsut reopen, and 0
just closes.  '*' completely opens the topic, including bodies, and
'+' shows all the sub headers, but not the bodies.

If the spec is a list, the first element must be a number which
dictates the exposure depth of the topic as a whole.  Subsequent
elements of the list are nested SPECs, dictating the specific exposure
for the corresponding offspring of the topic, as the SPEC as a whole
does for the parent topic.

Optional FOLLOWER elements dictate exposure for subsequent siblings
of the parent topic." "xExposure spec: "])
(defalias 'outline-exposure '(macro . #[(&rest spec) "ÀÁÂ\"B‡" [outline-expose mapcar #[(x) "À	D‡" [quote x] 2] spec] 4 "\
  Literal frontend for 'outline-expose', passes arguments unevaluated,
  so you needn't quote them."]))
(defalias 'outline-recent-depth #[nil "À	\nZZ]‡" [1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction] 3 "\
   Return depth of last heading encountered by an outline maneuvering
   function.

   All outline functions which directly do string matches to assess
   headings set the variables outline-recent-prefix-beginning and
   outline-recent-prefix-end if successful.  This function uses those settings
   to return the current depth."])
(defalias 'outline-recent-prefix #[nil "	{‡" [outline-recent-prefix-beginning outline-recent-prefix-end] 2 "\
   Like outline-recent-depth, but returns text of last encountered prefix.

   All outline functions which directly do string matches to assess
   headings set the variables outline-recent-prefix-beginning and
   outline-recent-prefix-end if successful.  This function uses those settings
   to return the current depth."])
(defalias 'outline-recent-bullet #[nil "S{‡" [outline-recent-prefix-end] 2 "\
   Like outline-recent-prefix, but returns bullet of last encountered
   prefix.

   All outline functions which directly do string matches to assess
   headings set the variables outline-recent-prefix-beginning and
   outline-recent-prefix-end if successful.  This function uses those settings
   to return the current depth of the most recently matched topic."])
(defalias 'outline-on-current-heading-p #[nil "ŠÀyˆÁ\n!… À•À”‰)‡" [0 looking-at outline-regexp outline-recent-prefix-end outline-recent-prefix-beginning] 2 "\
   Return prefix beginning point if point is on same line as current
   visible topic's header line."])
(defalias 'outline-hidden-p #[nil "ŠÀÁeÂ#… ÃÄ!)‡" [re-search-backward "[\n]" t looking-at ""] 4 "\
True if point is in hidden text." nil])
(defalias 'outline-current-depth #[nil "ŠÀ ƒ Á\nZZ]‚ Å)‡" [outline-back-to-current-heading 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0] 3 "\
   Return the depth to which the current containing visible topic is
   nested in the outline."])
(defalias 'outline-depth #[nil "ŠÀ ƒ Á ‚ ``Ä)‡" [outline-goto-prefix outline-recent-depth outline-recent-prefix-end outline-recent-prefix-beginning 0] 1 "\
   Like outline-current-depth, but respects hidden as well as visible
   topics."])
(defalias 'outline-get-current-prefix #[nil "ŠÀ … Á )‡" [outline-goto-prefix outline-recent-prefix] 1 "\
   Topic prefix of the current topic."])
(defalias 'outline-get-bullet #[nil "ŠÀ … Á )‡" [outline-goto-prefix outline-recent-bullet] 1 "\
   Return bullet of containing topic (visible or not)."])
(defalias 'outline-current-bullet #[nil "ÀÁÂ‡" [err (byte-code "ŠÀ ˆ	ÂZ	{)‡" [outline-back-to-current-heading outline-recent-prefix-end 1] 2) ((args-out-of-range))] 3 "\
  Return bullet of current (visible) topic heading, or none if none found."])
(defalias 'outline-get-prefix-bullet #[(prefix) "À	\n\"… \nÃ•SÃ•O‡" [string-match outline-regexp prefix 0] 3 "\
   Return the bullet of the header prefix string PREFIX."])
(defalias 'outline-goto-prefix #[nil "ŠÀyˆo)„ hÁ>ƒ Â!ƒ À•À”b‰‡ÆÈÉ#ƒ0 Ê•Ê”b‰‡Â!…> À•À”b‰‡" [0 (10 13) looking-at outline-regexp outline-recent-prefix-end outline-recent-prefix-beginning re-search-backward outline-line-boundary-regexp nil 1 2] 4 "\
  Put point at beginning of outline prefix for current topic, visible
   or not.

   Returns a list of char address of the beginning of the prefix and the
   end of it, or nil if none."])
(defalias 'outline-end-of-prefix #[nil "À ??…. Á Â•bˆÃÄ!ƒ Åuˆ‚ l„' ÃÆ!ƒ' ÅuˆÇ	!ˆ)È ‡" [outline-goto-prefix match-data 0 looking-at "[0-9]" 1 "\\s-" store-match-data outline-current-depth] 2 "\
   Position cursor at beginning of header text."])
(defalias 'outline-back-to-current-heading #[nil "ÀyˆÁ † ÂÃÅQÆÇ#… È•	È”‰\ntƒ# Ë ˆ‡" [0 outline-on-current-heading-p re-search-backward "^\\(" outline-regexp "\\)" nil move 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-end-of-prefix] 4 "\
   Move to heading line of current visible topic, or beginning of heading
   if already on visible heading line."])
(defalias 'outline-pre-next-preface #[nil "À	ÂÃ#… Ä”bˆÅ•Å”‰‡" [re-search-forward outline-line-boundary-regexp nil move 0 2 outline-recent-prefix-end outline-recent-prefix-beginning] 4 "\
Skip forward to just before the next heading line.

   Returns that character position."])
(defalias 'outline-end-of-current-subtree #[nil "À ˆ`Á Ä ˆm„ Á \nVƒ Ä ˆ‚ m„# ÅuˆhÆ>…+ Åu*‡" [outline-back-to-current-heading outline-recent-depth level opoint outline-next-heading -1 (10 13)] 2 "\
  Put point at the end of the last leaf in the currently visible topic." nil])
(defalias 'outline-beginning-of-current-entry #[nil "À ‡" [outline-end-of-prefix] 1 "\
   Position the point at the beginning of the body of the current topic." nil])
(defalias 'outline-end-of-current-entry #[nil "À ˆÁ o„ ÂÃ!ƒ Äuˆ‡" [outline-show-entry outline-pre-next-preface looking-at "^$" -1] 3 "\
   Position the point at the end of the current topic's entry." nil])
(defalias 'outline-ascend-to-depth #[(depth) "ÁVƒ; Â Xƒ; `Â Wƒ& `‰ƒ& Ä ƒ& Å „ Æ Uƒ5 bˆ‚9 bˆÈ)‡t…A É ‡" [depth 0 outline-depth last-good outline-beginning-of-level outline-previous-heading outline-recent-depth outline-recent-prefix-beginning nil outline-end-of-prefix] 2 "\
   Ascend to depth DEPTH, returning depth if successful, nil if not."])
(defalias 'outline-descend-to-depth #[(depth) "`À À ÃVƒ Å U„ Æ ƒ 	Å W„ À ÃVƒ1 Å Uƒ1 ‚5 \nbˆÇ*‡" [outline-depth start-depth start-point 0 depth outline-recent-depth outline-next-heading nil] 2 "\
   Descend to depth DEPTH within current topic, returning depth if
   successful, nil if not."])
(defalias 'outline-up-current-level #[(arg &optional dont-complain) "À ˆÁ Á ÃVƒ. ÅVƒ. o„. Á \nW„$ ÆÃ!„ Ç ÃZ‚ )ÅXƒ: ‚J tƒA É ˆ\n?…J ËÌ!tƒQ É ˆ‡" [outline-back-to-current-heading outline-recent-depth present-level 1 arg 0 outline-previous-visible-heading outline-current-depth outline-recent-prefix-beginning outline-end-of-prefix dont-complain error "Can't ascend past outermost level."] 2 "\
   Move to the heading line of which the present line is a subheading.
   With argument, move up ARG levels.  Don't return an error if
   second, optional argument DONT-COMPLAIN, is non-nil." "p"])
(defalias 'outline-next-visible-heading #[(arg) "ÁWƒ Áyˆ‚ ÂˆÃÄÆQÂÇ$…' È ˆÉ•\nÉ”‰‡" [arg 0 nil re-search-forward "^\\(" outline-regexp "\\)" go outline-end-of-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning] 5 "\
   Move to the next visible heading line.

   With argument, repeats, backward if negative." "p"])
(defalias 'outline-previous-visible-heading #[(arg) "À	[!‡" [outline-next-visible-heading arg] 2 "\
   Move to the previous heading line.

   With argument, repeats or can move forward if negative.
   A heading line is one that starts with a `*' (or that outline-regexp
   matches)." "p"])
(defalias 'outline-next-heading #[(&optional backward) "… o?…M ƒ Á ˆ‚ oƒ m„ Âuˆƒ1 ÃÅÆ#„9 Ç!‚6 ÉÅÆ#…M Ê•†@ Ê”†I ‰b‡" [backward outline-goto-prefix 1 re-search-backward outline-line-boundary-regexp nil 0 looking-at outline-bob-regexp re-search-forward 2 outline-recent-prefix-end outline-recent-prefix-beginning] 4 "\
   Move to the heading for the topic (possibly invisible) before this one.

   Optional arg BACKWARD means search for most recent prior heading.

   Returns the location of the heading, or nil if none found."])
(defalias 'outline-previous-heading #[nil "ÀÁ!‡" [outline-next-heading t] 2 "\
   Move to the next (possibly invisible) heading line.

   Optional repeat-count arg means go that number of headings.

   Return the location of the beginning of the heading, or nil if not found."])
(defalias 'outline-next-sibling #[(&optional backward) "… o?…M Á `Âƒ o‚ m„1 ƒ% Æ ‚' Ç ƒ1 È V„ m„H Á ÉVƒH È UƒH \n‚L bˆÂ+‡" [backward outline-depth nil last-good start-point start-depth outline-previous-heading outline-next-heading outline-recent-depth 0 outline-recent-prefix-beginning] 3 "\
   Like outline-forward-current-level, but respects invisible topics.

   Go backward if optional arg BACKWARD is non-nil.

   Return depth if successful, nil otherwise."])
(defalias 'outline-previous-sibling #[(&optional arg) "ÀÁ!‡" [outline-next-sibling t] 2 "\
   Like outline-forward-current-level, but goes backwards and respects
   invisible topics.

   Optional repeat count means go number backward.

   Note that the beginning of a level is (currently) defined by this
   implementation to be the first of previous successor topics of
   equal or greater depth.

   Return depth if successful, nil otherwise."])
(defalias 'outline-beginning-of-level #[nil "ÀÁ!‡" [outline-end-of-level backward] 2 "\
   Go back to the first sibling at this level, visible or not."])
(defalias 'outline-end-of-level #[(&optional backward) "À „  Á tƒ Â ˆ‡" [outline-previous-sibling outline-recent-depth outline-end-of-prefix] 2 "\
   Go to the last sibling at this level, visible or not."])
(defalias 'outline-forward-current-level #[(arg &optional backward) "À ˆ	ƒ 	ÂWƒ ?Ä	!‚ 	‚ Å‰ÂVƒ2 Ç!ƒ2 S‰‚ tƒ9 È ˆÂVƒQ ÉÊƒJ Ë‚K ÌÍ #‚R Î)‡" [outline-back-to-current-heading arg 0 backward abs 1 amt outline-next-sibling outline-end-of-prefix error "This is the %s topic on level %d." "first" "last" outline-current-depth t] 5 "\
   Position the point at the next heading of the same level, taking
   optional repeat-count.

   Returns that position, else nil if is not found." "p"])
(defalias 'outline-backward-current-level #[(arg) "ÀŽÁ\nÃ\")‡" [((outline-end-of-prefix)) outline-forward-current-level arg t] 3 "\
   Position the point at the previous heading of the same level, taking
   optional repeat-count.

   Returns that position, else nil if is not found." "p"])
(defvar outline-search-reconceal nil "\
Used for outline isearch provisions, to track whether current search
match was concealed outside of search.  The value is the location of the
match, if it was concealed, regular if the entire topic was concealed, in
a list if the entry was concealed.")
(defconst outline-search-quitting nil "\
Variable used by isearch-terminate/outline-provisions and
isearch-done/outline-provisions to distinguish between a conclusion
and cancellation of a search.")
(defalias 'outline-enwrap-isearch #[nil "?† ÁÂ!?…R ÁÃ!ƒ ÁÄ!„ ÅÆÇ…R ÂÁÈ!ƒ+ ÈK†3 ÁÉ!…3 ÉKMˆÈÊMˆÉÊMˆËÌKMˆÌÍMˆÎÏKMˆÏÐMˆÑÒ!‡" [outline-enwrap-isearch-mode fboundp real-isearch-terminate isearch-mode isearch-quote-char error (load-library outline-enwrap-isearch-mode) ((file-error (byte-code "ÀÁ\nA@\nAA@#ˆÃÄ!ˆÅ‰‡" [message "Skipping isearch-mode provisions - %s '%s'" error sit-for 1 nil outline-enwrap-isearch-mode] 4))) isearch-quit isearch-abort isearch-terminate/outline-provisions real-isearch-done isearch-done isearch-done/outline-provisions real-isearch-update isearch-update isearch-update/outline-provisions make-variable-buffer-local outline-search-reconceal] 3 "\
   Impose isearch-mode wrappers so isearch progressively exposes and
   reconceals hidden topics when working in outline mode, but works
   elsewhere.

   The function checks to ensure that the rebindings are done only once."])
(defalias 'outline-isearch-arrival-business #[nil "ÀÁ!…- 	…- Â …* ŠÃÅÆ#ƒ ÆuˆÂ ƒ$ `‚& `CÇ ˆ)‰‡" [boundp outline-mode outline-hidden-p re-search-backward outline-line-boundary-regexp nil 1 outline-show-entry outline-search-reconceal] 4 "\
   Do outline business like exposing current point, if necessary,
   registering reconcealment requirements in outline-search-reconceal
   accordingly.

   Set outline-search-reconceal to nil if current point is not
   concealed, to value of point if entire topic is concealed, and a
   list containing point if only the topic body is concealed.

   This will be used to determine whether outline-hide-current-entry
   or outline-hide-current-entry-completely will be necessary to
   restore the prior concealment state."])
(defalias 'outline-isearch-advancing-business #[nil "ÀÁ!…# 	…# \n…# Š\n<ƒ \n@bˆÃ ‚\" \nbˆÄ )‡" [boundp outline-mode outline-search-reconceal outline-hide-current-entry outline-hide-current-entry-completely] 2 "\
   Do outline business like deexposing current point, if necessary,
   according to reconceal state registration."])
(byte-code "ÀÁÂ\"ˆÀÃÄ\"‡" [defalias isearch-terminate/outline-provisions #[nil "ÀÁ!ƒ 	ƒ \nƒ Ã ˆÄÅÈ *‡" [boundp outline-mode outline-enwrap-isearch-mode outline-isearch-advancing-business t nil outline-search-reconceal outline-search-quitting real-isearch-terminate] 2 nil nil] isearch-done/outline-provisions #[(&optional nopush) "ÀÁ!ƒI 	ƒI \nƒI Šƒ7 <„7 ÄÅ!ˆÆÇ!ˆÈÉ S!ˆÊ ƒ1 Ë ˆ‚& Ë ˆÌ ˆÍ ˆ)ÀÎ!ƒF „I Ë ˆƒS Ð!‡Ð ‡" [boundp outline-mode outline-enwrap-isearch-mode outline-search-reconceal message "(exposing destination)" sit-for 0 outline-ascend-to-depth outline-current-depth outline-hidden-p outline-show-current-children outline-show-current-entry outline-isearch-arrival-business outline-search-quitting nopush real-isearch-done] 2 nil nil]] 3)
(defalias 'isearch-update/outline-provisions #[nil "ÀÁ!ƒ 	ƒ \n„ Ã ‡Ä ˆÃ ˆƒ Æ ‡?…% Ä ‡" [boundp outline-mode outline-enwrap-isearch-mode real-isearch-update outline-isearch-advancing-business isearch-success outline-isearch-arrival-business] 2 "\
    Wrapper around isearch which exposes and conceals hidden outline
   portions encountered in the course of searching."])
(defalias 'outline-solicit-alternate-bullet #[(depth &optional current-bullet) "† Á\n!ÄÅÆ#ÈÉ\"Ê#‰Ì˜ƒ\" ‚$ *‡" [current-bullet outline-bullet-for-depth depth default-bullet solicit-char-in-string format "Select bullet: %s ('%s' default): " outline-bullets-string string-sans-char 92 t choice ""] 6 "\
   Prompt for and return a bullet char as an alternative to the
   current one, but offer one suitable for current depth DEPTH
   as default."])
(defalias 'outline-sibling-index #[(&optional depth) "Šƒ ÁXƒ Á‚= ƒ Â Uƒ, ÃÅ ƒ' T‚ )‚= Æ Wƒ< Ç!ˆÈ ‚= Á)‡" [depth 0 outline-depth 1 index outline-previous-sibling outline-recent-depth outline-ascend-to-depth outline-sibling-index] 2 "\
   Item number of this prospective topic among it's siblings.

   If optional arg depth is greater than current depth, then we're
   opening a new level, and return 0.

   If less than this depth, ascend to that depth and count..."])
(defalias 'outline-distinctive-bullet #[(bullet) "ÀÁ\n!\"‡" [string-match regexp-quote bullet outline-distinctive-bullets-string] 3 "\
   True if bullet is one of those on outline-distinctive-bullets-string."])
(defalias 'outline-numbered-type-prefix #[(&optional prefix) "… 	ƒ Â	!‚ Ã ˜‡" [outline-numbered-bullet prefix outline-get-prefix-bullet outline-get-bullet] 3 "\
   True if current header prefix bullet is numbered bullet."])
(defalias 'outline-bullet-for-depth #[(&optional depth) "ƒ Á\nÃÅZ]¦H!‡‡" [outline-stylish-prefixes char-to-string outline-plain-bullets-string 0 depth 2 outline-plain-bullets-string-len outline-primary-bullet] 5 "\
   Return outline topic bullet suited to DEPTH, or for current depth if none
   specified."])
(defalias 'outline-make-topic-prefix #[(&optional prior-bullet new depth solicit number-control index) "ÀÀÀ† Å ÈXƒ É\n‚õ ƒ3 ÌÍ\n!\"ÉÉ‚õ ÌÎZÏ\"ƒa Ñ!…Z …Q ??…Z ˜)‚õ ƒ“ ƒ“ ?‰?‰ƒ{ ‚õ ƒ ˜„ ‚õ ×!‚õ ƒÍ Å XƒÍ ƒÍ „Í ŠÅ Y„´ Ù!ˆÚ )‰…É ˜…É ‰)†õ ƒò Ý!ƒò ƒí ˜ƒí ?‰ƒò †õ ×!	\n…!ßàƒ§ƒ‚ ƒá!T‚ á \"R.‡" [nil body numbering denumbering depth outline-depth outline-header-prefix header-lead 1 "" outline-primary-bullet outline-old-style-prefixes make-string string-to-char 2 32 solicit outline-solicit-alternate-bullet got outline-numbered-bullet number-control index current-bullet outline-bullet-for-depth new outline-ascend-to-depth outline-get-bullet sibling-bullet prior-bullet outline-distinctive-bullet bullet-char format "%d" outline-sibling-index] 8 "\
   Generate a topic prefix suitable for optional arg DEPTH, or current
   depth if not specified.

   All the arguments are optional.

   PRIOR-BULLET indicates the bullet of the prefix being changed, or
   nil if none.  This bullet may be preserved (other options
   notwithstanding) if it is on the outline-distinctive-bullets-string,
   for instance.

   Second arg NEW indicates that a new topic is being opened after the
   topic at point, if non-nil.  Default bullet for new topics, eg, may
   be set (contingent to other args) to numbered bullets if previous
   sibling is one.  The implication otherwise is that the current topic
   is being adjusted - shifted or rebulleted - and we don't consider
   bullet or previous sibling.

   Third arg DEPTH forces the topic prefix to that depth, regardless of
   the current topics' depth.

   Fourth arg SOLICIT non-nil provokes solicitation from the user of a
   choice among the valid bullets.  (This overrides other all the
   options, including, eg, a distinctive PRIOR-BULLET.)

   Fifth arg, NUMBER-CONTROL, matters only if 'outline-numbered-bullet'
   is non-nil *and* soliciting was not explicitly invoked.  Then
   NUMBER-CONTROL non-nil forces prefix to either numbered or
   denumbered format, depending on the value of the sixth arg, INDEX.

   (Note that NUMBER-CONTROL does *not* apply to level 1 topics.  Sorry...)

   If NUMBER-CONTROL is non-nil and sixth arg INDEX is non-nil then
   the prefix of the topic is forced to be numbered.  Non-nil
   NUMBER-CONTROL and nil INDEX forces non-numbered format on the
   bullet.  Non-nil NUMBER-CONTROL and non-nil, non-number INDEX means
   that the index for the numbered prefix will be derived, by counting
   siblings back to start of level.  If INDEX is a number, then that
   number is used as the index for the numbered prefix (allowing, eg,
   sequential renumbering to not require this function counting back the
   index for each successive sibling)."])
(defalias 'open-topic #[(relative-depth &optional before) "À 	\\ÃÄ!… Å‰?ÅÅ	Š	ÊWƒ& Ë\n!ˆ‚/ 	ÌY„/ Í ˆÎ 	Š…L 	ÊX„E Ð\n!…L Ñ …L )`)ÅÅ„bˆ	ÊV„s ŠÕyˆÃÖ!)†Š 	ÌU…Š †Š \nÌU†Š Š× )?ƒ£ Í ˆoØ „£ o„£ Ù ˆ\n	XƒÍ 	À UƒÍ ƒÇ ÚƒÁ Û‚Â Ì!ˆ‚ý Ü ˆ‚ý Åˆ× ˆnƒÝ ÝÞÅß#ˆŠà ˆÎ 	V…ï ÕyˆÃÖ!)ƒú ÌyˆÚÌ!ˆÅˆo„áƒÛ‚Ì!ˆâãß\n#äP!ˆåÅ\nÅ‰ß%ˆÅ.‡" [outline-current-depth relative-depth depth looking-at "^$" nil before opening-on-blank opening-numbered ref-depth 0 outline-ascend-to-depth 1 outline-back-to-current-heading outline-recent-depth outline-numbered-bullet outline-descend-to-depth outline-numbered-type-prefix ref-topic dbl-space doing-beginning -1 "^\\s-*$" outline-pre-next-preface outline-previous-sibling outline-previous-heading open-line 2 outline-end-of-current-subtree re-search-backward "[^ 	\n]" t outline-next-heading newline insert-string outline-make-topic-prefix " " outline-rebullet-heading] 6 "\
 Open a new topic at depth DEPTH.  New topic is situated after current
  one, unless optional flag BEFORE is non-nil, or unless current line
  is complete empty (not even whitespace), in which case open is done
  on current line.

  Nuances:

   - Creation of new topics is with respect to the visible topic
     containing the cursor, regardless of intervening concealed ones.

   - New headers are generally created after/before the body of a
     topic.  However, they are created right at cursor location if the
     cursor is on a blank line, even if that breaks the current topic
     body.  This is intentional, to provide a simple means for
     deliberately dividing topic bodies.

   - Double spacing of topic lists is preserved.  Also, the first
     level two topic is created double-spaced (and so would be
     subsequent siblings, if that's left intact).  Otherwise,
     single-spacing is used.

   - Creation of sibling or nested topics is with respect to the topic
     you're starting from, even when creating backwards.  This way you
     can easily create a sibling in front of the current topic without
     having to go to its preceding sibling, and then open forward
     from there."])
(defalias 'open-subtopic #[(arg) "ÀÁÂV\"‡" [open-topic 1 0 arg] 4 "\
   Open new topic header at deeper level than the current one.

  Negative universal arg means to open deeper, but place the new topic
  prior to the current one." "p"])
(defalias 'open-sibtopic #[(arg) "ÀÁ‰\nV\"‡" [open-topic 0 arg] 4 "\
   Open new topic header at same level as the current one.  Negative
  universal arg means to place the new topic prior to the current
  one." "p"])
(defalias 'open-supertopic #[(arg) "ÀÁÂV\"‡" [open-topic -1 0 arg] 4 "\
   Open new topic header at shallower level than the current one.
  Negative universal arg means to open shallower, but place the new
  topic prior to the current one." "p"])
(defalias 'outline-reindent-body #[(old-depth new-depth) "ŠŒÀ ˆÁuˆÂTÄ\"ÂTÄ\"ÇPÉÊËÌ#…6 Í!?…6 Í!ƒ Ï!ˆ‚ ,‡" [outline-goto-prefix 1 make-string old-depth 32 old-spaces-expr new-depth "\\1" new-spaces-expr re-search-forward "[\n]" nil t looking-at outline-regexp replace-match] 4 "\
  Reindent body lines which were indented at old-depth to new-depth.

  Note that refill of indented paragraphs is not done, and tabs are
  not accommodated.  ('untabify' your outline if you want to preserve
  hanging body indents.)"])
(defalias 'outline-rebullet-current-heading #[(arg) "ŠÀ ˆÁ ˆÂ?Ä‰‰Å%)‡" [outline-back-to-current-heading outline-end-of-prefix outline-rebullet-heading arg nil t] 6 "\
   Like non-interactive version 'outline-rebullet-heading', but work on
   (only) visible heading containing point.

   With repeat count, solicit for bullet." "P"])
(defvar current-bullet nil "\
Variable local to outline-rebullet-heading,but referenced by
outline-make-topic-prefix, also.  Should be resolved with explicitly
parameterized communication between the two, if suitable.")
(defalias 'outline-rebullet-heading #[(&optional solicit new-depth number-control index do-successors) "À \n† 	‰ÇZ{ÉÊ\n&	\nUƒ8 ‰GSÊO˜„^ |ˆbˆƒY ˜ƒY ÐÑ!ƒY Ò”Ò•|ˆÓ!ˆƒn \n	U„n Õ	\n\"ˆ…¢ Š× …¡ §ƒ… T‚ ?… Ø Ù ƒt ÚÊ\nÊ%ˆ‚t ).‡" [outline-depth current-depth new-depth outline-recent-prefix-beginning mb outline-recent-prefix-end me 1 current-bullet outline-make-topic-prefix nil solicit number-control index new-prefix outline-numbered-bullet looking-at "[0-9]+" 0 insert-string outline-reindent-bodies outline-reindent-body do-successors outline-next-sibling outline-sibling-index outline-numbered-type-prefix outline-rebullet-heading] 8 "\
   Adjust bullet of current topic prefix.

   All args are optional.

   If SOLICIT is non-nil then the choice of bullet is solicited from
   user.  Otherwise the distinctiveness of the bullet or the topic
   depth determines it.

   Second arg DEPTH forces the topic prefix to that depth, regardless
   of the topic's current depth.

   Third arg NUMBER-CONTROL can force the prefix to or away from
   numbered form.  It has effect only if 'outline-numbered-bullet' is
   non-nil and soliciting was not explicitly invoked (via first arg).
   Its effect, numbering or denumbering, then depends on the setting
   of the forth arg, INDEX.

   If NUMBER-CONTROL is non-nil and forth arg INDEX is nil, then the
   prefix of the topic is forced to be non-numbered.  Null index and
   non-nil NUMBER-CONTROL forces denumbering.  Non-nil INDEX (and
   non-nil NUMBER-CONTROL) forces a numbered-prefix form.  If non-nil
   INDEX is a number, then that number is used for the numbered
   prefix.  Non-nil and non-number means that the index for the
   numbered prefix will be derived by outline-make-topic-prefix.

   Fifth arg DO-SUCCESSORS t means re-resolve count on succeeding
   siblings.

   Cf vars 'outline-stylish-prefixes', 'outline-old-style-prefixes',
   and 'outline-numbered-bullet', which all affect the behavior of
   this function."])
(defalias 'outline-rebullet-topic #[(arg) "ilŠ\n„ Ã‚ \n<ƒ \n@\nÃU„  ÄÅ!ˆÆ ˆÇ \n\\ÃXƒ0 ÈÉ!ˆÊ\n!ˆ\nÃU„> ÄË!ˆ)ÌÃ	\n\\]!*‡" [was-eol start-col arg 0 message "Shifting..." outline-back-to-current-heading outline-recent-depth error "Attempt to shift topic below level 1" outline-rebullet-topic-grunt "Shifting... done." move-to-column] 4 "\
   Like outline-rebullet-topic-grunt, but start from topic visible at point.
   Descends into invisible as well as visible topics, however.

   With repeat count, shift topic depth by that amount." "P"])
(defalias 'outline-rebullet-topic-grunt #[(&optional relative-depth starting-depth starting-point index do-successors) "† ÁÂ † ?†& ÁU„$ ?…& È ÁW	†2 `ƒI 	ƒI Á\\VƒI ÊË!ˆUƒ| ÌÍ\\ÍÍ%ˆÁÎ ˆm„Š Ï WƒŠ TÐT$ˆ‚` WƒŠ Ð$ˆ…Ã „ª ÁU„² Ï U„ª Ï \\Uƒ² ÌÍ‰‰‰Ò%ˆbˆÁU?…Ã ÌÍ‰‰‰Ò%.‡" [relative-depth 0 outline-depth new-depth starting-depth starting-point on-starting-call index outline-sibling-index moving-outwards error "Attempt to shift topic out beyond level 1." outline-rebullet-heading nil outline-next-heading outline-recent-depth outline-rebullet-topic-grunt do-successors t] 6 "\
   Rebullet the topic at point, visible or invisible, and all
   contained subtopics.  See outline-rebullet-heading for rebulleting
   behavior.

   All arguments are optional.

   First arg RELATIVE-DEPTH means to shift the depth of the entire
   topic that amount.

   The rest of the args are for internal recursive use by the function
   itself.  The are STARTING-DEPTH, STARTING-POINT, and INDEX."])
(defalias 'outline-number-siblings #[(&optional denumber) "ŠÀ ˆÁ ˆ\n?… Ã\nÄšÅ…9 ÉÊÅÊ%ˆƒ0 TË ‰„ Ê,‡" [outline-back-to-current-heading outline-beginning-of-level denumber 1 (16) t more use-bullet index outline-rebullet-heading nil outline-next-sibling] 7 "\
   Assign numbered topic prefix to this topic and its siblings.

   With universal argument, denumber - assign default bullet to this
   topic and its siblings.

   With repeated universal argument (`^U^U'), solicit bullet for each
   rebulleting each topic at this level." "P"])
(defalias 'outline-shift-in #[(arg) "À	!‡" [outline-rebullet-topic arg] 2 "\
   Decrease prefix depth of current heading and any topics collapsed
   within it." "p"])
(defalias 'outline-shift-out #[(arg) "À	[!‡" [outline-rebullet-topic arg] 2 "\
   Decrease prefix depth of current heading and any topics collapsed
   within it." "p"])
(defalias 'outline-kill-line #[(&optional arg) "ÀÁ!ƒ 	ƒ \nƒ nƒ Ã!„ Å!‡Ç ‰	Å!ˆÊË!ˆŠÃ!„7 Ì ˆÇ VƒC Í Ç ËVƒ] Í 	Vƒ] Î	S‰	!„C \n…p Ï!…p ÐÑÑ‰Ò%+‡" [boundp outline-mode outline-numbered-bullet looking-at outline-regexp kill-line arg outline-depth depth ascender sit-for 0 outline-next-heading outline-recent-depth outline-ascend-to-depth outline-descend-to-depth outline-rebullet-heading nil t] 7 "\
   Kill line, adjusting subsequent lines suitably for outline mode." "*P"])
(defalias 'outline-kill-topic #[nil "À Â Ä ˆm„ ÅuˆÆ	`\"ˆÇÈ!ˆŠ	…, Ê!…, ËÌÌ‰Í%+‡" [outline-back-to-current-heading beg outline-recent-depth depth outline-end-of-current-subtree 1 kill-region sit-for 0 outline-numbered-bullet outline-descend-to-depth outline-rebullet-heading nil t] 6 "\
   Kill topic together with subtopics." nil])
(defalias 'outline-yank #[(&optional arg) "ÀÂÃ!ƒ „ À!‡`Å‰lƒ0 ŠÉyˆÊ!)ƒ0 É•É”ZÀ!ˆÌ ˆƒõ ÊÍÎQ!ƒõ Ï”Ï•‰S{ZZÅÖÖŠŒØ }ˆdbˆÊÙ!ƒ ÚÛ!ˆebˆdbˆƒ¶ Ü ˆÝÞ S!„ ŠßÞ `#ˆ)o?‰ƒ‡ ~ˆÛuˆ`}ˆ‚‡ *à!\"ƒÍ ŠÉyˆ`)|ˆ‚ì ‰\\|ˆÊâ!ƒâ ÚÏ!ˆ‚Õ Êã!ƒì ÚÏ!ˆbˆ.‚þ Ê!Ì ˆ…$…åÉ!ˆŠbˆæ …çÅÞ Å‰Ö%)+‡" [yank this-command boundp outline-mode arg nil established-depth topic-yanked beginning 0 looking-at outline-regexp exchange-dot-and-mark "\\(" "\\)" 1 yanked-beg yanked-end yanked-bullet yanked-depth depth-diff done t more mark "^$" delete-char -1 outline-back-to-current-heading outline-ascend-to-depth outline-depth outline-rebullet-topic-grunt string-match outline-distinctive-bullets-string "[0-9]" " " outline-numbered-bullet sit-for outline-goto-prefix outline-rebullet-heading] 7 "\
   Like regular yank, except does depth adjustment of yanked topics, when:

   1 the stuff being yanked starts with a valid outline header prefix, and
   2 it is being yanked at the end of a line which consists of only a valid
     topic prefix.

   If these two conditions hold then the depth of the yanked topics
   are all adjusted the amount it takes to make the first one at the
   depth of the header into which it's being yanked.

   The point is left in from of yanked, adjusted topics, rather than
   at the end (and vice-versa with the mark).  Non-adjusted yanks,
   however, (ones that don't qualify for adjustment) are handled
   exactly like normal yanks.

   Outline-yank-pop is used with outline-yank just as normal yank-pop
   is used with normal yank in non-outline buffers." "*P"])
(defalias 'outline-yank-pop #[(&optional arg) "Á=„\n ÂÃ!ˆÁ`Å |ˆÆ!ˆÈ ‡" [last-command yank error "Previous command was not a yank" this-command mark rotate-yank-pointer arg outline-yank] 2 "\
   Just like yank-pop, but works like outline-yank when popping
  topics just after fresh outline prefixes.  Adapts level of popped
  stuff to level of fresh prefix." "*p"])
(defalias 'outline-resolve-xref #[nil "„ ÁÂ!‡Ã ˜„ ÁÄ\"‡ÅŠÉ ˆ`\nbˆËÌ\nÍ#…4 Î”Î•{+ÏHÐU„G Ñ!‚[ ÒÎÅOÅÍ#‰…Z A@)Ô!„} Õ!ƒu Ö×Ø\"!‚z ÁÙ\"ƒ„ ÚÛÜ‚‰ ÁÝ\")‡" [outline-file-xref-bullet error "outline cross references disabled - no 'outline-file-xref-bullet'" outline-current-bullet "current heading lacks cross-reference bullet '%s'" nil file-name outline-recent-prefix-end text-start outline-pre-next-preface heading-end re-search-forward "\\s-\\(\\S-*\\)" t 1 0 58 expand-file-name reference-registered-file reg-ref file-exists-p file-writable-p y-or-n-p format "%s not there, create one? " "%s not found and can't be created" failure (find-file-other-window file-name) ((error failure)) "%s not found"] 5 "\
  Pop to file associated with current heading, if it has an xref bullet
  (according to setting of 'outline-file-xref-bullet')." nil])
(defvar next-entry-exists nil "\
Used by outline-to-entry-end, dunno why.")
(defalias 'outline-to-entry-end #[(&optional include-sub-entries curr-entry-level) "À	ÂÃ#‰ƒ ƒ ŠÆyˆÇ V)„  ƒ$ Æyˆ`‡db‡" [re-search-forward outline-regexp nil t next-entry-exists include-sub-entries 0 outline-depth curr-entry-level] 4 "\
   Go to end of whole entry if optional INCLUDE-SUB-ENTRIES is non-nil.
   CURR-ENTRY-LEVEL is an integer representing the length of the current level
   string which matched to 'outline-regexp'.  If INCLUDE-SUB-ENTRIES is nil,
   CURR-ENTRY-LEVEL is not needed."])
(defalias 'outline-copy-exposed #[(&optional workbuf) "„	 Á ÂPpÄ!„ Å!ˆÆ!ˆÇ ˆÈ!ˆÉÊË\"ˆeb)‡" [workbuf buffer-name " exposed" buf get-buffer generate-new-buffer pop-to-buffer erase-buffer insert-buffer replace-regexp "[^\n]*" ""] 3 "\
   Duplicate buffer to other buffer, sans hidden stuff.

   Without repeat count, this simple-minded function just generates
   the new buffer by concatenating the current buffer name with \"
   exposed\", and doing a 'get-buffer' on it." nil])
(defalias 'outlinify-sticky #[(&optional arg) "ÀÁ!ˆ\nƒ \n;ƒ Ã\n!ˆ‚K Ã ‚K Åƒ' ÃÆ!‚K Çƒ4 ÃÈ!‚K É=ƒA ÃÊ!‚K Ë=ƒK ÃÌ!ÍÎ\nƒW Ð‚X ÑP#ÍÔ\nƒi ‚j ÑÕÖ×ØÙÚ&	ŠebˆÜ!„” Þ\n„‹ ‚’ Íß#!ˆdbˆÞÍàáâã&!ˆÞÍäåæç$!ˆ\nƒ¼ ÞÍèé\n#!ˆÞÍêëìíîïð&!ˆÞÍñ\"!+‡" [outline-mode t arg outline-lead-with-comment-string major-mode (emacs-lisp-mode lisp-mode) ";;;_" (awk-mode csh-mode sh-mode perl-mode) "#" c++-mode "//_" c-mode "/*_" format "%s%s" outline-header-prefix " " "" outline-primary-bullet lead-prefix "%s%s %s\n%s %s\n  %s %s %s" "Local emacs vars." "'(This topic sets initial outline exposure" "of the file when loaded by emacs," "Encapsulate it in comments if" "file is a program" "otherwise ignore it," lead-line looking-at outline-regexp insert-string "%s%s\n" "\n\n%s\n%s %s %s\n%s %s " "local" "variables:" "eval:" "%s\n		%s\n			%s\n" "(condition-case err" "(save-excursion" "(outline-mode t)" "			(%s \"%s\")\n" "outline-lead-with-comment-string" "			%s %s\n			%s %s\n		%s %s" "(message \"Adjusting '%s' visibility\"" "(buffer-name))" "(goto-char 0)" "(outline-exposure -1 0))" "(error (message " "\"Failed file var 'allout' provisions\")))" "\n%s End: )\n"] 10 "\
   Activate outline mode and establish file eval to set initial exposure.
  
  Invoke with a string argument to designate a string to prepend to
  topic prefixs, or with a universal argument to be prompted for the
  string to be used.  Suitable defaults are provided for lisp,
  emacs-lisp, c, c++, awk, sh, csh, and perl modes." "P"])
(defalias 'solicit-char-in-string #[(prompt string &optional do-defaulting) "Á\n„E ÄÅ\"ˆÆÇÉ )!Ê\n\"„> ƒ/ \nÍ˜ƒ/ Î‰‚ \nÏÎ°Á‰‚ ÄÎ!ˆ‚ \n*‡" [prompt nil got new-prompt message "%s" char-to-string t cursor-in-echo-area read-char string-match string do-defaulting "" "" " ...pick from: "] 6 "\
   Solicit (with first arg PROMPT) choice of a character from string STRING.

   Optional arg DO-DEFAULTING indicates to accept empty input (CR)."])
(defalias 'string-sans-char #[(string char) "Á˜ƒ Á‡ÂHUƒ ÄÅÆO\"‡ÂÅOÄÅÆO\"P‡" [string "" 0 char string-sans-char 1 nil] 5 "\
  Return a copy of STRING that lacks all instances of CHAR."])