;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:25 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/hideshow.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


(byte-code "\300\301\302\303\304\305\306\307&\210\310\311\312\313\314\315\306\301&\210\310\316\302\317\314\320\306\301\321\322&	\210\310\323\324\325\314\326\306\301&\207" [custom-declare-group hideshow nil "Minor mode for hiding and showing program and comment blocks." :prefix "hs-" :group languages custom-declare-variable hs-hide-comments-when-hiding-all t "Hide the comments too when you do an `hs-hide-all'." :type boolean hs-minor-mode-hook "Hook called when hideshow minor mode is activated or deactivated." hook :version "21.1" hs-isearch-open 'code "What kind of hidden blocks to open when doing `isearch'.\nOne of the following symbols:\n\n  code    -- open only code blocks\n  comment -- open only comment blocks\n  t       -- open both code and comment blocks\n  nil     -- open neither code nor comment blocks\n\nThis has effect only if `search-invisible' is set to `open'." (choice (const :tag "open only code blocks" code) (const :tag "open only comment blocks" comment) (const :tag "open both code and comment blocks" t) (const :tag "don't open any of them" nil))] 10)
#@1214 Alist for initializing the hideshow variables for different modes.
Each element has the form
  (MODE START END COMMENT-START FORWARD-SEXP-FUNC ADJUST-BEG-FUNC).

If non-nil, hideshow will use these values as regexps to define blocks
and comments, respectively for major mode MODE.

START, END and COMMENT-START are regular expressions.  A block is
defined as text surrounded by START and END.

As a special case, START may be a list of the form (COMPLEX-START
MDATA-SELECTOR), where COMPLEX-START is a regexp w/ multiple parts and
MDATA-SELECTOR an integer that specifies which sub-match is the proper
place to adjust point, before calling `hs-forward-sexp-func'.  Point
is adjusted to the beginning of the specified match.  For example,
see the `hs-special-modes-alist' entry for `bibtex-mode'.

For some major modes, `forward-sexp' does not work properly.  In those
cases, FORWARD-SEXP-FUNC specifies another function to use instead.

See the documentation for `hs-adjust-block-beginning' to see what is the
use of ADJUST-BEG-FUNC.

If any of the elements is left nil or omitted, hideshow tries to guess
appropriate values.  The regexps should not contain leading or trailing
whitespace.  Case does not matter.
(defvar hs-special-modes-alist (mapcar 'purecopy '((c-mode "{" "}" "/[*/]" nil nil) (c++-mode "{" "}" "/[*/]" nil nil) (bibtex-mode ("@\\S(*\\(\\s(\\)" 1)) (java-mode "{" "}" "/[*/]" nil nil) (js-mode "{" "}" "/[*/]" nil))) (#$ . 1651))
#@71 Function called if non-nil when doing `hs-hide-all' for non-comments.
(defvar hs-hide-all-non-comment-function nil (#$ . 3107))
#@153 If non-nil, hiding remembers internal blocks.
This means that when the outer block is shown again,
any previously hidden internal blocks remain hidden.
(defvar hs-allow-nesting nil (#$ . 3242))
#@204 Hook called (with `run-hooks') at the end of commands to hide text.
These commands include the toggling commands (when the result is to hide
a block), `hs-hide-all', `hs-hide-block' and `hs-hide-level'.
(defvar hs-hide-hook nil (#$ . 3443))
#@187 Hook called (with `run-hooks') at the end of commands to show text.
These commands include the toggling commands (when the result is to show
a block), `hs-show-all' and `hs-show-block'.
(defvar hs-show-hook nil (#$ . 3691))
#@688 Function called with one arg, OV, a newly initialized overlay.
Hideshow puts a unique overlay on each range of text to be hidden
in the buffer.  Here is a simple example of how to use this variable:

  (defun display-code-line-counts (ov)
    (when (eq 'code (overlay-get ov 'hs))
      (overlay-put ov 'display
                   (format "... / %d"
                           (count-lines (overlay-start ov)
                                        (overlay-end ov))))))

  (setq hs-set-up-overlay 'display-code-line-counts)

This example shows how to get information from the overlay as well
as how to set its `display' property.  See `hs-make-overlay' and
info node `(elisp)Overlays'.
(defvar hs-set-up-overlay nil (#$ . 3922))
#@132 Non-nil if using hideshow mode as a minor mode of some other mode.
Use the command `hs-minor-mode' to toggle or set this variable.
(defvar hs-minor-mode nil (#$ . 4659))
#@33 Keymap for hideshow minor mode.
(defvar hs-minor-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210)\207" [map make-sparse-keymap define-key "@" hs-hide-block "@" hs-show-block "@\210" hs-hide-all "@\223" hs-show-all "@\f" hs-hide-level "@" hs-toggle-hiding [(shift mouse-2)] hs-mouse-toggle-hiding] 4) (#$ . 4835))
#@47 Menu used when hideshow minor mode is active.
(defvar hs-minor-mode-menu nil (#$ . 5270))
(easy-menu-do-define 'hs-minor-mode-menu hs-minor-mode-map "Menu used when hideshow minor mode is active." '("Hide/Show" ["Hide Block" hs-hide-block :help "Hide the code or comment block at point"] ["Show Block" hs-show-block :help "Show the code or comment block at point"] ["Hide All" hs-hide-all :help "Hide all the blocks in the buffer"] ["Show All" hs-show-all :help "Show all the blocks in the buffer"] ["Hide Level" hs-hide-level :help "Hide all block at levels below the current block"] ["Toggle Hiding" hs-toggle-hiding :help "Toggle the hiding state of the current block"] "----" ["Hide comments when hiding all" (setq hs-hide-comments-when-hiding-all (not hs-hide-comments-when-hiding-all)) :help "If t also hide comment blocks when doing `hs-hide-all'" :style toggle :selected hs-hide-comments-when-hiding-all] ("Reveal on isearch" ["Code blocks" (setq hs-isearch-open 'code) :help "Show hidden code blocks when isearch matches inside them" :active t :style radio :selected (eq hs-isearch-open 'code)] ["Comment blocks" (setq hs-isearch-open 'comment) :help "Show hidden comment blocks when isearch matches inside them" :active t :style radio :selected (eq hs-isearch-open 'comment)] ["Code and Comment blocks" (setq hs-isearch-open t) :help "Show both hidden code and comment blocks when isearch matches inside them" :active t :style radio :selected (eq hs-isearch-open t)] ["None" (setq hs-isearch-open nil) :help "Do not hidden code or comment blocks when isearch matches inside them" :active t :style radio :selected (eq hs-isearch-open nil)])))
#@122 Regexp for beginning of comments.
Differs from mode-specific comment regexps in that
surrounding whitespace is stripped.
(defvar hs-c-start-regexp nil (#$ . 6929))
(make-variable-buffer-local 'hs-c-start-regexp)
#@32 Regexp for beginning of block.
(defvar hs-block-start-regexp nil (#$ . 7147))
(make-variable-buffer-local 'hs-block-start-regexp)
#@225 Element in `hs-block-start-regexp' match data to consider as block start.
The internal function `hs-forward-sexp' moves point to the beginning of this
element (using `match-beginning') before calling `hs-forward-sexp-func'.
(defvar hs-block-start-mdata-select nil (#$ . 7284))
(make-variable-buffer-local 'hs-block-start-mdata-select)
#@26 Regexp for end of block.
(defvar hs-block-end-regexp nil (#$ . 7625))
(make-variable-buffer-local 'hs-block-end-regexp)
#@314 Function used to do a `forward-sexp'.
Should change for Algol-ish modes.  For single-character block
delimiters -- ie, the syntax table regexp for the character is
either `(' or `)' -- `hs-forward-sexp-func' would just be
`forward-sexp'.  For other modes such as simula, a more specialized
function is necessary.
(defvar hs-forward-sexp-func 'forward-sexp (#$ . 7752))
(make-variable-buffer-local 'hs-forward-sexp-func)
#@691 Function used to tweak the block beginning.
The block is hidden from the position returned by this function,
as opposed to hiding it from the position returned when searching
for `hs-block-start-regexp'.

For example, in c-like modes, if we wish to also hide the curly braces
(if you think they occupy too much space on the screen), this function
should return the starting point (at the end of line) of the hidden
region.

It is called with a single argument ARG which is the position in
buffer after the block beginning.

It should return the position from where we should start hiding.

It should not move the point.

See `hs-c-like-adjust-block-beginning' for an example of using this.
(defvar hs-adjust-block-beginning nil (#$ . 8179))
(make-variable-buffer-local 'hs-adjust-block-beginning)
#@369 Text of the line where a hidden block begins, set during isearch.
You can display this in the mode line by adding the symbol `hs-headline'
to the variable `mode-line-format'.  For example,

  (unless (memq 'hs-headline mode-line-format)
    (setq mode-line-format
          (append '("-" hs-headline) mode-line-format)))

Note that `mode-line-format' is buffer-local.
(defvar hs-headline nil (#$ . 8983))
#@119 Delete hideshow overlays in region defined by FROM and TO.
Skip "internal" overlays if `hs-allow-nesting' is non-nil.
(defalias 'hs-discard-overlays #[(from to) "	W\203\n	\n\203/\305\306	!\211V\205-\307	!\211\203\310!\311!\210\202)\207\312	\"\305\211\205P\f@\313\314\"\203H\311!\210\fA\211\204:\305*\207" [to from hs-allow-nesting ov --dolist-tail-- nil next-overlay-change hs-overlay-at overlay-end delete-overlay overlays-in overlay-get hs] 4 (#$ . 9395)])
#@656 Return a new overlay in region defined by B and E with type KIND.
KIND is either `code' or `comment'.  Optional fourth arg B-OFFSET
when added to B specifies the actual buffer position where the block
begins.  Likewise for optional fifth arg E-OFFSET.  If unspecified
they are taken to be 0 (zero).  The following properties are set
in the overlay: 'invisible 'hs 'hs-b-offset 'hs-e-offset.  Also,
depending on variable `hs-isearch-open', the following properties may
be present: 'isearch-open-invisible 'isearch-open-invisible-temporary.
If variable `hs-set-up-overlay' is non-nil it should specify a function
to call with the newly initialized overlay.
(defalias 'hs-make-overlay #[(b e kind &optional b-offset e-offset) "\204\306	\204\f\306\307\n\"\f\310=\203\311\202\f\312\313\314#\210\312\314#\210\312\315#\210\312\316	#\210
\317=\204H
=\203V\312\320\321#\210\312\322\323#\210\203a!\210*\207" [b-offset e-offset b e hs-isearch-open io 0 make-overlay block code overlay-put invisible hs hs-b-offset hs-e-offset t isearch-open-invisible hs-isearch-show isearch-open-invisible-temporary hs-isearch-show-temporary ov kind hs-set-up-overlay] 4 (#$ . 9889)])
#@141 Delete overlay OV, and set `hs-headline' to nil.

This function is meant to be used as the `isearch-open-invisible'
property of an overlay.
(defalias 'hs-isearch-show #[(ov) "\302\303	!\207" [hs-headline ov nil delete-overlay] 2 (#$ . 11096)])
#@339 Hide or show overlay OV, and set `hs-headline', all depending on HIDE-P.
If HIDE-P is non-nil, `hs-headline' is set to nil and overlay OV is hidden.
Otherwise, `hs-headline' is set to the line of text at the head of OV, and
OV is shown.

This function is meant to be used as the `isearch-open-invisible-temporary'
property of an overlay.
(defalias 'hs-isearch-show-temporary #[(ov hide-p) "?\205	\206\305\n!\212b\210\306 \210\307\310w\210`){)\311 \210\310\203?\312\n\313\"\211\203T\314\n\315\f#\210\314\n\313\310#\210\202T\312\n\315\"\211\203T\314\n\313\f#\210\314\n\315\310#\210)\314\n\316\205]\317#\207" [hide-p hs-headline ov start value overlay-start beginning-of-line " 	" nil force-mode-line-update overlay-get hs-isearch-display overlay-put display invisible hs] 4 (#$ . 11348)])
#@52 Return non-nil if the point is at the block start.
(defalias 'hs-looking-at-block-start-p #[nil "\302!\205\303 \304\216\305\306 8*?\207" [hs-block-start-regexp save-match-data-internal looking-at match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) 8 syntax-ppss] 2 (#$ . 12160)])
#@119 Adjust point based on MATCH-DATA and call `hs-forward-sexp-func' w/ ARG.
Original match data is restored upon return.
(defalias 'hs-forward-sexp #[(match-data arg) "\301 \305\216\306	!\210\n\224b\210\f!*\207" [save-match-data-internal match-data hs-block-start-mdata-select hs-forward-sexp-func arg ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) set-match-data] 2 (#$ . 12496)])
#@105 Hide a region from BEG to END, marking it as a comment.
Optional arg REPOS-END means reposition at end.
(defalias 'hs-hide-comment-region #[(beg end &optional repos-end) "b\210\305 	b\210\305 \306\n\"\210\307\n\310	%\210*\f\203\"	\202#b\207" [beg end end-eol beg-eol repos-end line-end-position hs-discard-overlays hs-make-overlay comment] 6 (#$ . 12923)])
#@335 Hide block if on block beginning.
Optional arg END means reposition at end.
Optional arg COMMENT-REG is a list of the form (BEGIN END) and
specifies the limits of the comment, or nil if the block is not
a comment.

The block beginning is adjusted by `hs-adjust-block-beginning'
and then further adjusted to be at the end of the line.
(defalias 'hs-hide-block-at-point #[(&optional end comment-reg) "\203\306@\211A@)\n#\207\307 \205\225\310\311!\312\225\313\211\211\212\2034!b\210\2028b\210\314 )\315\316\"\210\317!\203N\312\224\202O`
\fW\203\207\320
\f\"\316V\203\207\203s\321
!\211\203s\322!\210\202}\204}\323
\f\"\210\324
\f\325
Z$\210\n\203\217\f\202\223
^b-\207" [comment-reg x end ov q p hs-hide-comment-region hs-looking-at-block-start-p match-data t 0 nil line-end-position hs-forward-sexp 1 looking-back count-lines hs-overlay-at delete-overlay hs-discard-overlays hs-make-overlay code header-end mdata hs-adjust-block-beginning hs-block-end-regexp hs-allow-nesting] 7 (#$ . 13296)])
#@425 Return non-nil if point is inside a comment, otherwise nil.
Actually, return a list containing the buffer position of the start
and the end of the comment.  A comment block can be hidden only if on
its starting line there is only whitespace preceding the actual comment
beginning.  If we are inside of a comment but this condition is not met,
we return a list having a nil as its car and the end of comment position
as cdr.
(defalias 'hs-inside-comment-p #[nil "\212`\304\305w\210\306	!\204\307	e\310#\205\226o\204)`\311\312!\210`U\203)\312u\210\202\311\313 [!\210\314\305w\210`\310\315 \210\306\316	P!\204|b\210\311\317!\210\314\305w\210``W\203n`V\203n\306	!\204n`\311\317!\210\314\305w\210\202O\306	!\203z`V\203|\305\311\313 !\210\314\305x\210\305\210`Y\205\225\n\205\223`D**\207" [q hs-c-start-regexp hidable p "[:blank:]" nil looking-at re-search-backward t forward-comment -1 buffer-size " 	\n\f" beginning-of-line "[ 	]*" 1] 4 (#$ . 14345)])
#@266 Set up hideshow variables for new buffers.
If `hs-special-modes-alist' has information associated with the
current buffer's major mode, use that.
Otherwise, guess start, end and `comment-start' regexps; `forward-sexp'
function; and adjust-block-beginning function.
(defalias 'hs-grok-mode-type #[nil "\306\300!\203x\306\301!\203x\203x	\203x\307\n\"\211A@\206 \310\211<\2036
@
\211A@)\202<
\311\312\f8\206C\313\314\f8\206e\315!\316\317\"\203b\311\211\225SO\202d)\320\f8\206n\321\322\f8\211*\207\323\324\325\326 !\"\207" [comment-start comment-end major-mode hs-special-modes-alist lookup start-elem boundp assoc "\\s(" 0 2 "\\s)" 3 regexp-quote string-match " +$" 4 forward-sexp 5 nil error "%s Mode doesn't support Hideshow Minor Mode" format-mode-line hs-block-start-regexp x hs-block-start-mdata-select hs-block-end-regexp c-start-regexp hs-c-start-regexp hs-forward-sexp-func hs-adjust-block-beginning hs-minor-mode mode-name] 5 (#$ . 15329)])
#@93 Reposition point at block-start.
Return point, or nil if original point was not in a block.
(defalias 'hs-find-block-beginning #[nil "\304`\305 \203
`\202?\306\n\304\307#\2033\310 \311\216\312\313 8*\204
\212\314\310\307!\315\"\210`)W\211\203
	\203;`\202?b\210\304*\207" [here done hs-block-start-regexp save-match-data-internal nil hs-looking-at-block-start-p re-search-backward t match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) 8 syntax-ppss hs-forward-sexp 1] 4 (#$ . 16328)])
#@71 Recursively hide blocks ARG levels below point in region (MINP MAXP).
(defalias 'hs-hide-level-recursive #[(arg minp maxp) "\306 \203`T	\307!\210`S\204\310\n\"\210b\210\311\312 !\210`\nW\203Y\313\f\n\314#\203Y\315 \316\216\317\320 8*\204\307V\203M\321S\n#\210\202\224b\210\322\314!\210\202\nb\207" [minp hs-forward-sexp-func maxp hs-allow-nesting hs-block-start-regexp save-match-data-internal hs-find-block-beginning 1 hs-discard-overlays forward-comment buffer-size re-search-forward t match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) 8 syntax-ppss hs-hide-level-recursive hs-hide-block-at-point arg hs-block-start-mdata-select] 4 (#$ . 16876)])
#@163 Evaluate BODY forms if variable `hs-minor-mode' is non-nil.
In the dynamic context of this macro, `inhibit-point-motion-hooks'
and `case-fold-search' are both t.
(defalias 'hs-life-goes-on '(macro . #[(&rest body) "\301\302\303\304BBE\207" [body when hs-minor-mode let ((inhibit-point-motion-hooks t) (case-fold-search t))] 5 (#$ . 17605)]))
(put 'hs-life-goes-on 'edebug-form-spec '(&rest form))
#@66 Return hideshow overlay at POSITION, or nil if none to be found.
(defalias 'hs-overlay-at #[(position) "\304!\305\211	\204\"@\211\203\"\306\n\307\"\205\nA\202	+\207" [position found ov overlays overlays-at nil overlay-get hs] 3 (#$ . 18009)])
#@71 Return non-nil if point is in an already-hidden block, otherwise nil.
(defalias 'hs-already-hidden-p #[nil "\212\301 \211\203@\203@b\210\202)\302\210\204)\303 \203)\304 \203)\305\225b\210)\302\210\306`!)\207" [c-reg hs-inside-comment-p nil hs-find-block-beginning hs-looking-at-block-start-p 0 hs-overlay-at] 3 (#$ . 18273)])
#@268 Adjust INITIAL, the buffer position after `hs-block-start-regexp'.
Actually, point is never moved; a new position is returned that is
the end of the C-function header.  This adjustment function is meant
to be assigned to `hs-adjust-block-beginning' for C-like modes.
(defalias 'hs-c-like-adjust-block-beginning #[(initial) "\212Sb\210\301\302 [!\210`)\207" [initial forward-comment buffer-size] 2 (#$ . 18620)])
#@257 Hide all top level blocks, displaying only first and last lines.
Move point to the beginning of the line, and run the normal hook
`hs-hide-hook'.  See documentation for `run-hooks'.
If `hs-hide-comments-when-hiding-all' is non-nil, also hide the comments.
(defalias 'hs-hide-all #[nil "\205\273\306\211\212\204\307ed\"\210eb\210\310\311ed#\312\f\313
\203)\314\313Q\202*\315R
\2047\316d!\210\317d\306#\203\256\320\224\203a\320\224b\210\203T \202W\321\306!\204\215\322\225b\210\202\215\323 \211\203\214@\203\214\324@A@\"\320V\203\206\321\306\"\210\202\214A@b\210)` \247\203\243 @Y\205\251\325 \"*\210\202/\326!\210+\327 \210\330\331!*\207" [hs-minor-mode case-fold-search inhibit-point-motion-hooks hs-allow-nesting hs-block-start-regexp hs-hide-comments-when-hiding-all t hs-discard-overlays make-progress-reporter "Hiding all blocks..." "\\(" "\\)" "\\|\\(" "" forward-comment re-search-forward 1 hs-hide-block-at-point 0 hs-inside-comment-p count-lines progress-reporter-do-update progress-reporter-done beginning-of-line run-hooks hs-hide-hook hs-c-start-regexp re spew hs-hide-all-non-comment-function c-reg value reporter] 8 (#$ . 19040) nil])
#@60 Show everything then run `hs-show-hook'.  See `run-hooks'.
(defalias 'hs-show-all #[nil "\205\304\211\305\306!\210\307\310ed\"\210)\305\311!\210\312\313!*\207" [hs-minor-mode case-fold-search inhibit-point-motion-hooks hs-allow-nesting t message "Showing all blocks ..." nil hs-discard-overlays "Showing all blocks ... done" run-hooks hs-show-hook] 3 (#$ . 20256) nil])
#@184 Select a block and hide it.  With prefix arg, reposition at END.
Upon completion, point is repositioned and the normal hook
`hs-hide-hook' is run.  See documentation for `run-hooks'.
(defalias 'hs-hide-block #[(&optional end) "\205=\305\211\306 \211\203&@\203 \307@A@\"\310X\203&\311\312!\202<\2044\313 \2044\314 \205<\315\f\"\210\316\317!+\207" [hs-minor-mode case-fold-search inhibit-point-motion-hooks c-reg end t hs-inside-comment-p count-lines 1 message "(not enough comment lines to hide)" hs-looking-at-block-start-p hs-find-block-beginning hs-hide-block-at-point run-hooks hs-hide-hook] 4 (#$ . 20639) "P"])
#@213 Select a block and show it.
With prefix arg, reposition at END.  Upon completion, point is
repositioned and the normal hook `hs-show-hook' is run.
See documentation for functions `hs-hide-block' and `run-hooks'.
(defalias 'hs-show-block #[(&optional end) "\205\236\306\211\307\310 !`\211\2059
\203\311\f!\2022\312\f\313\"\314=\203*\2022\315\f!\312\f\316\"\\b\210\317\f!\210\306*\204\232\320 \321\211\211\203c@\203z@\211A@)\202z\322 \203z\323 \203z`\324\325\306!\326\"\210`\203\231\203\231\327\"\210
\203\224\202\227Tb\210+\330\331!*\207" [hs-minor-mode case-fold-search inhibit-point-motion-hooks here ov end t hs-overlay-at line-end-position overlay-end overlay-get hs comment overlay-start hs-b-offset delete-overlay hs-inside-comment-p nil hs-find-block-beginning hs-looking-at-block-start-p hs-forward-sexp match-data 1 hs-discard-overlays run-hooks hs-show-hook q p c-reg x] 5 (#$ . 21279) "P"])
#@95 Hide all blocks ARG levels below this block.
The hook `hs-hide-hook' is run; see `run-hooks'.
(defalias 'hs-hide-level #[(arg) "\205\304\211\212\305\306!\210\307ed#\210\305\310!\210)\311\312!*\207" [hs-minor-mode case-fold-search inhibit-point-motion-hooks arg t message "Hiding blocks ..." hs-hide-level-recursive "Hiding blocks ... done" run-hooks hs-hide-hook] 4 (#$ . 22243) "p"])
#@76 Toggle hiding/showing of a block.
See `hs-hide-block' and `hs-show-block'.
(defalias 'hs-toggle-hiding #[nil "\205\303\211\304 \203\305 \202\306 *\207" [hs-minor-mode case-fold-search inhibit-point-motion-hooks t hs-already-hidden-p hs-show-block hs-hide-block] 2 (#$ . 22640) nil])
#@176 Toggle hiding/showing of a block.
This command should be bound to a mouse key.
Argument E is a mouse event used by `mouse-set-point'.
See `hs-hide-block' and `hs-show-block'.
(defalias 'hs-mouse-toggle-hiding #[(e) "\205\304\211\305!\210\306 *\207" [hs-minor-mode case-fold-search inhibit-point-motion-hooks e t mouse-set-point hs-toggle-hiding] 2 (#$ . 22939) "@e"])
#@109 Hide the first block of comments in a file.
This can be useful if you have huge RCS logs in those comments.
(defalias 'hs-hide-initial-comment-block #[nil "\2054\306\211\212eb\210\307\310w\210\311 )\211\2053@\211A@)
\312

\"\313V\2052\314

\"*+\207" [hs-minor-mode case-fold-search inhibit-point-motion-hooks c-reg x end t " 	\n\f" nil hs-inside-comment-p count-lines 1 hs-hide-comment-region beg] 4 (#$ . 23320) nil])
#@95 Non-nil if Hs minor mode is enabled.
Use the command `hs-minor-mode' to change this variable.
(defvar hs-minor-mode nil (#$ . 23759))
(make-variable-buffer-local 'hs-minor-mode)
#@836 Minor mode to selectively hide/show code and comment blocks.
With a prefix argument ARG, enable the mode if ARG is positive,
and disable it otherwise.  If called from Lisp, enable the mode
if ARG is omitted or nil.

When hideshow minor mode is on, the menu bar is augmented with hideshow
commands and the hideshow commands are enabled.
The value '(hs . t) is added to `buffer-invisibility-spec'.

The main commands are: `hs-hide-all', `hs-show-all', `hs-hide-block',
`hs-show-block', `hs-hide-level' and `hs-toggle-hiding'.  There is also
`hs-hide-initial-comment-block' and `hs-mouse-toggle-hiding'.

Turning hideshow minor mode off reverts the menu bar and the
variables to default values and disables the hideshow commands.

Lastly, the normal hook `hs-minor-mode-hook' is run using `run-hooks'.

Key bindings:
\{hs-minor-mode-map}
(defalias 'hs-minor-mode #[(&optional arg) "\306 	\307=\203\n?\202\310	!\311V\312\n\2035\313 \210\314\315\316\312\317$\210\320\f!\210\321\305!\210\317\322\323!\210\202?\324\325!\210\317\326 \210)\327\330\n\203I\331\202J\332\"\210\333\334!\203k\306 \203^\306 \232\203k\335\336\n\203h\337\202i\340\"\210)\341 \210\n\207" [#1=#:last-message arg hs-minor-mode hs-headline hs-minor-mode-menu line-move-ignore-invisible current-message toggle prefix-numeric-value 0 nil hs-grok-mode-type add-hook change-major-mode-hook turn-off-hideshow t easy-menu-add make-local-variable add-to-invisibility-spec (hs . t) remove-from-invisibility-spec (hs . t) hs-show-all run-hooks hs-minor-mode-hook hs-minor-mode-on-hook hs-minor-mode-off-hook called-interactively-p any message "Hs minor mode %sabled" "en" "dis" force-mode-line-update] 5 (#$ . 23944) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\211%\207" [hs-minor-mode-map add-minor-mode hs-minor-mode " hs" nil] 6)
#@43 Unconditionally turn off `hs-minor-mode'.
(defalias 'turn-off-hideshow #[nil "\300\301!\207" [hs-minor-mode -1] 2 (#$ . 25783)])
(provide 'hideshow)