;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!\210\303\304\305\"\210\303\306\305\"\210\303\307\305\"\210\300\310!\207" [require psgml psgml-other autoload sgml-do-usemap-element "psgml-dtd" sgml-write-dtd sgml-check-dtd-subset cl-lib] 3)
#@225 If non-nil, it should be a function of no arguments.
The functions is evaluated before the standard auto-fill function,
`do-auto-fill', tries to fill a line.  If the function returns a true
value the auto-fill is inhibited.
(defvar sgml-auto-fill-inhibit-function nil (#$ . 635))
(defvar sgml-psgml-pi-enable-outside-dtd nil)
#@268 The hook run by `sgml-open-element'.
Theses functions are called with two arguments, the first argument is
the opened element and the second argument is the attribute specification
list.  It is probably best not to refer to the content or the end-tag of
the element.
(defvar sgml-open-element-hook nil (#$ . 968))
#@126 The hook run by `sgml-close-element'.
These functions are invoked with `sgml-current-tree' bound to the
element just parsed.
(defvar sgml-close-element-hook nil (#$ . 1289))
#@130 This hook is called after the doctype has been parsed.
It can be used to load any additional information into the DTD structure.
(defvar sgml-doctype-parsed-hook nil (#$ . 1470))
#@323 A list of functions for resolving sysids.
Each function should take one argument, the system identifier of an entity.
If the function can handle that identifier, it should insert the text
of the entity into the current buffer at point and return t.  If the
system identifier is not handled the function should return nil.
(defvar sgml-sysid-resolve-functions nil (#$ . 1656))
(defconst sgml-pcdata-token (intern "#PCDATA"))
#@47 Internal representation of entity search map.
(defvar sgml-computed-map nil (#$ . 2086))
#@83 Value of `sgml-current-entity-map' used to compute the map in `sgml-compute-map'.
(defvar sgml-used-entity-map nil (#$ . 2181))
#@80 Used to keep information about position in element structure between commands.
(defvar sgml-last-element nil (#$ . 2315))
#@61 List of commands that set the variable `sgml-last-element'.
(defconst sgml-users-of-last-element '(sgml-beginning-of-element sgml-end-of-element sgml-up-element sgml-backward-up-element sgml-backward-element sgml-forward-element sgml-down-element sgml-show-context sgml-next-data-field) (#$ . 2443))
#@35 Syntax table used during parsing.
(defvar sgml-parser-syntax nil (#$ . 2749))
#@34 Assoc list caching parsed ecats.
(defvar sgml-ecat-assoc nil (#$ . 2833))
#@37 Assoc list caching parsed catalogs.
(defvar sgml-catalog-assoc nil (#$ . 2913))
#@81 Set to a symbol other than nil to make `sgml-log-warning' throw to that symbol.
(defvar sgml-throw-on-warning nil (#$ . 2999))
#@75 Set to a symbol other than nil to make `sgml-error' throw to that symbol.
(defvar sgml-throw-on-error nil (#$ . 3132))
#@28 Set to t to show warnings.
(defvar sgml-show-warnings nil (#$ . 3257))
#@126 Can be nil for no trap, an element or t for any element.
Tested by `sgml-close-element' to see if the parse should be ended.
(defvar sgml-close-element-trap nil (#$ . 3335))
#@33 Point in buffer to parse up to.
(defvar sgml-goal 0 (#$ . 3515))
#@168 Function called by parser to handle a short reference.
Called with the entity as argument.  The start and end of the
short reference is `sgml-markup-start' and point.
(defvar sgml-shortref-handler 'sgml-handle-shortref (#$ . 3587))
#@35 Function called with parsed data.
(defvar sgml-data-function nil (#$ . 3825))
#@67 Function called with entity referenced at current point in parse.
(defvar sgml-entity-function nil (#$ . 3909))
#@53 Function called with parsed processing instruction.
(defvar sgml-pi-function nil (#$ . 4027))
#@89 Called when some data characters are conceptually parsed.
E.g. a data entity reference.
(defvar sgml-signal-data-function nil (#$ . 4127))
#@12 Throw tag.
(defvar sgml-throw-on-element-change nil (#$ . 4272))
#@59 This variable is bound to t while parsing a DTD (subset).
(defvar sgml-parsing-dtd nil (#$ . 4343))
#@58 Set to position of last parsing start in current buffer.
(defvar sgml-rs-ignore-pos nil (#$ . 4449))
(make-variable-buffer-local 'sgml-rs-ignore-pos)
#@60 Holds the `sgml-dtd' structure describing the current DTD.
(defvar sgml-dtd-info nil (#$ . 4605))
#@73 Value of `sgml-namecase-general' in main buffer.  Valid during parsing.
(defvar sgml-current-namecase-general t (#$ . 4709))
#@64 Value of `sgml-omittag' in main buffer.  Valid during parsing.
(defvar sgml-current-omittag nil (#$ . 4840))
#@65 Value of `sgml-shorttag' in main buffer.  Valid during parsing.
(defvar sgml-current-shorttag nil (#$ . 4955))
#@71 Value of `sgml-local-catalogs' in main buffer.  Valid during parsing.
(defvar sgml-current-localcat nil (#$ . 5072))
#@73 Value of `sgml-local-ecat-files' in main buffer.  Valid during parsing.
(defvar sgml-current-local-ecat nil (#$ . 5195))
#@129 The buffer of the document entity, the main buffer.
Valid during parsing.  This is used to find current directory for
catalogs.
(defvar sgml-current-top-buffer nil (#$ . 5323))
#@71 Current state in content model or model type if CDATA, RCDATA or ANY.
(defvar sgml-current-state nil (#$ . 5506))
#@41 The current active short reference map.
(defvar sgml-current-shortmap nil (#$ . 5626))
#@51 Current parse tree node, identifies open element.
(defvar sgml-current-tree nil (#$ . 5719))
#@70 Previous tree node in current tree.
This is nil if no previous node.
(defvar sgml-previous-tree nil (#$ . 5818))
#@94 Buffer where last parse was ended.
Used for restarting parser at the point where it left of.
(defvar sgml-last-buffer nil (#$ . 5937))
#@486 Contains the type of markup parsed last.
The value is a symbol:
nil	- pcdata or space
CDATA	- CDATA or RCDATA
comment	- comment declaration
doctype	- doctype declaration
end-tag
ignored	- ignored marked section
ms-end	- marked section start, if not ignored
ms-start - marked section end, if not ignored
pi	- processing instruction
sgml	- SGML declaration
start-tag
entity  - general entity reference
param   - parameter reference
shortref- short reference
mdecl   - markup declaration
(defvar sgml-markup-type nil (#$ . 6079))
#@41 Root node of parse tree during parsing.
(defvar sgml-top-tree nil (#$ . 6612))
#@137 Tree node of markup parsed.
In case markup closed element this is different from `sgml-current-tree'.
Only valid after `sgml-parse-to'.
(defvar sgml-markup-tree nil (#$ . 6698))
#@37 Start point of markup being parsed.
(defvar sgml-markup-start nil (#$ . 6882))
#@83 Set by `sgml-parse-attribute-specification-list' if a CONREF attribute is parsed.
(defvar sgml-conref-flag nil (#$ . 6967))
#@30 Number of declared elements.
(defvar sgml-no-elements nil (#$ . 7097))
(defvar sgml-previous-buffer nil)
#@112 This is the entity reference used to enter current entity.
If this is nil, then current entity is main buffer.
(defvar sgml-current-eref nil (#$ . 7209))
#@46 This is the file name of the current entity.
(defvar sgml-current-file nil (#$ . 7369))
#@181 The global value of this variable is the first scratch buffer for entities.
The entity buffers can have a buffer local value for this variable
to point to the next scratch buffer.
(defvar sgml-scratch-buffer nil (#$ . 7464))
(put 'sgml-scratch-buffer 'permanent-local t)
(defvar sgml-last-entity-buffer nil)
#@62 Octets greater than this is the first of a two octet coding.
(defconst sgml-max-single-octet-number 250 (#$ . 7778))
(defvar sgml-read-token-vector nil)
(defvar sgml-read-nodes nil)
#@41 File name corresponding to current DTD.
(defvar sgml-loaded-dtd nil (#$ . 7966))
(make-variable-buffer-local 'sgml-loaded-dtd)
#@48 Name of current element for mode line display.
(defvar sgml-current-element-name nil (#$ . 8099))
(make-variable-buffer-local 'sgml-current-element-name)
#@67 Non-nil means the document doesn't have a DTD.
Applicable to XML.
(defvar sgml-dtd-less nil (#$ . 8259))
(make-variable-buffer-local 'sgml-dtd-less)
(defconst sgml-parser-syntax (byte-code "\300 \301\302\211W\203 \211\303\304#\266\211T\262\202 \266\305\306\307\310\311\312!\313\"\314\315%\316\"\210\305\306\307\310\311\312!\317\"\314\315%\320\"\210\211\207" [make-syntax-table 256 0 modify-syntax-entry " " mapc make-byte-code 257 "\301\302\300#\207" vconcat vector [modify-syntax-entry "w"] 5 "\n\n(fn C)" ":ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrtsuvwxyz" [modify-syntax-entry "_"] "-.0123456789"] 8))
(defconst xml-parser-syntax (byte-code "\300 \301\302\211W\203 \211\303\304#\266\211T\262\202 \266\305\306\307\310\311\312!\313\"\314\315%\316\"\210\305\306\307\310\311\312!\317\"\314\315%\320\"\210\211\207" [make-syntax-table 128 0 modify-syntax-entry " " mapc make-byte-code 257 "\301\302\300#\207" vconcat vector [modify-syntax-entry "w"] 5 "\n\n(fn C)" "_:ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrtsuvwxyz" [modify-syntax-entry "_"] "-.0123456789·"] 8))
#@19 

(fn &rest BODY)
(defalias 'sgml-with-parser-syntax '(macro . #[128 "\300\301\302\303\304\305B\306BBEE\207" [let ((cb (current-buffer))) with-syntax-table (if sgml-xml-p xml-parser-syntax sgml-parser-syntax) unwind-protect progn ((setq sgml-last-buffer (current-buffer)) (set-buffer cb))] 8 (#$ . 9364)]))
(put 'sgml-with-parser-syntax 'edebug-form-spec t)
#@19 

(fn &rest BODY)
(defalias 'sgml-with-parser-syntax-ro '(macro . #[128 "\300\301\302\303\304\305B\306BBEE\207" [let ((cb (current-buffer)) (buffer-modified (buffer-modified-p))) with-syntax-table (if sgml-xml-p xml-parser-syntax sgml-parser-syntax) unwind-protect progn ((setq sgml-last-buffer (current-buffer)) (set-buffer cb) (unless buffer-modified (restore-buffer-modified-p buffer-modified)) (sgml-debug "Restoring buffer mod: %s" buffer-modified))] 8 (#$ . 9730)]))
(put 'sgml-with-parser-syntax-ro 'edebug-form-spec t)
#@13 

(fn FLAG)
(defalias 'sgml-set-buffer-multibyte #[257 "\300\301=\203 \302\303!\202 !\207" [set-buffer-multibyte default default-value enable-multibyte-characters] 4 (#$ . 10265)])
#@19 

(fn TOKEN NODE)
(defalias 'sgml-make-move '(macro . #[514 "\300E\207" [cons] 5 (#$ . 10456)]))
#@10 

(fn X)
(defalias 'sgml-move-token '(macro . #[257 "\300D\207" [car] 3 (#$ . 10561)]))
#@10 

(fn X)
(defalias 'sgml-move-dest '(macro . #[257 "\300D\207" [cdr] 3 (#$ . 10656)]))
#@23 

(fn TOKEN NODE SET)
(defalias 'sgml-add-move-to-set '(macro . #[771 "\300\211EE\207" [cons] 7 (#$ . 10750)]))
#@18 

(fn TOKEN SET)
(defalias 'sgml-moves-lookup '(macro . #[514 "\300E\207" [assq] 5 (#$ . 10871)]))
(defalias 'sgml-make-state #[0 "\300\301\211BB\207" [normal-state nil] 3])
(put 'sgml-make-state 'byte-optimizer 'byte-compile-inline-expand)
#@10 

(fn S)
(defalias 'sgml-normal-state-p '(macro . #[257 "\300\301D\302BB\207" [eq car ('normal-state)] 4 (#$ . 11120)]))
#@10 

(fn S)
(defalias 'sgml-state-opts '(macro . #[257 "\300D\207" [cadr] 3 (#$ . 11248)]))
#@10 

(fn S)
(defalias 'sgml-state-reqs '(macro . #[257 "\300D\207" [cddr] 3 (#$ . 11344)]))
#@10 

(fn S)
(defalias 'sgml-state-final-p '(macro . #[257 "\300\301DD\207" [null sgml-state-reqs] 4 (#$ . 11440)]))
#@21 

(fn S TOKEN DEST)
(defalias 'sgml-add-opt-move #[771 "A@\236\206 \211ABA@B\240\262\207" [] 7 (#$ . 11560)])
(put 'sgml-add-opt-move 'byte-optimizer 'byte-compile-inline-expand)
#@21 

(fn S TOKEN DEST)
(defalias 'sgml-add-req-move #[771 "AA\236\206 \211ABAAB\241\262\207" [] 7 (#$ . 11753)])
(put 'sgml-add-req-move 'byte-optimizer 'byte-compile-inline-expand)
#@14 

(fn TOKEN)
(defalias 'sgml-make-primitive-content-token #[257 "\300\301\211BB\300\301\211BBAA\236\206\" \211ABAAB\241\262\266\207" [normal-state nil] 10 (#$ . 11946)])
(put 'sgml-make-primitive-content-token 'byte-optimizer 'byte-compile-inline-expand)
#@24 

(fn STATE DFAS NEXT)
(defalias 'sgml-make-and-state #[771 "BB\207" [] 6 (#$ . 12219)])
(put 'sgml-make-and-state 'byte-optimizer 'byte-compile-inline-expand)
#@24 

(fn STATE AND-STATE)
(defalias 'sgml-step-and-state #[514 "AB\207" [] 4 (#$ . 12388)])
(put 'sgml-step-and-state 'byte-optimizer 'byte-compile-inline-expand)
#@10 

(fn S)
(defalias 'sgml-and-state-substate #[257 "\211@\207" [] 2 (#$ . 12556)])
(put 'sgml-and-state-substate 'byte-optimizer 'byte-compile-inline-expand)
#@10 

(fn S)
(defalias 'sgml-and-state-dfas #[257 "\211AA\207" [] 2 (#$ . 12719)])
(put 'sgml-and-state-dfas 'byte-optimizer 'byte-compile-inline-expand)
#@10 

(fn S)
(defalias 'sgml-and-state-next #[257 "\211A@\207" [] 2 (#$ . 12875)])
(put 'sgml-and-state-next 'byte-optimizer 'byte-compile-inline-expand)
#@18 

(fn DFAS NEXT)
(defalias 'sgml-make-and-node #[514 "\211B\207" [] 4 (#$ . 13031)])
(put 'sgml-make-and-node 'byte-optimizer 'byte-compile-inline-expand)
#@10 

(fn N)
(defalias 'sgml-and-node-next '(macro . #[257 "\300D\207" [car] 3 (#$ . 13193)]))
#@10 

(fn N)
(defalias 'sgml-and-node-dfas '(macro . #[257 "\300D\207" [cdr] 3 (#$ . 13291)]))
#@14 

(fn STATE)
(defalias 'sgml-final #[257 "\211@\300=\203\f \211AA?\207\301!\207" [normal-state sgml-final-and] 3 (#$ . 13389)])
(put 'sgml-final 'byte-optimizer 'byte-compile-inline-expand)
#@14 

(fn STATE)
(defalias 'sgml-final-and #[257 "\211\211@\262\211@\300=\203 \211AA?\262\202 \301!\262\205R \211\211AA\262\302\303:\203? @\262AA?\211\262\203? A\262\202% \211\205D \303\266\203\205R \211\211A@\262AA?\207" [normal-state sgml-final-and nil t] 6 (#$ . 13586)])
#@81 Return a new state or nil, after traversing TOKEN from STATE.

(fn STATE TOKEN)
(defalias 'sgml-get-move #[514 "9\203 \300\207@\301=\2036 \211A@\236\206 \211AA\236\211\2055 \211A\211@\301=\203, \211\2023 \302A@#\262\207\303\"\207" [nil normal-state sgml-next-sub-and sgml-get-and-move] 8 (#$ . 13878)])
(put 'sgml-get-move 'byte-optimizer 'byte-compile-inline-expand)
#@20 

(fn STATE TOKEN)
(defalias 'sgml-get-and-move #[514 "\211@\2629\203 \300\266\202\202J @\301=\203D \211A@\236\206% \211AA\236\211\205? \211A\211@\301=\2036 \211\202= \302A@#\262\266\203\202J \303\"\266\202\211\203U \211AB\202\201 \211@\262\211@\301=\203j \211AA?\262\202o \304!\262\205\201 \302\211AA\262\211A@\262#\207" [nil normal-state sgml-next-sub-and sgml-get-and-move sgml-final-and] 10 (#$ . 14264)])
#@159 Compute the next state, choosing from DFAS and moving by TOKEN.
If this is not possible, but all DFAS are final, move by TOKEN in NEXT.

(fn DFAS TOKEN NEXT)
(defalias 'sgml-next-sub-and #[771 "\300\301\211\211\203\200 \204\200 @\262\205 AA?\2629\203) \301\266\202\202b @\302=\203\\ \211A@\236\206= \211AA\236\211\205W \211A\211@\302=\203N \211\202U \303A@#\262\266\203\202b \304\"\266\202\262\211\205w \211\305\n\"BB\266\203\262A\262\202 \206\317 \205\317 9\203\226 \301\266\202\202\317 @\302=\203\311 \211A@\236\206\252 \211AA\236\211\205\304 \211A\211@\302=\203\273 \211\202\302 \303A@#\262\266\203\202\317 \304\"\266\202\207" [t nil normal-state sgml-next-sub-and sgml-get-and-move remq] 16 (#$ . 14706)])
#@14 

(fn MOVES)
(defalias 'sgml-tokens-of-moves #[257 "\300\301\"\207" [mapcar #[257 "\211@\207" [] 2 "\n\n(fn M)"]] 4 (#$ . 15471)])
(put 'sgml-tokens-of-moves 'byte-optimizer 'byte-compile-inline-expand)
#@14 

(fn STATE)
(defalias 'sgml-required-tokens #[257 "\211@\300=\203 \211AA\301\302\"\207\303\211@\262!\206T \211\211AA\262\304\211:\203? @\262AA\301\302\"\262\237\244\262A\262\202! \211\237\266\203\206T \211\211A@\262AA\301\302\"\262\207" [normal-state mapcar #[257 "\211@\207" [] 2 "\n\n(fn M)"] sgml-required-tokens nil] 8 (#$ . 15681)])
#@14 

(fn STATE)
(defalias 'sgml-optional-tokens #[257 "\211@\300=\203 \211A@\301\302\"\207\303\211@\262!\211@\262\211@\300=\203+ \211AA?\262\2020 \304!\262\205] \211AA\262\305\211:\203Y @\262A@\301\302\"\262\237\244\262A\262\202; \211\237\266\203\244\211AA\262\305\306:\203\200 @\262AA?\211\262\203\200 A\262\202f \211\205\205 \306\266\203\205\230 \211A@\262A@\301\302\"\262\244\207" [normal-state mapcar #[257 "\211@\207" [] 2 "\n\n(fn M)"] sgml-optional-tokens sgml-final-and nil t] 9 (#$ . 16044)])
#@37 

(fn NAME DCL-VALUE DEFAULT-VALUE)
(defalias 'sgml-make-attdecl #[771 "E\207" [] 6 (#$ . 16583)])
#@16 

(fn ATTDECL)
(defalias 'sgml-attdecl-name #[257 "\211@\207" [] 2 (#$ . 16691)])
#@136 The declared value of ATTDECL.
It may be a symbol or (name-token-group (NAME1 ... NAMEn))
or (notation  (NOT1 ... NOTn))

(fn ATTDECL)
(defalias 'sgml-attdecl-declared-value #[257 "\211A@\207" [] 2 (#$ . 16780)])
#@203 The default value of ATTDECL.
The default value is either a symbol (REQUIRED | IMPLIED | CURRENT |
CONREF) or a list with first element nil or symbol `FIXED' and second
element the value.

(fn ATTDECL)
(defalias 'sgml-attdecl-default-value #[257 "\211AA@\207" [] 2 (#$ . 17000)])
#@74 Return the attribute declaration for NAME in ATTLIST.

(fn NAME ATTLIST)
(defalias 'sgml-lookup-attdecl #[514 "\300\"\207" [assoc] 5 (#$ . 17286)])
#@91 Find the first attribute in ATTLIST that has DECLARED-VALUE.

(fn ATTLIST DECLARED-VALUE)
(defalias 'sgml-attribute-with-declared-value #[514 "\300\203 \211\204 \301@!\232\203 @\262A\262\202 \211\207" [nil sgml-attdecl-declared-value] 6 (#$ . 17442)])
#@160 Make a declared-value of TYPE.
TYPE should be a symbol.  If TYPE is name-token-group or notation
NAMES should be a list of symbols.

(fn TYPE &optional NAMES)
(defalias 'sgml-make-declared-value #[513 "\211:\203	 D\207\207" [] 4 (#$ . 17712)])
#@153 Return the name token group for the DECLARED-VALUE.
This applies to name token groups.  For other declared values nil is
returned.

(fn DECLARED-VALUE)
(defalias 'sgml-declared-value-token-group #[257 "\211:\205 \211@\300=\205 \211A@\207" [name-token-group] 3 (#$ . 17966)])
#@165 Return the list of notation names for the DECLARED-VALUE.
This applies to notation declared value.  For other declared values
nil is returned.

(fn DECLARED-VALUE)
(defalias 'sgml-declared-value-notation #[257 "\211:\205 \211@\300=\205 \211A@\207" [NOTATION] 3 (#$ . 18250)])
#@30 

(fn TYPE &optional ATTVAL)
(defalias 'sgml-make-default-value #[513 "\211\203 D\207\207" [] 4 (#$ . 18534)])
#@146 Return the actual default value of the declared DEFAULT-VALUE.
The actual value is a string.  Return nil if no actual value.

(fn DEFAULT-VALUE)
(defalias 'sgml-default-value-attval #[257 "\211:\205 \211A@\207" [] 2 (#$ . 18656)])
#@135 Return true if DEFAULT-VALUE is of TYPE.
Where TYPE is a symbol, one of REQUIRED, IMPLIED, CONREF, or FIXED.

(fn TYPE DEFAULT-VALUE)
(defalias 'sgml-default-value-type-p #[514 "=\206 \211:\205 @=\207" [] 4 (#$ . 18895)])
#@120 Create an attspec from NAME and ATTVAL.
Special case, if ATTVAL is nil this is an implied attribute.

(fn NAME ATTVAL)
(defalias 'sgml-make-attspec #[514 "B\207" [] 4 (#$ . 19130)])
#@16 

(fn ATTSPEC)
(defalias 'sgml-attspec-name #[257 "\211@\207" [] 2 (#$ . 19320)])
#@104 Return the value of attribute specification ATTSPEC.
If ATTSPEC is nil, nil is returned.

(fn ATTSPEC)
(defalias 'sgml-attspec-attval #[257 "\211A\207" [] 2 (#$ . 19409)])
#@17 

(fn NAME ASL)
(defalias 'sgml-lookup-attspec #[514 "\300\"\207" [assoc] 5 (#$ . 19587)])
#@14 

(fn MODEL)
(defalias 'sgml-model-group-p #[257 "\211:\207" [] 2 (#$ . 19686)])
(put 'sgml-model-group-p 'byte-optimizer 'byte-compile-inline-expand)
(defconst sgml-cdata 'CDATA)
(defconst sgml-rcdata 'RCDATA)
(defconst sgml-empty 'EMPTY)
(defconst sgml-any 'ANY)
#@39 

(fn PUBID SYSID &optional PUBID-OK)
(defalias 'sgml-make-extid #[770 "\203 \211\204 \203 \204 \302\303!\210	BB\207" [sgml-xml-p default-directory sgml-error "XML requires a system ID after a public ID"] 6 (#$ . 19957)])
#@14 

(fn EXTID)
(defalias 'sgml-extid-pubid #[257 "\211@\207" [] 2 (#$ . 20194)])
#@14 

(fn EXTID)
(defalias 'sgml-extid-sysid #[257 "\211A:\203\n \211A@\207\211A\207" [] 2 (#$ . 20279)])
#@49 Directory where EXTID was declared.

(fn EXTID)
(defalias 'sgml-extid-dir #[257 "\211A:\205	 \211AA\207" [] 2 (#$ . 20387)])
#@65 Expand file name FILE in the context of EXTID.

(fn FILE EXTID)
(defalias 'sgml-extid-expand #[514 "\301!B\302\"\206 \303\301!\")\207" [sgml-system-path sgml-extid-dir sgml-extid-expand-2 expand-file-name] 6 (#$ . 20518)])
#@25 

(fn FILE DIRECTORIES)
(defalias 'sgml-extid-expand-2 #[514 "\211\204 \300\207\301@\"\302!\203 \211\202 \303A\"\207" [nil expand-file-name file-exists-p sgml-extid-expand-2] 6 (#$ . 20755)])
#@73 compiler-macro for inlining `sgml-dtd-doctype'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-dtd-doctype--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-dtd-doctype (aref cl-x 0)) nil] 9 (#$ . 20961)])
(put 'sgml-dtd-doctype 'compiler-macro 'sgml-dtd-doctype--cmacro)
#@117 Access slot "doctype" of `(sgml-dtd (:type vector) (:constructor sgml-make-dtd (doctype)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-dtd-doctype #[257 "\211\300H\207" [0] 3 (#$ . 21275)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-dtd-doctype side-effect-free t] 4)
#@73 compiler-macro for inlining `sgml-dtd-eltypes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-dtd-eltypes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-dtd-eltypes (aref cl-x 1)) nil] 9 (#$ . 21561)])
(put 'sgml-dtd-eltypes 'compiler-macro 'sgml-dtd-eltypes--cmacro)
#@117 Access slot "eltypes" of `(sgml-dtd (:type vector) (:constructor sgml-make-dtd (doctype)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-dtd-eltypes #[257 "\211\300H\207" [1] 3 (#$ . 21875)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-dtd-eltypes side-effect-free t] 4)
#@76 compiler-macro for inlining `sgml-dtd-parameters'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-dtd-parameters--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-dtd-parameters (aref cl-x 2)) nil] 9 (#$ . 22161)])
(put 'sgml-dtd-parameters 'compiler-macro 'sgml-dtd-parameters--cmacro)
#@120 Access slot "parameters" of `(sgml-dtd (:type vector) (:constructor sgml-make-dtd (doctype)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-dtd-parameters #[257 "\211\300H\207" [2] 3 (#$ . 22490)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-dtd-parameters side-effect-free t] 4)
#@74 compiler-macro for inlining `sgml-dtd-entities'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-dtd-entities--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-dtd-entities (aref cl-x 3)) nil] 9 (#$ . 22785)])
(put 'sgml-dtd-entities 'compiler-macro 'sgml-dtd-entities--cmacro)
#@118 Access slot "entities" of `(sgml-dtd (:type vector) (:constructor sgml-make-dtd (doctype)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-dtd-entities #[257 "\211\300H\207" [3] 3 (#$ . 23104)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-dtd-entities side-effect-free t] 4)
#@75 compiler-macro for inlining `sgml-dtd-shortmaps'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-dtd-shortmaps--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-dtd-shortmaps (aref cl-x 4)) nil] 9 (#$ . 23393)])
(put 'sgml-dtd-shortmaps 'compiler-macro 'sgml-dtd-shortmaps--cmacro)
#@119 Access slot "shortmaps" of `(sgml-dtd (:type vector) (:constructor sgml-make-dtd (doctype)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-dtd-shortmaps #[257 "\211\300H\207" [4] 3 (#$ . 23717)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-dtd-shortmaps side-effect-free t] 4)
#@75 compiler-macro for inlining `sgml-dtd-notations'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-dtd-notations--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-dtd-notations (aref cl-x 5)) nil] 9 (#$ . 24009)])
(put 'sgml-dtd-notations 'compiler-macro 'sgml-dtd-notations--cmacro)
#@119 Access slot "notations" of `(sgml-dtd (:type vector) (:constructor sgml-make-dtd (doctype)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-dtd-notations #[257 "\211\300H\207" [5] 3 (#$ . 24333)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-dtd-notations side-effect-free t] 4)
#@78 compiler-macro for inlining `sgml-dtd-dependencies'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-dtd-dependencies--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-dtd-dependencies (aref cl-x 6)) nil] 9 (#$ . 24625)])
(put 'sgml-dtd-dependencies 'compiler-macro 'sgml-dtd-dependencies--cmacro)
#@122 Access slot "dependencies" of `(sgml-dtd (:type vector) (:constructor sgml-make-dtd (doctype)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-dtd-dependencies #[257 "\211\300H\207" [6] 3 (#$ . 24964)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-dtd-dependencies side-effect-free t] 4)
#@72 compiler-macro for inlining `sgml-dtd-merged'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-dtd-merged--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-dtd-merged (aref cl-x 7)) nil] 9 (#$ . 25265)])
(put 'sgml-dtd-merged 'compiler-macro 'sgml-dtd-merged--cmacro)
#@116 Access slot "merged" of `(sgml-dtd (:type vector) (:constructor sgml-make-dtd (doctype)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-dtd-merged #[257 "\211\300H\207" [7] 3 (#$ . 25574)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-dtd-merged side-effect-free t] 4)
#@80 compiler-macro for inlining `sgml-dtd-undef-entities'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-dtd-undef-entities--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-dtd-undef-entities (aref cl-x 8)) nil] 9 (#$ . 25857)])
(put 'sgml-dtd-undef-entities 'compiler-macro 'sgml-dtd-undef-entities--cmacro)
#@124 Access slot "undef-entities" of `(sgml-dtd (:type vector) (:constructor sgml-make-dtd (doctype)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-dtd-undef-entities #[257 "\211\300H\207" [8] 3 (#$ . 26206)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put sgml-dtd-undef-entities side-effect-free t defalias copy-sgml-dtd copy-sequence] 4)
#@167 compiler-macro for inlining `make-sgml-dtd'.

(fn CL-WHOLE &cl-quote &key DOCTYPE ELTYPES PARAMETERS ENTITIES SHORTMAPS NOTATIONS DEPENDENCIES MERGED UNDEF-ENTITIES)
(defalias 'make-sgml-dtd--cmacro #[385 "\300\301\"A@\300\302\"\206 \303A@\300\304\"\206 \305A@\300\306\"\206\" \307A@\300\310\"\206, \311A@\300\312\"A@\300\313\"A@\300\314\"A@\300	\315\"A@	\211\203w \211@\316>\203_ \211AA\262\202L \317>A@\203n \320\262\202L \321\322@\"\210\202L \210\323\324\325\320\320&\207" [plist-member :doctype :eltypes (nil (sgml-make-eltype-table)) :parameters (nil (sgml-make-entity-table)) :entities (nil (sgml-make-entity-table)) :shortmaps (nil (sgml-make-shortref-table)) :notations :dependencies :merged :undef-entities (:doctype :eltypes :parameters :entities :shortmaps :notations :dependencies :merged :undef-entities :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:doctype :eltypes :parameters :entities :shortmaps :notations :dependencies :merged :undef-entities)" cl--defsubst-expand (doctype eltypes parameters entities shortmaps notations dependencies merged undef-entities) (cl-block make-sgml-dtd (vector doctype eltypes parameters entities shortmaps notations dependencies merged undef-entities))] 26 (#$ . 26561)])
(put 'make-sgml-dtd 'compiler-macro 'make-sgml-dtd--cmacro)
#@147 Constructor for objects of type `sgml-dtd'.

(fn &key DOCTYPE ELTYPES PARAMETERS ENTITIES SHORTMAPS NOTATIONS DEPENDENCIES MERGED UNDEF-ENTITIES)
(defalias 'make-sgml-dtd #[128 "\300\301\"A@\300\302\"\206 \303\304 DA@\300\305\"\206 \303\306 DA@\300\307\"\206+ \303\306 DA@\300\310\"\2068 \303\311 DA@\300\312\"A@\300\313\"A@\300\314\"A@\300	\315\"A@	\211\203\203 \211@\316>\203k \211AA\262\202X \317>A@\203z \303\262\202X \320\321@\"\210\202X \210\322									&	\207" [plist-member :doctype :eltypes nil sgml-make-eltype-table :parameters sgml-make-entity-table :entities :shortmaps sgml-make-shortref-table :notations :dependencies :merged :undef-entities (:doctype :eltypes :parameters :entities :shortmaps :notations :dependencies :merged :undef-entities :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:doctype :eltypes :parameters :entities :shortmaps :notations :dependencies :merged :undef-entities)" vector] 20 (#$ . 27925)])
#@73 compiler-macro for inlining `sgml-make-dtd'.

(fn CL-WHOLE-ARG DOCTYPE)
(defalias 'sgml-make-dtd--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (doctype) (cl-block sgml-make-dtd (vector doctype (sgml-make-eltype-table) (sgml-make-entity-table) (sgml-make-entity-table) (sgml-make-shortref-table) nil nil nil nil)) nil] 9 (#$ . 28922)])
(put 'sgml-make-dtd 'compiler-macro 'sgml-make-dtd--cmacro)
#@59 Constructor for objects of type `sgml-dtd'.

(fn DOCTYPE)
(defalias 'sgml-make-dtd #[257 "\300\301 \302 \302 \303 \304\211\211\211&	\207" [vector sgml-make-eltype-table sgml-make-entity-table sgml-make-shortref-table nil] 11 (#$ . 29347)])
(byte-code "\300\301\302\211\303\302\304\305\301\302&	\207" [cl-struct-define sgml-dtd nil vector ((doctype) (eltypes (sgml-make-eltype-table)) (parameters (sgml-make-entity-table)) (entities (sgml-make-entity-table)) (shortmaps (sgml-make-shortref-table)) (notations nil) (dependencies nil) (merged nil) (undef-entities nil)) cl-struct-sgml-dtd-tags] 10)
#@11 

(fn ET)
(defalias 'sgml-eltype-name #[257 "\300!\207" [symbol-name] 3 (#$ . 29950)])
(put 'sgml-eltype-name 'byte-optimizer 'byte-compile-inline-expand)
#@11 

(fn ET)
(defalias 'sgml-eltype-defined #[257 "\300!\207" [fboundp] 3 (#$ . 30112)])
(put 'sgml-eltype-defined 'byte-optimizer 'byte-compile-inline-expand)
#@47 Return a token for the element type.

(fn ET)
(defalias 'sgml-eltype-token #[257 "\207" [] 2 (#$ . 30276)])
(put 'sgml-eltype-token 'byte-optimizer 'byte-compile-inline-expand)
#@61 Return the element type corresponding to TOKEN.

(fn TOKEN)
(defalias 'sgml-token-eltype #[257 "\207" [] 2 (#$ . 30459)])
(put 'sgml-token-eltype 'byte-optimizer 'byte-compile-inline-expand)
#@20 

(fn &rest NAMES)
(defalias 'sgml-prop-fields '(macro . #[128 "\300\301\211:\203+ @\262\302\303\304\305\"!\306\307\310\311\312\211	DDFFB\262A\262\202 \211\237\266\203B\207" [progn nil defmacro intern format "sgml-eltype-%s" (et) list 'get et quote] 14 (#$ . 30656)]))
#@11 

(fn ET)
(defalias 'sgml-eltype-attlist '(macro . #[257 "\300\301E\207" [get 'attlist] 4 (#$ . 30942)]))
#@11 

(fn ET)
(defalias 'sgml-eltype-includes '(macro . #[257 "\300\301E\207" [get 'includes] 4 (#$ . 31055)]))
#@11 

(fn ET)
(defalias 'sgml-eltype-excludes '(macro . #[257 "\300\301E\207" [get 'excludes] 4 (#$ . 31170)]))
#@11 

(fn ET)
(defalias 'sgml-eltype-shortmap '(macro . #[257 "\300\301E\207" [get 'shortmap] 4 (#$ . 31285)]))
#@11 

(fn ET)
(defalias 'sgml-eltype-flags '(macro . #[257 "\300D\207" [symbol-value] 3 (#$ . 31400)]))
#@11 

(fn ET)
(defalias 'sgml-eltype-model #[257 "\301!\203	 \211K\207\207" [sgml-any fboundp] 3 (#$ . 31507)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-eltype-model gv-expander #[385 "\300\301\302$\207" [gv--defsetter sgml-eltype-model #[385 "\300\301C\"B\207" [fset append] 6 "\n\n(fn VAL &rest ARGS)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@11 

(fn ET)
(defalias 'sgml-eltype-stag-optional #[257 "\300J\301\"\301U\207" [logand 1] 4 (#$ . 31870)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-eltype-stag-optional gv-expander #[385 "\300\301\302$\207" [gv--defsetter sgml-eltype-stag-optional #[514 "\300\301F\207" [sgml-set-eltype-flag 1] 6 "\n\n(fn F ET)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@11 

(fn ET)
(defalias 'sgml-eltype-etag-optional #[257 "\300J\301\"\302U?\207" [logand 2 0] 4 (#$ . 32242)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-eltype-etag-optional gv-expander #[385 "\300\301\302$\207" [gv--defsetter sgml-eltype-etag-optional #[514 "\300\301F\207" [sgml-set-eltype-flag 2] 6 "\n\n(fn F ET)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@11 

(fn ET)
(defalias 'sgml-eltype-mixed #[257 "\300JW\207" [3] 3 (#$ . 32617)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put sgml-eltype-mixed gv-expander #[385 "\300\301\302$\207" [gv--defsetter sgml-eltype-mixed #[514 "\300\301F\207" [sgml-set-eltype-flag 4] 6 "\n\n(fn F ET)"]] 7 "\n\n(fn DO &rest ARGS)"] put byte-optimizer byte-compile-inline-expand] 5)
#@18 

(fn ET MASK F)
(defalias 'sgml-set-eltype-flag #[771 "\211\300\301\302!\203 J\202 \303\304!\"\203 \202  \303\"L\207" [logior logand boundp 0 lognot] 10 (#$ . 33007)])
#@21 

(fn SYM PROP VAL)
(defalias 'sgml-maybe-put #[771 "\211\205	 \300#\207" [put] 7 (#$ . 33194)])
(byte-code "\300\301\302\303#\300\304\302\305#\300\207" [function-put sgml-eltype-includes gv-expander #[385 "\300\301\302$\207" [gv--defsetter sgml-eltype-includes #[514 "\300\301F\207" [sgml-maybe-put 'includes] 6 "\n\n(fn L ET)"]] 7 "\n\n(fn DO &rest ARGS)"] sgml-eltype-excludes #[385 "\300\301\302$\207" [gv--defsetter sgml-eltype-excludes #[514 "\300\301F\207" [sgml-maybe-put 'excludes] 6 "\n\n(fn L ET)"]] 7 "\n\n(fn DO &rest ARGS)"]] 5)
#@213 Get application data from element type ET with name PROP.
PROP should be a symbol, reserved names are: flags, model, attlist,
includes, excludes, conref-regexp, mixed, stag-optional, etag-optional.

(fn ET PROP)
(defalias 'sgml-eltype-appdata '(macro . #[514 "\300E\207" [get] 5 (#$ . 33755)]))
#@11 

(fn ET)
(defalias 'sgml-eltype-all-miscdata #[257 "\300!\301:\203# @\302>\204 @A@D\237\244\262AA\262\202 \211\237\207" [symbol-plist nil (model flags includes excludes)] 5 (#$ . 34058)])
#@20 

(fn ET MISCDATA)
(defalias 'sgml-eltype-set-all-miscdata #[514 "\300\301!\244\"\207" [setplist symbol-plist] 7 (#$ . 34264)])
#@13 

(fn NAME)
(defalias 'sgml-make-eltype #[257 "\300!\211\211\301L\266\211\207" [make-symbol 0] 5 (#$ . 34402)])
#@39 Make an empty table of element types.
(defalias 'sgml-make-eltype-table #[0 "\300\301\302\"\207" [make-vector 73 0] 3 (#$ . 34522)])
#@21 

(fn ELTYPE-TABLE)
(defalias 'sgml-eltype-table-empty #[257 "\211\300\301\302T\211\262GW\203 H\262\303=\211\262\204 \211\205\" \302\207" [-1 nil t 0] 7 (#$ . 34661)])
#@165 Return the merge of two element type tables ELTYPES1 and ELTYPES2.
This may change ELTYPES1, ELTYPES2 is unchanged.  Returns the new table.

(fn ELTYPES1 ELTYPES2)
(defalias 'sgml-merge-eltypes #[514 "\300!\203 \207\301\302\303\304\305\306!\307\"\310\311%\"\210\207" [sgml-eltype-table-empty mapatoms make-byte-code 257 "\301\302!\300\"\303!\204\" \303!\203 \211KM\210\304!\203\" \211JL\210\211\305\306!\307\306!!\244\"\262\207" vconcat vector [intern symbol-name fboundp boundp setplist symbol-plist copy-sequence] 9 "\n\n(fn SYM)"] 9 (#$ . 34846)])
#@75 Lookup the element definition for NAME (string).

(fn NAME &optional DTD)
(defalias 'sgml-lookup-eltype #[513 "\301\206 \302H\"\207" [sgml-dtd-info intern 1] 6 (#$ . 35421)])
#@79 Make a completion table from a list, ELTYPES, of element types.

(fn ELTYPES)
(defalias 'sgml-eltype-completion-table #[257 "\211\300\211\211:\203) @\262\301!\262\262\302!\203\" \211BB\262A\262\202 \211\237\207" [nil symbol-name boundp] 8 (#$ . 35606)])
#@241 Read an element type name.
PROMPT is displayed as a prompt and DTD should be the dtd to get the
element types from.  Optional argument DEFAULT (string) will be used as
a default for the element type name.

(fn PROMPT DTD &optional DEFAULT)
(defalias 'sgml-read-element-type #[770 "\303\304H\n\203 \305\202 \306\n?$)\211\307\232\203# \206! \310\311!\262\312\"\207" [sgml-namecase-general completion-ignore-case sgml-dtd-less completing-read 1 symbolp fboundp "" error "Aborted" sgml-lookup-eltype] 8 (#$ . 35881)])
#@37 

(fn FN DTD &optional COLLECT ALL)
(defalias 'sgml-map-eltypes #[1026 "\300C\301\203 \203 \302\303\304\305\306\n\"\307\"\310\311%\202H \2033 \302\303\312\305\306\n\"\313\"\310\311%\202H \203; \202H \302\303\314\305\306\n!\315\"\316\311%\317H\"\210\211\242\237\207" [nil mapatoms make-byte-code 257 "\301\300!\301\242B\240\207" vconcat vector [] 4 "\n\n(fn A)" "\302!\205 \301\300!\301\242B\240\207" [boundp] "\301!\205	 \300!\207" [boundp] 3 1] 13 (#$ . 36411)])
#@11 

(fn CH)
(defalias 'sgml-char-int '(macro . #[257 "\300\301!\203\n \301D\207\207" [fboundp char-int] 3 (#$ . 36902)]))
(defalias 'sgml-read-octet #[0 "g\300u\210\207" [nil] 2])
(put 'sgml-read-octet 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-read-peek #[0 "g\207" [] 1])
(put 'sgml-read-peek 'byte-optimizer 'byte-compile-inline-expand)
#@130 Read a number.
A number is 1: an octet [0--sgml-max-single-octet-number]
or 2: two octets (n,m) interpreted as  (n-t-1)*256+m+t.
(defalias 'sgml-read-number #[0 "gV\203 \301g\302u\210\303Z\304_g\302u\210#\207g\302u\210\207" [sgml-max-single-octet-number + nil 251 256] 4 (#$ . 37266)])
(put 'sgml-read-number 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-read-sexp #[0 "p\301 )\302\303w\210\304u\210\207" [standard-input read " 	" nil 1] 3])
(defalias 'sgml-read-token #[0 "g	V\203 \302g\303u\210\304Z\305_g\303u\210	#\202 g\303u\210H\207" [sgml-read-token-vector sgml-max-single-octet-number + nil 251 256] 5])
(put 'sgml-read-token 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-read-node-ref #[0 "g\301u\210H\207" [sgml-read-nodes nil] 3])
(put 'sgml-read-node-ref 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-read-model-seq #[0 "gV\203 \301g\302u\210\303Z\304_g\302u\210#\202 g\302u\210\302S\211\262\305Y\2030 \306 B\262\202 \211\237\207" [sgml-max-single-octet-number + nil 251 256 0 sgml-read-model] 4])
(defalias 'sgml-read-token-seq #[0 "gV\203 \302g\303u\210\304Z\305_g\303u\210#\202 g\303u\210\303S\211\262\306Y\203L 	gV\203@ \302g\303u\210\304Z\305_g\303u\210#\202D g\303u\210HB\262\202 \211\237\207" [sgml-max-single-octet-number sgml-read-token-vector + nil 251 256 0] 7])
(defalias 'sgml-read-moves #[0 "gV\203 \303g\304u\210\305Z\306_g\304u\210#\202 g\304u\210\304S\211\262\307Y\203S 	gV\203@ \303g\304u\210\305Z\306_g\304u\210#\202D g\304u\210H\ng\304u\210HBB\262\202 \211\237\207" [sgml-max-single-octet-number sgml-read-token-vector sgml-read-nodes + nil 251 256 0] 7])
(defalias 'sgml-read-model #[0 "gV\203 \302g\303u\210\304Z\305_g\303u\210#\202 g\303u\210\306\303\"\307W\2039 	\310\303\211BBI\210T\262\202# \266	\311\303T\211\262GW\203\201 H\262g\312=\203n g\303u\266\211\211	g\303u\210H\240\266\211\211\313 \241\266\202> \211\211A\314 \240\266\211\211A\314 \241\266\202> \266	\307H)\207" [sgml-max-single-octet-number sgml-read-nodes + nil 251 256 make-vector 0 normal-state -1 255 sgml-read-model-seq sgml-read-moves] 9])
(defalias 'sgml-read-content #[0 "g\304u\210\211\305=\203 \202> \211\306=\203 	\202> \211\307=\203\" \n\202> \211\310=\203, \202> \211\311=\2036 \304\202> \211\312=\205> \313 \207" [sgml-cdata sgml-rcdata sgml-empty sgml-any nil 0 1 2 3 4 128 sgml-read-model] 3])
#@18 

(fn FLAG MASK)
(defalias 'sgml-read-decode-flag #[514 "\300\"\301U?\207" [logand 0] 5 (#$ . 39695)])
#@11 

(fn ET)
(defalias 'sgml-read-element #[257 "\300\301 \"\210g\302u\210\211\303U?\2050 \211L\266\211\304 M\266\305\306\307 #\266\305\310\307 #\262\207" [sgml-eltype-set-all-miscdata sgml-read-sexp nil 128 sgml-read-content sgml-maybe-put includes sgml-read-token-seq excludes] 7 (#$ . 39806)])
#@57 Decode the saved DTD in current buffer, return the DTD.
(defalias 'sgml-read-dtd #[0 "\301]\302 \303\304\232\203 \305 \262\202 \306\307\"\210)\207" [gc-cons-threshold 500000 sgml-read-sexp nil (sgml-saved-dtd-version 7) sgml-bdtd-read-dtd error "Unknown file format for saved DTD: %s"] 6 (#$ . 40118)])
#@40 Load a saved DTD from FILE.

(fn FILE)
(defalias 'sgml-load-dtd #[257 "\305\306\307\310\311\312\313\314\315!\316\"\317\320%\321	B\"\"@\211\204! \322\323\"\210p\305\211\324 \211\203B \204B \211@q\210\232\203; p\262\211A\262\202& \203] \325\n!>\204U \326\327\330\nD\"\210\n\331H\262\202w q\210\332!\210\333\334\"\210\335 \262\333\336\"\210\337 \210q\210\340!\210\211\266\204\207" [sgml-loaded-dtd sgml-system-path sgml-buffer-parse-state cl-struct-sgml-pstate-tags sgml-default-dtd-file nil apply nconc mapcar make-byte-code 257 "\301\300\"\302!\205\f \211C\207" vconcat vector [expand-file-name file-exists-p] 4 "\n\n(fn DIR)" "." error "Saved DTD file %s not found" buffer-list type-of signal wrong-type-argument sgml-pstate 1 sgml-push-to-entity message "Loading DTD from %s..." sgml-read-dtd "Loading DTD from %s...done" sgml-pop-entity sgml-set-initial-state] 10 (#$ . 40435) (byte-code "\301\206 \300 !\302\303\304!\305\306!%C\207" [sgml-default-dtd-file expand-file-name read-file-name "Load DTD from: " file-name-directory t file-name-nondirectory] 8)])
#@242 Load the compiled dtd from CFILE into the current buffer.
If this file does not exist, is of an old version or out of date, a
new compiled dtd will be created from file DTDFILE and parameter entity
settings in ENTS.

(fn CFILE DTDFILE ENTS)
(defalias 'sgml-bdtd-load #[771 "\203	 \303\304\"\210\305\306!\210\307!\203@ \310\311\306\211\211$)\203@ \312 \313\232\203@ \314\312 \"\206E \n\315=\203; \316\317!?\202= \n?\206E \320#\207" [sgml-debug coding-system-for-read sgml-recompile-out-of-date-cdtd message "Trying to load compiled DTD from %s..." sgml-set-buffer-multibyte nil file-readable-p binary insert-file-contents sgml-read-sexp (sgml-saved-dtd-version 7) sgml-up-to-date-p ask y-or-n-p "Compiled DTD is out of date, recompile? " sgml-compile-dtd] 8 (#$ . 41535)])
#@158 Check if FILE is newer than all files in the list DEPENDENCIES.
If DEPENDENCIES contains the symbol t, FILE is not considered newer.

(fn FILE DEPENDENCIES)
(defalias 'sgml-up-to-date-p #[514 "\300>?\205+ \211\301\300:\203$ @\262\302\"\211\262\203$ A\262\202\n \211\205) \300\266\203\207" [t nil file-newer-than-file-p] 8 (#$ . 42323)])
#@288 Construct a binary code compiled dtd from DTD-FILE and write it to TO-FILE.
The dtd will be constructed with the parameter entities set according
to ENTS.  The bdtd will be left in the current buffer.  The current
buffer is assumed to be empty to start with.

(fn DTD-FILE TO-FILE ENTS)
(defalias 'sgml-compile-dtd #[771 "\303\304\"\210\305\306\307 \310 \310 \311 \306\211\211\211&	\211\312H\313\211\314\314HBI\266\306\211:\203I @\262\211A\262\242\262\315\316$\210A\262\202* \266\317!\210\320 \210\n\203Z \303\321!\210\322 \210\323 \210\324\"\210*\313\207" [sgml-dtd-info sgml-parsing-dtd sgml-debug message "Recompiling DTD file %s..." vector nil sgml-make-eltype-table sgml-make-entity-table sgml-make-shortref-table 2 t 6 sgml-entity-declare text sgml-push-to-entity sgml-check-dtd-subset "sgml-compile-dtd: poping entity" sgml-pop-entity erase-buffer sgml-write-dtd] 14 (#$ . 42676)])
#@70 Check that PARAMS1 is compatible with PARAMS2.

(fn PARAMS1 PARAMS2)
(defalias 'sgml-check-entities #[514 "\3002 \301\302\303\304\305\306!\307\"\310\311%\"\210\3120\207" [--cl-block-check-entities-- sgml-map-entities make-byte-code 257 "\301@\300\"\211?\206 \232?\205\" \302\303@\3048\3048$\210\305\306\307\"\207" vconcat vector [sgml-lookup-entity message "Parameter %s in compiled DTD has wrong value; is '%s' should be '%s'" 2 throw --cl-block-check-entities-- nil] 8 "\n\n(fn ENTITY)" t] 9 (#$ . 43595)])
#@177 Merge the binary coded dtd in the current buffer with the current dtd.
The current dtd is the variable `sgml-dtd-info'.  Return t if the merge
was successful or nil if failed.
(defalias 'sgml-bdtd-merge #[0 "eb\210\305 \210\305 \305 \306]\307\310	\311H\"\205\322 \312\313!\210\314	\311H\"\210	\211\315	\315H\244I\266\305 \262\211\203E 	\316H\204E 	\211\316I\266g\nV\203] \317g\307u\210\320Z\321_g\307u\210\n#\202a g\307u\210\262\322T\307\"\211\316\fI\210\323X\203\205 \324\305 !I\210T\262\202p \266\323g\nV\203\240 \317g\307u\210\320Z\321_g\307u\210\n#\202\244 g\307u\210X\203\267 \325H!\210T\262\202\244 \266\314	\326H\305 \"\210\327	\330H\305 \"\210	\211\331\305 I\266\332)\207" [gc-cons-threshold sgml-dtd-info sgml-max-single-octet-number sgml-read-token-vector sgml-pcdata-token sgml-read-sexp 500000 nil sgml-check-entities 2 sgml-message "Reading compiled DTD..." sgml-merge-entity-tables 6 0 + 251 256 make-vector 1 sgml-lookup-eltype sgml-read-element 3 sgml-merge-shortmaps 4 5 t] 11 (#$ . 44123)])
#@74 Create and return a dtd from the binary coded dtd in the current buffer.
(defalias 'sgml-bdtd-read-dtd #[0 "\301\302\303 \304 \304 \305 \302\211\211\211&	\306 \210)\207" [sgml-dtd-info vector nil sgml-make-eltype-table sgml-make-entity-table sgml-make-shortref-table sgml-bdtd-merge] 10 (#$ . 45168)])
#@142 Set the type of the markup parsed to TYPE.
The markup starts at position given by variable `sgml-markup-start' and
ends at point.

(fn TYPE)
(defalias 'sgml-set-markup-type #[257 "\203 	\204 \304\n`#\210\211\211\207" [sgml-set-face sgml-current-eref sgml-markup-start sgml-markup-type sgml-set-face-for] 5 (#$ . 45479)])
(put 'sgml-set-markup-type 'byte-optimizer 'byte-compile-inline-expand)
(defvar sgml-delimiters '("AND" "&" "COM" "--" "CRO" "&#" "DSC" "]" "DSO" "[" "DTGC" "]" "DTGO" "[" "ERO" "&" "ETAGO" "</" "GRPC" ")" "GRPO" "(" "LIT" "\"" "LITA" "'" "MDC" ">" "MDO" "<!" "MINUS" "-" "MSC" "]]" "NESTC" "/" "NET" "/" "OPT" "?" "OR" "|" "PERO" "%" "PIC" ">" "PIO" "<?" "PLUS" "+" "REFC" ";" "REP" "*" "RNI" "#" "SEQ" "," "STAGO" "<" "TAGC" ">" "VI" "=" "MS-START" "<![" "MS-END" "]]>" "XML-ECOM" "-->" "XML-PIC" "?>" "XML-SCOM" "<!--" "XML-TAGCE" "/>" "NULL" ""))
#@14 

(fn DROLE)
(defalias 'sgml-get-delim-string #[257 "\211\235A@\207" [sgml-delimiters] 3 (#$ . 46362)])
#@14 

(fn DROLE)
(defalias 'sgml-delim '(macro . #[257 "\211;\203\n \300\226!\207\300D\207" [sgml-get-delim-string] 3 (#$ . 46473)]))
#@667 Macro for matching delimiters.
Syntax: DELIM &optional CONTEXT MOVE
where DELIM is the delimiter name (string or symbol),
CONTEXT the contextual constraint, and
MOVE is `nil', `move' or `check'.

Test if the text following point in current buffer matches the SGML
delimiter DELIM.  Also check the characters after the delimiter for
CONTEXT.  Applicable values for CONTEXT is
`gi' -- name start or TAGC if SHORTTAG YES,
`com' -- if COM or MDC,
`nmstart' -- name start character,
`stagc' -- TAGC if SHORTTAG YES,
`digit' -- any Digit,
string -- delimiter with that name,
list -- any of the contextual constraints in the list.

(fn DELIM &optional CONTEXT MOVE OFFSET)
(defalias 'sgml-is-delim '(macro . #[1025 "\211\204 \300\262\301\302\"\226\262\303!\211\204 \304\305!\210\306=\203% \307\262\202D \310=\2031 \311\262\202D \204; \312\262\202D <\204D C\262\313\314\315\300G\316W\203h \317H\320\\DEB\262T\262\202K \211\237\266\203\321\316\211:\203\333 @\262\322=\203\216 \323\321\320GD\324BBD\202\320 \325=\203\243 \314\326\327\330\316\211G\257E\202\320 \331=\203\265 \332\320\nGD\333BB\202\320 ;\203\306 \327\316\211\fG\257\202\320 \334=\206\320 \335\336\"B\262A\262\202q \211\237\266\203BC\"B\337\315\205\357 \340GDC\341=?\205\370 \342\"B\341=\205\343DCBBB\207" [0 format "%s" sgml-get-delim-string cl--assertion-failed ds gi (nmstart stagc) com ("COM" "MDC") (t) if and append nil eq sgml-following-char or nmstart sgml-startnm-char (0) stagc sgml-current-shorttag sgml-is-delim "TAGC" digit memq ('(48 49 50 51 52 53 54 55 56 57)) t error "Context type: %s" progn forward-char check (t) sgml-delimiter-parse-error] 20 (#$ . 46612)]))
(put 'sgml-is-delim 'edebug-form-spec '(sexp &optional sexp sexp sexp))
#@10 

(fn N)
(defalias 'sgml-following-char '(macro . #[257 "\211\300U\203 \301\207\211\302U\203 \303\207\304\305\306BBD\207" [0 (following-char) 1 (char-after (1+ (point))) char-after + ((point))] 5 (#$ . 48386)]))
#@14 

(fn DELIM)
(defalias 'sgml-delimiter-parse-error #[257 "\300\301\302!#\207" [sgml-parse-error "Delimiter %s (%s) expected" sgml-get-delim-string] 6 (#$ . 48607)])
#@32 

(fn DELIM &optional CONTEXT)
(defalias 'sgml-parse-delim '(macro . #[513 "\300\301BBB\207" [sgml-is-delim (move)] 6 (#$ . 48780)]))
(put 'sgml-parse-delim 'edebug-form-spec '(sexp &optional sexp))
#@32 

(fn DELIM &optional CONTEXT)
(defalias 'sgml-check-delim '(macro . #[513 "\300\301BBB\207" [sgml-is-delim (check)] 6 (#$ . 48987)]))
(put 'sgml-check-delim 'edebug-form-spec '(sexp sexp))
#@287 Skip until the delimiter or first char of one of the delimiters.
If DELIM is a string/symbol this is should be a delimiter role.
Characters are skipped until the delimiter is recognized.
If DELIM is a list of delimiters, skip until a character that is first
in any of them.

(fn DELIM)
(defalias 'sgml-skip-upto '(macro . #[257 "\211:\203I \301\302\303\304:\203D @\262\211\305\306\"\226\235\211\204# \307\310!\210\211A@\311\312O\211\313\235\2035 \314P\2026 \211\262\262P\262A\262\202\n \266\202PD\207\315\305\306\"\226!\211G\312U\203_ \301\302PD\202j \316\317\320BB\321GDE\207" [sgml-delimiters skip-chars-forward "^" nil "" format "%s" cl--assertion-failed ds 0 1 ("-" "\\") "\\" sgml-get-delim-string and search-forward (nil t) backward-char] 11 (#$ . 49186)]))
(put 'sgml-skip-upto 'edebug-form-spec '(sexp))
#@13 

(fn CHAR)
(defalias 'sgml-parse-char '(macro . #[257 "\300\301\302BB\303BD\207" [cond eq ((following-char)) ((forward-char 1) t)] 5 (#$ . 50020)]))
#@82 Parse two or three chars; return nil if can't.

(fn CHAR1 CHAR2 &optional CHAR3)
(defalias 'sgml-parse-chars '(macro . #[770 "\211\204 \300\301\302\303BB\302\304BBE\305BD\207\300\301\302\306BB\302\307BB\302\310BBF\311BD\207" [cond and eq ((following-char)) ((char-after (1+ (point)))) ((forward-char 2) t) ((following-char)) ((char-after (1+ (point)))) ((char-after (1+ (1+ (point))))) ((forward-char 3) t)] 10 (#$ . 50177)]))
#@13 

(fn CHAR)
(defalias 'sgml-check-char #[257 "\211g=\205\n \300u\210\301?\205 \302\303\"\207" [1 t sgml-parse-error "Expecting %c"] 4 (#$ . 50616)])
(defalias 'sgml-parse-RE #[0 "g\300=\203 \301u\210\302\207g\303=\205 \301u\210\302\207" [10 1 t 13] 2])
#@10 

(fn C)
(defalias 'sgml-startnm-char '(macro . #[257 "\300\301\302DE\207" [eq 119 char-syntax] 5 (#$ . 50879)]))
(defalias 'sgml-startnm-char-next #[0 "m?\205	 gz\300=\207" [119] 2])
(put 'sgml-startnm-char-next 'byte-optimizer 'byte-compile-inline-expand)
#@10 

(fn C)
(defalias 'sgml-name-char #[257 "\211\205 \211z\300=\206 \211z\301=\207" [119 95] 3 (#$ . 51144)])
(defalias 'sgml-is-end-tag #[0 "g\301=\205* `Tf\302=\205* \303`\\f\206 \304z\305=\204) \205* \303`\\f\306=\205* \307\207" [sgml-current-shorttag 60 47 2 0 119 62 t] 2])
(defalias 'sgml-is-enabled-net #[0 "g\302=\205 \205 	\303H\207" [sgml-current-shorttag sgml-current-tree 47 12] 2])
(put 'sgml-is-enabled-net 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-is-start-tag #[0 "g\301=\205  `Tf\206 \302z\303=\204 \205  `Tf\304=\205  \305\207" [sgml-current-shorttag 60 0 119 62 t] 2])
#@27 

(fn &optional SHORTMAP)
(defalias 'sgml-parse-s #[256 "\211\203, \300\301w\302U?\2062 \303\301w\302U?\2062 g\304=\203! \305u\210\306\207g\307=\205+ \305u\210\306\207\310\301w\302U?\207" [" " nil 0 "	" 10 1 t 13 " 	\n"] 3 (#$ . 51765)])
(put 'sgml-parse-s 'byte-optimizer 'byte-compile-inline-expand)
#@33 

(fn &optional IN-DECLARATION)
(defalias 'sgml-parse-processing-instruction #[256 "g\300=\205 `Tf\301=\205 \302u\210\303!\207" [60 63 2 sgml-do-processing-instruction] 3 (#$ . 52074)])
(put 'sgml-parse-processing-instruction 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn STRING)
(defalias 'sgml-entity-case '(macro . #[257 "\207" [] 2 (#$ . 52354)]))
#@15 

(fn STRING)
(defalias 'sgml-general-case #[257 "\203 \211\226\207\207" [sgml-current-namecase-general] 2 (#$ . 52446)])
#@16 

(fn FLAGSYM)
(defalias 'sgml-parse-set-appflag #[257 "\300\211m?\205 gz\301=\205 \302\303`\304\305!\210`\"!\262\203s \306!\262\211\307\310#\266\311\312#\210\300\211\203g \313\300w\314U?\206m \315\300w\314U?\206m g\316=\203X \317u\210\310\262\202o g\320=\205b \317u\210\310\262\202o \321\300w\314U?\262\210\202 \300\207" [nil 119 sgml-general-case buffer-substring-no-properties skip-syntax-forward "w_" sgml-lookup-eltype put t message "Defining element %s as %s" " " 0 "	" 10 1 13 " 	\n"] 9 (#$ . 52576)])
#@23 

(fn IN-DECLARATION)
(defalias 'sgml-do-processing-instruction #[257 "`g\306=\205\n \307\310!\203 \311\312\313\314#\203  \315u\210\202  \316\313w\210`\203@ g\317=\2039 `Tf\320=\2039 \321u\210\202P \322\323!\210\202P g\320=\203L \324u\210\202P \322\325!\210`\203` b\210\326\"\210\202k 	\203k 	\327\"!\210\211b\266\211\204\207 \330\n\203\202 \204\202 \331\f`#\210\211\211\266\314\207" [sgml-xml-p sgml-pi-function sgml-set-face sgml-current-eref sgml-markup-start sgml-markup-type 80 looking-at "PSGML +\\(\\sw+\\) *" search-forward "?>" nil t -2 "^>" 63 62 2 sgml-delimiter-parse-error "XML-PIC" 1 "PIC" sgml--pi-psgml-handler buffer-substring-no-properties pi sgml-set-face-for] 9 (#$ . 53108)])
#@27 

(fn IN-DECLARATION END)
(defalias 'sgml--pi-psgml-handler #[514 "\204 \2056 \214`}\210\301\302!\227\303\304\"\305\225b\210\211\203$ \306A!\2023 \307\232\203/ \310 \2023 \311\312\"\266\202)\207" [sgml-psgml-pi-enable-outside-dtd match-string 1 assoc (("nofill" . nofill) ("breakafter" . break-after-stag) ("breakbefore" . break-before-stag) ("structure" . structure)) 0 sgml-parse-set-appflag "element" sgml--pi-element-handler sgml-log-warning "Unknown processing instruction for PSGML: %s"] 7 (#$ . 53825)])
(defalias 'sgml--pi-element-handler #[0 "\300\211\2035 \301\300w\302U?\206; \303\300w\302U?\206; g\304=\203& \305u\210\306\262\202= g\307=\2050 \305u\210\306\262\202= \310\300w\302U?\262\210\311m?\205U gz\312=\205U \313\314`\315\316!\210`\"!!\300\211\211\211\203\215 \301\300w\302U?\206\223 \303\300w\302U?\206\223 g\304=\203~ \305u\210\306\262\202\225 g\307=\205\210 \305u\210\306\262\202\225 \310\300w\302U?\262\210m?\205\254 gz\312=\205\254 \313\314`\315\316!\210`\"!\211\262\205\240\300\211\203\347 \301\300w\302U?\206\355 \303\300w\302U?\206\355 g\304=\203\330 \305u\210\306\262\202\357 g\307=\205\342 \305u\210\306\262\202\357 \310\300w\302U?\262\210g\317=\203J\305u\210\300\211\203.\301\300w\302U?\2064\303\300w\302U?\2064g\304=\203\305u\210\306\262\2026g\307=\205)\305u\210\306\262\2026\310\300w\302U?\262\210\320\321!\203B\322 \202E\323p!\262\202M\306\262\324\325#\210\326\227!\327#\266\300\211\203\224\301\300w\302U?\206\232\303\300w\302U?\206\232g\304=\203\205\305u\210\306\262\202\234g\307=\205\217\305u\210\306\262\202\234\310\300w\302U?\262\210\202\226 \207" [nil " " 0 "	" 10 1 t 13 " 	\n" sgml-lookup-eltype 119 sgml-general-case buffer-substring-no-properties skip-syntax-forward "w_" 61 looking-at "['\"]" sgml-parse-literal read message "%s = %S" intern put] 9])
#@13 

(fn TEXT)
(defalias 'sgml-general-insert-case #[257 "\203 	\302=\203 \211\226\207	\303=\203 \211\227\207\207\207" [sgml-namecase-general sgml-general-insert-case upper lower] 3 (#$ . 55679)])
#@13 

(fn TEXT)
(defalias 'sgml-entity-insert-case #[257 "\203 	\302=\203 \211\226\207	\303=\203 \211\227\207\207\207" [sgml-namecase-entity sgml-entity-insert-case upper lower] 3 (#$ . 55883)])
#@30 

(fn &optional ENTITY-NAME)
(defalias 'sgml-parse-name #[256 "m?\205! gz\300=\205! \301`\302\303!\210`\"\203 \211\202 \304!\262\207" [119 buffer-substring-no-properties skip-syntax-forward "w_" sgml-general-case] 5 (#$ . 56084)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-parse-name compiler-macro sgml-parse-name--anon-cmacro] 4)
#@35 

(fn FORM &optional ENTITY-NAME)
(defalias 'sgml-parse-name--anon-cmacro #[513 "\211\300>\203 \301\302\203 \303\202 \304\305BE\207\207" [(nil t) if (sgml-startnm-char-next) sgml-entity-case sgml-general-case ((buffer-substring-no-properties (point) (progn (skip-syntax-forward "w_") (point))))] 6 (#$ . 56443)])
#@30 

(fn &optional ENTITY-NAME)
(defalias 'sgml-check-name #[256 "\300!\206	 \301\302!\207" [sgml-parse-name sgml-parse-error "Name expected"] 3 (#$ . 56767)])
(put 'sgml-check-name 'byte-optimizer 'byte-compile-inline-expand)
#@94 Parses a name token and returns a string or nil if no nametoken.

(fn &optional ENTITY-NAME)
(defalias 'sgml-parse-nametoken #[256 "\300g!\205 \301`\302\303!\210`\"\203 \211\202 \304!\262\207" [sgml-name-char buffer-substring-no-properties skip-syntax-forward "w_" sgml-general-case] 5 (#$ . 56998)])
(defalias 'sgml-check-nametoken #[0 "\300 \206 \301\302!\207" [sgml-parse-nametoken sgml-parse-error "Name token expected"] 2])
(defalias 'sgml-parse-general-entity-ref #[0 "g\300=\205 `Tf\206 \301z\302=\205 \303u\210\304 \207" [38 0 119 1 sgml-do-general-entity-ref] 2])
(put 'sgml-parse-general-entity-ref 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-do-general-entity-ref #[0 "\304m?\205 gz\305=\205 \306`\307\310!\210`\"g\311=\203! \312u\210\202$ \313 \210\314\2033 	\2043 \315\n`#\210\211\211\266!\210\316\207" [sgml-set-face sgml-current-eref sgml-markup-start sgml-markup-type sgml-do-entity-ref 119 buffer-substring-no-properties skip-syntax-forward "w_" 59 1 sgml-parse-RE entity sgml-set-face-for t] 7])
#@13 

(fn NAME)
(defalias 'sgml-do-entity-ref #[257 "\306\307H\"\211\204 	\205N \310\311\"\202N \312!\203I \n\203$ \313\314\"\210\203+  \210\f\2035 \f!\202N \205N \315\"\210\316 !\210\317 \202N \315\"\207" [sgml-dtd-info sgml-warn-about-undefined-entities sgml-xml-p sgml-signal-data-function sgml-entity-function sgml-data-function sgml-lookup-entity 3 sgml-log-warning "Undefined entity %s" sgml-entity-data-p sgml-error "XML forbids data-entity references in data or DTD (%s)" sgml-push-to-entity buffer-string sgml-pop-entity sgml-markup-start] 5 (#$ . 58051)])
#@66 Parse and push to a parameter entity, return nil if no ref here.
(defalias 'sgml-parse-parameter-entity-ref #[0 "g\300=\205 `Tf\206 \301z\302=\205 \303u\210\304 \207" [37 0 119 1 sgml-do-parameter-entity-ref] 2 (#$ . 58636)])
(put 'sgml-parse-parameter-entity-ref 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-do-parameter-entity-ref #[0 "m?\205 gz\302=\205 \303`\304\305!\210`\"\306\307H\"g\310=\203& \311u\210\202/ g\312=\203/ \311u\210\211\203< \313	\314#\210\202A \315\316\"\210\317\207" [sgml-dtd-info sgml-markup-start 119 buffer-substring-no-properties skip-syntax-forward "w_" sgml-lookup-entity 2 59 1 10 sgml-push-to-entity param sgml-parse-warning "Undefined parameter entity %s" t] 6])
(defalias 'sgml-parse-comment #[0 "g\301=\205= `Tf\301=\205= \302u\210\203 \303\304!\210\305\306\307\310#\203$ \311u\210g\301=\2038 `Tf\301=\2038 \302u\210\202< \312\313!\210\310\207" [sgml-xml-p 45 2 sgml-parse-warning "XML forbids nested comments." search-forward "--" nil t -2 sgml-delimiter-parse-error "COM"] 4])
(defalias 'sgml-parse-xml-comment #[0 "g\304=\205d `Tf\305=\205d \306`\\f\307=\205d \310`\\f\307=\205d \311u\210\312\313\314\315#\203. \316u\210g\307=\203K `Tf\307=\203K \306`\\f\317=\203K \310u\210\202O \320\321!\210\322\203^ 	\204^ \323\n`#\210\211\211\266\315\207" [sgml-set-face sgml-current-eref sgml-markup-start sgml-markup-type 60 33 2 45 3 4 search-forward "-->" nil t -3 62 sgml-delimiter-parse-error "XML-ECOM" comment sgml-set-face-for] 5])
#@91 Skip over the separator used in the catalog.
Return true if not at the end of the buffer.
(defalias 'sgml-skip-cs #[0 "\300\211\2035 \301\300w\302U?\206; \303\300w\302U?\206; g\304=\203& \305u\210\306\262\202= g\307=\2050 \305u\210\306\262\202= \310\300w\302U?\262\204  \311 \204  m?\207" [nil " " 0 "	" 10 1 t 13 " 	\n" sgml-parse-comment] 3 (#$ . 60141)])
#@77 Move point forward stopping before a char that isn't a parameter separator.
(defalias 'sgml-skip-ps #[0 "\300\211\2035 \301\300w\302U?\206; \303\300w\302U?\206; g\304=\203& \305u\210\306\262\202= g\307=\2050 \305u\210\306\262\202= \310\300w\302U?\262\204  m\203I \311 \204  g\312=\203d `Tf\206V \302z\313=\203d \305u\210\314 \204  \315 \205l \202  \207" [nil " " 0 "	" 10 1 t 13 " 	\n" sgml-pop-entity 37 119 sgml-do-parameter-entity-ref sgml-parse-comment] 3 (#$ . 60509)])
(put 'sgml-skip-ps 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-parse-ds #[0 "m\203	 \300 \206{ \301\211\203> \302\301w\303U?\206D \304\301w\303U?\206D g\305=\203/ \306u\210\307\262\202F g\310=\2059 \306u\210\307\262\202F \311\301w\303U?\262\206{ g\312=\203d `Tf\206V \303z\313=\203d \306u\210\314 \206{ \315g\316=\205y `Tf\317=\205y \320u\210\321!\262\207" [sgml-pop-entity nil " " 0 "	" 10 1 t 13 " 	\n" 37 119 sgml-do-parameter-entity-ref in-declaration 60 63 2 sgml-do-processing-instruction] 3])
(put 'sgml-parse-ds 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-skip-ds #[0 "m\203	 \300 \204  \301\211\203> \302\301w\303U?\206D \304\301w\303U?\206D g\305=\203/ \306u\210\307\262\202F g\310=\2059 \306u\210\307\262\202F \311\301w\303U?\262\204  g\312=\203d `Tf\206V \303z\313=\203d \306u\210\314 \204  \315g\316=\205y `Tf\317=\205y \320u\210\321!\262\205\201 \202  \207" [sgml-pop-entity nil " " 0 "	" 10 1 t 13 " 	\n" 37 119 sgml-do-parameter-entity-ref in-declaration 60 63 2 sgml-do-processing-instruction] 3])
#@108 Parse a RNI (#) return nil if none.
With optional NAME, RNI must be followed by NAME.

(fn &optional NAME)
(defalias 'sgml-parse-rni '(macro . #[256 "\211\203 \300\301\302DE\207\303\207" [if (sgml-parse-delim "RNI") sgml-check-token (sgml-parse-delim "RNI")] 5 (#$ . 62056)]))
#@13 

(fn NAME)
(defalias 'sgml-check-token #[257 "\300\301\302!\206 \303\304!\262!\232\206 \303\305\"\207" [sgml-check-case nil sgml-parse-name sgml-parse-error "Name expected" "Reserved name not expected (expecting %s)"] 5 (#$ . 62341)])
#@148 Check that NAME is in upper case.
If `sgml-namecase-general' is nil, then signal an error if the argument
is not already in upper case.

(fn NAME)
(defalias 'sgml-check-case #[257 "\204 \211\226\232\204 \301\302\"\210\207" [sgml-current-namecase-general sgml-parse-error "Uppercase keyword expected (found %s)"] 4 (#$ . 62590)])
#@64 Parse a literal and return a string, if no literal return nil.
(defalias 'sgml-parse-literal #[0 "\300\211\211g\301=\203 \302u\210\202 g\303=\205 \302u\210\304\211\262\205_ `\262\203- \305\300w\210\2021 \306\300w\210\307`\"\262\203N g\303=\203G \302u\210\202^ \310\311!\210\202^ g\301=\203Z \302u\210\202^ \310\312!\210\211\207" [nil 34 1 39 t "^'" "^\"" buffer-substring-no-properties sgml-delimiter-parse-error "LITA" "LIT"] 6 (#$ . 62930)])
(defalias 'sgml-check-literal #[0 "\300 \206 \301\302!\207" [sgml-parse-literal sgml-parse-error "A literal expected"] 2])
#@68 Parse a quoted SGML string and return it, if no string return nil.
(defalias 'sgml-parse-minimum-literal #[0 "g\300>\205\216 g\301\302\303#`\304\211\305u\210\306w\210g=\203# \305u\210\202\213 m\2031 b\210\307\310!\210\202 \306\211\203f \311\306w\312U?\206l \313\306w\312U?\206l g\314=\203W \305u\210\315\262\202n g\316=\205a \305u\210\315\262\202n \317\306w\312U?\262\203w \311\262\202 \320`\306w\210`\"Q\262\304\262\202 \266\206\207" [(34 39) " 	\n" format "^%s%c" "" 1 nil sgml-parse-error "Unterminated literal" " " 0 "	" 10 t 13 " 	\n" buffer-substring-no-properties] 12 (#$ . 63513)])
(defalias 'sgml-check-minimum-literal #[0 "\300 \206 \301\302!\207" [sgml-parse-minimum-literal sgml-parse-error "A minimum literal expected"] 2])
#@76 Leaves nil if no external id, or (pubid . sysid).

(fn &optional PUBID-OK)
(defalias 'sgml-parse-external #[256 "\300\211\2035 \301\300w\302U?\206; \303\300w\302U?\206; g\304=\203& \305u\210\306\262\202= g\307=\2050 \305u\210\306\262\202= \310\300w\302U?\262\204  m\203I \311 \204  g\312=\203d `Tf\206V \302z\313=\203d \305u\210\314 \204  \315 \204  `\316 \211\205i\300\211\203\245 \301\300w\302U?\206\253 \303\300w\302U?\206\253 g\304=\203\226 \305u\210\306\262\202\255 g\307=\205\240 \305u\210\306\262\202\255 \310\300w\302U?\262\204p m\203\271 \311 \204p g\312=\203\324 `Tf\206\306 \302z\313=\203\324 \305u\210\314 \204p \315 \204p \317!\320\235\203e\211\321\230\205\357 \322 \206\357 \323\324!\300\211\203$\301\300w\302U?\206*\303\300w\302U?\206*g\304=\203\305u\210\306\262\202,g\307=\205\305u\210\306\262\202,\310\300w\302U?\262\204\357 m\2038\311 \204\357 g\312=\203S`Tf\206E\302z\313=\203S\305u\210\314 \204\357 \315 \204\357 \325 \326#\266\202\202ib\210\300\207" [nil " " 0 "	" 10 1 t 13 " 	\n" sgml-pop-entity 37 119 sgml-do-parameter-entity-ref sgml-parse-comment sgml-parse-nametoken sgml-check-case ("PUBLIC" "SYSTEM") "PUBLIC" sgml-parse-minimum-literal sgml-parse-error "Public identifier expected" sgml-parse-literal sgml-make-extid] 9 (#$ . 64278)])
(defalias 'sgml-skip-tag #[0 "g\300=\2053 \301u\210g\302=\203 \301u\210\303\304\305\306#\204 \307\310!\210g\311=\203) \301u\210\306\207g\302=\2053 \301u\210\306\207" [60 1 47 search-forward-regexp "\\([^\"'<>/]\\|\"[^\"]*\"\\|'[^']*'\\)*" nil t sgml-error "Invalid tag" 62] 4])
#@73 compiler-macro for inlining `sgml-entity-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-entity-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-entity-name (car cl-x)) nil] 9 (#$ . 65862)])
(put 'sgml-entity-name 'compiler-macro 'sgml-entity-name--cmacro)
#@144 Access slot "name" of `(sgml-entity (:type list) (:constructor sgml-make-entity (name type text &optional notation)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-entity-name #[257 "\211@\207" [] 2 (#$ . 66173)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-entity-name side-effect-free t] 4)
#@73 compiler-macro for inlining `sgml-entity-type'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-entity-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-entity-type (nth 1 cl-x)) nil] 9 (#$ . 66481)])
(put 'sgml-entity-type 'compiler-macro 'sgml-entity-type--cmacro)
#@144 Access slot "type" of `(sgml-entity (:type list) (:constructor sgml-make-entity (name type text &optional notation)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-entity-type #[257 "\211A@\207" [] 2 (#$ . 66794)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-entity-type side-effect-free t] 4)
#@73 compiler-macro for inlining `sgml-entity-text'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-entity-text--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-entity-text (nth 2 cl-x)) nil] 9 (#$ . 67103)])
(put 'sgml-entity-text 'compiler-macro 'sgml-entity-text--cmacro)
#@144 Access slot "text" of `(sgml-entity (:type list) (:constructor sgml-make-entity (name type text &optional notation)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-entity-text #[257 "\3008\207" [2] 3 (#$ . 67416)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-entity-text side-effect-free t] 4)
#@77 compiler-macro for inlining `sgml-entity-notation'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-entity-notation--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-entity-notation (nth 3 cl-x)) nil] 9 (#$ . 67726)])
(put 'sgml-entity-notation 'compiler-macro 'sgml-entity-notation--cmacro)
#@148 Access slot "notation" of `(sgml-entity (:type list) (:constructor sgml-make-entity (name type text &optional notation)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-entity-notation #[257 "\3008\207" [3] 3 (#$ . 68059)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put sgml-entity-notation side-effect-free t defalias copy-sgml-entity copy-sequence] 4)
#@103 compiler-macro for inlining `make-sgml-entity'.

(fn CL-WHOLE &cl-quote &key NAME TYPE TEXT NOTATION)
(defalias 'make-sgml-entity--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D \211@\305>\203, \211AA\262\202 \306>A@\203; \307\262\202 \310\311@\"\210\202 \210\312\313\314\307	\307				&	\207" [plist-member :name :type :text :notation (:name :type :text :notation :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :type :text :notation)" cl--defsubst-expand (name type text notation) (cl-block make-sgml-entity (list name type text notation))] 16 (#$ . 68432)])
(put 'make-sgml-entity 'compiler-macro 'make-sgml-entity--cmacro)
#@83 Constructor for objects of type `sgml-entity'.

(fn &key NAME TYPE TEXT NOTATION)
(defalias 'make-sgml-entity #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D \211@\305>\203, \211AA\262\202 \306>A@\203; \307\262\202 \310\311@\"\210\202 \210F\207" [plist-member :name :type :text :notation (:name :type :text :notation :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :type :text :notation)"] 9 (#$ . 69144)])
(byte-code "\300\301\302\303#\300\207" [function-put make-sgml-entity side-effect-free t] 4)
#@102 compiler-macro for inlining `sgml-make-entity'.

(fn CL-WHOLE-ARG NAME TYPE TEXT &optional NOTATION)
(defalias 'sgml-make-entity--cmacro #[1284 "\300\301\302\303\211\211				&	\207" [cl--defsubst-expand (name type text notation) (cl-block sgml-make-entity (list name type text notation)) nil] 15 (#$ . 69723)])
(put 'sgml-make-entity 'compiler-macro 'sgml-make-entity--cmacro)
#@88 Constructor for objects of type `sgml-entity'.

(fn NAME TYPE TEXT &optional NOTATION)
(defalias 'sgml-make-entity #[1027 "F\207" [] 8 (#$ . 70109)])
(byte-code "\300\301\302\303#\304\305\306\211\307\306\310\311\305\306&	\207" [function-put sgml-make-entity side-effect-free t cl-struct-define sgml-entity nil list ((name) (type) (text) (notation)) cl-struct-sgml-entity-tags] 11)
#@74 True if ENTITY is a data entity, that is not a text entity.

(fn ENTITY)
(defalias 'sgml-entity-data-p #[257 "\211A@\300=?\207" [text] 3 (#$ . 70500)])
#@15 

(fn ENTITY)
(defalias 'sgml-entity-marked-undefined-p #[257 "\300\233\207" [4] 3 (#$ . 70658)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-entity-marked-undefined-p gv-expander #[385 "\300\301\302$\207" [gv--defsetter sgml-entity-marked-undefined-p #[514 "\300\301\302\303EEE\207" [progn setcdr nthcdr 3] 7 "\n\n(fn VAL ENTITY)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
(defalias 'sgml-make-entity-table #[0 "\300C\207" [nil] 1])
#@26 

(fn NAME ENTITY-TABLE)
(defalias 'sgml-lookup-entity #[514 "\300A\"\206\n \211@\207" [assoc] 5 (#$ . 71110)])
#@354 Declare an entity with name NAME in table ENTITY-TABLE.
TYPE should be the type of the entity (text|CDATA|NDATA|SDATA...).
TEXT is the text of the entity, a string or an external identifier.
NOTATION is the notation of an external entity, if present.
If NAME is nil, this defines the default entity.

(fn NAME ENTITY-TABLE TYPE TEXT &optional NOTATION)
(defalias 'sgml-entity-declare #[1284 "\203! \301\"?\2058 \203 \302\303$\210FC\244\207@?\2058 \2031 \302\304#\210\305F\240\207" [sgml-debug sgml-lookup-entity message "Declare entity %s %s as %S" "Declare default entity %s as %S" nil] 10 (#$ . 71231)])
#@67 Make a completion table from the ENTITY-TABLE.

(fn ENTITY-TABLE)
(defalias 'sgml-entity-completion-table #[257 "\211A\207" [] 2 (#$ . 71865)])
#@42 

(fn FN ENTITY-TABLE &optional COLLECT)
(defalias 'sgml-map-entities #[770 "\211\203\n \300A\"\207A\301:\203! @\262!\210A\262\202 \301\207" [mapcar nil] 7 (#$ . 72015)])
#@71 Merge entity table TAB2 into TAB1.  TAB1 is modified.

(fn TAB1 TAB2)
(defalias 'sgml-merge-entity-tables #[514 "A\244\210\211@\206 @\240\207" [] 4 (#$ . 72203)])
#@108 Insert the text of ENTITY.
PTYPE can be 'param if this is a parameter entity.

(fn ENTITY &optional PTYPE)
(defalias 'sgml-entity-insert-text #[513 "\3008\211;\203 \211c\202 \301\206 A@@#\207" [2 sgml-insert-external-entity] 7 (#$ . 72378)])
#@318 Return parsed catalog.
FILE is the file containing the catalog.  Maintains a cache of parsed
catalog files in variable CACHE-VAR. The parsing is done by function
PARSER-FUN that should parse the current buffer and return the parsed
representation of the catalog.

(fn FILE CACHE-VAR PARSER-FUN &optional DEFAULT-DIR)
(defalias 'sgml-cache-catalog #[1027 "\301\"\262\302!\205j \303J\"\304\305!!\306\234\203+ A@\232\203+ AA\202h \2038 \307J\"L\210\310\311\312\"\210\212\313!\210\314! \262)BB\211JBL\266\311\315\"\210\211\262\266\202\207" [default-directory expand-file-name file-readable-p assoc file-attributes file-truename 5 delq nil message "Loading %s ..." sgml-push-to-entity file-name-directory "Loading %s ... done"] 12 (#$ . 72635)])
#@35 Directory of the document entity.
(defalias 'sgml-main-directory #[0 "pq\210	q\210\207" [sgml-current-top-buffer default-directory] 3 (#$ . 73420)])
#@104 Log a message like `sgml-log-message', but only if `sgml-trace-entity-lookup' is set.

(fn &rest ARGS)
(defalias 'sgml-trace-lookup #[128 "\205 \301\302\"\207" [sgml-trace-entity-lookup apply sgml-log-message] 4 (#$ . 73578)])
#@370 Look up the an entity in the catalogs.
The entity is identified by a public identifier PUBID, system
identifier SYSID and entity TYPE and NAME. If INITIAL-OVERRIDE is
true, the system identifier will be used unless the catalog specifies
otherwise. The result is a file name or nil. FILES is a list of
catalogs to use.

(fn FILES PUBID SYSID TYPE NAME INITIAL-OVERRIDE)
(defalias 'sgml-catalog-lookup #[1542 "\300=\203 \301\302\"\262\303\262\202 \304=\203 \305\262\306\203\203\211\204\203\306\307@\310\311\312 $\313\314\315@\312 \"\204@ \316\202A \317#\210\203\215 \211\306\211\211\211:\203\213 @\262\211A\262\242\262\211A\262\242\262\211@\262\204\213 \320=\203\204 \230\203\204 \313\321\"\210\262	A\262\202M \266	\203\372 \211\306\211\211\211:\203\370 @\262\211A\262\242\262\211A\262\242\262\211@\262\204\370 \204\303 \204\350 \322=\203\350 \230\203\350 \323!\203\331 \262	\313\324\203\345 \325\202\346 \326#\210\327=\203\361 \262A\262\202\227 \266\211\306\211\211\211:\203u@\262\211A\262\242\262\211A\262\242\262\211@\262\204u\330=\203-B\262\2047\204e\f=\203e\203I\230\203e\323!\203R\262	\313\331\203b\325\202c\326%\210\327=\203n\262A\262\202\377 \266\237A\244\262\266\202 \207" [param format "%%%s" entity dtd doctype nil sgml-cache-catalog sgml-catalog-assoc sgml-parse-catalog-buffer sgml-main-directory sgml-trace-lookup "  catalog: %s %s" expand-file-name "empty/non existent" "exists" system "  >> %s [by system]" public file-readable-p "  >> %s [by pubid]%s" "" " !unreadable" override catalog "  >> %s [by %s %s]%s"] 22 (#$ . 73815)])
#@24 

(fn EXTID TYPE NAME)
(defalias 'sgml-path-lookup #[771 "\302!\303!\304C\203 \211\305\306!BC\244\307!\244\210\310!\262\203) \211\311BC\244\210\2034 \211\312BC\244\210\203` \211\313\314=\203E \315\202\\ \316=\203P \317\202\\ \320=\203[ \321\202\\ \322BC\244\210\203i \323\324\"\210	\325\326\325:\203\251 @\262\327\"\211\262\205\230 \330\331\332!\f\"\211\262!\205\230 \333!?\205\230 \211\262?\211\262\203\251 A\262\202m \266\203\207" [sgml-debug sgml-public-map sgml-extid-pubid sgml-extid-sysid (37 37) 112 sgml-transliterate-file sgml-pubid-parts sgml-canonize-pubid 115 110 121 dtd "dtd" text "text" param "parm" "sgml" message "Ext. file subst. = %S" nil t sgml-subst-expand file-readable-p sgml-extid-expand substitute-in-file-name file-directory-p] 14 (#$ . 75497)])
#@181 Return file name for entity with external identifier EXTID.
Optional argument TYPE should be the type of entity and NAME should be
the entity name.

(fn EXTID &optional TYPE NAME)
(defalias 'sgml-external-file #[769 "\303!\304!?\203 \305!\262\306\307\206 \310\206 \311%\210\312	&\206` \312\n&\206` \203X \313\314\"\211\262!\203X \206` \315#\207" [sgml-system-identifiers-are-preferred sgml-current-localcat sgml-catalog-files sgml-extid-pubid sgml-extid-sysid sgml-canonize-pubid sgml-trace-lookup "Start looking for %s entity %s public %s system %s" "-" "?" sgml-catalog-lookup file-readable-p sgml-extid-expand sgml-path-lookup] 13 (#$ . 76313)])
#@267 Insert the contents of an external entity at point.
EXTID is the external identifier of the entity.  Optional arguments TYPE
is the entity type and NAME is the entity name, used to find the entity.
Returns nil if entity is not found.

(fn EXTID &optional TYPE NAME)
(defalias 'sgml-insert-external-entity #[769 "\301!\302!\211\2030 \303\304\303:\203+ @\262!\211\262?\211\262\203+ A\262\202 \266\203\206H \305#\211\205< \306!\262\206H \307#\210\303\207" [sgml-sysid-resolve-functions sgml-extid-pubid sgml-extid-sysid nil t sgml-external-file insert-file-contents sgml-warn-external-entity-not-found] 11 (#$ . 77016)])
#@25 

(fn NAME PUBID SYSID)
(defalias 'sgml-warn-external-entity-not-found #[771 "\300\301\203 \302\303\"\202 \304\203 \302\305\"\202 \304$\207" [sgml-log-warning "External entity not found: %s%s%s" format " PUBLIC \"%s\"" "" " SYSTEM \"%s\""] 10 (#$ . 77661)])
#@35 Parse all entries in a catalogue.
(defalias 'sgml-parse-catalog-buffer #[0 "\301\302\303!\210\301\211\211\304 \203u \305 \227\262\306\307\"A\262\203	 \310=\203. \304 \210\311\312 !\202\\ \313\230\203; \314\305 !\202\\ \315=\203F \305 \202\\ \316=\203Q \305 \202\\ \317=\205\\ \305 \227\320\232\317=\206f \321\305 !\322!E\266\202B\262\202	 \211\237\266\203)\207" [sgml-xml-p nil sgml-trace-lookup "  (Parsing catalog)" sgml-skip-cs sgml-check-cat-literal assoc (("public" . public) ("dtddecl" . public) ("entity" . name) ("linktype" . name) ("doctype" . name) ("sgmldecl" . noname) ("document" . noname) ("catalog" . noname) ("system" . two-files) ("override" . flag)) public sgml-canonize-pubid sgml-check-minimum-literal "doctype" sgml-general-case name two-files flag "yes" expand-file-name intern] 8 (#$ . 77936)])
#@65 Read the next catalog token.
Skips any leading spaces/comments.
(defalias 'sgml-check-cat-literal #[0 "\300 \210\301 \206 \302`\303\304w\210`\"\207" [sgml-skip-cs sgml-parse-literal buffer-substring-no-properties "^ \n	" nil] 4 (#$ . 78776)])
(defconst sgml-formal-pubid-regexp "^\\(+//\\|-//\\|\\)\\(\\([^/]\\|/[^/]\\)+\\)//\\([^ ]+\\) \\(\\([^/]\\|/[^/]\\)*\\)//\\(\\([^/]\\|/[^/]\\)*\\)\\(//\\(\\([^/]\\|/[^/]\\)*\\)\\)?")
#@14 

(fn PUBID)
(defalias 'sgml-pubid-parts #[257 "\301\"\205@ \302\303\304\305\"!B\306\304\307\"\227B\310\303\304\311\"!B\312\303\304\311\"!B\313\304\314\"\227B\257\315\224\205? \316\303\304\317\"!BC\244\207" [sgml-formal-pubid-regexp string-match 111 sgml-transliterate-file sgml-matched-string 2 99 4 100 5 116 108 7 9 118 10] 9 (#$ . 79210)])
#@14 

(fn PUBID)
(defalias 'sgml-canonize-pubid #[257 "\301\"\2053 \302\303\"\302\304\"\305\302\306\"\226\307\302\310\"\305\302\311\"\226\305\312\224\2030 \302\n\313\"\2021 \314\260\n\207" [sgml-formal-pubid-regexp string-match sgml-matched-string 1 2 "//" 4 " " 5 7 9 10 ""] 13 (#$ . 79571)])
#@15 

(fn STRING)
(defalias 'sgml-transliterate-file #[257 "\300\301\302#\207" [mapconcat #[257 "\301\236\243\206	 !\207" [sgml-public-transliterations char-to-string] 4 "\n\n(fn C)"] ""] 5 (#$ . 79877)])
#@16 

(fn C PARTS)
(defalias 'sgml-subst-expand-char #[514 "\227\236\243\207" [] 4 (#$ . 80088)])
#@16 

(fn S PARTS)
(defalias 'sgml-subst-expand #[514 "\3002G \301GS\302\303X\203D H\262\211\304=\2033 \305T\211\262H\"\206: \306\300\302\"\202: \307H!P\262T\262\202\n \266\2030\207" [--cl-block-nil-- 0 nil "" 37 sgml-subst-expand-char throw char-to-string] 11 (#$ . 80190)])
#@42 

(fn STRING N &optional REGEXP NOERROR)
(defalias 'sgml-matched-string #[1026 "\205 \300\"\206 \211\206 \301\302!\203 \211\247\205! \224\225O\207" [string-match error "String match fail"] 8 (#$ . 80489)])
(defalias 'sgml-declaration #[0 "\206 	\203 \303	\304\"\206 \n\203 \303\n@\305\"\206 \306\307\310\"\207" [sgml-declaration sgml-doctype sgml-parent-document sgml-in-file-eval (sgml-declaration) (sgml-declaration) sgml-external-file nil sgmldecl] 3])
#@18 

(fn FILE EXPR)
(defalias 'sgml-in-file-eval #[514 "r\300!q\210\301!)\207" [find-file-noselect eval] 4 (#$ . 80968)])
#@73 compiler-macro for inlining `sgml-eref-entity'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-eref-entity--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-eref-entity (car cl-x)) nil] 9 (#$ . 81095)])
(put 'sgml-eref-entity 'compiler-macro 'sgml-eref-entity--cmacro)
#@125 Access slot "entity" of `(sgml-eref (:constructor sgml-make-eref (entity start end)) (:type list))' struct CL-X.

(fn CL-X)
(defalias 'sgml-eref-entity #[257 "\211@\207" [] 2 (#$ . 81406)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-eref-entity side-effect-free t] 4)
#@72 compiler-macro for inlining `sgml-eref-start'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-eref-start--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-eref-start (nth 1 cl-x)) nil] 9 (#$ . 81695)])
(put 'sgml-eref-start 'compiler-macro 'sgml-eref-start--cmacro)
#@124 Access slot "start" of `(sgml-eref (:constructor sgml-make-eref (entity start end)) (:type list))' struct CL-X.

(fn CL-X)
(defalias 'sgml-eref-start #[257 "\211A@\207" [] 2 (#$ . 82003)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-eref-start side-effect-free t] 4)
#@70 compiler-macro for inlining `sgml-eref-end'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-eref-end--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-eref-end (nth 2 cl-x)) nil] 9 (#$ . 82290)])
(put 'sgml-eref-end 'compiler-macro 'sgml-eref-end--cmacro)
#@122 Access slot "end" of `(sgml-eref (:constructor sgml-make-eref (entity start end)) (:type list))' struct CL-X.

(fn CL-X)
(defalias 'sgml-eref-end #[257 "\3008\207" [2] 3 (#$ . 82588)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put sgml-eref-end side-effect-free t defalias copy-sgml-eref copy-sequence] 4)
#@94 compiler-macro for inlining `make-sgml-eref'.

(fn CL-WHOLE &cl-quote &key ENTITY START END)
(defalias 'make-sgml-eref--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\211\203= \211@\304>\203& \211AA\262\202 \305>A@\2034 \306\262\202 \307\310@\"\210\202 \210\311\312\313\306\306&\207" [plist-member :entity :start :end (:entity :start :end :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:entity :start :end)" cl--defsubst-expand (entity start end) (cl-block make-sgml-eref (list entity start end))] 14 (#$ . 82918)])
(put 'make-sgml-eref 'compiler-macro 'make-sgml-eref--cmacro)
#@74 Constructor for objects of type `sgml-eref'.

(fn &key ENTITY START END)
(defalias 'make-sgml-eref #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\211\203= \211@\304>\203& \211AA\262\202 \305>A@\2034 \306\262\202 \307\310@\"\210\202 \210E\207" [plist-member :entity :start :end (:entity :start :end :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:entity :start :end)"] 8 (#$ . 83559)])
(byte-code "\300\301\302\303#\300\207" [function-put make-sgml-eref side-effect-free t] 4)
#@83 compiler-macro for inlining `sgml-make-eref'.

(fn CL-WHOLE-ARG ENTITY START END)
(defalias 'sgml-make-eref--cmacro #[1028 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (entity start end) (cl-block sgml-make-eref (list entity start end)) nil] 13 (#$ . 84085)])
(put 'sgml-make-eref 'compiler-macro 'sgml-make-eref--cmacro)
#@69 Constructor for objects of type `sgml-eref'.

(fn ENTITY START END)
(defalias 'sgml-make-eref #[771 "E\207" [] 6 (#$ . 84428)])
(byte-code "\300\301\302\303#\304\305\306\211\307\306\310\311\305\306&	\207" [function-put sgml-make-eref side-effect-free t cl-struct-define sgml-eref nil list ((entity) (start) (end)) cl-struct-sgml-eref-tags] 11)
#@17 

(fn EREF POS)
(defalias 'sgml-make-epos #[514 "B\207" [] 4 (#$ . 84781)])
#@13 

(fn EPOS)
(defalias 'sgml-epos-eref #[257 "\211:\205 \211@\207" [] 2 (#$ . 84865)])
#@59 The buffer position of EPOS within its entity.

(fn EPOS)
(defalias 'sgml-epos-pos #[257 "\211:\203 \211A\207\207" [] 2 (#$ . 84958)])
#@59 True if EPOS is a position in the main buffer.

(fn EPOS)
(defalias 'sgml-bpos-p #[257 "\211\247\207" [] 2 (#$ . 85100)])
#@80 True if EPOS is a position in an entity other then the main buffer.

(fn EPOS)
(defalias 'sgml-strict-epos-p #[257 "\211:\207" [] 2 (#$ . 85228)])
#@55 Convert a buffer position POS into an epos.

(fn POS)
(defalias 'sgml-epos #[257 "\203	 \301\"\207\207" [sgml-current-eref sgml-make-epos] 4 (#$ . 85381)])
#@185 The last position in buffer not after EPOS.
If EPOS is a buffer position this is the same.  If EPOS is in an entity
this is the buffer position before the entity reference.

(fn EPOS)
(defalias 'sgml-epos-before #[257 "\211:\203 \300!\211A@\262\262\202  \207" [sgml-epos-eref] 3 (#$ . 85547)])
#@143 The first position in buffer after EPOS.
If EPOS is in an other entity, buffer position is after
entity reference leading to EPOS.

(fn EPOS)
(defalias 'sgml-epos-after #[257 "\211:\203 \300!\3018\262\262\202  \207" [sgml-epos-eref 2] 4 (#$ . 85852)])
#@272 Convert position in entity structure EPOS to a buffer position.
If EPOS is in an entity, the buffer position will be the position
before the entity reference if EPOS is first character in entity
text.  Otherwise buffer position will be after entity reference.

(fn EPOS)
(defalias 'sgml-epos-promote #[257 "\211:\203 \211A\300U\203 \211@A@\262\202  \301!\207" [1 sgml-epos-after] 3 (#$ . 86116)])
#@34 Return ecat for FILE.

(fn FILE)
(defalias 'sgml-load-ecat #[257 "\300\301\302\303\304\305\306!\307\"\310$#\207" [sgml-cache-catalog sgml-ecat-assoc make-byte-code 0 "\302\211\211\211\211\211\211\211\303 \210m?\205$ gz\304=\205$ \305\306`\307\310!\210`\"!\211\262\203\270 \311\227!\262\302\262\302\262\303 \210\312=\203I \313\314 !\262\202U \315=\203U \316\317 !\262\204a \320\321\300\"\210\202 \303 \210g\322=\203\242 \323u\210\303 \210m?\205\204 gz\304=\205\204 \306`\307\310!\210`\"\211\262\203\233 \303 \210\324 \262BB\262\202m \325\326!\210\303 \210\316\317 !\262BBBB\262\202 \237)\207" vconcat vector [sgml-xml-p nil sgml-skip-cs 119 sgml-general-case buffer-substring-no-properties skip-syntax-forward "w_" intern public sgml-canonize-pubid sgml-check-minimum-literal file expand-file-name sgml-check-cat-literal error "Syntax error in ECAT: %s" 91 1 sgml-check-literal sgml-check-char 93] 13] 10 (#$ . 86523)])
#@53 Return (file . ents) or nil.

(fn FILES PUBID FILE)
(defalias 'sgml-ecat-lookup #[771 "\302H\303\304\303:\203\305 @\262	\203 \305\306\"\210\307!\303\211\211\211\304\303:\203\262 @\262\211A\262\242\262\211A\262\242\262\211A\262\242\262\310=\203R \232\202\\ \311=\205\240 \232\205\240 \303\211\211\304:\203\222 @\262\211A\262\242\262\312\"\262\205\205 \3028\232\211\262\203\222 A\262\202d \211\205\227 \304\266\205\205\240 B\211\262?\211\262\203\262 A\262\202\" \266\206\211\262?\211\262\203\305 A\262\202 \266\203\207" [sgml-dtd-info sgml-debug 2 nil t message "Search ECAT %s" sgml-load-ecat public file sgml-lookup-entity] 23 (#$ . 87484)])
#@19 

(fn PUBID FILE)
(defalias 'sgml-try-merge-compiled-dtd #[514 "\203	 \303!\262\211\203 \304!\262\203 \305\306#\210\307	#\206) \307\n#\211\205S \211@A\203: \305\310\"\210\311 \203G \312#\202Q \313#\205Q \314 \266\202\207" [sgml-debug sgml-current-local-ecat sgml-ecat-files sgml-canonize-pubid expand-file-name message "Find compiled dtd for %s %s" sgml-ecat-lookup "Found %s" sgml-use-special-case sgml-try-merge-special-case sgml-bdtd-load sgml-bdtd-merge] 9 (#$ . 88192)])
(defalias 'sgml-use-special-case #[0 "\302H?\205 \303\304H!\205 	@A@\305=\207" [sgml-dtd-info sgml-current-eref 7 sgml-eltype-table-empty 1 dtd] 3])
#@24 

(fn FILE CFILE ENTS)
(defalias 'sgml-try-merge-special-case #[771 "\304\203	 \305\306!\210p\307 \304:\203N @\262\211q\210	\203G \310	!\n>\204, \311\312\313	D\"\210	\314H\315H\211\205B @\230\205B \211A\211\262\262\204N A\262\202 \266\211q\266\211\204d \316#\203d \317 \262\211\205\255 \320\321H\321H\"\205\255 \211\314\314HI\266\322\323H\323H\"\210\322\321H\321H\"\210\324\325H\325H\"\210\211\326\326H\326H\244I\266\211\315BI\262\207" [sgml-debug sgml-buffer-parse-state cl-struct-sgml-pstate-tags sgml-dtd-info nil message "Merging special case" buffer-list type-of signal wrong-type-argument sgml-pstate 1 7 sgml-bdtd-load sgml-bdtd-read-dtd sgml-check-entities 2 sgml-merge-entity-tables 3 sgml-merge-shortmaps 4 6] 11 (#$ . 88850)])
#@282 Set current buffer to a buffer containing the entity ENTITY.
ENTITY can also be a file name.  Optional argument REF-START should be
the start point of the entity reference.  Optional argument TYPE,
overrides the entity type in entity look up.

(fn ENTITY &optional REF-START TYPE)
(defalias 'sgml-push-to-entity #[769 "\203 	\203 \306	!\203 \307\310!\204 \311\312!p\n\313 ;\203. \314\211\211F\2020 \315\2067 `!\315`!E\266\203	q\210	\316\301!=\203R \317\301!\210\314p\320 \210\307\321!\210\322\314\310\"\210\317\305!\210\314\317\323!\210\211\324!\210\317\325!\210;\204\212 \3268;\203\216 `\202\217 \327&\203\241 '\203\236 \330\331!\210\314&;\203\304 '\203\263 \330\332p\n#\210\333!\210\334!\211\202\227\3268:\203\202\3268\335\206\333 \nA@@#(\203\365 \211\206\351 \310)\211\336\336HBI\266'\203\330\337p$\210\211\203(\203\340\341!\"\203db\202}\211\2031\320 \210\333\314\211\211$\210\211\334!eb\202}\212\341!\342!\211\203c*\314\310\314:\203^@\262!\211\262?\211\262\203^A\262\202A\266\203\206z\343\233\310\241\266+\203y\344\f@#\210\314\266\202)\266\202\202\227'\203\220\330\345p\3268#\210\212\3268c)\207" [sgml-rs-ignore-pos sgml-scratch-buffer default-directory sgml-xml-p sgml-last-entity-buffer sgml-current-file buffer-live-p sgml-set-buffer-multibyte t generate-new-buffer " *entity*" syntax-table nil sgml-epos default-value make-local-variable erase-buffer default set-visited-file-name sgml-current-eref set-syntax-table sgml-previous-buffer 2 0 message "-- pstate set in scratch buffer" "Push to %s: FILE %s" insert-file-contents file-name-directory sgml-external-file 6 "Push to %s: %s = %s" sgml-try-merge-compiled-dtd sgml-extid-pubid sgml-extid-sysid 3 sgml-warn-external-entity-not-found "Push to %s: string '%s'" sgml-buffer-parse-state sgml-debug sgml-parsing-dtd sgml-dtd-info sgml-sysid-resolve-functions sgml-warn-about-undefined-entities] 18 (#$ . 89632)])
(defalias 'sgml-pop-entity #[0 "\303\300!\205 \304!\205 	\203 \305\306p#\210q\210\307\207" [sgml-previous-buffer sgml-debug sgml-last-entity-buffer boundp bufferp message "Exit entity %s => %s" t] 4])
#@32 Value of point in main buffer.
(defalias 'sgml-mainbuf-point #[0 "\203 \3018\207`\207" [sgml-current-eref 2] 2 (#$ . 91843)])
#@56 Goto a position in an entity given by EPOS.

(fn EPOS)
(defalias 'sgml-goto-epos #[257 "\211\204 \300\301!\210\302!\203 \211b\207\303!\304 \210\305\3068!\210\307@\310A@!\"\266\310!b\207" [cl--assertion-failed epos sgml-bpos-p sgml-epos-eref sgml-cleanup-entities sgml-goto-epos 2 sgml-push-to-entity sgml-epos-pos] 6 (#$ . 91978)])
(defalias 'sgml-pop-all-entities #[0 "\300 \205 \202  \207" [sgml-pop-entity] 1])
(defalias 'sgml-cleanup-entities #[0 "p\302\203\" \303!\203\" q\210\304\300!=\203 \305\306!\210\211T\262\202 \211\307V\2036 	\310p!\210q\210\211S\262\202\" q\207" [sgml-scratch-buffer sgml-previous-buffer 0 buffer-live-p default-value cl--assertion-failed (not (eq sgml-scratch-buffer (default-value 'sgml-scratch-buffer))) 10 kill-buffer] 5])
#@61 Return true if there currently is a parameter or file open.
(defalias 'sgml-any-open-param/file #[0 "\301\300!\205 \207" [sgml-previous-buffer boundp] 2 (#$ . 92761)])
#@73 compiler-macro for inlining `sgml-tree-eltype'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-eltype--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-eltype (aref cl-x 0)) nil] 9 (#$ . 92937)])
(put 'sgml-tree-eltype 'compiler-macro 'sgml-tree-eltype--cmacro)
#@226 Access slot "eltype" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-eltype #[257 "\211\300H\207" [0] 3 (#$ . 93251)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-eltype side-effect-free t] 4)
#@76 compiler-macro for inlining `sgml-tree-stag-epos'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-stag-epos--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-stag-epos (aref cl-x 1)) nil] 9 (#$ . 93646)])
(put 'sgml-tree-stag-epos 'compiler-macro 'sgml-tree-stag-epos--cmacro)
#@229 Access slot "stag-epos" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-stag-epos #[257 "\211\300H\207" [1] 3 (#$ . 93975)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-stag-epos side-effect-free t] 4)
#@76 compiler-macro for inlining `sgml-tree-etag-epos'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-etag-epos--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-etag-epos (aref cl-x 2)) nil] 9 (#$ . 94379)])
(put 'sgml-tree-etag-epos 'compiler-macro 'sgml-tree-etag-epos--cmacro)
#@229 Access slot "etag-epos" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-etag-epos #[257 "\211\300H\207" [2] 3 (#$ . 94708)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-etag-epos side-effect-free t] 4)
#@75 compiler-macro for inlining `sgml-tree-stag-len'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-stag-len--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-stag-len (aref cl-x 3)) nil] 9 (#$ . 95112)])
(put 'sgml-tree-stag-len 'compiler-macro 'sgml-tree-stag-len--cmacro)
#@228 Access slot "stag-len" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-stag-len #[257 "\211\300H\207" [3] 3 (#$ . 95436)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-stag-len side-effect-free t] 4)
#@75 compiler-macro for inlining `sgml-tree-etag-len'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-etag-len--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-etag-len (aref cl-x 4)) nil] 9 (#$ . 95837)])
(put 'sgml-tree-etag-len 'compiler-macro 'sgml-tree-etag-len--cmacro)
#@228 Access slot "etag-len" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-etag-len #[257 "\211\300H\207" [4] 3 (#$ . 96161)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-etag-len side-effect-free t] 4)
#@73 compiler-macro for inlining `sgml-tree-parent'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-parent--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-parent (aref cl-x 5)) nil] 9 (#$ . 96562)])
(put 'sgml-tree-parent 'compiler-macro 'sgml-tree-parent--cmacro)
#@226 Access slot "parent" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-parent #[257 "\211\300H\207" [5] 3 (#$ . 96876)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-parent side-effect-free t] 4)
#@72 compiler-macro for inlining `sgml-tree-level'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-level--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-level (aref cl-x 6)) nil] 9 (#$ . 97271)])
(put 'sgml-tree-level 'compiler-macro 'sgml-tree-level--cmacro)
#@225 Access slot "level" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-level #[257 "\211\300H\207" [6] 3 (#$ . 97580)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-level side-effect-free t] 4)
#@75 compiler-macro for inlining `sgml-tree-excludes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-excludes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-excludes (aref cl-x 7)) nil] 9 (#$ . 97972)])
(put 'sgml-tree-excludes 'compiler-macro 'sgml-tree-excludes--cmacro)
#@228 Access slot "excludes" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-excludes #[257 "\211\300H\207" [7] 3 (#$ . 98296)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-excludes side-effect-free t] 4)
#@75 compiler-macro for inlining `sgml-tree-includes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-includes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-includes (aref cl-x 8)) nil] 9 (#$ . 98697)])
(put 'sgml-tree-includes 'compiler-macro 'sgml-tree-includes--cmacro)
#@228 Access slot "includes" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-includes #[257 "\211\300H\207" [8] 3 (#$ . 99021)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-includes side-effect-free t] 4)
#@73 compiler-macro for inlining `sgml-tree-pstate'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-pstate--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-pstate (aref cl-x 9)) nil] 9 (#$ . 99422)])
(put 'sgml-tree-pstate 'compiler-macro 'sgml-tree-pstate--cmacro)
#@226 Access slot "pstate" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-pstate #[257 "\211\300H\207" [9] 3 (#$ . 99736)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-pstate side-effect-free t] 4)
#@71 compiler-macro for inlining `sgml-tree-next'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-next--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-next (aref cl-x 10)) nil] 9 (#$ . 100131)])
(put 'sgml-tree-next 'compiler-macro 'sgml-tree-next--cmacro)
#@224 Access slot "next" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-next #[257 "\211\300H\207" [10] 3 (#$ . 100437)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-next side-effect-free t] 4)
#@74 compiler-macro for inlining `sgml-tree-content'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-content--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-content (aref cl-x 11)) nil] 9 (#$ . 100828)])
(put 'sgml-tree-content 'compiler-macro 'sgml-tree-content--cmacro)
#@227 Access slot "content" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-content #[257 "\211\300H\207" [11] 3 (#$ . 101149)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-content side-effect-free t] 4)
#@78 compiler-macro for inlining `sgml-tree-net-enabled'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-net-enabled--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-net-enabled (aref cl-x 12)) nil] 9 (#$ . 101549)])
(put 'sgml-tree-net-enabled 'compiler-macro 'sgml-tree-net-enabled--cmacro)
#@231 Access slot "net-enabled" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-net-enabled #[257 "\211\300H\207" [12] 3 (#$ . 101890)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-net-enabled side-effect-free t] 4)
#@73 compiler-macro for inlining `sgml-tree-conref'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-conref--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-conref (aref cl-x 13)) nil] 9 (#$ . 102302)])
(put 'sgml-tree-conref 'compiler-macro 'sgml-tree-conref--cmacro)
#@226 Access slot "conref" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-conref #[257 "\211\300H\207" [13] 3 (#$ . 102618)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-conref side-effect-free t] 4)
#@75 compiler-macro for inlining `sgml-tree-shortmap'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-shortmap--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-shortmap (aref cl-x 14)) nil] 9 (#$ . 103015)])
(put 'sgml-tree-shortmap 'compiler-macro 'sgml-tree-shortmap--cmacro)
#@228 Access slot "shortmap" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-shortmap #[257 "\211\300H\207" [14] 3 (#$ . 103341)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-shortmap side-effect-free t] 4)
#@76 compiler-macro for inlining `sgml-tree-pshortmap'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-pshortmap--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-pshortmap (aref cl-x 15)) nil] 9 (#$ . 103744)])
(put 'sgml-tree-pshortmap 'compiler-macro 'sgml-tree-pshortmap--cmacro)
#@229 Access slot "pshortmap" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-pshortmap #[257 "\211\300H\207" [15] 3 (#$ . 104075)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-tree-pshortmap side-effect-free t] 4)
#@70 compiler-macro for inlining `sgml-tree-asl'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-tree-asl--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-tree-asl (aref cl-x 16)) nil] 9 (#$ . 104481)])
(put 'sgml-tree-asl 'compiler-macro 'sgml-tree-asl--cmacro)
#@223 Access slot "asl" of `(sgml-tree (:type vector) (:constructor sgml-make-tree (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref &optional shortmap pshortmap asl)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-tree-asl #[257 "\211\300H\207" [16] 3 (#$ . 104782)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put sgml-tree-asl side-effect-free t defalias copy-sgml-tree copy-sequence] 4)
#@215 compiler-macro for inlining `make-sgml-tree'.

(fn CL-WHOLE &cl-quote &key ELTYPE STAG-EPOS ETAG-EPOS STAG-LEN ETAG-LEN PARENT LEVEL EXCLUDES INCLUDES PSTATE NEXT CONTENT NET-ENABLED CONREF SHORTMAP PSHORTMAP ASL)
(defalias 'make-sgml-tree--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\300\f\314\"A@\300\315\"A@\300\316\"A@\300\317\"A@\300\320\"A@\300\321\"A@\211\203\237 \211@\322>\203\207 \211AA\262\202t \323>A@\203\226 \324\262\202t \325\326@\"\210\202t \210\327\330\331\324\324&\207" [plist-member :eltype :stag-epos :etag-epos :stag-len :etag-len :parent :level :excludes :includes :pstate :next :content :net-enabled :conref :shortmap :pshortmap :asl (:eltype :stag-epos :etag-epos :stag-len :etag-len :parent :level :excludes :includes :pstate :next :content :net-enabled :conref :shortmap :pshortmap :asl :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:eltype :stag-epos :etag-epos :stag-len :etag-len :parent :level :excludes :includes :pstate :next :content :net-enabled :conref :shortmap :pshortmap :asl)" cl--defsubst-expand (eltype stag-epos etag-epos stag-len etag-len parent level excludes includes pstate next content net-enabled conref shortmap pshortmap asl) (cl-block make-sgml-tree (vector eltype stag-epos etag-epos stag-len etag-len parent level excludes includes pstate next content net-enabled conref shortmap pshortmap asl))] 42 (#$ . 105219)])
(put 'make-sgml-tree 'compiler-macro 'make-sgml-tree--cmacro)
#@195 Constructor for objects of type `sgml-tree'.

(fn &key ELTYPE STAG-EPOS ETAG-EPOS STAG-LEN ETAG-LEN PARENT LEVEL EXCLUDES INCLUDES PSTATE NEXT CONTENT NET-ENABLED CONREF SHORTMAP PSHORTMAP ASL)
(defalias 'make-sgml-tree #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\300\f\314\"A@\300\315\"A@\300\316\"A@\300\317\"A@\300\320\"A@\300\321\"A@\211\203\237 \211@\322>\203\207 \211AA\262\202t \323>A@\203\226 \324\262\202t \325\326@\"\210\202t \210\327&\207" [plist-member :eltype :stag-epos :etag-epos :stag-len :etag-len :parent :level :excludes :includes :pstate :next :content :net-enabled :conref :shortmap :pshortmap :asl (:eltype :stag-epos :etag-epos :stag-len :etag-len :parent :level :excludes :includes :pstate :next :content :net-enabled :conref :shortmap :pshortmap :asl :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:eltype :stag-epos :etag-epos :stag-len :etag-len :parent :level :excludes :includes :pstate :next :content :net-enabled :conref :shortmap :pshortmap :asl)" vector] 36 (#$ . 106867)])
(byte-code "\300\301\302\303#\300\207" [function-put make-sgml-tree side-effect-free t] 4)
#@182 compiler-macro for inlining `sgml-make-tree'.

(fn CL-WHOLE-ARG ELTYPE STAG-EPOS STAG-LEN PARENT LEVEL EXCLUDES INCLUDES PSTATE NET-ENABLED CONREF &optional SHORTMAP PSHORTMAP ASL)
(defalias 'sgml-make-tree--cmacro #[3595 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (eltype stag-epos stag-len parent level excludes includes pstate net-enabled conref shortmap pshortmap asl) (cl-block sgml-make-tree (vector eltype stag-epos nil stag-len nil parent level excludes includes pstate nil nil net-enabled conref shortmap pshortmap asl)) nil] 33 (#$ . 108172)])
(put 'sgml-make-tree 'compiler-macro 'sgml-make-tree--cmacro)
#@168 Constructor for objects of type `sgml-tree'.

(fn ELTYPE STAG-EPOS STAG-LEN PARENT LEVEL EXCLUDES INCLUDES PSTATE NET-ENABLED CONREF &optional SHORTMAP PSHORTMAP ASL)
(defalias 'sgml-make-tree #[3338 "\300\301\301\301\211&\207" [vector nil] 31 (#$ . 108832)])
(byte-code "\300\301\302\303#\304\305\306\211\307\306\310\311\305\306&	\207" [function-put sgml-make-tree side-effect-free t cl-struct-define sgml-tree nil vector ((eltype) (stag-epos) (etag-epos) (stag-len) (etag-len) (parent) (level) (excludes) (includes) (pstate) (next) (content) (net-enabled) (conref) (shortmap) (pshortmap) (asl)) cl-struct-sgml-tree-tags] 11)
#@47 Buffer position after end of TREE.

(fn TREE)
(defalias 'sgml-tree-end #[257 "\211\300H\301H\302!\203 \\\202! \211\303U\203 \304!\202! \305!\207" [2 4 sgml-bpos-p 0 sgml-epos-promote sgml-epos-after] 5 (#$ . 109492)])
#@13 

(fn TREE)
(defalias 'sgml-max-pos-in-tree #[257 "\211\300H\211\204& \301H\211\203 \211\203\" \211\262\211\302H\262\202 \303H\262\210\202 \304!\207" [2 11 10 1 sgml-epos-after] 5 (#$ . 109724)])
#@31 

(fn ORIG DEST &rest FIELDS)
(defalias 'sgml-alias-fields '(macro . #[642 "\300\301\302\303\304\305\306		\"\307\"\310\311%\"B\207" [progn mapcar make-byte-code 257 "\302\303\304\305\306\301#!D\303\304\305\306\300#!DE\207" vconcat vector [defalias quote intern format "%s-%s"] 9 "\n\n(fn FIELD)"] 12 (#$ . 109935)]))
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\312\"\210\300\313\314\"\210\300\315\316\"\210\300\317\320\"\210\300\321\322\"\210\300\323\324\"\210\300\325\326\"\207" [defalias sgml-element-eltype sgml-tree-eltype sgml-element-stag-epos sgml-tree-stag-epos sgml-element-etag-epos sgml-tree-etag-epos sgml-element-stag-len sgml-tree-stag-len sgml-element-etag-len sgml-tree-etag-len sgml-element-parent sgml-tree-parent sgml-element-level sgml-tree-level sgml-element-excludes sgml-tree-excludes sgml-element-includes sgml-tree-includes sgml-element-pstate sgml-tree-pstate sgml-element-net-enabled sgml-tree-net-enabled] 3)
#@61 Declared content or content model of ELEMENT.

(fn ELEMENT)
(defalias 'sgml-element-model #[257 "\300\301H!\207" [sgml-eltype-model 0] 4 (#$ . 110934)])
#@48 Return name (symbol) of ELEMENT.

(fn ELEMENT)
(defalias 'sgml-element-name #[257 "\211\300H\207" [0] 3 (#$ . 111094)])
#@62 Return general identifier (string) of ELEMENT.

(fn ELEMENT)
(defalias 'sgml-element-gi #[257 "\211\300H\301!\207" [0 symbol-name] 4 (#$ . 111220)])
#@96 Return the application data named PROP associated with the type of ELEMENT.

(fn ELEMENT PROP)
(defalias 'sgml-element-appdata #[514 "\300HN\207" [0] 4 (#$ . 111376)])
#@58 True if start-tag of ELEMENT is omissible.

(fn ELEMENT)
(defalias 'sgml-element-stag-optional '(macro . #[257 "\300\301DD\207" [sgml-eltype-stag-optional sgml-tree-eltype] 4 (#$ . 111552)]))
#@56 True if end-tag of ELEMENT is omissible.

(fn ELEMENT)
(defalias 'sgml-element-etag-optional #[257 "\300\301H!\207" [sgml-eltype-etag-optional 0] 4 (#$ . 111751)])
(put 'sgml-element-etag-optional 'byte-optimizer 'byte-compile-inline-expand)
#@67 Return the attribute specification list of ELEMENT.

(fn ELEMENT)
(defalias 'sgml-element-attlist #[257 "\211\300H\301N\207" [0 attlist] 3 (#$ . 112000)])
#@50 True if ELEMENT has mixed content.

(fn ELEMENT)
(defalias 'sgml-element-mixed #[257 "\211\300H\301JW\207" [0 3] 4 (#$ . 112161)])
(put 'sgml-element-mixed 'byte-optimizer 'byte-compile-inline-expand)
#@49 Position before start of ELEMENT.

(fn ELEMENT)
(defalias 'sgml-element-start #[257 "\300\301H!\207" [sgml-epos-promote 1] 4 (#$ . 112369)])
#@52 Position after start-tag of ELEMENT.

(fn ELEMENT)
(defalias 'sgml-element-stag-end #[257 "\211\300H\301H\302!\203 \\\202! \211\303U\203 \304!\202! \305!\207" [1 3 sgml-bpos-p 0 sgml-epos-promote sgml-epos-after] 5 (#$ . 112517)])
#@41 True if ELEMENT is empty.

(fn ELEMENT)
(defalias 'sgml-element-empty #[257 "\211\302H\206 ?\205 	\303!=\207" [sgml-xml-p sgml-empty 13 sgml-element-model] 4 (#$ . 112762)])
#@48 True if element with NAME is empty.

(fn NAME)
(defalias 'sgml-check-empty #[257 "\2119\203	 \211\202\f \301!\302!=\207" [sgml-empty sgml-lookup-eltype sgml-eltype-model] 5 (#$ . 112946)])
#@72 True if ELEMENT can have data characters in its content.

(fn ELEMENT)
(defalias 'sgml-element-data-p #[257 "\211\211\302H\303JW\266\202\206 \304!=\206 	\304!=\207" [sgml-cdata sgml-rcdata 0 3 sgml-element-model] 5 (#$ . 113144)])
#@60 Return string describing context of ELEMENT.

(fn ELEMENT)
(defalias 'sgml-element-context-string #[257 "\211=\203 \301\207\302\303\304!\305\306H!#\207" [sgml-top-tree "" format "in %s %s" sgml-element-gi sgml-element-context-string 5] 7 (#$ . 113387)])
(defalias 'sgml-update-display #[0 "\306=?\205\225 \307`\310\"\203: \307`\310\"\307`S\310\"=\203: \311\312>\2030 \313`\310\"\206+ eb\210\202: \314`\310\"\2068 db\210\n?\205\225 \315\303!\203I \204M \f\205\225 \205\225 \316\317!\205\225 \311\320 \210>\205k 	\205k \321	!\212\322\210`)\f\203\220 \323 \204\220 \212\3241\212 \325\323\326#0\202\216 \210\202\217 \210)\210\327\330!)\207" [this-command sgml-last-element executing-macro which-function-mode sgml-set-face sgml-buffer-parse-state keyboard-quit get-text-property invisible nil (backward-char previous-line backward-word) previous-single-property-change next-single-property-change boundp sit-for 0 sgml-need-dtd sgml-element-gi 1 input-pending-p (error) sgml-parse-to t sgml-fontify-buffer 6 deactivate-mark sgml-users-of-last-element sgml-current-element-name] 5])
#@14 

(fn DELAY)
(defalias 'sgml-fontify-buffer #[257 "\205: \303	!\n>\204 \304\305\306	D\"\210	\307H\307H?\205: \310!\205: \31118 \212\312\313!\210\314\315\211\316\317$\210\312\320!)0\207\210\315\207" [sgml-set-face sgml-buffer-parse-state cl-struct-sgml-pstate-tags type-of signal wrong-type-argument sgml-pstate 2 sit-for (error) message "Fontifying..." sgml-parse-until-end-of nil input-pending-p t "Fontifying...done"] 6 (#$ . 114489)])
(defalias 'sgml-current-element-name #[0 "\206% \212\3021  \303`\304\"\210\304 \203 \305\202 \306	!\2110\202$ \210\307\211)\207" [sgml-current-element-name sgml-current-tree (error) sgml-parse-to input-pending-p "?" sgml-element-gi "*error*"] 3])
#@70 compiler-macro for inlining `sgml-pstate-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-pstate-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-pstate-p (and (memq (type-of cl-x) cl-struct-sgml-pstate-tags) t)) nil] 9 (#$ . 115188)])
(put 'sgml-pstate-p 'compiler-macro 'sgml-pstate-p--cmacro)
#@13 

(fn CL-X)
(defalias 'sgml-pstate-p #[257 "\301!>\205	 \302\207" [cl-struct-sgml-pstate-tags type-of t] 3 (#$ . 115530)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put sgml-pstate-p side-effect-free error-free put sgml-pstate cl-deftype-satisfies] 5)
#@72 compiler-macro for inlining `sgml-pstate-dtd'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-pstate-dtd--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-pstate-dtd (or (sgml-pstate-p cl-x) (signal 'wrong-type-argument (list 'sgml-pstate cl-x))) (aref cl-x 1)) nil] 9 (#$ . 115810)])
(put 'sgml-pstate-dtd 'compiler-macro 'sgml-pstate-dtd--cmacro)
#@109 Access slot "dtd" of `(sgml-pstate (:constructor sgml-make-pstate (dtd top-tree)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-pstate-dtd #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-sgml-pstate-tags type-of signal wrong-type-argument sgml-pstate 1] 5 (#$ . 116201)])
(byte-code "\300\301\302\303#\300\207" [function-put sgml-pstate-dtd side-effect-free t] 4)
#@77 compiler-macro for inlining `sgml-pstate-top-tree'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'sgml-pstate-top-tree--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sgml-pstate-top-tree (or (sgml-pstate-p cl-x) (signal 'wrong-type-argument (list 'sgml-pstate cl-x))) (aref cl-x 2)) nil] 9 (#$ . 116586)])
(put 'sgml-pstate-top-tree 'compiler-macro 'sgml-pstate-top-tree--cmacro)
#@114 Access slot "top-tree" of `(sgml-pstate (:constructor sgml-make-pstate (dtd top-tree)))' struct CL-X.

(fn CL-X)
(defalias 'sgml-pstate-top-tree #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-sgml-pstate-tags type-of signal wrong-type-argument sgml-pstate 2] 5 (#$ . 117002)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put sgml-pstate-top-tree side-effect-free t defalias copy-sgml-pstate copy-sequence] 4)
#@92 compiler-macro for inlining `make-sgml-pstate'.

(fn CL-WHOLE &cl-quote &key DTD TOP-TREE)
(defalias 'make-sgml-pstate--cmacro #[385 "\300\301\"A@\300\302\"A@\211\2037 \211@\303>\203  \211AA\262\202 \304>A@\203. \305\262\202 \306\307@\"\210\202 \210\310\311\312\305\305&\207" [plist-member :dtd :top-tree (:dtd :top-tree :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:dtd :top-tree)" cl--defsubst-expand (dtd top-tree) (cl-block make-sgml-pstate (record 'sgml-pstate dtd top-tree))] 12 (#$ . 117452)])
(put 'make-sgml-pstate 'compiler-macro 'make-sgml-pstate--cmacro)
#@72 Constructor for objects of type `sgml-pstate'.

(fn &key DTD TOP-TREE)
(defalias 'make-sgml-pstate #[128 "\300\301\"A@\300\302\"A@\211\2037 \211@\303>\203  \211AA\262\202 \304>A@\203. \305\262\202 \306\307@\"\210\202 \210\310\311#\207" [plist-member :dtd :top-tree (:dtd :top-tree :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:dtd :top-tree)" record sgml-pstate] 7 (#$ . 118077)])
(byte-code "\300\301\302\303#\300\207" [function-put make-sgml-pstate side-effect-free t] 4)
#@81 compiler-macro for inlining `sgml-make-pstate'.

(fn CL-WHOLE-ARG DTD TOP-TREE)
(defalias 'sgml-make-pstate--cmacro #[771 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (dtd top-tree) (cl-block sgml-make-pstate (record 'sgml-pstate dtd top-tree)) nil] 11 (#$ . 118604)])
(put 'sgml-make-pstate 'compiler-macro 'sgml-make-pstate--cmacro)
#@67 Constructor for objects of type `sgml-pstate'.

(fn DTD TOP-TREE)
(defalias 'sgml-make-pstate #[514 "\300\301#\207" [record sgml-pstate] 6 (#$ . 118958)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put sgml-make-pstate side-effect-free t cl-struct-define sgml-pstate nil cl-structure-object record ((cl-tag-slot) (dtd) (top-tree)) cl-struct-sgml-pstate-tags] 11)
(defalias 'sgml-current-mixed-p #[0 "\211\301H\302JW\207" [sgml-current-tree 0 3] 4])
(put 'sgml-current-mixed-p 'byte-optimizer 'byte-compile-inline-expand)
#@41 Set initial state of parsing.

(fn DTD)
(defalias 'sgml-set-initial-state #[257 "\301\302\303\304\305$\210\301\306\307\304\305$\210\310\311!\211\211\312\313H\"\314\304\211BB\314\304\211BBAA\236\206; \211ABAAB\241\262\266\266\203M\266\315\313\304\313\304\211\313\304\211\211\211\211\211\211\211\211\211&\316\317#\266\202\211\207" [sgml-buffer-parse-state add-hook before-change-functions sgml-note-change-at nil local after-change-functions sgml-set-face-after-change sgml-make-eltype "#DOC" sgml-lookup-eltype 0 normal-state vector record sgml-pstate] 21 (#$ . 119533)])
#@129 Set parse state from TREE.
Either from start of TREE if WHERE is start or from after TREE if
WHERE is `after'.

(fn TREE WHERE)
(defalias 'sgml-set-parse-state #[514 "\306\307!\310=\203D \211\204D \311!\312H\313\314H\306U?\205/ \315\316H!\205/ \317\320!\321\316H!\210\314Hu\210\202o \322H\323H\321\324H!\210\325Hu\210\211\203a \317\202b \326`\325HZ\327H\204w \330\303!\210\313\207" [sgml-current-tree sgml-markup-tree sgml-rs-ignore-pos sgml-current-state sgml-current-shortmap sgml-previous-tree 0 sgml-element-empty start sgml-element-model 14 nil 3 sgml-bpos-p 1 start-tag sgml-element-start sgml-goto-epos 9 15 2 4 end-tag 5 cl--assertion-failed sgml-markup-type sgml-markup-start] 6 (#$ . 120132)])
#@14 

(fn STATE)
(defalias 'sgml-final-p #[257 "\211\211:\262?\206 \211\211@\300=\203 \211AA?\207\301!\262\207" [normal-state sgml-final-and] 4 (#$ . 120879)])
(put 'sgml-final-p 'byte-optimizer 'byte-compile-inline-expand)
#@161 Return an entity position for start of region START END.
If region is empty, choose return an epos as high in the
entity hierarchy as possible.

(fn START END)
(defalias 'sgml-promoted-epos #[514 "\300!U\203$ \301!\203$ \302!\303U\203$ \304!\211A@\262\262\202	 \211\207" [sgml-epos sgml-strict-epos-p sgml-epos-pos 1 sgml-epos-eref] 5 (#$ . 121111)])
#@69 

(fn ELTYPE CONREF BEFORE-TAG AFTER-TAG &optional ASL NET-ENABLED)
(defalias 'sgml-open-element #[1540 "\306!\262\204( \307\310\311#\266\307\312\311#\266\203( \313\314\315!\262\"\210\316N\211\203? \211\317=?\205@ \320	\310H\"\202@ \n\321\"Z\211\322HT\323\324N\325H\"\323\326N\327H\"\f\n\206q \330H\205q \331\n\n\332\333\333\333\211&\266\215\203\267 (\203\255 \334\335\n\336H#\210\211\337I\266\202\314 (\203\305 \334\340\n\336H#\210\211\341I\266\211\337\333I\266\342	!\211\333\f\204\346 \343\304!\210)\344\345#\210\346!\205\373 \347\211\"\207" [sgml-warn-about-undefined-elements sgml-dtd-info sgml-current-shortmap sgml-current-tree sgml-current-state sgml-previous-tree fboundp sgml-set-eltype-flag 4 t 2 sgml-log-warning "Start-tag of undefined element %s; assume O O ANY" symbol-name shortmap empty sgml-lookup-shortref-map sgml-promoted-epos 6 append excludes 7 includes 8 12 1 vector nil message "Open element %s: after %s" 0 10 "Open element %s: first in %s" 11 sgml-eltype-model cl--assertion-failed run-hook-with-args sgml-open-element-hook sgml-element-empty sgml-close-element sgml-debug sgml-markup-tree] 39 (#$ . 121476)])
#@32 

(fn TREE EL &optional STATE)
(defalias 'sgml-fake-open-element #[770 "\300\301N\302H\"\300\303N\304H\"\305\306\307\306\307	\306\n\n\n\307\211\211\211\211\211\211&\207" [append excludes 7 includes 8 vector 0 nil] 26 (#$ . 122714)])
#@29 

(fn BEFORE-TAG AFTER-TAG)
(defalias 'sgml-close-element #[514 "\306=\204\f 	=\203 `\203 \307\310\"\210\f\203\" \311\312	\313H\"\210	\211\314\315!I\266	\211\316ZI\266\317\320!\210		=\203J m?\205e \321\322!\207		\323H	\324H	\325H\204d \326\327!\210\330\207" [sgml-close-element-trap sgml-current-tree sgml-goal sgml-throw-on-element-change sgml-debug sgml-markup-tree t throw end message "Close element %s" 0 2 sgml-epos 4 run-hooks sgml-close-element-hook sgml-error "Parse ended" 9 15 5 cl--assertion-failed sgml-current-state nil sgml-top-tree sgml-previous-tree sgml-current-shortmap] 7 (#$ . 122968)])
#@13 

(fn TREE)
(defalias 'sgml-fake-close-element #[257 "\211\300H\207" [5] 3 (#$ . 123605)])
#@25 

(fn AT &optional END)
(defalias 'sgml-note-change-at #[513 "\205\310 	\203 \305\306\"\210\307!\n>\204 \310\311\312D\"\210\313H\211\205\306 \203= eV\203= \2062 `Sf\314=\203= S\262\211\315H\203V \316\315H!V\203V \211\315H\211\262\202\300 \211\211\315\317I\266\211\313H\203} \320!V\203} \211\321H\322V\204y \323!\203} \317\202\306 \211\211\313\317I\266\211\324H\203\235 \316\324H!V\203\235 \211\324H\211\262\202\300 \211\325H\322U\203\271 \326!V\203\271 \326!\262\f\211\262\202\300 \211\211\324\317I\262\205\306 \202= \262\207" [sgml-buffer-parse-state sgml-debug cl-struct-sgml-pstate-tags sgml-xml-p sgml-top-tree message "sgml-note-change-at %s" type-of signal wrong-type-argument sgml-pstate 2 47 10 sgml-element-stag-end nil sgml-tree-end 4 0 sgml-element-empty 11 3 sgml-element-start] 7 (#$ . 123702)])
#@174 Return a list of the tags implied by a token TOKEN.
TOKEN is a token, and the list elements are either tokens or `t'.
Where the latter represents end-tags.

(fn TOKEN TYPE)
(defalias 'sgml-list-implications #[514 "	\305\211\n=\204.\211:\262\203l \306H>\204l \307H>\204.9\2030 \305\266\202\202i @\310=\203c \211A@\236\206D \211AA\236\211\205^ \211A\211@\310=\203U \211\202\\ \311A@#\262\266\203\202i \312\"\266\202\204.=\204\235 \211\211:\262?\206\222 \211\211@\310=\203\215 \211AA?\266\202\202\224 \313!\262\262\203\265 \f=\204\265 =\204\250 \314B\262\315H\262\316!\262\202 \317!\211\262\203!A\204!@\262\3209\203\330 \305\266\202\202@\310=\203\211A@\236\206\354 \211AA\236\211\205\211A\211@\310=\203\375 \211\202\311A@#\262\266\203\202\312\"\266\202#\262\321!\262B\262\202 \322\323\"\210\305\211\262\204 \211\237\207" [sgml-current-state sgml-current-tree sgml-any sgml-empty sgml-top-tree nil 7 8 normal-state sgml-next-sub-and sgml-get-and-move sgml-final-and t 9 sgml-fake-close-element sgml-required-tokens sgml-fake-open-element sgml-element-model sgml-log-warning "Out of context %s"] 17 (#$ . 124548)])
#@81 Return list of element types (eltype) valid in STATE and TREE.

(fn TREE STATE)
(defalias 'sgml-eltypes-in-state #[514 "\211\211:\262\205 \302!\211:\262\205 \211\303\304!\"\244\305H\306:\203: @\262\211>\2043 \211B\262A\262\202 \266\307H\306:\203V @\262\303\"\262A\262\202@ \266	\203\241 \211\211:\262?\206| \211\211@\310=\203w \211AA?\266\202\202~ \311!\262\262\204\241 \203\241 A\204\241 @\312!\203\240 \313\314\"\315!\"\244\262\210\207" [sgml-pcdata-token sgml-omittag-transparent sgml-required-tokens delq sgml-optional-tokens 8 nil 7 normal-state sgml-final-and sgml-eltype-stag-optional sgml-eltypes-in-state sgml-fake-open-element sgml-eltype-model] 10 (#$ . 125748)])
#@61 Return a list of contextually valid element types (eltype).
(defalias 'sgml-current-list-of-valid-eltypes #[0 "\303	\"	\n\203n \203n \211\211\211:\262?\206. \211\211@\304=\203) \211AA?\266\202\2020 \305!\262\262\203n \306\307H!\262\203n \310H\262\311H\262\303\"\312:\203i @\262\211>\204b C\244\262A\262\202M \266\202\n \313\314\"\207" [sgml-current-tree sgml-current-state sgml-omittag-transparent sgml-eltypes-in-state normal-state sgml-final-and sgml-eltype-etag-optional 0 9 5 nil sort string-lessp] 7 (#$ . 126473)])
#@62 Return a list of the element types endable in current state.
(defalias 'sgml-current-list-of-endable-eltypes #[0 "\304	\211\211\211:\262?\206# \211\211@\305=\203 \211AA?\266\202\202% \306!\262\262\203O \n=\204O \307HC\244\262\203O \310\307H!\203O \311H\262\312H\262\202 \207" [sgml-current-tree sgml-current-state sgml-top-tree sgml-omittag nil normal-state sgml-final-and 0 sgml-eltype-etag-optional 9 5] 7 (#$ . 127027)])
(defconst sgml-log-buffer-name "*SGML LOG*")
(defvar sgml-log-last-size 0)
(defalias 'sgml-display-log #[0 "\302!\211\205 \303!\210r\211q\210d)\211\207" [sgml-log-buffer-name sgml-log-last-size get-buffer display-buffer] 3])
#@28 

(fn FORMAT &rest THINGS)
(defalias 'sgml-log-message #[385 "\302\303#\304!pq\210db\210\305\261\210\306!\203 d\211q\207" [sgml-log-buffer-name sgml-log-last-size apply format get-buffer-create "\n" get-buffer-window] 7 (#$ . 127704)])
(defalias 'sgml-reset-log #[0 "\302!\211\205 r\211q\210d)\211\207" [sgml-log-buffer-name sgml-log-last-size get-buffer] 3])
(defalias 'sgml-clear-log #[0 "\302!\211\205 \303!\210\304!\210\305\211\207" [sgml-log-buffer-name sgml-log-last-size get-buffer delete-windows-on kill-buffer 0] 3])
#@88 Show the *SGML LOG* buffer if it is not showing.
clear and remove it if it is showing.
(defalias 'sgml-show-or-clear-log #[0 "\301!\203 \302!\204 \303 \207\304 \207" [sgml-log-buffer-name get-buffer get-buffer-window sgml-display-log sgml-clear-log] 2 (#$ . 128253) nil])
(defalias 'sgml-log-entity-stack #[0 "\212\303\304\206 \305 \206 \306\307e`\"i	\205 	@\211\203* \211A@\203* \310\311@\"\202+ \312\262%\210\313\302!\203? \n\203? \nq\210\202 )\314\207" [sgml-current-file sgml-current-eref sgml-previous-buffer sgml-log-message "%s line %s col %s %s" buffer-file-name "-" count-lines format "entity %s" "" boundp nil] 9])
#@108 True if a warning message has been displayed.
To avoid clearing message with out showing previous warning.
(defvar sgml-warning-message-flag nil (#$ . 128896))
#@28 

(fn FORMAT &rest THINGS)
(defalias 'sgml-log-warning #[385 "\203 \304\305#\210\306\307\"\210	\204 \n\205  \304\310#\210\307\211\207" [sgml-throw-on-warning sgml-show-warnings sgml-parsing-dtd sgml-warning-message-flag apply message throw t sgml-message] 6 (#$ . 129062)])
#@28 

(fn FORMAT &rest THINGS)
(defalias 'sgml-error #[385 "\203	 \302\303\"\210\303\304\305\306\307#\310 #\207" [sgml-throw-on-error sgml-warning-message-flag throw nil error "%s%s" apply format sgml-entity-stack] 8 (#$ . 129351)])
(defalias 'sgml-entity-stack-1 #[0 "\303\304\206\f \305 \206\f \306\307e`\"i	\205 	@\211\203) \211A@\203) \303\310@\"\202* \311\262\312\302!\203> \n\203> \nq\210\313 \202? \311&\207" [sgml-current-file sgml-current-eref sgml-previous-buffer format "\n %s line %s col %s %s%s" buffer-file-name "-" count-lines "entity %s" "" boundp sgml-entity-stack-1] 9])
(defalias 'sgml-entity-stack #[0 "\212\300 )\207" [sgml-entity-stack-1] 1])
#@28 

(fn FORMAT &rest THINGS)
(defalias 'sgml-parse-warning #[385 "\301\302\303\304#\305 #\210\306\211\207" [sgml-warning-message-flag message "%s%s" apply format sgml-entity-stack t] 8 (#$ . 130028)])
#@28 

(fn FORMAT &rest THINGS)
(defalias 'sgml-parse-error #[385 "\300\301\302P\303\304`d`\305\\^\"C\"#\207" [apply sgml-error "; at: %s" append buffer-substring-no-properties 12] 12 (#$ . 130236)])
#@28 

(fn FORMAT &rest THINGS)
(defalias 'sgml-message #[385 "\301\232\204 \302\303\"\205 ?\205 \304\305#\210\306\211\207" [sgml-warning-message-flag "" string-match "\\.\\.done$" apply message nil] 6 (#$ . 130439)])
(defvar sgml-lazy-time 0)
#@19 

(fn &rest ARGS)
(defalias 'sgml-lazy-message #[128 "\301 A@U?\205 \302\303\"\210\301 A@\211\207" [sgml-lazy-time current-time apply message] 4 (#$ . 130693)])
(defconst sgml-shortref-list '("	" "\n" "" "B" "\n" "B\n" "B\n" " " "BB" "\"" "#" "%" "'" "(" ")" "*" "+" "," "-" "--" ":" ";" "=" "@" "[" "]" "^" "_" "{" "|" "}" "~"))
#@15 

(fn STRING)
(defalias 'sgml-shortref-index #[257 "\211\235G\205 \211GZ\207" [sgml-shortref-list] 5 (#$ . 131037)])
#@95 Create a shortreference map from PAIRS.
Where PAIRS is a list of (delim . ename).

(fn PAIRS)
(defalias 'sgml-make-shortmap #[257 "\301GT\302\"\302\302\211\211:\2039 @\262@\262A\262\303!\262\204- \304\305\"\210\2022 I\210A\262\202 \266\306\307\310\311\312\313\314	!\315\"\316\317%\320\"\203T \321\202U \322I\210\207" [sgml-shortref-list make-vector nil sgml-shortref-index sgml-log-warning "Illegal short reference delimiter '%s'" 32 cl-some make-byte-code 257 "\300\301!H\207" vconcat vector [sgml-shortref-index] 4 "\n\n(fn R)" ("B\n" "B\n" " " "BB") "^<]/& \n	\"#%'()*+,\\-:;=@[]\\^_{|}~" "^<]/&\n	\"#%'()*+,\\-:;=@[]\\^_{|}~"] 12 (#$ . 131165)])
#@12 

(fn MAP)
(defalias 'sgml-shortmap-skipstring #[257 "n\203 \300\207\211\301H\207" ["" 32] 3 (#$ . 131846)])
(defconst sgml-shortref-oneassq (byte-code "\301\211\211:\2035 @\262\302H\262G\303U\203. \303U\204. \304U\204. \305!BB\262A\262\202 \211\237\207" [sgml-shortref-list nil 0 1 10 sgml-shortref-index] 7))
(defalias 'sgml-parse-B #[0 "\300\301w\302U?\207" [" 	" nil 0] 2])
#@154 Identify shortref delimiter at point and return entity name.
Also move point.  Return nil, either if no shortref or undefined.

(fn MAP &optional NOBOL)
(defalias 'sgml-deref-shortmap #[513 "\211\203 \301\202	 \302\211\247\203\271 n\203B \211\302U\203B \303 \203- l\203' \304H\202\264 \305H\202\264 \306 \2038 \307H\202\264 \310H\206\264 \301\202\264 g\311=\203S \301u\210\302H\262\202a g\312=\203~ \301u\210\313H\262\303 \203k \314H\262g\315=\203z \301u\210\316H\202\264 \211\202\264 \306 \203\211 \301H\202\264 g\317=\203\240 `Tf\317=\203\240 \310u\210\320H\202\264 g\236\211\262\205\264 \211\203\260 \301u\210AH\262\202	 \211\207" [sgml-shortref-oneassq 1 0 sgml-parse-B 5 3 sgml-parse-RE 4 2 9 32 7 8 10 6 45 19] 5 (#$ . 132248)])
(defalias 'sgml-make-shortref-table #[0 "\300C\207" [nil] 1])
#@23 

(fn TABLE NAME MAP)
(defalias 'sgml-add-shortref-map #[771 "BC\244\207" [] 6 (#$ . 133070)])
#@19 

(fn TABLE NAME)
(defalias 'sgml-lookup-shortref-map #[514 "\300A\"A\207" [assoc] 5 (#$ . 133174)])
#@18 

(fn TABLE MAP)
(defalias 'sgml-lookup-shortref-name #[514 "\300A\"@\207" [rassq] 5 (#$ . 133283)])
#@86 Merge tables of short reference maps TAB2 into TAB1, modifying TAB1.

(fn TAB1 TAB2)
(defalias 'sgml-merge-shortmaps #[514 "A\244\207" [] 4 (#$ . 133392)])
(defalias 'sgml-skip-until-dsc #[0 "\203 \301\302w\210\202 \303\302w\210g\304=\205 \305u\210\306?\205I \307 \204  g\310=\2031 \305u\210\311 \210\202  \203: \312 \204  \204C \313 \204  \305u\210\202  \207" [sgml-xml-p "^[]'\"<\\-" nil "^[]'\"\\-" 93 1 t sgml-parse-literal 91 sgml-skip-until-dsc sgml-parse-xml-comment sgml-parse-comment] 2])
#@116 Move point forward until end of current markup declaration.
Assumes starts with point inside a markup declaration.
(defalias 'sgml-skip-upto-mdc #[0 "\300\301w\210g\302=\205 \303?\205. g\304=\203 \305u\210\306 \210\202  \307 \204  \310 \204  \305u\210\202  \207" ["^[>\"'\\-" nil 62 t 91 1 sgml-skip-until-dsc sgml-parse-literal sgml-parse-comment] 2 (#$ . 133905)])
(defalias 'sgml-do-sgml-declaration #[0 "\301 \210\302\211\207" [sgml-markup-type sgml-skip-upto-mdc sgml] 2])
(defalias 'sgml-do-doctype #[0 "\203\n \303 \210\202& \304\305\306!\210\307\304\310!\206 \311\312!\262\313 \"\210\305\314!\210)\315\211\207" [sgml-dtd-info sgml-markup-start sgml-markup-type sgml-skip-upto-mdc nil message "Parsing doctype..." sgml-setup-doctype sgml-parse-name sgml-parse-error "Name expected" sgml-parse-external "Parsing doctype...done" doctype] 4])
#@13 

(fn TYPE)
(defalias 'sgml-check-end-of-entity #[257 "m?\205\n \300\301g#\207" [sgml-parse-error "Illegal character '%c' in %s"] 5 (#$ . 134767)])
#@25 

(fn DOCNAME EXTERNAL)
(defalias 'sgml-setup-doctype #[514 "\304\305\306\307 \310 \310 \311 \312\211\211\211&	\312\211\203J \313\312w\305U?\206P \314\312w\305U?\206P g\315=\203; \316u\210\304\262\202R g\317=\205E \316u\210\304\262\202R \320\312w\305U?\262\204 m\203^ \321 \204 g\322=\203y `Tf\206k \305z\323=\203y \316u\210\324 \204 \325 \204 g\326=\203\252 \316u\210p\327 \210p=\203\244 g\330=\203\235 \316u\210\202\251 \331\332!\210\202\251 \333\334g\"\210\210\211\203\300 \335\336\312F!\210\327 \210\337\340!\210\321 \210\203\353 \n\341H\342\343\344\345$\210\342\346\344\347$\210\342\350\344\351$\210\342\352\344\353$\210\342\354\344\355$\266\356\n!\210\357\360!)\207" [sgml-parsing-dtd sgml-no-elements sgml-dtd-info sgml-xml-p t 0 vector sgml-make-eltype-table sgml-make-entity-table sgml-make-shortref-table nil " " "	" 10 1 13 " 	\n" sgml-pop-entity 37 119 sgml-do-parameter-entity-ref sgml-parse-comment 91 sgml-check-dtd-subset 93 sgml-delimiter-parse-error "DSC" sgml-parse-error "Illegal character '%c' in doctype declaration" sgml-push-to-entity dtd sgml-check-end-of-entity "DTD subset" 3 sgml-entity-declare "lt" text "&#60;" "gt" ">" "amp" "&#38;" "apos" "'" "quot" "\"" sgml-set-initial-state run-hooks sgml-doctype-parsed-hook] 12 (#$ . 134922)])
#@100 Move point forward until there is an end-tag open after point.

(fn TYPE &optional MARKED-SECTION)
(defalias 'sgml-do-data #[513 "`\306\306?\205\363 \203G \n=\203 \307\202 \310\306w\210\203' \311`\"!\210g\312=\205B `Tf\312=\205B \313`\\f\314=\205B \315u\210\316\262\202\234 \n=\203Q \317\202R \320\306w\210\203` \311`\"!\210g\321=\203\215 `Tf\322=\203\215 \313`\\f\206v \323z\324=\204\211 \f\203\215 \313`\\f\314=\203\215 \316\202\232 g\322=\205\232 \f\205\232 \325H\262`\262\204 m\203\302 \211=\203\271 \326\327\205\267 \330#\210\331 \210`\262\202 \204\314 \332u\210\202 g\333=\203\355 `Tf\206\331 \323z\324=\203\355 \332u\210\334 \203\355 `\262\202 \332u\210\202 )\207" [sgml-current-eref sgml-signal-data-function sgml-cdata sgml-data-function sgml-current-shorttag sgml-current-tree nil "^]" "^&]" buffer-substring-no-properties 93 2 62 3 t "^</" "^</&" 60 47 0 119 12 sgml-error "Unterminated %s %s" "marked section" sgml-pop-entity 1 38 sgml-do-general-entity-ref] 9 (#$ . 136216)])
(defalias 'sgml-do-marked-section #[0 "\306\306\211\2036 \307\306w\310U?\206< \311\306w\310U?\206< g\312=\203' \313u\210\314\262\202> g\315=\2051 \313u\210\314\262\202> \316\306w\310U?\262\204 m\203J \317 \204 g\320=\203e `Tf\206W \310z\321=\203e \313u\210\322 \204 \323 \204 g\324=\203v \313u\210\202\211 \306\325!\206\200 \326\327!\262B\262\202 \330\235\203\251 \331 \210\332\203\241 	\204\241 \333\n`#\210\211\211\262\202\372 \334\235\204\265 \335\235\203\346 \f\203\274 \f \210\334\235\203\306 \202\310  \336\314\"\210\211\203\334 	\204\334 \333\n`#\210\211\211\262\262\202\372 \337\203\365 	\204\365 \333\n`#\210\211\211\262\207" [sgml-set-face sgml-current-eref sgml-markup-start sgml-markup-type sgml-signal-data-function sgml-cdata nil " " 0 "	" 10 1 t 13 " 	\n" sgml-pop-entity 37 119 sgml-do-parameter-entity-ref sgml-parse-comment 91 sgml-parse-name sgml-parse-error "Name expected" "IGNORE" sgml-skip-marked-section ignored sgml-set-face-for "CDATA" "RCDATA" sgml-do-data ms-start sgml-rcdata] 7])
(defalias 'sgml-skip-marked-section #[0 "\300\301w\210m\203\f \302\303!\210g\304=\205' `Tf\304=\205' \305`\\f\306=\205' \307u\210\310?\205Q g\311=\203K `Tf\312=\203K \305`\\f\313=\203K \307u\210\314 \210\202  \315u\210\202  \207" ["^<]" nil sgml-error "Marked section unterminated" 93 2 62 3 t 60 33 91 sgml-skip-marked-section 1] 2])
(defalias 'sgml-do-usemap #[0 "\303g\304=\203 \305u\210\306\307!\204 \303\310!\206 \311\312!\262\262\303\211\203S \313\303w\314U?\206Y \315\303w\314U?\206Y g\316=\203D \305u\210\317\262\202[ g\320=\205N \305u\210\317\262\202[ \321\303w\314U?\262\204 m\203g \322 \204 g\323=\203\202 `Tf\206t \314z\324=\203\202 \305u\210\325 \204 \326 \204 g\327=\203\276 \203\236 \330\331\203\233 \202\234 \332\"\210	\203\270 \211\205\263 \333	\334H\"\206\263 \335\336\"\211\202\301 \337\340!\202\301 \341!\207" [sgml-debug sgml-dtd-info sgml-current-shortmap nil 35 1 sgml-check-token "EMPTY" sgml-parse-name sgml-parse-error "Name expected" " " 0 "	" 10 t 13 " 	\n" sgml-pop-entity 37 119 sgml-do-parameter-entity-ref sgml-parse-comment 62 message "USEMAP %s" "#EMPTY" sgml-lookup-shortref-map 4 sgml-error "Undefined shortref map %s" sgml-log-warning "USEMAP without associated element type in prolog" sgml-do-usemap-element] 4])
(defconst sgml-markup-declaration-table '(("SGML" . sgml-do-sgml-declaration) ("DOCTYPE" . sgml-do-doctype) ("ELEMENT" . sgml-declare-element) ("ENTITY" . sgml-declare-entity) ("USEMAP" . sgml-do-usemap) ("SHORTREF" . sgml-declare-shortref) ("NOTATION" . sgml-declare-notation) ("ATTLIST" . sgml-declare-attlist) ("USELINK" . sgml-skip-upto-mdc) ("LINKTYPE" . sgml-skip-upto-mdc) ("LINK" . sgml-skip-upto-mdc) ("IDLINK" . sgml-skip-upto-mdc)))
#@164 Parse a markup declaration.
OPTION can be `prolog' if parsing the prolog or `dtd' if parsing the
dtd or `ignore' if the declaration is to be ignored.

(fn OPTION)
(defalias 'sgml-parse-markup-declaration #[257 "\203	 \306 \206\273g\307=\203\237`Tf\310=\203\237\311`\\f\206 \312z\313=\204@ \311`\\f\314=\2037 \315`\\f\314=\204@ \311`\\f\316=\203\237\311u\210m\204gz\313=\203\317\320 \321\322!\n\"\323>\204i \324\235\203i \325\326\"\210\327>\204z \330\235\203z \325\331\"\210\332=\203\206 \333 \210\202\377 \211\203\372 \317\211\203\277 \334\317w\312U?\206\305 \335\317w\312U?\206\305 g\336=\203\260 \337u\210\340\262\202\307 g\341=\205\272 \337u\210\340\262\202\307 \342\317w\312U?\262\204\212 m\203\323 \343 \204\212 g\344=\203\356 `Tf\206\340 \312z\313=\203\356 \337u\210\345 \204\212 \346 \204\212 \211A \210\202\377 \347\350\"\210\266\202\351\317\211\203;\334\317w\312U?\206A\335\317w\312U?\206Ag\336=\203,\337u\210\340\262\202Cg\341=\2056\337u\210\340\262\202C\342\317w\312U?\262\204m\203O\343 \204g\344=\203j`Tf\206\\\312z\313=\203j\337u\210\345 \204\346 \204g\316=\203{\337u\210\202\352\353!\210\211\332=\204\235	\203\235	\203\230\f\204\230\354`#\210\211\211\266\340\207g\307=\205\273`Tf\310=\205\273\311`\\f\355=\205\273\315u\210\356 \207" [sgml-xml-p sgml-markup-type sgml-markup-declaration-table sgml-set-face sgml-current-eref sgml-markup-start sgml-parse-xml-comment 60 33 2 0 119 45 3 62 nil sgml-parse-nametoken assoc sgml-check-case (prolog ignore) ("SGML" "DOCTYPE") sgml-error "%s declaration is only valid in prolog" (dtd ignore) ("ELEMENT" "ENTITY" "ATTLIST" "NOTATION" "SHORTREF") "%s declaration is only valid in doctype" ignore sgml-skip-upto-mdc " " "	" 10 1 t 13 " 	\n" sgml-pop-entity 37 sgml-do-parameter-entity-ref sgml-parse-comment sgml-parse-error "Illegal markup declaration %s" comment sgml-delimiter-parse-error "MDC" sgml-set-face-for 91 sgml-do-marked-section] 6 (#$ . 140003)])
#@50 Set of `id' attributes that we have encountered.
(defvar psgml-ids-seen (make-hash-table :test 'equal) (#$ . 141988))
#@176 Parse an attribute specification list.
Optional argument ELTYPE, is used to resolve omitted name=.
Returns a list of attspec (attribute specification).

(fn &optional ELTYPE)
(defalias 'sgml-parse-attribute-specification-list #[256 "\304\211\205	 \211\305N\304\211\211\211\304\211\203B \306\304w\307U?\206H \310\304w\307U?\206H g\311=\2033 \312u\210\313\262\202J g\314=\205= \312u\210\313\262\202J \315\304w\307U?\262\210\316 \211\262\203k\304\211\203\210 \306\304w\307U?\206\216 \310\304w\307U?\206\216 g\311=\203y \312u\210\313\262\202\220 g\314=\205\203 \312u\210\313\262\202\220 \315\304w\307U?\262\210g\317=\203	\312u\210\304\211\203\317 \306\304w\307U?\206\325 \310\304w\307U?\206\325 g\311=\203\300 \312u\210\313\262\202\327 g\314=\205\312 \312u\210\313\262\202\327 \315\304w\307U?\262\210\320\321!\262\204\347 \304\262\2026\2036\322\"\211\262\2046	\2046\323\324\325!\262#\210\2026\204\326\327!\210\2026\n\204\323\330!\210\331\211\262\"\211\262\2046\323\332\325!\262#\210\211\203`\333!\334=\203H\335\313#\210\336\337!\"B\262\340\341\342!\"\203 \313\202 \336\"B\262\202 \207" [sgml-conref-flag sgml-dtd-less sgml-current-shorttag psgml-ids-seen nil attlist " " 0 "	" 10 1 t 13 " 	\n" sgml-parse-nametoken 61 sgml-parse-attribute-value-specification warn sgml-lookup-attdecl sgml-log-warning "Attribute %s not declared for element %s" symbol-name sgml-parse-error "Expecting a =" "Must have attribute name when SHORTTAG NO" sgml-find-attdecl-for-value "%s is not in any name group for element %s" sgml-attdecl-declared-value ID puthash sgml-make-attspec sgml-attdecl-name sgml-default-value-type-p CONREF sgml-attdecl-default-value] 12 (#$ . 142113)])
(defalias 'sgml-check-attribute-value-specification #[0 "\301 \206 \302\303!\203 \304\305!\210\206 \306\307!\207" [sgml-xml-p sgml-parse-literal sgml-parse-nametoken t sgml-parse-warning "XML forbids undelimited literals." sgml-parse-error "Expecting an attribute value: literal or token"] 3])
#@23 

(fn &optional WARN)
(defalias 'sgml-parse-attribute-value-specification #[256 "\300 \206 \301\302!\206 \211\205 \303\304!\210\305\207" [sgml-parse-literal sgml-parse-nametoken t sgml-log-warning "Expecting an attribute value: literal or token" nil] 3 (#$ . 144142)])
#@142 Find the attribute declaration of ELTYPE that has VALUE in its name group.
VALUE is a string.  Returns nil or an attdecl.

(fn VALUE ELTYPE)
(defalias 'sgml-find-attdecl-for-value #[514 "\211\300N\301\203\" \302@!\211\262:\203 \303!\235\204\" A\262\202 \205( @\207" [attlist nil sgml-attdecl-declared-value sgml-declared-value-token-group] 7 (#$ . 144421)])
#@53 Make sure that an eventual DTD is parsed or loaded.
(defalias 'sgml-need-dtd #[0 "\306 \210\307 \210\204# \310\311\312\"\210\313\301!\210\314\n\203  \315\n!\210\202# \316 \210\203- \317\320\321 \"\210\322!\f>\204< \323\324\325D\"\210\326H\322!\f>\204O \323\324\325D\"\210\327H\330 \207" [sgml-buffer-parse-state sgml-auto-fill-inhibit-function sgml-default-dtd-file sgml-debug cl-struct-sgml-pstate-tags sgml-dtd-info sgml-pop-all-entities sgml-cleanup-entities add-hook pre-command-hook sgml-reset-log make-local-variable sgml-in-prolog-p sgml-load-dtd sgml-load-doctype message "Need dtd getting state from %s" buffer-name type-of signal wrong-type-argument sgml-pstate 1 2 sgml-set-global sgml-top-tree] 4 (#$ . 144796)])
#@88 Load the documents DTD.
Either from parent document or by parsing the document prolog.
(defalias 'sgml-load-doctype #[0 "\204 	\203@ \212\304:\203 @\202 	\206 !q\210\305 \210\306\n!>\204. \307\310\311\nD\"\210\n\312H)\313!\210:\205? \314A!\207\212\315 )\207" [sgml-parent-document sgml-doctype sgml-buffer-parse-state cl-struct-sgml-pstate-tags find-file-noselect sgml-need-dtd type-of signal wrong-type-argument sgml-pstate 1 sgml-set-initial-state sgml-modify-dtd sgml-parse-prolog] 4 (#$ . 145539) nil])
#@17 

(fn MODIFIER)
(defalias 'sgml-modify-dtd #[257 "\306!	>\204 \307\310\311D\"\210\312H\306!	>\204\" \307\310\311D\"\210\313H\314 \210\211A@;\203F \315\316@!!\317\320ee$\210A\266\202\202+ \211@;\204P \321\322!\210\211@\315\3169\203_ \323!\202` !!\211\324\320\211BB\324\320\211BBAA\236\206\205 \211ABAAB\241\262\266\266\203A:\203\317\320ee$\210A@\320:\203 @\262\315\316!!9\203\266 \320\266\202\202\357 @\324=\203\351 \211A@\236\206\312 \211AA\236\211\205\344 \211A\211@\324=\203\333 \211\202\342 \325A@#\262\266\203\202\357 \326\"\266\202\211\204\370 \321\327\"\210A\262\202\234 \266\266\306!	>\204\307\310\311D\"\210\313H\211\211\330\f\330HI\266\211\211\331\f\331HI\266\211\211\332I\266\211\333H\211M\266\211\211\334\320I\262\207" [sgml-buffer-parse-state cl-struct-sgml-pstate-tags sgml-dtd-info sgml-top-tree sgml-current-tree sgml-current-state type-of signal wrong-type-argument sgml-pstate 1 2 sgml-set-global sgml-lookup-eltype sgml-general-case sgml-open-element nil error "Wrong format of sgml-parent-document" symbol-name normal-state sgml-next-sub-and sgml-get-and-move "Illegal has-seen-element in sgml-parent-document: %s" 8 7 14 0 11 sgml-current-shortmap] 13 (#$ . 146064)])
(defalias 'sgml-set-global #[0 "\n\f	\np\306\211\f\207" [sgml-namecase-general sgml-current-namecase-general sgml-omittag sgml-current-omittag sgml-shorttag sgml-current-shorttag nil sgml-local-catalogs sgml-current-localcat sgml-local-ecat-files sgml-current-local-ecat sgml-current-top-buffer sgml-markup-start] 2])
#@45 Parse the document prolog to learn the DTD.
(defalias 'sgml-parse-prolog #[0 "\203\n \306\307\310 \"\210\204 \311 \210\306\312!\210\313 \210\314 \210\315eb\210\315\n?\205' p\316 \317 p\320\321\322\323\324\"\325\"\326$\216\327\n\203G \202I 8!\210\320\321\330\323\324\"\331\"\332$\216`9\315\211\203\222 \333\315w\321U?\206\230 \334\315w\321U?\206\230 g\335=\203\203 \336u\210\337\262\202\232 g\340=\205\215 \336u\210\337\262\202\232 \341\315w\321U?\262\204Z \315g\342=\205\262 `Tf\343=\205\262 \326u\210\344!\262\204Z \345\346!\203\301 	\203Z 	\204:\203\321 \347:!\206\ng\342=\205\n`Tf\206\336 \321z\350=\204\361 ;\205\n`Tf\351=\205\n\336u\210m?\205\ngz\350=\205\n\347\352`\353\354!\210`\"!\211\203\355\356\"\210\210*\266*\357\360!\210	?\206-\361\321\362	\336H\315\"\"G\336U0\n\203E0\203E\357\363!\210\3153\357\303!\210\315	\204M\364\365!\210\366\367!\207" [sgml-debug sgml-dtd-info sgml-xml-p sgml-warn-about-undefined-entities sgml-set-face xml-parser-syntax message "Parse prolog in buffer %s" buffer-name sgml-clear-log "Parsing prolog..." sgml-cleanup-entities sgml-set-global nil buffer-modified-p syntax-table make-byte-code 0 "r\301q\210\302\300!)\207" vconcat vector [set-syntax-table] 2 set-syntax-table "p\300q\210\301\204 \304\301!\210\205 \305\306\301\"\207" [sgml-last-buffer sgml-debug restore-buffer-modified-p message "Restoring buffer mod: %s"] 3 " " "	" 10 1 t 13 " 	\n" 60 63 sgml-do-processing-instruction sgml-parse-markup-declaration prolog sgml-general-case 119 62 buffer-substring-no-properties skip-syntax-forward "w_" sgml-setup-doctype (nil) make-local-variable sgml-dtd-less delq append sgml-warn-about-undefined-elements error "No document type defined by prolog" sgml-message "Parsing prolog...done" sgml-parser-syntax sgml-markup-start sgml-default-doctype-name sgml-current-shorttag] 11 (#$ . 147659) nil])
#@185 Parse until the CLOSE-ELEMENT-TRAP has ended.
Or if it is t, any additional element has ended,
or if nil, until end of buffer.

(fn CLOSE-ELEMENT-TRAP &optional CONT EXTRA-COND QUIET)
(defalias 'sgml-parse-until-end-of #[1025 "	\203\n \304\305!\210\203 \306d!\210\202 \307d#\210m\2038 \310=\206. \n=\206. \n=?\311\312``#\210\204 	\205? \304\313!)\207" [sgml-close-element-trap sgml-debug sgml-current-tree sgml-top-tree message "-> sgml-parse-until-end-of" sgml-parse-continue sgml-parse-to t sgml-implied-end-tag "buffer end" "<- sgml-parse-until-end-of"] 9 (#$ . 149555)])
#@293 Parse until (at least) GOAL.
Optional argument EXTRA-COND should be a function.  This function is
called in the parser loop, and the loop is exited if the function returns t.
If third argument QUIET is non-nil, no "Parsing..." message will be displayed.

(fn GOAL &optional EXTRA-COND QUIET)
(defalias 'sgml-parse-to #[769 "\304 \210p\305 \306 p\307\310\311\312\313\"\314\"\315$\216\316	\203# \n\202$ !\210\307\310\317\312\313\"\320\"\321$\216\322d^!\210\206E \323 Z\324W\262\204O \325\326!\210\327!\210?\205\\ \325\330!*\266\202\266\202)\207" [sgml-goal sgml-xml-p xml-parser-syntax sgml-parser-syntax sgml-need-dtd buffer-modified-p syntax-table make-byte-code 0 "r\301q\210\302\300!)\207" vconcat vector [set-syntax-table] 2 set-syntax-table "p\300q\210\301\204 \304\301!\210\205 \305\306\301\"\207" [sgml-last-buffer sgml-debug restore-buffer-modified-p message "Restoring buffer mod: %s"] 3 sgml-goto-start-point sgml-mainbuf-point 500 sgml-message "Parsing..." sgml-parser-loop ""] 14 (#$ . 150148)])
#@68 Parse until (at least) GOAL.

(fn GOAL &optional EXTRA-COND QUIET)
(defalias 'sgml-parse-continue #[769 "	\204\n \306\301!\210\211\204 \307\310!\210\n\203 \311\312!\210p\313 \314 p\315\316\317\320\321\"\322\"\323$\216\324\2038 \f\2029 !\210\315\316\325\320\321\"\326\"\327$\216q\210\330!\210*\266\211?\205^ \307\331!)\207" [sgml-goal sgml-current-tree sgml-debug sgml-xml-p xml-parser-syntax sgml-parser-syntax cl--assertion-failed sgml-message "Parsing..." message "Parse continue" buffer-modified-p syntax-table make-byte-code 0 "r\301q\210\302\300!)\207" vconcat vector [set-syntax-table] 2 set-syntax-table "p\300q\210\301\204 \304\301!\210\205 \305\306\301\"\207" [sgml-last-buffer sgml-debug restore-buffer-modified-p message "Restoring buffer mod: %s"] 3 sgml-parser-loop "" sgml-last-buffer] 14 (#$ . 151184)])
#@228 Reparse the buffer and let SHORTREF-FUN take care of short references.
SHORTREF-FUN is called with the entity as argument and `sgml-markup-start'
pointing to start of short ref and point pointing to the end.

(fn SHORTREF-FUN)
(defalias 'sgml-reparse-buffer #[257 "\301e!\210\211\302\303!)\207" [sgml-shortref-handler sgml-note-change-at sgml-parse-until-end-of nil] 3 (#$ . 152033)])
#@14 

(fn TOKEN)
(defalias 'sgml-move-current-state #[257 "9\203 \301\266\202\202F @\302=\203@ \211A@\236\206! \211AA\236\211\205; \211A\211@\302=\2032 \211\2029 \303A@#\262\266\203\202F \304\"\266\202\206J \211\207" [sgml-current-state nil normal-state sgml-next-sub-and sgml-get-and-move] 9 (#$ . 152425)])
(put 'sgml-move-current-state 'byte-optimizer 'byte-compile-inline-expand)
#@18 

(fn IMPS TYPE)
(defalias 'sgml-execute-implied #[514 "\306:\203\240 @\262\211\307=\203 \310\211#\210\202\231 \211	9\203( \306\266\202\202a @\311=\203[ \211A@\236\206< \211AA\236\211\205V \211A\211@\311=\203M \211\202T \312A@#\262\266\203\202a \313\"\266\202\206e 	\211\266\n\203r \314\n\315\"\210\316\205} \f\317!=\211$\210\203\216 \320\321H!\204\231 \322\323\324!\262#\210A\262\202 \306\207" [sgml-markup-start sgml-current-state sgml-throw-on-element-change sgml-xml-p sgml-empty sgml-current-omittag nil t sgml-implied-end-tag normal-state sgml-next-sub-and sgml-get-and-move throw start sgml-open-element sgml-eltype-model sgml-eltype-stag-optional 0 sgml-log-warning "%s start-tag implied by %s; not minimizable" symbol-name sgml-current-tree] 13 (#$ . 152826)])
#@19 

(fn TOKEN TYPE)
(defalias 'sgml-do-move #[514 "	=\206d \302\303\"\"\210	=?\205d 	9\203# \304\266\202\202\\ @\305=\203V \211A@\236\2067 \211AA\236\211\205Q \211A\211@\305=\203H \211\202O \306A@#\262\266\203\202\\ \307\"\266\202\206` 	\211\262\207" [sgml-any sgml-current-state sgml-execute-implied sgml-list-implications nil normal-state sgml-next-sub-and sgml-get-and-move] 11 (#$ . 153636)])
#@45 Modify parser state to reflect parsed data.
(defalias 'sgml-pcdata-move #[0 "\301\302\"\207" [sgml-pcdata-token sgml-do-move "data character"] 3 (#$ . 154056)])
(defalias 'sgml-parse-pcdata #[0 "\203\f \301!\302w\202 \303\302w\304U?\207" [sgml-current-shortmap sgml-shortmap-skipstring nil "^<]/&" 0] 2])
(put 'sgml-parse-pcdata 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'sgml-do-pcdata #[0 "\306 \210\307u\210\203 \310!\311w\202 \312\311w\313U\210	\203# 	\314\n`\"!\210\311\2032 \f\2042 \315\n`#\210\211\211\207" [sgml-current-shortmap sgml-data-function sgml-markup-start sgml-set-face sgml-current-eref sgml-markup-type sgml-pcdata-move 1 sgml-shortmap-skipstring nil "^<]/&" 0 buffer-substring-no-properties sgml-set-face-for] 5])
(put 'sgml-do-pcdata 'byte-optimizer 'byte-compile-inline-expand)
(defvar sgml-parser-loop-hook nil)
#@19 

(fn EXTRA-COND)
(defalias 'sgml-parser-loop #[257 "\306\307\310 \311\211\311\312\313\314\315\316!\317\"\320$\216\f=\203\217 `1W\204) 2\203\217 `3\306\2114\211\203d \321\306w\313U?\206j \322\306w\313U?\206j g\323=\203U \324u\210\311\262\202l g\325=\205_ \324u\210\311\262\202l \326\306w\313U?\262\204 \327\330!\204 \306g\331=\205\212 `Tf\332=\205\212 \320u\210\333!\262\204 `1W\204\233 2\205\276\205\241  ?\205\276\f\204\255 \334\304!\210`3\3064m\203\275 \335 \210\202\217 56=\204\315 57=\203g\331=\203\375 `Tf\336=\203\375 \320`\\f\206\343 \313z\337=\204\367 8\203\375 \320`\\f\340=\203\375 \320u\210\202g\336=\2038\203\f\341H\203\342 \210\202\217 \3435!\210\202\217 9\203B\3449`:=\"\211\262\20463b\210\202B3:;!\210\202\217 \f\211\313H\345JW\266\202\204\2209\211\203\205\321\306w\313U?\206\213\322\306w\313U?\206\213g\323=\203v\324u\210\311\262\202\215g\325=\205\200\324u\210\311\262\202\215\326\306w\313U?\262\204\217 g\331=\203\300`Tf\336=\203\300\320`\\f\206\246\313z\337=\204\2728\203\300\320`\\f\340=\203\300\320u\210\202\321g\336=\203\3278\203\327\f\341H\203\327\342 \210\202\217 g\331=\203 `Tf\206\344\313z\337=\204\3678\203 `Tf\340=\203 \324u\210\346 \210\202\217 g\347=\203`Tf\206\313z\337=\203\324u\210\350 \204\217 \327\306!\204\217 g\351=\203V`Tf\351=\203V\320`\\f\340=\203V\345u\210\352<\203M2\204M\3533`#\210\211\2114\266\202\217 \306g\331=\205k`Tf\332=\205k\320u\210\333!\262\204\217 -\203{\354\355!\204\217 \307 \210\324u\2109\203\217\3569!\306w\202\222\357\306w\313U\210=\203\243=\3603`\"!\210\306<\203\2652\204\265\3533`#\210\211\2114\266\202\217 ,\262)\207" [sgml-signal-data-function buffer-undo-list inhibit-read-only inhibit-modification-hooks sgml-current-tree sgml-top-tree nil sgml-pcdata-move buffer-modified-p t make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 " " "	" 10 1 13 " 	\n" sgml-parse-markup-declaration prolog 60 63 sgml-do-processing-instruction cl--assertion-failed sgml-pop-entity 47 119 62 12 sgml-do-end-tag sgml-do-data sgml-deref-shortmap 3 sgml-do-start-tag 38 sgml-do-general-entity-ref 93 ms-end sgml-set-face-for run-hook-with-args-until-success sgml-parser-loop-hook sgml-shortmap-skipstring "^<]/&" buffer-substring-no-properties sgml-goal sgml-current-eref sgml-markup-start sgml-markup-type sgml-current-state sgml-cdata sgml-rcdata sgml-current-shorttag sgml-current-shortmap sgml-rs-ignore-pos sgml-shortref-handler sgml-set-face sgml-data-function] 10 (#$ . 154922)])
#@13 

(fn NAME)
(defalias 'sgml-handle-shortref #[257 "\304\203 	\204 \305\n`#\210\211\211\266\306!\207" [sgml-set-face sgml-current-eref sgml-markup-start sgml-markup-type shortref sgml-set-face-for sgml-do-entity-ref] 6 (#$ . 157525)])
(defalias 'sgml-do-start-tag #[0 "\203	 \306\307\"\210\310\211\310\211g\311=\203 \312 \202' \313\310\314!\206$ \315\316!\262!\262g\311=\2035 \317u\210\202t \320!\262\n\204V g\321=\203V \317u\210\322\211\262\204S \323\324!\210\204t \n\203q g\321=\203q `Tf\311=\203q \325u\210\322\211\204t \326 \210\327\f\203\204 \204\204 \330 `#\210\211\211!\266\"\203\251 \331!\262\204\251 #\205\301 \323\332\333!\262\"\202\301 \334\335\336\333!\262\"\"\210\337	 `&\207" [sgml-throw-on-element-change sgml-conref-flag sgml-xml-p sgml-current-shorttag sgml-set-face sgml-current-eref throw start nil 62 sgml-do-empty-start-tag sgml-lookup-eltype sgml-parse-name sgml-parse-error "Name expected" 1 sgml-parse-attribute-specification-list 47 t sgml-log-warning "NET enabling start-tag is not allowed with SHORTTAG NO" 2 sgml-check-tag-close start-tag sgml-set-face-for fboundp "Start-tag of undefined element %s; ignored" symbol-name sgml-do-move format "%s start-tag" sgml-open-element sgml-markup-start sgml-markup-type sgml-ignore-undefined-elements sgml-warn-about-undefined-elements] 11])
#@42 Return eltype to use if empty start tag.
(defalias 'sgml-do-empty-start-tag #[0 "	=\203\f \305\n\306H!\207\203 \306H\207\f\203 \f\306H\207\3072s \310\211\311\211\203+ \202. \312H\262\312H\262	=\203? \313\314!\210\315H=\204m \310\311\211\203S \315H\202V \316H\262\316H=\203g \317\307\306H\"\210\310\262\202I \310\262\202# \207" [sgml-current-tree sgml-top-tree sgml-dtd-info sgml-current-omittag sgml-previous-tree sgml-lookup-eltype 0 --cl-block-outer-- nil t 5 sgml-error "No previously closed element" 11 10 throw] 9 (#$ . 158882)])
#@41 Assume point after </ or at / in a NET.
(defalias 'sgml-do-end-tag #[0 "\306\307\310g\311=\203 \312u\210\313H\262\202q g\314=\203  \312u\210\202q \315\307\316!\206+ \317\320!\262!\262\307\211\203e \321\307w\313U?\206k \322\307w\313U?\206k g\323=\203V \312u\210\310\262\202m g\324=\205` \312u\210\310\262\202m \325\307w\313U?\262\210\326 \210\327	\203\200 \n\204\200 \330`#\210\211\211\266\203\310 \331!\262\262\307\310\211\307\203\235 \202\240 \332H\262\203\273 \313H=\211\262?\211\262\203\273 \307\262\202\225 \266\203\262\211\204\310 \333\334\"\210\211\2058\307\262\211\2044\211\211:\262?\206\363 \211\211@\335=\203\356 \211AA?\266\202\202\365 \336!\262\262\204\333\337\340!\341!$\210)=\203\342\343\"\210\313H=\206\"?\205\"\344H\310=\262\211\204\317 \345\346\347\"\211#\210\202\317 \350`\"\207" [sgml-current-tree sgml-set-face sgml-current-eref sgml-markup-start sgml-markup-type sgml-current-state "Null" nil t 62 1 0 47 sgml-lookup-eltype sgml-parse-name sgml-parse-error "Name expected" " " "	" 10 13 " 	\n" sgml-check-tag-close end-tag sgml-set-face-for symbol-name 5 sgml-log-warning "End-tag %s does not end any open element; ignored" normal-state sgml-final-and "%s element can't end here, need one of %s; %s end-tag out of context" sgml-element-gi sgml-required-tokens sgml-error "%s end-tag ended document and parse" 12 sgml-implied-end-tag format "%s end-tag" sgml-close-element sgml-top-tree] 10 (#$ . 159444)])
#@18 

(fn GOAL TREE)
(defalias 'sgml-is-goal-after-start #[514 "\211\205 \300\301H!\203 \301HV\207\302\301H!Y\207" [sgml-bpos-p 1 sgml-epos-after] 6 (#$ . 160936)])
#@13 

(fn GOAL)
(defalias 'sgml-goto-start-point #[257 "\301\302H\"\203 \211\302H\211\262\202R \211\303H\203: \211\304H\305V\203) \306!Y\202. \306!V\203: \307\310\"\210\311\202X \301\312H\"\203L \211\312H\211\262\202R \307\313\"\210\311\205X \202 \207" [sgml-top-tree sgml-is-goal-after-start 10 2 4 0 sgml-tree-end sgml-set-parse-state after nil 11 start] 6 (#$ . 161110)])
(defalias 'sgml-check-tag-close #[0 "g\301=\203 \302u\210\303\207g\304=\203* `Tf\206 \305z\306=\204S \203* `Tf\301=\204S g\304=\203_ `Tf\307=\203_ \310`\\f\206@ \305z\306=\204S \203_ \310`\\f\301=\203_ \206c \311\312!\206c \303\207\311\313g\"\207" [sgml-current-shorttag 62 1 t 60 0 119 47 2 sgml-log-warning "Unclosed tag is not allowed with SHORTTAG NO" "Invalid character in markup %c"] 3])
#@23 

(fn TYPE START END)
(defalias 'sgml-implied-end-tag #[771 "	=\203 dU\204+ \303\304\"\210\202+ \n\203# \305\306H!\262\204+ \307\310\311!#\210\312\"\207" [sgml-current-tree sgml-top-tree sgml-current-omittag sgml-error "Document ended by %s" sgml-eltype-etag-optional 0 sgml-log-warning "%s end-tag implied by %s; not minimizable" sgml-element-gi sgml-close-element] 7 (#$ . 161901)])
#@237 Find the parser context for POS, return the parse tree.
Also sets `sgml-current-tree' and `sgml-current-state'.  If POS is in
markup, `sgml-markup-type' will be a symbol identifying the markup
type.  It will be nil otherwise.

(fn POS)
(defalias 'sgml-find-context-of #[257 "\212\303!\210`V\203 \203 \304>\203 	\202 \305\n)\207" [sgml-markup-type sgml-markup-tree sgml-current-tree sgml-parse-to (start-tag end-tag) nil] 3 (#$ . 162304)])
#@69 Find context of point.
See documentation of `sgml-find-context-of'.
(defalias 'sgml-parse-to-here #[0 "\300`!\207" [sgml-find-context-of] 2 (#$ . 162759)])
#@57 Find the element containing character at POS.

(fn POS)
(defalias 'sgml-find-element-of #[257 "\211d=\203\n \301\302!\210\212\303T!\210\211\304H\203* \305\304H!Y\203* \211\304H\211\262\202V \211\306H\203@ \307!Y\203@ \211\310H\262\202Y \211\311H\203Y \305\311H!Y\203Y \211\311H\211\262\204 \211\262)\207" [sgml-top-tree error "End of buffer" sgml-parse-to 10 sgml-element-start 2 sgml-tree-end 5 11] 6 (#$ . 162921)])
#@289 Find the element before POS and return it, error if non found.
If in IN-ELEMENT is given look for previous element in IN-ELEMENT else
look in current element.  If this element has no content elements but
end at POS, it will be returned as previous element.

(fn POS &optional IN-ELEMENT)
(defalias 'sgml-find-previous-element #[513 "\212\301!\210\211\204\f \262\211\302H\211\204! \303!U\203I \262\202I \304!X\2030 \305\211\262\202F \211\306H\203I \304\306H!Y\204I \211\306H\211\262\204 \211\206S \307\310\311!\"\262)\207" [sgml-current-tree sgml-parse-to 11 sgml-element-end sgml-element-start nil 10 error "No previous element in %s element" sgml-element-gi] 7 (#$ . 163359)])
#@126 Find the first element starting after POS.
Returns parse tree; error if no element after POS.

(fn POS &optional IN-ELEMENT)
(defalias 'sgml-find-element-after #[513 "\211\206	 \212\300!)\262\301!\211\203\" \302!V\203\" \303!\262\202 \211\262\206G \304!\211\2058 \302!U\2058 \211\262\206G \305\306!\210\307\310\311!\"\207" [sgml-find-context-of sgml-element-content sgml-element-start sgml-element-next sgml-find-element-of sgml-message "" error "No more elements in %s element" sgml-element-gi] 6 (#$ . 164060)])
#@60 First element in content of ELEMENT, or nil.

(fn ELEMENT)
(defalias 'sgml-element-content #[257 "\211\300H\204 \211\301H\204 \212\302\303!\210)\211\300H\207" [11 2 sgml-parse-until-end-of t] 3 (#$ . 164594)])
#@40 Next sibling of ELEMENT.

(fn ELEMENT)
(defalias 'sgml-element-next #[257 "\211\300H\204\f \212\301!\210)\211\302H\204  \211\303H\300H\204  \212\301\304!\210)\211\302H\207" [2 sgml-parse-until-end-of 10 5 t] 3 (#$ . 164812)])
#@81 Last position in content of ELEMENT and start of end-tag, if any.

(fn ELEMENT)
(defalias 'sgml-element-etag-start #[257 "\211\301H\204\f \212\302!\210)\211\301H\204 \203 \303\304\305!\"\210\211\301H\204' \306\307!\210\310\301H!\207" [sgml-debug 2 sgml-parse-until-end-of message "Failed to define end of element %s" sgml-element-gi cl--assertion-failed (sgml-tree-etag-epos element) sgml-epos-promote] 5 (#$ . 165045)])
#@45 First position after ELEMENT.

(fn ELEMENT)
(defalias 'sgml-element-end #[257 "\300!\210\301!\207" [sgml-element-etag-start sgml-tree-end] 3 (#$ . 165478)])
#@15 

(fn PROMPT)
(defalias 'sgml-read-element-name #[257 "\306 \210\203 \307\310!\207	\n=\204 \203 \311\f\"\207	\n=\204C \312\313\314 \"\211\204/ \307\315!\202B \316\317\320A?\205@ @@%)\207\321!\207" [sgml-markup-type sgml-current-state sgml-any sgml-dtd-less sgml-dtd-info sgml-namecase-general sgml-parse-to-here error "No elements allowed in markup" sgml-read-element-type mapcar #[257 "\300\301!!\302B\207" [sgml-general-insert-case symbol-name nil] 4 "\n\n(fn X)"] sgml-current-list-of-valid-eltypes "No element valid at this point" completing-read nil t read-from-minibuffer completion-ignore-case] 8 (#$ . 165643)])
#@109 Return the attribute specification list for ELEMENT.
This is a list of (attname value) lists.

(fn ELEMENT)
(defalias 'sgml-element-attribute-specification-list #[257 "\211\300H\207" [16] 3 (#$ . 166285)])
#@77 Return the element to which an attribute editing command should be applied.
(defalias 'sgml-find-attribute-element #[0 "\302`!\212\303`!\210\304=\203 	\202 \211)\207" [sgml-markup-type sgml-markup-tree sgml-find-element-of sgml-parse-to start-tag] 3 (#$ . 166497)])
#@86 Return the value of the ATTRIBUTE in ELEMENT, string or nil.

(fn ELEMENT ATTRIBUTE)
(defalias 'sgml-element-attval #[514 "\300!\301\302\303!\"!\304\305\"!\206 \306!\207" [sgml-element-attribute-specification-list sgml-attdecl-default-value sgml-lookup-attdecl sgml-element-attlist sgml-attspec-attval sgml-lookup-attspec sgml-default-value-attval] 8 (#$ . 166772)])
#@82 Convert X into a string where X can be a string, a symbol or an element.

(fn X)
(defalias 'sgml-cohere-name #[257 "\211;\203 \207\2119\203 \300!\207\301!\207" [symbol-name sgml-element-gi] 3 (#$ . 167153)])
#@49 Return the start-tag for ELEMENT.

(fn ELEMENT)
(defalias 'sgml-start-tag-of #[257 "\203 \301\302!!\203 \303\304\305\302!!\"\207\303\306\305\302!!\"\207" [sgml-xml-p sgml-check-empty sgml-cohere-name format "<%s/>" sgml-general-insert-case "<%s>"] 6 (#$ . 167371)])
#@66 Return the end-tag for ELEMENT (token or element).

(fn ELEMENT)
(defalias 'sgml-end-tag-of #[257 "\300\301\302\303!!\"\207" [format "</%s>" sgml-general-insert-case sgml-cohere-name] 6 (#$ . 167649)])
#@30 Return the document element.
(defalias 'sgml-top-element #[0 "\300\301e!!\207" [sgml-element-content sgml-find-context-of] 3 (#$ . 167858)])
#@81 True if ELEMENT is the pseudo element above the document element.

(fn ELEMENT)
(defalias 'sgml-off-top-p #[257 "\211\300H?\207" [5] 3 (#$ . 168005)])
#@12 

(fn POS)
(defalias 'sgml-safe-context-of #[257 "\301\2112\f \210\302!0)\207" [sgml-throw-on-error parse-error sgml-find-context-of] 4 (#$ . 168162)])
#@12 

(fn POS)
(defalias 'sgml-safe-element-at #[257 "\301\2112 \210\211dU\203 \302!\202 \303!0)\207" [sgml-throw-on-error parse-error sgml-find-context-of sgml-find-element-of] 4 (#$ . 168323)])
(defalias 'sgml-in-prolog-p #[0 "\300`!\211?\206 \301!\207" [sgml-safe-context-of sgml-off-top-p] 3])
(provide 'psgml-parse)