;ELC   
;;; Compiled
;;; in Emacs version 27.1
;;; 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\300\303!\210\300\304!\210\300\305!\210\306\307!\210\300\310!\210\300\311!\210\312\313\314\315\316\317\320\321&\210\312\322\314\323\320\313%\210\324\325\326\327\330DD\331\320\313\332\333&\210\324\334\326\327\335DD\336\337\340\320\313\332\333&	\210\324\341\326\327\342DD\343\320\313\332\333&\210\324\344\326\327\345DD\346\320\313\332\347&\210\324\350\326\327\351DD\352\320\313\332\347&\210\324\353\326\327\354DD\355\320\313\332\333&\210\324\356\326\327\357DD\360\320\313\332\333&\210\324\361\326\327\362DD\363\320\313\332\333&\210\324\364\326\327\365DD\366\320\313\332\367&\210\324\370\326\327\371DD\372\320\313\332\333&\210\373\374\375\376\320\322%\210\373\377\201@ \201A \320\322%\210\373\201B \201C \201D \320\322%\210\373\201E \314\201F \320\322%\210\373\201G \314\201H \320\322%\210\373\201I \201J \201K \320\322%\210\373\201L \201M \201N \320\322%\210\373\201O \201P \201Q \320\322%\210\373\201R \201S \201T \320\322%\210\373\201U \201V \201W \320\322%\210\373\201X \201Y \201Z \320\322%\210\373\201[ \201\\ \201] \320\322%\210\373\201^ \201_ \201` \320\322%\210\373\201a \201b \201c \320\322%\210\373\201d \201e \201f \320\322%\210\373\201g \201h \201i \320\322%\210\373\201j \201k \201l \320\322%\210\373\201m \201n \201o \320\322%\210\373\201p \314\201q \320\322%\210\373\201r \201s \201t \320\322%\210\373\201u \201v \201w \320\322%\210\373\201x \201y \201z \320\322%\210\373\201{ \201| \201} \320\322%\210\373\201~ \201 \201\200 \320\322%\210\373\201\201 \201\202 \201\203 \320\322%\210\373\201\204 \201\205 \201\206 \320\322%\210\373\201\207 \201\210 \201\211 \320\322%\210\373\201\212 \201\213 \201\214 \320\322%\210\373\201\215 \201\216 \201\217 \320\322%\210\373\201\220 \201\221 \201\222 \320\322%\210\373\201\223 \201\224 \201\225 \320\322%\210\373\201\226 \201\227 \201\230 \320\322%\210\373\201\231 \201\232 \201\233 \320\322%\210\373\201\234 \201\235 \201\236 \320\322%\207" [require xmltok nxml-enc nxml-util nxml-rap nxml-outln provide nxml-mode rng-nxml sgml-mode custom-declare-group nxml nil "New XML editing mode." :link (custom-manual "(nxml-mode) Top") :group languages nxml-faces "Faces for XML syntax highlighting." custom-declare-variable nxml-char-ref-display-glyph-flag funcall function #[0 "\300\207" [t] 1] "Non-nil means display glyph following character reference.\nThe glyph is displayed in face `nxml-glyph'." :type boolean nxml-sexp-element-flag #[0 "\300\207" [t] 1] "Non-nil means sexp commands treat an element as a single expression." :version "27.1" nxml-slash-auto-complete-flag #[0 "\300\207" [nil] 1] "Non-nil means typing a slash automatically completes the end-tag.\nThis is used by `nxml-electric-slash'." nxml-child-indent #[0 "\300\207" [2] 1] "Indentation for the children of an element relative to the start-tag.\nThis only applies when the line or lines containing the start-tag contains\nnothing else other than that start-tag." integer nxml-attribute-indent #[0 "\300\207" [4] 1] "Indentation for the attributes of an element relative to the start-tag.\nThis only applies when the first attribute of a tag starts a line.\nIn other cases, the first attribute on one line is indented the same\nas the first attribute on the previous line." nxml-bind-meta-tab-to-complete-flag #[0 "\300\207" [t] 1] "Non-nil means to use nXML completion in \\[completion-at-point]." nxml-prefer-utf-16-to-utf-8-flag #[0 "\300\207" [nil] 1] "Non-nil means prefer UTF-16 to UTF-8 when saving a buffer.\nThis is used only when a buffer does not contain an encoding declaration\nand when its current `buffer-file-coding-system' specifies neither UTF-16\nnor UTF-8." nxml-prefer-utf-16-little-to-big-endian-flag #[0 "\301=\207" [system-type windows-nt] 2] "Non-nil means prefer little-endian to big-endian byte-order for UTF-16.\nThis is used only for saving a buffer; when reading the byte-order is\nauto-detected. It may be relevant both when there is no encoding declaration\nand when the encoding declaration specifies `UTF-16'." nxml-default-buffer-file-coding-system #[0 "\300\207" [nil] 1] "Default value for `buffer-file-coding-system' for a buffer for a new file.\nA value of nil means use the default value of `buffer-file-coding-system' as normal.\nA buffer's `buffer-file-coding-system' affects what \\[nxml-insert-xml-declaration] inserts." coding-system nxml-auto-insert-xml-declaration-flag #[0 "\300\207" [nil] 1] "Non-nil means automatically insert an XML declaration in a new file.\nThe XML declaration is inserted using `nxml-insert-xml-declaration'." custom-declare-face nxml-delimited-data ((t (:inherit font-lock-doc-face))) "Face used to highlight data enclosed between delimiters.\nThis is not used directly, but only via inheritance by other faces." nxml-name ((t (:inherit font-lock-builtin-face))) "Face used to highlight various names.\nThis includes element and attribute names, processing\ninstruction targets and the CDATA keyword in a CDATA section.\nThis is not used directly, but only via inheritance by other faces." nxml-ref ((t (:inherit font-lock-constant-face))) "Face used to highlight character and entity references.\nThis is not used directly, but only via inheritance by other faces." nxml-delimiter "Face used to highlight delimiters.\nThis is not used directly, but only via inheritance by other faces." nxml-text "Face used to highlight text." nxml-processing-instruction-delimiter ((t (:inherit nxml-delimiter))) "Face used for the delimiters of processing instructions, i.e., <? and ?>." nxml-processing-instruction-target ((t (:inherit font-lock-keyword-face))) "Face used for the target of processing instructions." nxml-processing-instruction-content ((t (:inherit nxml-delimited-data))) "Face used for the content of processing instructions." nxml-cdata-section-delimiter ((t (:inherit nxml-delimiter))) "Face used for the delimiters of CDATA sections, i.e., <![, [, and ]]>." nxml-cdata-section-CDATA ((t (:inherit nxml-name))) "Face used for the CDATA keyword in CDATA sections." nxml-cdata-section-content ((t (:inherit nxml-text))) "Face used for the content of CDATA sections." nxml-char-ref-number ((t (:inherit nxml-ref))) "Face used for the number in character references.\nThis includes ths `x' in hex references." nxml-char-ref-delimiter ((t (:inherit nxml-ref))) "Face used for the delimiters of character references, i.e., &# and ;." nxml-entity-ref-name ((t (:inherit nxml-ref))) "Face used for the entity name in general entity references." nxml-entity-ref-delimiter ((t (:inherit nxml-ref))) "Face used for the delimiters of entity references, i.e., & and ;." nxml-tag-delimiter ((t (:inherit nxml-delimiter))) "Face used for the angle brackets delimiting tags.\n`nxml-tag-slash' is used for slashes." nxml-tag-slash ((t (:inherit nxml-tag-delimiter))) "Face used for slashes in tags, both in end-tags and empty-elements." nxml-element-prefix ((t (:inherit nxml-name))) "Face used for the prefix of elements." nxml-element-colon "Face used for the colon in element names." nxml-element-local-name ((t (:inherit font-lock-function-name-face))) "Face used for the local name of elements." nxml-attribute-prefix ((t (:inherit nxml-name))) "Face used for the prefix of attributes." nxml-attribute-colon ((t (:inherit nxml-delimiter))) "Face used for the colon in attribute names." nxml-attribute-local-name ((t (:inherit font-lock-variable-name-face))) "Face used for the local name of attributes." nxml-namespace-attribute-xmlns ((t (:inherit nxml-attribute-prefix))) "Face used for `xmlns' in namespace attributes." nxml-namespace-attribute-colon ((t (:inherit nxml-attribute-colon))) "Face used for the colon in namespace attributes." nxml-namespace-attribute-prefix ((t (:inherit nxml-attribute-local-name))) "Face used for the prefix declared in namespace attributes." nxml-attribute-value ((t (:inherit font-lock-string-face))) "Face used for the value of attributes." nxml-attribute-value-delimiter ((t (:inherit nxml-attribute-value))) "Face used for the delimiters of attribute values." nxml-prolog-literal-delimiter ((t (:inherit nxml-delimited-data))) "Face used for the delimiters of literals in the prolog." nxml-prolog-literal-content ((t (:inherit nxml-delimited-data))) "Face used for the content of literals in the prolog." nxml-prolog-keyword ((t (:inherit font-lock-keyword-face))) "Face used for keywords in the prolog." nxml-markup-declaration-delimiter ((t (:inherit nxml-delimiter))) "Face used for the delimiters of markup declarations in the prolog.\nThe delimiters are <! and >." nxml-hash ((t (:inherit nxml-name))) "Face used for # before a name in the prolog." nxml-glyph ((((type x)) (:family "misc-fixed" :background "light grey" :foreground "black" :weight normal :slant normal)) (t (:background "light grey" :foreground "black" :weight normal :slant normal))) "Face used for glyph for char references."] 10)
#@97 The parent document for a part of a modular document.
Use `nxml-parent-document-set' to set it.
(defvar nxml-parent-document nil (#$ . 9295))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local nxml-parent-document put safe-local-variable stringp] 4)
#@111 List of regions in the prolog to be fontified.
See the function `xmltok-forward-prolog' for more information.
(defvar nxml-prolog-regions nil (#$ . 9577))
(make-variable-buffer-local 'nxml-prolog-regions)
#@161 Non-nil if currently operating in degraded mode.
Degraded mode is enabled when an internal error is encountered in the
fontification or after-change functions.
(defvar nxml-degraded nil (#$ . 9789))
(make-variable-buffer-local 'nxml-degraded)
#@62 Hook run by `nxml-complete'.
This hook is run until success.
(defvar nxml-completion-hook nil (#$ . 10038))
#@226 Hook to determine whether point is in mixed content.
The hook is called without arguments.  It should return nil if it is
definitely not mixed; non-nil otherwise.  The hook will be run until
one of the functions returns nil.
(defvar nxml-in-mixed-content-hook nil (#$ . 10153))
#@70 Maximum distance from point to scan when checking for mixed content.
(defvar nxml-mixed-scan-distance 4000 (#$ . 10437))
#@71 Maximum distance from point to scan backwards when indenting end-tag.
(defvar nxml-end-tag-indent-scan-distance 4000 (#$ . 10564))
#@275 Non-nil means display extra information for character references.
The extra information consists of a tooltip with the character name
and, if `nxml-char-ref-display-glyph-flag' is non-nil, a glyph
corresponding to the referenced character following the character
reference.
(defvar nxml-char-ref-extra-display t (#$ . 10702))
(make-variable-buffer-local 'nxml-char-ref-extra-display)
#@23 Keymap for nxml-mode.
(defvar nxml-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\322#\210\302\324\322#\210\302\325\326#\210\302\327\330#\210\302\331\332#\210\302\333\334#\210\302\335\336#\210\302\337\340#\210\302\341#\210\302\342\343#\210\302\344\345#\210\302\346\347#\210\211\207" [nxml-outline-prefix-map make-sparse-keymap define-key "\225" nxml-backward-up-element "\204" nxml-down-element "\216" nxml-forward-element "\220" nxml-backward-element "\373" nxml-backward-paragraph "\375" nxml-forward-paragraph "\350" nxml-mark-paragraph "" nxml-finish-element "]" "/" "" nxml-split-element "" nxml-balanced-close-start-tag-block "	" nxml-balanced-close-start-tag-inline "" nxml-insert-xml-declaration "" nxml-dynamic-markup-word "" nxml-insert-named-char "" [S-mouse-2] nxml-mouse-hide-direct-text-content "/" nxml-electric-slash "\211" completion-at-point] 5) (#$ . 11092))
#@43 Default font lock keywords for nxml-mode.
(defvar nxml-font-lock-keywords '(nxml-fontify-matcher) (#$ . 12138))
#@23 

(fn START END FACE)
(defalias 'nxml-set-face #[771 "\211\205 W\205 \300\301$\207" [font-lock-prepend-text-property face] 8 (#$ . 12256)])
(put 'nxml-set-face 'byte-optimizer 'byte-compile-inline-expand)
#@74 Set `nxml-parent-document' and inherit the DTD &c.

(fn PARENT-DOCUMENT)
(defalias 'nxml-parent-document-set #[257 "\306\211\211\211\211\211\307!\307!\230\203 \310\311!\210r\312!q\210	\262\n\262\262\f\262\262\262\262)\211\313\314\"\210\205R \315p!\207" [buffer-file-name rng-dtd rng-current-schema rng-current-schema-file-name rng-compile-table rng-ipattern-table nil file-truename error "Parent document cannot be the same as the document" find-file-noselect message "Set parent document to %s" rng-validate-while-idle rng-last-ipattern-index nxml-parent-document rng-validate-mode] 10 (#$ . 12474) "fParent document"])
#@53 Syntactic keywords for `nxml-mode'.

(fn START END)
(defalias 'nxml-syntax-propertize #[514 "W\203	 \301 \210\302\"\207" [nxml-prolog-end nxml-scan-prolog sgml-syntax-propertize] 5 (#$ . 13139)])
(defvar nxml-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [nxml-mode-hook variable-documentation put "Hook run after entering nXML mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp nxml-mode-map definition-name nxml-mode] 4)
(defvar nxml-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\307!\204 \303\307\310\311#\210\312\313 !\210\307\302N\204- \303\307\302\304\314!#\210\306\300!\204B \303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P \303\300\302\304\320!#\210\303\311\321\322#\207" [nxml-mode-abbrev-table nxml-mode-map variable-documentation put purecopy "Keymap for `nxml-mode'." boundp nxml-mode-syntax-table definition-name nxml-mode (lambda (#1=#:def-tmp-var) (defvar nxml-mode-syntax-table #1#)) make-syntax-table "Syntax table for `nxml-mode'." (lambda (#1#) (defvar nxml-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `nxml-mode'." derived-mode-parent text-mode] 5)
#@2653 Major mode for editing XML.

\[nxml-finish-element] finishes the current element by inserting an end-tag.
C-c C-i closes a start-tag with `>' and then inserts a balancing end-tag
leaving point between the start-tag and end-tag.
\[nxml-balanced-close-start-tag-block] is similar but for block rather than inline elements:
the start-tag, point, and end-tag are all left on separate lines.
If `nxml-slash-auto-complete-flag' is non-nil, then inserting a `</'
automatically inserts the rest of the end-tag.

\[completion-at-point] performs completion on the symbol preceding point.

\[nxml-dynamic-markup-word] uses the contents of the current buffer
to choose a tag to put around the word preceding point.

Sections of the document can be displayed in outline form.  The
variable `nxml-section-element-name-regexp' controls when an element
is recognized as a section.  The same key sequences that change
visibility in outline mode are used except that they start with C-c C-o
instead of C-c.

Validation is provided by the related minor-mode `rng-validate-mode'.
This also makes completion schema- and context- sensitive.  Element
names, attribute names, attribute values and namespace URIs can all be
completed. By default, `rng-validate-mode' is automatically enabled.
You can toggle it using \[rng-validate-mode] or change the default by
customizing `rng-nxml-auto-validate-flag'.

\[indent-for-tab-command] indents the current line appropriately.
This can be customized using the variable `nxml-child-indent'
and the variable `nxml-attribute-indent'.

\[nxml-insert-named-char] inserts a character reference using
the character's name (by default, the Unicode name).
\[universal-argument] \[nxml-insert-named-char] inserts the character directly.

The Emacs commands that normally operate on balanced expressions will
operate on XML markup items.  Thus \[forward-sexp] will move forward
across one markup item; \[backward-sexp] will move backward across
one markup item; \[kill-sexp] will kill the following markup item;
\[mark-sexp] will mark the following markup item.  By default, the
complete element is treated as a single markup item; to make each tag be
treated as a separate markup item, set the variable `nxml-sexp-element-flag'
to nil.  For more details, see the function `nxml-forward-balanced-item'.

\[nxml-backward-up-element] and \[nxml-down-element] move up and down the element structure.

Many aspects this mode can be customized using
\[customize-group] nxml RET.

In addition to any hooks its parent mode `text-mode' might have run,
this mode runs the hook `nxml-mode-hook', as the final or penultimate step
during initialization.
(defalias 'nxml-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315!\204' \316\317 \"\210\320\f!\211\2035 \211\321 =\203; \322\f\323 \"\210\210\324\325\"\204R @=\204R \326\325@C#\210\327!\210\330\f!\210@\306\331!\210\332\333\334A\"A\"\334\232\203s \334\202t \335\306\336!\210\337\340\341\"\306\342!\210\343\"\306\344!\210\345$\306\346!\210\347&\306\350!\210\351(\306\352!\210\353*\306\354!\210\351,\306\355!\210\356-\306\357!\210\360/\306\361!\210\3621\306\363!\210\3643\306\365!\210\3665\306\367!\210\3707\212\214~\210\371 \307\211BC\307D\372\373\374\375\376!\377\"\201L $\216\307E\201M  \210-\210*\306\201G !\210FG\306\201H !\210\201N H\201O \201P \201Q \345\307$\210\201R  \2030\201S \201R  !\204VI\203C\201T \201A !\204CIAJ\203V\201U  \373U\203V\201V  \210\201W K\201X 1i\201Y  0\202s\201Z \201[ \"\262\210)\201\\ \201] !\207" [delay-mode-hooks major-mode mode-name nxml-mode-map nxml-mode-syntax-table nxml-mode-abbrev-table make-local-variable t text-mode nxml-mode "nXML" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table tildify-space-string decode-coding-string encode-coding-string " " "&#160;" tildify-foreach-region-function apply-partially tildify-foreach-ignore-environments (("<! *--" . "-- *>") ("<" . ">")) mode-line-process ((nxml-degraded "/degraded")) adaptive-fill-mode nil forward-sexp-function nxml-forward-balanced-item indent-line-function nxml-indent-line fill-paragraph-function nxml-do-fill-paragraph comment-indent-function comment-start "<!--" comment-start-skip "<!--[ 	\n]*" comment-end "-->" comment-end-skip "[ 	\n]*-->" comment-line-break-function nxml-newline-and-indent comment-quote-nested-function nxml-comment-quote-nested buffer-modified-p make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] local-abbrev-table buffer-file-coding-system buffer-undo-list inhibit-read-only inhibit-modification-hooks inhibit-point-motion-hooks sgml-tag-syntax-table syntax-ppss-table syntax-propertize-function nxml-default-buffer-file-coding-system nxml-auto-insert-xml-declaration-flag font-lock-defaults 2 nxml-scan-prolog nxml-syntax-propertize add-hook change-major-mode-hook nxml-cleanup buffer-file-name file-exists-p local-variable-p buffer-size nxml-insert-xml-declaration (nxml-font-lock-keywords nil nil nil (font-lock-extend-region-functions nxml-extend-region) (jit-lock-contextually . t) (font-lock-unfontify-region-function . nxml-unfontify-region) (font-lock-syntactic-face-function . sgml-font-lock-syntactic-face)) (debug error) rng-nxml-mode-init message "Error: %S" run-mode-hooks nxml-mode-hook] 8 (#$ . 14455) nil])
#@27 Clean up after nxml-mode.
(defalias 'nxml-cleanup #[0 "\304\305!\210\212~\210\306 \307\211\307\310\311\312\313\314!\315\"\316$\216\307\317ed\320#\210-\210)\321\322\323\307#\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks inhibit-point-motion-hooks rng-validate-mode -1 buffer-modified-p t make-byte-code 0 "\300?\205 \301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 remove-text-properties (face nil) remove-hook change-major-mode-hook nxml-cleanup] 8 (#$ . 19972)])
#@20 

(fn CONTEXT ERR)
(defalias 'nxml-degrade #[514 "\302\303\304!#\210\305 \210\306\307\211\207" [nxml-degraded nxml-prolog-end message "Internal nXML mode error in %s (%s), degrading" error-message-string ding t 1] 7 (#$ . 20485)])
#@18 

(fn START END)
(defalias 'nxml-debug-region #[514 "\302 \210	b\210\303!*\207" [font-lock-end font-lock-beg nxml-extend-region set-mark] 4 (#$ . 20726) "r"])
#@155 Insert an XML declaration at the beginning of buffer.
The XML declaration will declare an encoding depending on the buffer's
`buffer-file-coding-system'.
(defalias 'nxml-insert-xml-declaration #[0 "\203 \301!\203 \302\303\"\203 \202 \304 eb\210\305\306\307!\"c\207" [buffer-file-coding-system coding-system-p coding-system-get mime-charset nxml-choose-utf-coding-system format "<?xml version=\"1.0\" encoding=\"%s\"?>\n" nxml-coding-system-name] 5 (#$ . 20897) "*"])
(defalias 'nxml-prepare-to-save #[0 "\204 \302\301!\203 	\203 \303	!\304=\204! 	\305=\204! \212\306 )\307\207" [enable-multibyte-characters buffer-file-coding-system local-variable-p coding-system-type 5 no-conversion nxml-select-coding-system nil] 2])
(defalias 'nxml-select-coding-system #[0 "\302ed\"eb\210\303 \211:\205 \304@A\"\211\203* \211\227\305\230\203$ \306 \2020 \307!\2020 \2050 \310 \211\204} ?\205< \311!\262\203I \312\313\"\202J \314\204V \315\316\"\210\202| \317\320\312\203c \321\202d \322\323!\"\324R!\203w \325\"\210\202| \326\327\330\"\210\210\331!>\204\301 \332\232\204\301 \333\"?\205\227 \311!\262\204\245 \315\316\"\210\202\300 \317\312\334\323!\"P!\203\273 \325\"\210\202\300 \326\327\330\"\210\210\335	!\211\203\323 \211\250\203\323 \336\"\262\210\207" [buffer-read-only buffer-file-coding-system find-coding-systems-region xmltok-get-declared-encoding-position buffer-substring-no-properties "utf-16" nxml-choose-utf-16-coding-system nxml-mime-charset-coding-system nxml-choose-utf-coding-system nxml-choose-suitable-coding-system format "Unknown encoding %s" "XML declaration is not well-formed" error "%s" y-or-n-p ". " "Save with %s" "Modify and save with encoding %s" nxml-coding-system-name " " nxml-fix-encoding-declaration signal quit nil coding-system-base (undecided) nxml-unsuitable-coding-system-message ". Save with %s " coding-system-eol-type coding-system-change-eol-conversion] 12])
#@41 

(fn CODING-SYSTEM &optional ENC-NAME)
(defalias 'nxml-unsuitable-coding-system-message #[513 "\300!\203 \301\207\302\303\206 \304!\"\207" [nxml-coding-system-unicode-p "Cannot translate some characters to Unicode" format "Cannot encode some characters with %s" nxml-coding-system-name] 6 (#$ . 22847)])
(defconst nxml-utf-16-coding-systems (byte-code "\300\301!\205 \300\302!\205 \303\207" [coding-system-p utf-16-be utf-16-le (utf-16-be utf-16-le)] 2))
(defconst nxml-utf-coding-systems (cons 'utf-8 nxml-utf-16-coding-systems))
#@22 

(fn CODING-SYSTEM)
(defalias 'nxml-coding-system-unicode-p #[257 "\301\302!\"\207" [nxml-utf-coding-systems nxml-coding-system-member coding-system-base] 4 (#$ . 23392)])
#@22 

(fn CODING-SYSTEM)
(defalias 'nxml-coding-system-name #[257 "\301!\262\302\303\"\203 \304\202 \305\306\"\206 !\207" [nxml-utf-16-coding-systems coding-system-base symbol-name nxml-coding-system-member utf-16 coding-system-get mime-charset] 5 (#$ . 23573)])
#@30 

(fn ENC-POS CODING-SYSTEM)
(defalias 'nxml-fix-encoding-declaration #[514 "\302!:\203 @A|\210@b\210\211c\202B \250\203' b\210\303\304\261\202B eb\210\305\306\261\210?\205B \307\310	!)\205B `\311\225|\207" [case-fold-search xmltok-bad-xml-decl-regexp nxml-coding-system-name " encoding=\"" 34 "<?xml version=\"1.0\" encoding=\"" "\"?>\n" t looking-at 0] 6 (#$ . 23847)])
#@32 

(fn SUITABLE-CODING-SYSTEMS)
(defalias 'nxml-choose-suitable-coding-system #[257 "\301\211\203 \302!>\203 \2023 \2032 \2042 @\262\303\304\"\203+ \211\262\202 A\262\202 \207" [buffer-file-coding-system nil coding-system-base coding-system-get mime-charset] 6 (#$ . 24239)])
(defalias 'nxml-choose-utf-coding-system #[0 "\304\300!\205 \205 \305!\306	\"@\2062 \n\2031 \307\310!\2031 \307\311!\2031 \203- \310\2022 \311\2022 \312\207" [buffer-file-coding-system nxml-utf-coding-systems nxml-prefer-utf-16-to-utf-8-flag nxml-prefer-utf-16-little-to-big-endian-flag local-variable-p coding-system-base nxml-coding-system-member coding-system-p utf-16-le utf-16-be utf-8] 4])
(defalias 'nxml-choose-utf-16-coding-system #[0 "\303\300!\205 \205 \304!\305	\"@\206* \n\203# \306\307!\205* \307\202* \306\310!\205* \310\207" [buffer-file-coding-system nxml-utf-16-coding-systems nxml-prefer-utf-16-little-to-big-endian-flag local-variable-p coding-system-base nxml-coding-system-member coding-system-p utf-16-le utf-16-be] 4])
#@37 

(fn CODING-SYSTEM CODING-SYSTEMS)
(defalias 'nxml-coding-system-member #[514 "\300\203 \211\204 \301@\"\203 \262\202 A\262\202 \211\207" [nil coding-system-equal] 6 (#$ . 25291)])
#@18 

(fn START END)
(defalias 'nxml-unfontify-region #[514 "\300\"\210\301\"\207" [font-lock-default-unfontify-region nxml-clear-char-ref-extra-display] 5 (#$ . 25491)])
#@137 Extend the region to hold the minimum area we can fontify with nXML.
Called with `font-lock-beg' and `font-lock-end' dynamically bound.
(defalias 'nxml-extend-region #[0 "	\nW\203 e\262\211\nX\203 \n\262\202C b\210\303\304!\210\305f\306\232\204+ \307\310\n\311#\210\312 \210\313 \210`\262`W\203@ \314 \210\2024 `\262W\204O \211	V\205T \211\311\207" [font-lock-beg font-lock-end nxml-prolog-end skip-syntax-forward " " nil 60 search-backward "<" t nxml-ensure-scan-up-to-date nxml-move-outside-backwards nxml-tokenize-forward] 6 (#$ . 25669)])
#@50 Called as font-lock keyword matcher.

(fn BOUND)
(defalias 'nxml-fontify-matcher #[257 "\303!\210\2040 `	W\203 o\204 \304\305!\210\306 \210	b\210\307\310 \203/ `X\203/ \311 \210\202 )\307\207" [nxml-degraded nxml-prolog-end xmltok-errors syntax-propertize cl--assertion-failed (bobp) nxml-fontify-prolog nil nxml-tokenize-forward nxml-apply-fontify-rule] 3 (#$ . 26233)])
#@158 Fontify the prolog.
The buffer is assumed to be prepared for fontification.
This does not set the fontified property, but it does clear
faces appropriately.
(defalias 'nxml-fontify-prolog #[0 "\211\205 \211@\301\302H\303H\304H#\266\211A\262\202 \207" [nxml-prolog-regions nxml-apply-fontify-rule 0 1 2] 7 (#$ . 26619)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\210\300\314\302\315#\210\300\316\302\317#\210\300\320\302\321#\210\300\322\302\323#\210\300\324\302\325#\210\300\326\302\327#\210\300\330\302\331#\210\300\332\302\333#\210\300\334\302\335#\210\300\336\302\337#\210\300\340\302\341#\210\300\342\302\343#\210\300\344\302\345#\210\300\346\302\347#\210\300\350\302\351#\210\300\352\302\353#\210\300\354\302\355#\210\300\356\302\357#\207" [put start-tag nxml-fontify-rule ([nil 1 nxml-tag-delimiter] [-1 nil nxml-tag-delimiter] (element-qname . 1) attributes) partial-start-tag ([nil 1 nxml-tag-delimiter] (element-qname . 1) attributes) end-tag ([nil 1 nxml-tag-delimiter] [1 2 nxml-tag-slash] [-1 nil nxml-tag-delimiter] (element-qname . 2)) partial-end-tag ([nil 1 nxml-tag-delimiter] [1 2 nxml-tag-slash] (element-qname . 2)) empty-element ([nil 1 nxml-tag-delimiter] [-2 -1 nxml-tag-slash] [-1 nil nxml-tag-delimiter] (element-qname . 1) attributes) partial-empty-element ([nil 1 nxml-tag-delimiter] [-1 nil nxml-tag-slash] (element-qname . 1) attributes) char-ref ([nil 2 nxml-char-ref-delimiter] [2 -1 nxml-char-ref-number] [-1 nil nxml-char-ref-delimiter] char-ref) entity-ref ([nil 1 nxml-entity-ref-delimiter] [1 -1 nxml-entity-ref-name] [-1 nil nxml-entity-ref-delimiter]) processing-instruction ([nil 2 nxml-processing-instruction-delimiter] [-2 nil nxml-processing-instruction-delimiter] processing-instruction-content) cdata-section ([nil 3 nxml-cdata-section-delimiter] [3 8 nxml-cdata-section-CDATA] [8 9 nxml-cdata-section-delimiter] [9 -3 nxml-cdata-section-content] [-3 nil nxml-cdata-section-delimiter]) data ([nil nil nxml-text]) xml-declaration ([nil 2 nxml-processing-instruction-delimiter] [2 5 nxml-processing-instruction-target] [-2 nil nxml-processing-instruction-delimiter]) xml-declaration-attribute-name ([nil nil nxml-attribute-local-name]) xml-declaration-attribute-value ([nil 1 nxml-attribute-value-delimiter] [1 -1 nxml-attribute-value] [-1 nil nxml-attribute-value-delimiter]) processing-instruction-left ([nil 2 nxml-processing-instruction-delimiter] [2 nil nxml-processing-instruction-target]) processing-instruction-right ([nil -2 nxml-processing-instruction-content] [-2 nil nxml-processing-instruction-delimiter]) literal ([nil 1 nxml-prolog-literal-delimiter] [1 -1 nxml-prolog-literal-content] [-1 nil nxml-prolog-literal-delimiter]) keyword ([nil nil nxml-prolog-keyword]) markup-declaration-open ([0 2 nxml-markup-declaration-delimiter] [2 nil nxml-prolog-keyword]) markup-declaration-close ([nil nil nxml-markup-declaration-delimiter]) internal-subset-open ([nil nil nxml-markup-declaration-delimiter]) internal-subset-close ([nil 1 nxml-markup-declaration-delimiter] [-1 nil nxml-markup-declaration-delimiter]) hash-name ([nil 1 nxml-hash] [1 nil nxml-prolog-keyword])] 4)
#@33 

(fn &optional TYPE START END)
(defalias 'nxml-apply-fontify-rule #[768 "\206 \304N\204 	\262\204 `\262\211\205\362 \211@A\262\305!\203u \211\306H\211\2040 \202? \211\306W\203< \\\202? \\\262\307H\211\204L \202[ \211\306W\203X \\\202[ \\\262\310H\211\205p W\205p \311\312$\266\202\356 \211:\203\225 \211@\313=\203\225 \n\203\356 \314A\\\n\315\316\317&\210\202\356 \211\320\267\202\351 \321 \210\202\356 \310\\\n\322\211\205\266 W\205\266 \311\312$\266\212\nb\210\323\324w\210`)\310Z\325\211\205\326 W\205\326 \311\312$\266\202\356 \326\327\"#\210\202\356 \330\331\"\210\210\202 \207" [xmltok-type xmltok-start xmltok-name-end xmltok-name-colon nxml-fontify-rule vectorp 0 1 2 font-lock-prepend-text-property face element-qname nxml-fontify-qname nxml-element-prefix nxml-element-colon nxml-element-local-name #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (attributes 155 processing-instruction-content 161 char-ref 219)) nxml-fontify-attributes nxml-processing-instruction-target " 	\n" nil nxml-processing-instruction-content nxml-char-ref-display-extra xmltok-char-number error "Invalid nxml-fontify-rule action %s"] 13 (#$ . 29831)])
(defalias 'nxml-fontify-attributes #[0 "\203 \302@\303\"\210A\211\204 	\205\" \302	@!\210	A\211\204 \304\207" [xmltok-namespace-attributes xmltok-attributes nxml-fontify-attribute namespace nil] 4])
#@44 

(fn ATT &optional NAMESPACE-DECLARATION)
(defalias 'nxml-fontify-attribute #[513 "\211\203! \300\211\301H\262\211\302H\262\211\303H\262\304\305\306\304&\210\202: \300\211\301H\262\211\302H\262\211\303H\262\307\310\311&\210\211\312H\262\211\205] \211@\211\301H\302H\303H\313#\266A\266\202\202@ \207" [nxml-fontify-qname 0 1 2 nxml-namespace-attribute-xmlns nxml-namespace-attribute-colon nxml-namespace-attribute-prefix nxml-attribute-prefix nxml-attribute-colon nxml-attribute-local-name 6 nxml-apply-fontify-rule] 11 (#$ . 31280)])
#@89 

(fn START COLON END PREFIX-FACE COLON-FACE LOCAL-NAME-FACE &optional UNPREFIXED-FACE)
(defalias 'nxml-fontify-qname #[1798 "\203F \211\205 W\205 \300\301$\266\211T\211\205/ W\205/ \300\301$\266T\211\205E W\205E \300\301$\207\206N \211\205^ W\205^ \300\301$\207" [font-lock-prepend-text-property face] 15 (#$ . 31844)])
#@376 Insert a slash.

With a prefix ARG, do nothing other than insert the slash.

Otherwise, if `nxml-slash-auto-complete-flag' is non-nil, insert the
rest of the end-tag or empty-element if the slash is potentially part
of an end-tag or the close of an empty-element.

If the slash is part of an end-tag that is the first non-whitespace
on the line, reindent the line.

(fn ARG)
(defalias 'nxml-electric-slash #[257 "\303 \210`\211\206	 `Sf\304=\205& \211\212\305!)\3068\206! \3078\310=\262\262?\212\311 \210`S)=\312\313!!\210?\205\231 \203\217 \203 \3141w \315S\310\"\211\205q \316 \317\261\210\205q \212	b\210\311 \210`	)=\205q \212\320\212	b\210i)!)\2620\202{ \210\202\217 \210\202\217 \321 `=\203\217 \n\322=\203\217 \317c\210\205\231 \211\205\231 \323 \207" [nxml-slash-auto-complete-flag xmltok-start xmltok-type nxml-ensure-scan-up-to-date 60 syntax-ppss 4 3 t back-to-indentation self-insert-command prefix-numeric-value (nxml-scan-error) nxml-scan-element-backward xmltok-start-tag-qname ">" indent-line-to nxml-token-before partial-empty-element nxml-indent-line] 7 (#$ . 32212) "*P"])
#@300 Close the start-tag before point with `>' and insert a balancing end-tag.
Point is left between the start-tag and the end-tag.
If there is nothing but whitespace before the `<' that opens the
start-tag, then put point on a blank line, and put the end-tag on
another line aligned with the start-tag.
(defalias 'nxml-balanced-close-start-tag-block #[0 "\300\301!\207" [nxml-balanced-close-start-tag block] 2 (#$ . 33327) "*"])
#@161 Close the start-tag before point with `>' and insert a balancing end-tag.
Point is left between the start-tag and the end-tag.
No extra whitespace is inserted.
(defalias 'nxml-balanced-close-start-tag-inline #[0 "\300\301!\207" [nxml-balanced-close-start-tag inline] 2 (#$ . 33759) "*"])
#@24 

(fn BLOCK-OR-INLINE)
(defalias 'nxml-balanced-close-start-tag #[257 "\304 `T	\305=\204 	\306>\203 Y\204 \307\310!\210\311\312T\n`^\"\313\261\210\314=\2032 b\202[ \211b\210\315 \210`U\203Y ib\210\316c\210\317!\210b\210\316c\210\317\\!\262\202[ b\207" [xmltok-start xmltok-type xmltok-name-end nxml-child-indent nxml-token-before partial-start-tag (start-tag empty-element partial-empty-element) error "Not in a start-tag" "></" buffer-substring-no-properties ">" inline back-to-indentation "\n" indent-line-to] 9 (#$ . 34053)])
#@53 Finish the current element by inserting an end-tag.
(defalias 'nxml-finish-element #[0 "\300\301!\207" [nxml-finish-element-1 nil] 2 (#$ . 34606) "*"])
#@64 Position where `nxml-split-element' split the current element.
(defvar nxml-last-split-position nil (#$ . 34764))
#@220 Split the current element by inserting an end-tag and a start-tag.
Point is left after the newly inserted start-tag.  When repeated,
split immediately before the previously inserted start-tag and leave
point unchanged.
(defalias 'nxml-split-element #[0 "	=\203 \n\203 \212\nb\210\303\304!)\202 \303\304!\211\207" [last-command this-command nxml-last-split-position nxml-finish-element-1 t] 2 (#$ . 34885) "*"])
#@208 Insert an end-tag for the current element and optionally a start-tag.
The start-tag is inserted if STARTP is non-nil.  Return the position
of the inserted start-tag or nil if none was inserted.

(fn STARTP)
(defalias 'nxml-finish-element-1 #[257 "\303 \212`W\203 \304>\203 \305\306\307!\"\210\310\311\")\212\312=\204& \305\313!\210	b\210\314 \210`	)=\212b\210\315\316!)\212	b\210i)\317 \320\203[ \203[ `\212\314 \210`)X\204W \321c\210\322!\210\323\324\261\210\203\242 \203q \321c\210\322!\210`\262\325\324\261\210\203\242 \203\242 \321c\210\322\212	b\210\326y\210\314 \210i\n\\U\203\236 \n\\\202\237 )!\210\207" [xmltok-type xmltok-start nxml-child-indent nxml-token-before (cdata-section processing-instruction comment start-tag end-tag empty-element) error "Point is inside a %s" nxml-token-type-friendly-name nxml-scan-element-backward t start-tag "No matching start-tag" back-to-indentation looking-at "[ 	\n]*$" xmltok-start-tag-qname nil "\n" indent-line-to "</" ">" "<" 1] 12 (#$ . 35308) "*"])
#@108 Quote nested comments in buffer.
See `comment-quote-nested-function' for more information.

(fn CS CE UNP)
(defalias 'nxml-comment-quote-nested #[771 "eb\210\300 \301\302\303\304\305!\306\"\307$\216\310\311\312\313#\2051 \302\224b\210\314u\210\203+ \315\314!\210\202 \316c\210\202 )\207" [match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 re-search-forward "-[\\]*-" nil t 1 delete-char "\\"] 10 (#$ . 36343)])
#@29 Indent current line as XML.
(defalias 'nxml-indent-line #[0 "`\3001! \212\301y\210\302\303w\210`Y\203 \303\262\304 \206 \301)0\202# \210\301\211\247\204, \211\202D \211\301W\2035 \301\262\203A \212\305!)\202D \305!\207" [(error) 0 " 	" nil nxml-compute-indent indent-line-to] 4 (#$ . 36807)])
#@50 Return the indent for the line containing point.
(defalias 'nxml-compute-indent #[0 "\300 \206 \301 \207" [nxml-compute-indent-from-matching-start-tag nxml-compute-indent-from-previous-line] 1 (#$ . 37114)])
#@322 Compute the indent for a line with an end-tag using the matching start-tag.
When the line containing point ends with an end-tag and does not start
in the middle of a token, return the indent of the line containing the
matching start-tag, if there is one and it occurs at the beginning of
its line.  Otherwise return nil.
(defalias 'nxml-compute-indent-from-matching-start-tag #[0 "\212\304 \210`\305\306\210)\307\306x\210\310 `U\205` 	\311>\205` \nU\2046 \212\211b\210\312 \210\nU)\2046 	\313=\205` \3141E \315`\306`Z#0\202J \210\306\202` \205` \nW\205` \nb\210\307\306x\210n\205` \316 \262)\207" [inhibit-field-text-motion xmltok-type xmltok-start nxml-end-tag-indent-scan-distance back-to-indentation t nil " 	" nxml-token-before (end-tag partial-end-tag) nxml-token-after data (nxml-scan-error) nxml-scan-element-backward current-indentation] 6 (#$ . 37330)])
#@73 Compute the indent for a line using the indentation of a previous line.
(defalias 'nxml-compute-indent-from-previous-line #[0 "\212\303\210`\303\211\211\211\211\304 \210`\262\3052\310 \306y\306U\203  \307\305\310\"\210\304 \210\311\312!\204 \2040 `\262\313 \210`U\204? 	\314=\203 `\262`W\203\251 \315 \210X\203Z \316!\262\202\242 `X\203t 	\317=\203l `U\204t \316!\262\202\242 	\314=\203\207 \316!\262\316!\262\202\242 \316!\320=\203\232 b\210\307\305i\"\210\202\242 \307\305\321!\"\210\322\303w\210\202B b\210i\n\323=\203\270 \324\202\271 \310\325=\203\303 \306\202\304 \310\\_\\0\266\206)\207" [xmltok-start xmltok-type nxml-child-indent nil back-to-indentation indent -1 throw 0 looking-at "[ 	]*$" nxml-token-after data nxml-tokenize-forward nxml-merge-indent-context-type partial-start-tag mixed nxml-compute-indent-in-token " 	\n" start-tag 1 end-tag] 11 (#$ . 38206)])
#@239 Merge the indent context type CONTEXT with the token in `xmltok-type'.
Return the merged indent context type.  An indent context type is
either nil or one of the symbols `start-tag', `end-tag', `markup',
`comment', `mixed'.

(fn CONTEXT)
(defalias 'nxml-merge-indent-context-type #[257 "\301\267\202) \211\302>\203 \303\207\304\207\211\305>\203 \306\207\304\207\211\307>\203! \207\211\203' \304\207\310\207\211\203/ \304\207\311\207" [xmltok-type #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (start-tag 6 partial-start-tag 6 end-tag 16 partial-end-tag 16 comment 26)) (nil start-tag comment) start-tag mixed (nil end-tag comment) end-tag (start-tag end-tag comment) comment markup] 3 (#$ . 39118)])
#@212 Return the indent for a line that starts inside a token.
POS is the position of the first non-whitespace character of the line.
This expects the xmltok-* variables to be set up as by `xmltok-forward'.

(fn POS)
(defalias 'nxml-compute-indent-in-token #[257 "\302\267\202 \303!\207\304\305\306#\207\304\307\310#\207\304\311\312#\207\211b\210\313y\314U\2032 	`W\2032 \315 \210\2025 	b\210i\207" [xmltok-type xmltok-start #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (start-tag 6 partial-start-tag 6 empty-element 6 partial-empty-element 6 comment 10 cdata-section 16 processing-instruction 22)) nxml-compute-indent-in-start-tag nxml-compute-indent-in-delimited-token "<!--" "-->" "<![CDATA[" "]]>" "<?" "?>" -1 0 back-to-indentation] 5 (#$ . 39867)])
#@269 Return the indent for a line that starts inside a start-tag.
Also for a line that starts inside an empty element.
POS is the position of the first non-whitespace character of the line.
This expects the xmltok-* variables to be set up as by `xmltok-forward'.

(fn POS)
(defalias 'nxml-compute-indent-in-start-tag #[257 "\302!\303\203# @b\210\304y\210`W\203 \211b\210\202 \305 \210\210\202c b\210\304y\303U\2033 \302`!\204& `X\203` b\210	\262\306 \211\203\\ \211@\211\211\303H\262\211W\203Z \211b\210\303\262\266\210\202c \305 \210i\\\207" [xmltok-start nxml-attribute-indent nxml-attribute-value-boundary 0 -1 back-to-indentation xmltok-merge-attributes] 8 (#$ . 40669)])
#@265 Return a pair (START . END) if POS is inside an attribute value.
Otherwise return nil.  START and END are the positions of the start
and end of the attribute value containing POS.  This expects the
xmltok-* variables to be set up as by `xmltok-forward'.

(fn POS)
(defalias 'nxml-attribute-value-boundary #[257 "\300 \301\211\211\211\203N @\262\211\302H\262\262\211\303H\262\262\203. W\203. \301\262\202 \203G \203G X\203G B\262\301\262\202 A\262\202 \207" [xmltok-merge-attributes nil 3 4] 9 (#$ . 41364)])
#@335 Return the indent for a line that starts inside a token with delimiters.
OPEN-DELIM and CLOSE-DELIM are strings giving the opening and closing
delimiters.  POS is the position of the first non-whitespace character
of the line.  This expects the xmltok-* variables to be set up as by
`xmltok-forward'.

(fn POS OPEN-DELIM CLOSE-DELIM)
(defalias 'nxml-compute-indent-in-delimited-token #[771 "G\\\211dX\205 \301\"\230\262\203 b\210\202C b\210\302y\210`X\203@ G\\b\210\303\230\203C \304\305!\203C `Tb\210\202C \306 \210i\207" [xmltok-start buffer-substring-no-properties -1 "<!--" looking-at " " back-to-indentation] 7 (#$ . 41905)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias nxml-complete completion-at-point nil make-obsolete "26.1"] 4)
#@932 Move forward across one balanced item.
With ARG, do it that many times.  Negative arg -N means
move backward across N balanced expressions.
This is the equivalent of `forward-sexp' for XML.

An element is by default treated as a single markup item.
However, if the variable `nxml-sexp-element-flag' is nil, then an
element contains as items strings with no markup, tags,
processing instructions, comments, CDATA sections, entity
references and character references.  A start-tag contains an
element name followed by one or more attributes.  An end-tag
contains just an element name.  An attribute value literals
contains strings with no markup, entity references and character
references.  A processing instruction consists of a target and a
content string.  A comment or a CDATA section contains a single
string.  An entity reference contains a single name.  A character
reference contains a character number.

(fn &optional ARG)
(defalias 'nxml-forward-balanced-item #[256 "\211\204 \300\262\211\301V\203 \302 \210\211S\211\262\301V\2053 \202 \211\301W\2053 \303 \210\211T\211\262\301W\2053 \202# \207" [1 0 nxml-forward-single-balanced-item nxml-backward-single-balanced-item] 3 (#$ . 42686) "^p"])
(defalias 'nxml-forward-single-balanced-item #[0 "\3031J \304 \212\305=\203 \211b\210\304 \262\202 `	U\204# \306!\202D \n\2033 \307=\2033 \310	!\202D \n\203C \311>\203C \312\313!\202D \211)\262b0\207\211A@b\210\314\312AA\"\207" [xmltok-type xmltok-start nxml-sexp-element-flag (nxml-scan-error) nxml-token-after space nxml-scan-forward-within start-tag nxml-scan-element-forward (end-tag partial-end-tag) error "Already at end of element" apply] 4])
(defalias 'nxml-backward-single-balanced-item #[0 "\3031L \304 \212\305=\203 	b\210\304 \262\202 `U\204# \306!\202F \n\2035 \307=\2035 \310!\210	\202F \n\203E \311=\203E \312\313!\202F 	)\262b0\207\211A@b\210\314\312AA\"\207" [xmltok-type xmltok-start nxml-sexp-element-flag (nxml-scan-error) nxml-token-before space nxml-scan-backward-within end-tag nxml-scan-element-backward start-tag error "Already at start of element" apply] 4])
#@12 

(fn END)
(defalias 'nxml-scan-forward-within #[257 "\211\302!Z\262\211`X\203 \303\304\305!\"\210\306>\203u `	W\203\" 	\207\307 \211\204, \202t \211\211\310H\262\203F \211\211\310H\262`X\203F \311!\202t \211\211\312H\262\203Y \211\211\312H\262T\202t \212\211\211\313H\262b\210\314\315!)\203n \316\225\202t \211\211\313H\262\207\317=\203\203 `	W\203\203 	\207\207" [xmltok-type xmltok-name-end nxml-end-delimiter-length error "Already at end of %s" nxml-token-type-friendly-name (start-tag empty-element partial-start-tag partial-empty-element) nxml-find-following-attribute 3 nxml-scan-forward-in-attribute-value 4 2 looking-at "[ 	\n]*=" 0 processing-instruction] 5 (#$ . 44805)])
#@12 

(fn END)
(defalias 'nxml-scan-backward-within #[257 "\303	!\\`X\203 \304\305\306	!\"\210	\307>\203O \310 \211\204# \202N \211\211\311H\262\203H \211\211\311H\262`X\203H `\211\312H\262X\203H \313!\202N \211\211\314H\262\207	\315=\203k \212\nb\210\316\317w\210`)\211`W\205f \211\262\206l \207" [xmltok-start xmltok-type xmltok-name-end nxml-start-delimiter-length error "Already at start of %s" nxml-token-type-friendly-name (start-tag empty-element partial-start-tag partial-empty-element) nxml-find-preceding-attribute 3 4 nxml-scan-backward-in-attribute-value 0 processing-instruction " 	\n" nil] 6 (#$ . 45509)])
#@12 

(fn ATT)
(defalias 'nxml-scan-forward-in-attribute-value #[257 "`\211\300H\262U\203 \301\302!\210\211\211\303H\262\304\2036 @\262`\305HW\203, \304\262\202 \304\262A\262\202 \211\204C \211\300H\262\202| `\306HW\203Q \211\306H\202| `\306HU\203_ \211\305H\202| \211\305H\307\310H!Z`W\203r \211\202z \301\311\312\310H!\"\262\207" [4 error "Already at end of attribute value" 6 nil 2 1 nxml-end-delimiter-length 0 "Already at end of %s" nxml-token-type-friendly-name] 9 (#$ . 46146)])
#@12 

(fn ATT)
(defalias 'nxml-scan-backward-in-attribute-value #[257 "`\211\300H\262U\203 \301\302!\210\303\211\304H\262!\305\2038 @\262\211\306H`W\203. \305\262\202 \305\262A\262\202 \211\204E \211\300H\262\202~ \211\307H`W\203S \211\307H\202~ `\307HU\203a \211\306H\202~ \211\306H\310\311H!\\\211`W\203t \211\202| \301\312\313\311H!\"\262\207" [3 error "Already at start of attribute value" reverse 6 nil 1 2 nxml-start-delimiter-length 0 "Already at start of %s" nxml-token-type-friendly-name] 9 (#$ . 46656)])
(defalias 'nxml-find-following-attribute #[0 "\302\206 	\205 	\203e @\211\211\303H\262\211`X\203: \211\304H\262\203: `\211\304H\262X\203: \302\262\262\202R `W\203R \203O \211\211\303H\262W\203R \262\266A\262\204 \211\262\302\262\202 \207" [xmltok-attributes xmltok-namespace-attributes nil 0 4] 9])
(defalias 'nxml-find-preceding-attribute #[0 "\302\206 	\205 	\203e @\211\211\303H\262\211`W\203: \211\304H\262\203: `\211\304H\262X\203: \302\262\262\202R \211`W\203R \203O \211\303H\262W\203R \262\266A\262\204 \211\262\302\262\202 \207" [xmltok-attributes xmltok-namespace-attributes nil 0 4] 9])
#@22 

(fn &optional ARG)
(defalias 'nxml-up-element #[256 "\211\204 \302\262\211\303W\203 \304[!\207\3051` \211\303V\205^ `dW\205^ \306 \307>\2046 \310>\203: 	`W\203: \211\202T \311\312=\203K `	U\203K 	\202L \313\"\206T \314\315!b\266\211S\262\202 0\207\211A@b\210\316\314AA\"\207" [xmltok-type xmltok-start 1 0 nxml-backward-up-element (nxml-scan-error) nxml-token-after (end-tag partial-end-tag) (empty-element partial-empty-element) nxml-scan-element-forward start-tag t error "No parent element" apply] 5 (#$ . 47849) "^p"])
#@22 

(fn &optional ARG)
(defalias 'nxml-backward-up-element #[256 "\211\204 \302\262\211\303W\203 \304[!\207\3051d \211\303V\205b e`W\205b \306 \307>\2046 \310>\203: `W\203: 	\202X \311\312=\203K `U\203K \202L 	\313\"\203U 	\202X \314\315!b\266\211S\262\202 0\207\211A@b\210\316\314AA\"\207" [xmltok-type xmltok-start 1 0 nxml-up-element (nxml-scan-error) nxml-token-before (start-tag partial-start-tag) (empty-element partial-empty-element) nxml-scan-element-backward end-tag t error "No parent element" apply] 5 (#$ . 48392) "^p"])
#@155 Move forward down into the content of an element.
With ARG, do this that many times.
Negative ARG means move backward but still down.

(fn &optional ARG)
(defalias 'nxml-down-element #[256 "\211\204 \301\262\211\302W\203 \303[!\207\211\302V\205A \304 \212\211b\210\305>\203( \306\307!\210\310>\2044 \311 \210\202 `)\262b\210\211S\262\202 \207" [xmltok-type 1 0 nxml-backward-down-element nxml-token-after (nil end-tag partial-end-tag) error "No following start-tags in this element" (start-tag partial-start-tag) nxml-tokenize-forward] 4 (#$ . 48944) "^p"])
#@22 

(fn &optional ARG)
(defalias 'nxml-backward-down-element #[256 "\211\204 \303\262\211\304W\203 \305[!\207\211\304V\205W \212\306 \210b\210	\307>\203) \310\311!\210	\312>\204L `\nX\204= \313\314\n\315#\204C \316\211\202  \317 \210\320 \210\202 )b\210\211S\262\202 \207" [xmltok-start xmltok-type nxml-prolog-end 1 0 nxml-down-element nxml-token-before (start-tag partial-start-tag prolog nil) error "No preceding end-tags in this element" (end-tag partial-end-tag) search-backward "<" t nil nxml-move-outside-backwards xmltok-forward] 6 (#$ . 49518) "^p"])
#@119 Move forward over one element.
With ARG, do it that many times.
Negative ARG means move backward.

(fn &optional ARG)
(defalias 'nxml-forward-element #[256 "\211\204 \300\262\211\301W\203 \302[!\207\30317 \211\301V\2055 `dW\2055 \304\305 !\206, \306\307!b\210\211S\262\202 0\207\211A@b\210\310\306AA\"\207" [1 0 nxml-backward-element (nxml-scan-error) nxml-scan-element-forward nxml-token-before error "No more elements" apply] 5 (#$ . 50093) "^p"])
#@119 Move backward over one element.
With ARG, do it that many times.
Negative ARG means move forward.

(fn &optional ARG)
(defalias 'nxml-backward-element #[256 "\211\204 \301\262\211\302W\203 \303[!\207\3041= \211\302V\205; e`W\205; \305\306 \210!\203/ \2062 \307\310!b\210\211S\262\202 0\207\211A@b\210\311\307AA\"\207" [xmltok-start 1 0 nxml-forward-element (nxml-scan-error) nxml-scan-element-backward nxml-token-after error "No preceding elements" apply] 5 (#$ . 50557) "^p"])
(defalias 'nxml-mark-token-after #[0 "\302\303 \304\305#\210b\210\306\307	\"\207" [xmltok-start xmltok-type push-mark nxml-token-after nil t message "Marked %s"] 4 nil nil])
#@126 Put point at beginning of this paragraph, mark at end.
The paragraph marked is the one that contains point or follows point.
(defalias 'nxml-mark-paragraph #[0 "\300 \210\301\302\303\211#\210\304 \207" [nxml-forward-paragraph push-mark nil t nxml-backward-paragraph] 4 (#$ . 51226) nil])
#@22 

(fn &optional ARG)
(defalias 'nxml-forward-paragraph #[256 "\211\204 \300\262\211\301W\203 \302[!\207\211\301V\205- \301y\210\303 \205- \211S\211\262\301V\205- \202 \207" [1 0 nxml-backward-paragraph nxml-forward-single-paragraph] 3 (#$ . 51520) "^p"])
#@22 

(fn &optional ARG)
(defalias 'nxml-backward-paragraph #[256 "\211\204 \301\262\211\302W\203 \303[!\207\211\302V\2054 n\204\" \304\305\210)\306 \2054 \211S\211\262\302V\2054 \202\" \207" [inhibit-field-text-motion 1 0 nxml-forward-paragraph t nil nxml-backward-single-paragraph] 3 (#$ . 51787) "^p"])
#@81 Move forward over a single paragraph.
Return nil at end of buffer, t otherwise.
(defalias 'nxml-forward-single-paragraph #[0 "\301 `Z\302\211b\210`dW\203, \303\"\211\262\204, \304!\203# \305\262\306 \210\307\262\202\n \2052 b\207" [xmltok-start nxml-token-after nil nxml-paragraph-end-pos nxml-token-contains-data-p t nxml-tokenize-forward 0] 7 (#$ . 52102)])
#@84 Move backward over a single paragraph.
Return nil at start of buffer, t otherwise.
(defalias 'nxml-backward-single-paragraph #[0 "\302 \211`Z\303\211\211b\210\304\303\"\211\262\204\224 \305\303\"\262b\210\204\224 e`W\203\224 \306\307	\310#\203\216 \311 \210\212`W\203^ \312 \210\204O \305 \203O \303\262\262\304\313\"\211\203Z \211\262\210\2027 )\204\210 \211\203\210 \204\210 \310\262\212`W\203{ \312 \210\202o \304\313\"\211\203\206 \211\262\210)`\262\202! eb\210\202! \205\232 b\207" [xmltok-start nxml-prolog-end nxml-token-before nil nxml-paragraph-start-pos nxml-token-contains-data-p search-backward "<" t nxml-move-outside-backwards xmltok-forward 0] 10 (#$ . 52478)])
#@28 

(fn &optional START END)
(defalias 'nxml-token-contains-data-p #[512 "\206 \302\\\262`\206 \302Z\262	\303=\203& \304\\]\262\211`\305Z^\262	\306=\2038 =\2038 \211`=\206T 	\307=\206T 	\310>\205T W\205T \212b\210\311\312\313#)\207" [xmltok-start xmltok-type 0 cdata-section 9 3 data char-ref (data cdata-section) re-search-forward "[^ 	\n]" t] 6 (#$ . 53187)])
#@312 Return the position of the paragraph end if contained in the current token.
Return nil if the current token does not contain the paragraph end.
Only characters after OFFSET from the start of the token are eligible.
HAD-DATA says whether there have been non-whitespace data characters yet.

(fn HAD-DATA OFFSET)
(defalias 'nxml-paragraph-end-pos #[514 "\204y \302>\2033 \212`	\303=\203 \304\202 \305]\\b\210\306\307\310#\205/ \306\311\310#\205/ \305\224\262)\207\312=\205x \313 \205x \314 \205\315 \212`	\315]\\b\210\306\307\316Z\310#\205u \306\311\310#\203c \305\224\202u \211\316Zb\210\317\320x\210n\204t \321\322!\210`\262)\207\323>\203\224 \212`	\\b\210\306\311\310#\205\220 \305\224\262)\207\324>\203\257 \313 \203\257 \314 \203\257 \212	b\210\317\320x\210`)\207\325=\205\315 \326\327!\205\315 \330\310!?\205\315 \212\331\332\320\310#\206\314 d)\207" [xmltok-type xmltok-start (data cdata-section) cdata-section 9 0 re-search-forward "[^ 	\n]" t "^[ 	]*$" comment nxml-token-begins-line-p nxml-token-ends-line-p 4 3 " 	" nil beginning-of-line 2 (data space cdata-section) (start-tag end-tag empty-element comment processing-instruction entity-ref) end-tag looking-at "[ 	]*$" nxml-in-mixed-content-p search-forward "\n"] 7 (#$ . 53572)])
#@315 Return the position of the paragraph start if contained in the current token.
Return nil if the current token does not contain the paragraph start.
Only characters before OFFSET from the end of the token are eligible.
HAD-DATA says whether there have been non-whitespace data characters yet.

(fn HAD-DATA OFFSET)
(defalias 'nxml-paragraph-start-pos #[514 "\204| \302>\2030 \212`\303=\203 \304\202 \305]Zb\210\306\307	\310#\205. \306\311	\310#\205. \305\224)\207\312=\205{ \313 \205{ \314 \205\351 \212`\304]Zb\210	\315\\`W\205z \306\307	\315\\\310#\205z \306\311	\310#\203g \305\224\202z 	b\210\316\317!\203u \305\225\202z \320\321x\210`)\207\322>\203\224 \212`Zb\210\306\311	\310#\205\222 \305\224)\207\323>\203\256 \313 \203\256 \314 \203\256 \324\325\321\310#\206\351 d\207\326=\205\351 \314 \205\351 \212	b\210\327\321!)?\205\351 \212	b\210\320\321x\210`Sf\330=\203\347 \212`Sb\210\320\321x\210n\205\343 `)\206\350 `)\207" [xmltok-type xmltok-start (data cdata-section) cdata-section 3 0 re-search-backward "[^ 	\n]" t "^[ 	]*$" comment nxml-token-ends-line-p nxml-token-begins-line-p 4 looking-at "<!--[ 	]*\n" " 	" nil (data space cdata-section) (start-tag end-tag empty-element comment processing-instruction entity-ref) search-forward "\n" start-tag nxml-in-mixed-content-p 10] 6 (#$ . 54842)])
(defalias 'nxml-token-ends-line-p #[0 "\300\301!\207" [looking-at "[ 	]*$"] 2])
(defalias 'nxml-token-begins-line-p #[0 "\212b\210\301\302x\210n)\207" [xmltok-start " 	" nil] 2])
#@160 Return non-nil if point is in mixed content.
Point must be after an end-tag or before a start-tag.
ENDP is t in the former case, nil in the latter.

(fn ENDP)
(defalias 'nxml-in-mixed-content-p #[257 "\306\307\310!\204 \306\202\225 \3111T \306\211\211\211\211\211\211\211\2030 \312`!\2053 \2023 \313`!.\262\211\205P \212\211b\210\203K \314\306x\210n\202N \315\316!)?0\202X \210\202_ \203_ \317\202\225 \306\211\203n \262`\262\202t `\262\262\212\203\201 b\210\320 \206\212 \211\205\212 \211b\210\321 )\266\202\203\224 \317\202\225 \306\207" [xmltok-errors xmltok-namespace-attributes xmltok-attributes xmltok-replacement xmltok-name-end xmltok-name-colon nil run-hook-with-args-until-failure nxml-in-mixed-content-hook (nxml-scan-error) nxml-scan-element-backward nxml-scan-element-forward " 	" looking-at "[ 	]*$" t nxml-preceding-sibling-data-p nxml-following-sibling-data-p xmltok-start xmltok-type] 10 (#$ . 56346)])
#@61 Return non-nil if there is a previous sibling that is data.
(defalias 'nxml-preceding-sibling-data-p #[0 "`Z	]\306\307\211\211\211\211\211\211\211\211\211\212`W\203w \306Y\203w \204w `\262\310\311\312#\203w \313 \210\212\314 \210\315\267\202R T\262\202R S\262\211\306=\203r `W\203r \204r \314 \210\316>\203X \312\262\202X \210)\202 .	\207" [nxml-mixed-scan-distance nxml-prolog-end xmltok-errors xmltok-namespace-attributes xmltok-attributes xmltok-replacement 0 nil search-backward "<" t nxml-move-outside-backwards xmltok-forward #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (end-tag 71 start-tag 78)) (data cdata-section char-ref) xmltok-name-end xmltok-name-colon xmltok-start xmltok-type] 12 (#$ . 57298)])
(defalias 'nxml-following-sibling-data-p #[0 "`\\d^\306\307\211\211\211\211\211\211\211\211\f\212`W\203X \306Y\203X \310 \203X \211\204X \311\267\202E T\262\202 S\262\202 \306=\203 \312>\203 \313\262\202 .	\207" [nxml-mixed-scan-distance xmltok-errors xmltok-namespace-attributes xmltok-attributes xmltok-replacement xmltok-name-end 0 nil nxml-tokenize-forward #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (start-tag 55 end-tag 62)) (data cdata-section char-ref) t xmltok-name-colon xmltok-start xmltok-type] 11])
#@12 

(fn ARG)
(defalias 'nxml-do-fill-paragraph #[257 "\303\211\211\211\212\304 \210`\262\305 \210\306\303w\210`\262\307 \210\310`\"`\212\311!)\3128\2062 \3138\314=\262\262\204C \315\316!\203C \317P\320#\210)\211\205k `\321 Z\nGW\205k \212\307 \210\315\322\n!!)\205k \323\225b)\210*\207" [fill-prefix fill-paragraph-function prefix nil nxml-forward-paragraph nxml-backward-paragraph " 	\n" beginning-of-line buffer-substring-no-properties syntax-ppss 4 3 t looking-at "[ 	]*<!--" "     " fill-region-as-paragraph line-beginning-position regexp-quote 0] 10 (#$ . 58670)])
#@13 

(fn SOFT)
(defalias 'nxml-newline-and-indent #[257 "\300 \210\211\203 \301\302!\210\202 \303\304!\210\305 \207" [delete-horizontal-space insert-and-inherit 10 newline 1 nxml-indent-line] 3 (#$ . 59267)])
(defvar nxml-dynamic-markup-prev-pos nil)
(defvar nxml-dynamic-markup-prev-lengths nil)
(defvar nxml-dynamic-markup-prev-found-marker nil)
(defvar nxml-dynamic-markup-prev-start-tags (make-hash-table :test 'equal))
#@910 Dynamically markup the word before point.
This attempts to find a tag to put around the word before point based
on the contents of the current buffer. The end-tag will be inserted at
point.  The start-tag will be inserted at or before the beginning of
the word before point; the contents of the current buffer is used to
decide where.

It works in a similar way to \[dabbrev-expand].  It searches first
backwards from point, then forwards from point for an element whose
content is a string which matches the contents of the buffer before
point and which includes at least the word before point.  It then
copies the start- and end-tags from that element and uses them to
surround the matching string before point.

Repeating \[nxml-dynamic-markup-word] immediately after successful
\[nxml-dynamic-markup-word] removes the previously inserted markup
and attempts to find another possible way to do the markup.
(defalias 'nxml-dynamic-markup-word #[0 "\306\250\2034 `U\2034 	\n=\2034 \2034 \3078Z\211A@Z\211@Z|\210\211|\210\310\f!\266\204\2028 \311!\210\306\211\306\212`\312v\210`W\204M \313\314!\210\315`\"\211\316P\306\203\\ b\210\211\204\207 `W\203q \317\306\320#\204y b\210\321\306\320#\203\207 \322\225\307Zb\210\323!\262\202\\ \211\206\233 \313\324!\322U\203\230 \325\202\231 \326\"\266\204)b\207" [nxml-dynamic-markup-prev-pos last-command this-command nxml-dynamic-markup-prev-lengths nxml-dynamic-markup-prev-found-marker nxml-dynamic-markup-prev-start-tags nil 2 marker-position clrhash -1 error "No word to markup" buffer-substring-no-properties "</" search-backward t search-forward 0 nxml-try-copy-markup hash-table-count "No possible markup found for `%s'" "No more markup possibilities found for `%s'"] 10 (#$ . 59697) "*"])
#@21 

(fn WORD-END-POS)
(defalias 'nxml-try-copy-markup #[257 "\212`\211\212\306!)\3078\206 \3108\311=\262\262?\205\312 \312\313\314\311#\205\312 `\212\306!)\3078\2064 \3108\311=\262\262?\205\312 \315 \210\316=\205\312 `W\205\312 `\317	\"\320\317\"\321\"\237b\210\211\203w \322\323@!\324P\314\311#\203w \211A\262\325\314x\210\202[ \211?\205\310 \325\314w\210\326`B\n\"?\205\310 `W\204\226 	W\205\310 \327\311\"\330`B\311\n#\210	Z`Z\f	Z\331\\E\332 c\210	Z\\b\210\333\334\261\210`\211\262\266\203\262)\207" [xmltok-type xmltok-start nxml-dynamic-markup-prev-start-tags nxml-dynamic-markup-prev-found-marker xmltok-name-end nxml-dynamic-markup-prev-lengths syntax-ppss 4 3 t search-backward "<" nil xmltok-forward start-tag buffer-substring-no-properties split-string "[ 	\n]+" re-search-backward regexp-quote "\\=" " 	\n" gethash copy-marker puthash 2 xmltok-start-tag-qname "</" ">" nxml-dynamic-markup-prev-pos] 9 (#$ . 61467)])
#@206 Insert a character using its name.
The name is read from the minibuffer.
Normally, inserts the character as a numeric character reference.
With a prefix argument, inserts the character directly.

(fn ARG)
(defalias 'nxml-insert-named-char #[257 "\300\301!\211\205 \203 \211\202 \302\303\"c\207" [read-char-by-name "Character name: " format "&#x%X;"] 5 (#$ . 62438) "*P"])
#@77 Toggle the display of extra information for character references.

(fn ARG)
(defalias 'nxml-toggle-char-ref-extra-display #[257 "\211\204	 ?\202 \301!\302V\211=?\205 \211\303 \207" [nxml-char-ref-extra-display prefix-numeric-value 0 font-lock-flush] 4 (#$ . 62821) "P"])
(put 'nxml-char-ref 'evaporate t)
#@20 

(fn START END N)
(defalias 'nxml-char-ref-display-extra #[771 "\302\303\"?\205V \205V \304\305\"\206 \304\306\"	\205$ \307!\205$ \310!\311\204- \205T \312\311\313$\262\314\315\316#\210\203G \314\317#\210\205T \314\320\321\322\323##\266\203\207" [nxml-char-ref-extra-display nxml-char-ref-display-glyph-flag eql 10 get-char-code-property name old-name char-displayable-p string nil make-overlay t overlay-put category nxml-char-ref help-echo after-string propertize face nxml-glyph] 13 (#$ . 63138)])
#@18 

(fn START END)
(defalias 'nxml-clear-char-ref-extra-display #[514 "\300\"\211\205 \301@\302\"\303=\203 \304@!\210\211A\262\202 \207" [overlays-in overlay-get category nxml-char-ref delete-overlay] 6 (#$ . 63667)])
#@13 

(fn TYPE)
(defalias 'nxml-start-delimiter-length #[257 "\211\300N\206 \301\207" [nxml-start-delimiter-length 0] 3 (#$ . 63897)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\311#\210\300\313\302\311#\210\300\314\302\311#\210\300\315\302\307#\207" [put cdata-section nxml-start-delimiter-length 9 comment 4 processing-instruction 2 start-tag 1 empty-element partial-empty-element entity-ref char-ref] 4)
#@13 

(fn TYPE)
(defalias 'nxml-end-delimiter-length #[257 "\211\300N\206 \301\207" [nxml-end-delimiter-length 0] 3 (#$ . 64373)])
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\306#\210\300\307\302\310#\210\300\311\302\306#\210\300\312\302\310#\210\300\313\302\310#\210\300\314\302\310#\207" [put cdata-section nxml-end-delimiter-length 3 comment processing-instruction 2 start-tag 1 empty-element partial-empty-element entity-ref char-ref] 4)
#@13 

(fn TYPE)
(defalias 'nxml-token-type-friendly-name #[257 "\211\300N\206	 \301!\207" [nxml-friendly-name symbol-name] 3 (#$ . 64841)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\312\313!\207" [put cdata-section nxml-friendly-name "CDATA section" processing-instruction "processing instruction" entity-ref "entity reference" char-ref "character reference" provide nxml-mode] 4)