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

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

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

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


(require 'org)
#@228 Regexp to separate paragraphs in an Org buffer.
In the case of lines starting with "#" and ":", this regexp
is not sufficient to know if point is at a paragraph ending.  See
`org-element-paragraph-parser' for more information.
(defconst org-element-paragraph-separate (byte-code "\306\307\310\307\311\312\307\313\307\314\307\315\307\316\307\317	\n\fF!\307\320
\321\"\203#\322\202/\320
\323\"\203.\324\202/\325\2055\326\327\330\330\331\260*\332\260\207" [org-outline-regexp org-scheduled-string org-deadline-string org-closed-string org-clock-string org-plain-list-ordered-item-terminator "^\\(?:" "\\|" "\\[\\(?:[0-9]+\\|fn:[-_[:word:]]+\\)\\]" "[ 	]*\\(?:" "$" "\\(?:|\\|\\+-[-+]\\)" "[#:]" "-\\{5,\\}[ 	]*$" "\\\\begin{\\([A-Za-z0-9]+\\*?\\)}" regexp-opt eql 41 ")" 46 "\\." "[.)]" "\\|[A-Za-z]" "\\(?:[-+*]\\|\\(?:[0-9]+" "\\)" "\\(?:[ 	]\\|$\\)" "\\)\\)" org-alphabetical-lists alpha term] 24) (#$ . 574))
#@33 Complete list of element types.
(defconst org-element-all-elements '(center-block clock comment comment-block drawer dynamic-block example-block export-block fixed-width footnote-definition headline horizontal-rule inlinetask item keyword latex-environment babel-call paragraph plain-list planning property-drawer quote-block quote-section section special-block src-block table table-row verse-block) (#$ . 1509))
#@55 List of recursive element types aka Greater Elements.
(defconst org-element-greater-elements '(center-block drawer dynamic-block footnote-definition headline inlinetask item plain-list quote-block section special-block table) (#$ . 1929))
#@30 Complete list of successors.
(defconst org-element-all-successors '(export-snippet footnote-reference inline-babel-call inline-src-block latex-or-entity line-break link macro radio-target statistics-cookie sub/superscript table-cell target text-markup timestamp) (#$ . 2174))
#@186 Alist of translations between object type and successor name.

Sharing the same successor comes handy when, for example, the
regexp matching one object can also match the other object.
(defconst org-element-object-successor-alist '((subscript . sub/superscript) (superscript . sub/superscript) (bold . text-markup) (code . text-markup) (italic . text-markup) (strike-through . text-markup) (underline . text-markup) (verbatim . text-markup) (entity . latex-or-entity) (latex-fragment . latex-or-entity)) (#$ . 2457))
#@32 Complete list of object types.
(defconst org-element-all-objects '(bold code entity export-snippet footnote-reference inline-babel-call inline-src-block italic line-break latex-fragment link macro radio-target statistics-cookie strike-through subscript superscript table-cell target timestamp underline verbatim) (#$ . 2980))
#@33 List of recursive object types.
(defconst org-element-recursive-objects '(bold italic link macro subscript radio-target strike-through superscript table-cell underline) (#$ . 3312))
#@181 Alist between block names and the associated parsing function.
Names must be uppercase.  Any block whose name has no association
is parsed with `org-element-special-block-parser'.
(defconst org-element-block-name-alist '(("CENTER" . org-element-center-block-parser) ("COMMENT" . org-element-comment-block-parser) ("EXAMPLE" . org-element-example-block-parser) ("QUOTE" . org-element-quote-block-parser) ("SRC" . org-element-src-block-parser) ("VERSE" . org-element-verse-block-parser)) (#$ . 3501))
#@162 List of affiliated keywords as strings.
By default, all keywords setting attributes (i.e. "ATTR_LATEX")
are affiliated keywords and need not to be in this list.
(defconst org-element-affiliated-keywords '("CAPTION" "DATA" "HEADER" "HEADERS" "LABEL" "NAME" "PLOT" "RESNAME" "RESULT" "RESULTS" "SOURCE" "SRCNAME" "TBLNAME") (#$ . 4007))
#@244 Regexp matching any affiliated keyword.

Keyword name is put in match group 1.  Moreover, if keyword
belongs to `org-element-dual-keywords', put the dual value in
match group 2.

Don't modify it, set `org-element-affiliated-keywords' instead.
(defconst org-element--affiliated-re (byte-code "\301\302\301\303\304!\"\"\207" [org-element-affiliated-keywords format "[ 	]*#\\+%s:" "\\(%s\\|ATTR_[-_A-Za-z0-9]+\\)\\(?:\\[\\(.*\\)\\]\\)?" regexp-opt] 6) (#$ . 4349))
#@169 Alist of usual translations for keywords.
The key is the old name and the value the new one.  The property
holding their value will be named after the translated name.
(defconst org-element-keyword-translation-alist '(("DATA" . "NAME") ("LABEL" . "NAME") ("RESNAME" . "NAME") ("SOURCE" . "NAME") ("SRCNAME" . "NAME") ("TBLNAME" . "NAME") ("RESULT" . "RESULTS") ("HEADERS" . "HEADER")) (#$ . 4819))
#@410 List of affiliated keywords that can occur more that once in an element.

Their value will be consed into a list of strings, which will be
returned as the value of the property.

This list is checked after translations have been applied.  See
`org-element-keyword-translation-alist'.

By default, all keywords setting attributes (i.e. "ATTR_LATEX")
allow multiple occurrences and need not to be in this list.
(defconst org-element-multiple-keywords '("HEADER") (#$ . 5224))
#@233 List of keywords whose value can be parsed.

Their value will be stored as a secondary string: a list of
strings and objects.

This list is checked after translations have been applied.  See
`org-element-keyword-translation-alist'.
(defconst org-element-parsed-keywords '("AUTHOR" "CAPTION" "DATE" "TITLE") (#$ . 5705))
#@366 List of keywords which can have a secondary value.

In Org syntax, they can be written with optional square brackets
before the colons.  For example, results keyword can be
associated to a hash value with the following:

  #+RESULTS[hash-string]: some-source

This list is checked after translations have been applied.  See
`org-element-keyword-translation-alist'.
(defconst org-element-dual-keywords '("CAPTION" "RESULTS") (#$ . 6032))
#@499 Alist of objects restrictions.

CAR is an element or object type containing objects and CDR is
a list of successors that will be called within an element or
object of such type.

For example, in a `radio-target' object, one can only find
entities, export snippets, latex-fragments, subscript and
superscript.

This alist also applies to secondary string.  For example, an
`headline' type element doesn't directly contain objects, but
still has an entry since one of its properties (`:title') does.
(defconst org-element-object-restrictions '((bold export-snippet inline-babel-call inline-src-block latex-or-entity link radio-target sub/superscript target text-markup timestamp) (footnote-reference export-snippet footnote-reference inline-babel-call inline-src-block latex-or-entity line-break link macro radio-target sub/superscript target text-markup timestamp) (headline inline-babel-call inline-src-block latex-or-entity link macro radio-target statistics-cookie sub/superscript target text-markup timestamp) (inlinetask inline-babel-call inline-src-block latex-or-entity link macro radio-target sub/superscript target text-markup timestamp) (italic export-snippet inline-babel-call inline-src-block latex-or-entity link radio-target sub/superscript target text-markup timestamp) (item export-snippet footnote-reference inline-babel-call latex-or-entity link macro radio-target sub/superscript target text-markup) (keyword latex-or-entity macro sub/superscript text-markup) (link export-snippet inline-babel-call inline-src-block latex-or-entity link sub/superscript text-markup) (macro macro) (paragraph export-snippet footnote-reference inline-babel-call inline-src-block latex-or-entity line-break link macro radio-target statistics-cookie sub/superscript target text-markup timestamp) (radio-target export-snippet latex-or-entity sub/superscript) (strike-through export-snippet inline-babel-call inline-src-block latex-or-entity link radio-target sub/superscript target text-markup timestamp) (subscript export-snippet inline-babel-call inline-src-block latex-or-entity sub/superscript target text-markup) (superscript export-snippet inline-babel-call inline-src-block latex-or-entity sub/superscript target text-markup) (table-cell export-snippet latex-or-entity link macro radio-target sub/superscript target text-markup timestamp) (table-row table-cell) (underline export-snippet inline-babel-call inline-src-block latex-or-entity link radio-target sub/superscript target text-markup timestamp) (verse-block footnote-reference inline-babel-call inline-src-block latex-or-entity line-break link macro radio-target sub/superscript target text-markup timestamp)) (#$ . 6476))
#@62 Alist between element types and location of secondary value.
(defconst org-element-secondary-value-alist '((headline . :title) (inlinetask . :title) (item . :tag) (footnote-reference . :inline-definition)) (#$ . 9166))
#@258 Return type of ELEMENT.

The function returns the type of the element or object provided.
It can also return the following special value:
  `plain-text'       for a string
  `org-data'         for a complete document
  nil                in any other case.
(defalias 'org-element-type #[(element) ":\204\f;\205\301\207@9\205@\207" [element plain-text] 1 (#$ . 9392)])
(put 'org-element-type 'byte-optimizer 'byte-compile-inline-expand)
#@52 Extract the value from the PROPERTY of an ELEMENT.
(defalias 'org-element-property #[(property element) "\302A@	\"\207" [element property plist-get] 3 (#$ . 9843)])
(put 'org-element-property 'byte-optimizer 'byte-compile-inline-expand)
#@35 Extract contents from an ELEMENT.
(defalias 'org-element-contents #[(element) ":\205AA\207" [element] 1 (#$ . 10087)])
(put 'org-element-contents 'byte-optimizer 'byte-compile-inline-expand)
#@132 Return restriction associated to ELEMENT.
ELEMENT can be an element, an object or a symbol representing an
element or object type.
(defalias 'org-element-restriction #[(element) "9\203	\202\"\211:\204;\205!\302\202!@9\205!@)	\236A\207" [element org-element-object-restrictions plain-text] 3 (#$ . 10289)])
(put 'org-element-restriction 'byte-optimizer 'byte-compile-inline-expand)
#@60 In ELEMENT set PROPERTY to VALUE.
Return modified element.
(defalias 'org-element-put-property #[(element property value) ":\203A\303A@	\n#\240\210\207" [element property value plist-put] 5 (#$ . 10690)])
(put 'org-element-put-property 'byte-optimizer 'byte-compile-inline-expand)
#@60 Set ELEMENT contents to CONTENTS.
Return modified element.
(defalias 'org-element-set-contents #[(element &rest contents) "\204	C\207A\203A	\241\207	\244\207" [element contents] 2 (#$ . 10983)])
(put 'org-element-set-contents 'byte-optimizer 'byte-compile-inline-expand)
#@122 Replace element or object OLD with element or object NEW.
The function takes care of setting `:parent' property for NEW.
(defalias 'org-element-set-element #[(old new) "\305\306\211:\205\f	AA)\"\210\307\310\n\211:\205	AA)#\210\311\211\n\312	A@\"*\211:\203?	A\313	A@\f#\240\210	+\210\nAA@\240\210\n@\240\207" [new element old property value mapc #[(blob) "\305	\211:\203\fA\306\fA@\n#\240\210\f+\207" [blob old value property element :parent plist-put] 6] apply org-element-set-contents :parent plist-get plist-put] 6 (#$ . 11269)])
(put 'org-element-set-element 'byte-optimizer 'byte-compile-inline-expand)
#@225 Append elements to the contents of another element.

PARENT is an element or object.  CHILDREN can be elements,
objects, or a strings.

The function takes care of setting `:parent' property for CHILD.
Return parent element.
(defalias 'org-element-adopt-elements #[(parent &rest children) "\204	\207\303\304	\"\210\305\306\211\211:\205\nAA)	\244#\210\207" [parent children element mapc #[(child) ";?\205\305	\211:\203\fA\306\fA@\n#\240\210\f+\207" [child parent value property element :parent plist-put] 6] apply org-element-set-contents] 5 (#$ . 11908)])
(put 'org-element-adopt-elements 'byte-optimizer 'byte-compile-inline-expand)
#@263 Parse a center block.

LIMIT bounds the search.

Return a list whose CAR is `center-block' and CDR is a plist
containing `:begin', `:end', `:hiddenp', `:contents-begin',
`:contents-end' and `:post-blank' keywords.

Assume point is at the beginning of the block.
(defalias 'org-element-center-block-parser #[(limit) "\306\212\307\310	\306#)\204\311	!\202r\312\224\313 \211@\314y\210`\nW\205%`\211\205+\n\315 \nb\210\314y\210`\212\316	w\210\317\314x\210n\203K`\202M\320 )\321\322\f\323\324\325
\326\327\330\"\257\f\211A@)\244.D)\207" [case-fold-search limit block-end-line keywords begin contents-begin t re-search-forward "^[ 	]*#\\+END_CENTER[ 	]*$" org-element-paragraph-parser 0 org-element--collect-affiliated-keywords nil org-invisible-p2 " 
	\n" " 	" line-end-position center-block :begin :end :hiddenp :contents-begin :contents-end :post-blank count-lines contents-end hidden pos-before-blank end x] 16 (#$ . 12566)])
#@88 Interpret CENTER-BLOCK element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-center-block-interpreter #[(center-block contents) "\301\302\"\207" [contents format "#+BEGIN_CENTER\n%s#+END_CENTER"] 3 (#$ . 13530)])
#@260 Parse a drawer.

LIMIT bounds the search.

Return a list whose CAR is `drawer' and CDR is a plist containing
`:drawer-name', `:begin', `:end', `:hiddenp', `:contents-begin',
`:contents-end' and `:post-blank' keywords.

Assume point is at beginning of drawer.
(defalias 'org-element-drawer-parser #[(limit) "\306\212\307\310	\306#)\204\311	!\202\213\312\224\212\306\313!\210\314\315\316
\f\"*\317 \211@\315y\210`\nW\2059`\211 \205@\n!\320 \"\nb\210\315y\210`#\321	w\210\322\315x\210n\203_`\202a\323 $\324\325\326$\327\330\"\331 \332!\333\334#$\"\257\211%A@)\244.D)\207" [case-fold-search limit drawer-end-line org-drawer-regexp string num t re-search-forward "^[ 	]*:END:[ 	]*$" org-element-paragraph-parser 0 looking-at 1 nil match-string-no-properties org-element--collect-affiliated-keywords org-invisible-p2 " 
	\n" " 	" line-end-position drawer :begin :end :drawer-name :hiddenp :contents-begin :contents-end :post-blank count-lines name keywords begin contents-begin contents-end hidden pos-before-blank end x] 18 (#$ . 13784)])
#@82 Interpret DRAWER element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-drawer-interpreter #[(drawer contents) "\304\305\306\307	A@\n\"*#\207" [drawer element property contents format ":%s:\n%s:END:" :drawer-name plist-get] 5 (#$ . 14863)])
#@294 Parse a dynamic block.

LIMIT bounds the search.

Return a list whose CAR is `dynamic-block' and CDR is a plist
containing `:block-name', `:begin', `:end', `:hiddenp',
`:contents-begin', `:contents-end', `:arguments' and
`:post-blank' keywords.

Assume point is at beginning of dynamic block.
(defalias 'org-element-dynamic-block-parser #[(limit) "\306\212\307\310	\306#)\204\311	!\202\227\312\224\212\313!\210\314\315\316
\f\"*\317\315\316
\f\"* \320 \211!@\"\315y\210`\nW\205B`\211#\205I\n$\321 %\nb\210\315y\210`&\322	w\210\323\315x\210n\203h`\202j\324 '\325\326\"\327'\330\331 \332%\333#\334$\335\336&'\"\257!\211(A@)\244.D)\207" [case-fold-search limit block-end-line org-dblock-start-re string num t re-search-forward "^[ 	]*#\\+END:?[ 	]*$" org-element-paragraph-parser 0 looking-at 1 nil match-string-no-properties 3 org-element--collect-affiliated-keywords org-invisible-p2 " 
	\n" " 	" line-end-position dynamic-block :begin :end :block-name :arguments :hiddenp :contents-begin :contents-end :post-blank count-lines name arguments keywords begin contents-begin contents-end hidden pos-before-blank end x] 20 (#$ . 15147)])
#@89 Interpret DYNAMIC-BLOCK element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-dynamic-block-interpreter #[(dynamic-block contents) "\305\306\307\310	A@\n\"*\311\310	A@\n\"*\211\205 \312P)\f$\207" [dynamic-block element property args contents format "#+BEGIN: %s%s\n%s#+END:" :block-name plist-get :arguments " "] 7 (#$ . 16324)])
#@288 Parse a footnote definition.

LIMIT bounds the search.

Return a list whose CAR is `footnote-definition' and CDR is
a plist containing `:label', `:begin' `:end', `:contents-begin',
`:contents-end' and `:post-blank' keywords.

Assume point is at the beginning of the footnote definition.
(defalias 'org-element-footnote-definition-parser #[(limit) "\212\306!\210\307\310\311\n	\"*\312 \211@\212\310\210\313\314\314\315\260\316#\203.\317\224\202/`)\320\321!\210\322w\210`U?\205D`\211 \205L!b\210\322w\210\323\310x\210n\203c`\202e\324 \"\325\326\327
\330\"\331 \332!\333\334\"\"\257\f\f\211#A@)\244.D\207" [org-footnote-definition-re string num label keywords begin looking-at 1 nil match-string-no-properties org-element--collect-affiliated-keywords re-search-forward "\\|" "^[ 	]*$" move 0 search-forward "]" " 
	\n" " 	" line-end-position footnote-definition :label :begin :end :contents-begin :contents-end :post-blank count-lines org-outline-regexp-bol limit ending contents-begin contents-end end x] 16 (#$ . 16703)])
#@107 Interpret FOOTNOTE-DEFINITION element as Org syntax.
CONTENTS is the contents of the footnote-definition.
(defalias 'org-element-footnote-definition-interpreter #[(footnote-definition contents) "\304\305\306\307	A@\n\"*\"\310Q\207" [footnote-definition element property contents format "[%s]" :label plist-get " "] 5 (#$ . 17774)])
#@750 Parse an headline.

Return a list whose CAR is `headline' and CDR is a plist
containing `:raw-value', `:title', `:begin', `:end',
`:pre-blank', `:hiddenp', `:contents-begin' and `:contents-end',
`:level', `:priority', `:tags', `:todo-keyword',`:todo-type',
`:scheduled', `:deadline', `:timestamp', `:clock', `:category',
`:quotedp', `:archivedp', `:commentedp' and `:footnote-section-p'
keywords.

The plist also contains any property set in the property drawer,
with its name in lowercase, the underscores replaced with hyphens
and colons at the beginning (i.e. `:custom-id').

When RAW-SECONDARY-P is non-nil, headline's title will not be
parsed as a secondary string, but as a plain string instead.

Assume point is at beginning of the headline.
(defalias 'org-element-headline-parser #[(limit &optional raw-secondary-p) "\212\306 \211A@\3078\211\205\n\235\203\310\202\302\3118\211\205(\312
\313\")@\3148\2062\315A\316B\317\320\321C\"A\")D\316B\317\320\321E\"A\")FG@\235HI\205cIA\230J\316K\322\323\324\316\325\"\"\210K)L\324\316\326\327#M\330\331M\"AN\330\332M\"AO\330\327M\"AP\330\333M\"AQ`R\212\334\335\211\"b)S\316y\210`T\212\336Sw\210`SU?\205\276\337 )U\340 VU\205\326Sb\210\336\316x\210\316y\210`WD\204\342F\203\366\316B\341\342CED!\343P\315A#A)H\203
\344G@\"@\345\346A\347R\350S\351U\204
\352\202
\353TU\"\354V\355U\356W\357	\360\3618\362@\363\n\364\f\365N\366O\367Q\370P\371\353W\204K
T\202S
Wb\210\316y\210`S\"\372J\373H\374F\375D\257*L\244D\211%\376X\203v
A\202\256
\377A\345\211Y9\203\206
Y\202\246
Y\211Y:\204\233
Y;\205\245
\201]\202\245
Y@9\205\245
Y@)Z\236A)%#[\\\211Y:\203\312
YA\201^YA@\\[#\240\210Y.\207" [components level todo org-done-keywords todo-type raw-tags org-heading-components 2 done 5 org-split-string ":" 4 "" nil string-match format "^%s\\( \\|$\\)" mapc #[(p) "@\227\303\304	\"\203\305\306\307\211	$\202\310\311	P!\312\n	A#\211)\207" [p p-name plist string-match "_" replace-match "-" nil intern ":" plist-put] 5] org-entry-properties standard special "CLOCK" assoc "SCHEDULED" "DEADLINE" "TIMESTAMP" org-end-of-subtree t " 
	\n" line-beginning-position org-invisible-p2 replace-regexp-in-string regexp-opt "\\(?: \\|$\\)" delete headline :raw-value :begin :end :pre-blank 0 count-lines :hiddenp :contents-begin :contents-end :level :priority 3 :tags :todo-keyword :todo-type :scheduled :deadline :timestamp :clock :post-blank :footnote-section-p :archivedp :commentedp :quotedp :title org-element-parse-secondary-string tags raw-value case-fold-search org-quote-string quotedp org-comment-string commentedp org-archive-tag archivedp org-footnote-section footnote-section-p plist standard-props time-props scheduled deadline clock timestamp begin end pos-after-head contents-begin hidden contents-end raw-secondary-p element org-element-object-restrictions value property plain-text plist-put] 44 (#$ . 18117)])
#@84 Interpret HEADLINE element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-headline-interpreter #[(headline contents) "\306\307	A@\n\"*\310\307	A@\n\"*\311\307	A@\n\"*\312\313\307	A@\n\"*!#\314\307	A@\n\"*\203R$\315\307	A@\n\"*B\202]\315\307	A@\n\"*\211%\205l\316\317\320\321%\322#\")&\323\307	A@\n\"*'\324\307	A@\n\"*(\325\307	A@\n\"*\206\230\326)\327\330\"\f\205\245\331\fP(\205\256\331*P'\205\267\331+P
\205\301\316\332\333
!\",\203\333\334\307	A@\n\"*\203\333\331,P\202\344#\205\344\331#P\260\211-&\205(
\335.!\203\375\316\336&\"\202(
.\326W\203
\327\337.-G&G#[\340]\341\"&P\202(
\327.-GZ\340]\341\"&P\327)T\342\"/R.	\207" [headline element property level todo priority :level plist-get :todo-keyword :priority org-element-interpret-data :title :archivedp :tags format ":%s:" mapconcat identity ":" :commentedp :quotedp :pre-blank 0 make-string 42 " " " [#%s]" char-to-string :footnote-section-p zerop " %s" + 1 32 10 title org-archive-tag tag-list tags commentedp quotedp pre-blank org-quote-string org-comment-string org-footnote-section heading org-tags-column contents] 9 (#$ . 21103)])
#@704 Parse an inline task.

Return a list whose CAR is `inlinetask' and CDR is a plist
containing `:title', `:begin', `:end', `:hiddenp',
`:contents-begin' and `:contents-end', `:level', `:priority',
`:raw-value', `:tags', `:todo-keyword', `:todo-type',
`:scheduled', `:deadline', `:timestamp', `:clock' and
`:post-blank' keywords.

The plist also contains any property set in the property drawer,
with its name in lowercase, the underscores replaced with hyphens
and colons at the beginning (i.e. `:custom-id').

When optional argument RAW-SECONDARY-P is non-nil, inline-task's
title will not be parsed as a secondary string, but as a plain
string instead.

Assume point is at beginning of the inline task.
(defalias 'org-element-inlinetask-parser #[(limit &optional raw-secondary-p) "\212\306 \211@\307 \310\n8\211\205\f\235\203\311\202\303\312\n8\2119\205,\3139\314\"):\315\n8\2066\316;\317<\320\321\322\317\323\"\"\210<)=\322\317\324\325#>\326\327>\"A?\326\330>\"A@\326\325>\"AA\326\331>\"AB\212\317\210\332\333C\334#\205~\335\224)D\317y\210D\205\221`DW\205\221`\211E\205\231\336 FE\205\242DGD\204\255`\202\265Db\210\317y\210`H\337Cw\210\340\317x\210n\203\310`\202\312\341 I\342\343;\344	\345I\346F\347E\350G\351\nA@\352\353\n8\354:\355\356
\357?\360@\361B\362A\363\364HI\"\257 =\244\211JA@)\244D\211\"\365K\203
;\202R
\366;\342\211L9\203,
L\202J
L\211L:\204?
L;\205I
\367\202I
L@9\205I
L@)M\236A)\"#NO\211L:\203l
LA\370LA@ON#\240\210L.\207" [keywords begin components todo org-done-keywords todo-type org-element--collect-affiliated-keywords org-heading-components 2 done 5 org-split-string ":" 4 "" nil mapc #[(p) "@\227\303\304	\"\203\305\306\307\211	$\202\310\311	P!\312\n	A#\211)\207" [p p-name plist string-match "_" replace-match "-" nil intern ":" plist-put] 5] org-entry-properties standard special "CLOCK" assoc "SCHEDULED" "DEADLINE" "TIMESTAMP" re-search-forward "^\\*+ END" t 0 org-invisible-p2 " 
	\n" " 	" line-end-position inlinetask :raw-value :begin :end :hiddenp :contents-begin :contents-end :level :priority 3 :tags :todo-keyword :todo-type :scheduled :deadline :timestamp :clock :post-blank count-lines :title org-element-parse-secondary-string plain-text plist-put raw-tags tags raw-value plist standard-props time-props scheduled deadline clock timestamp limit task-end contents-begin hidden contents-end before-blank end x raw-secondary-p element org-element-object-restrictions value property] 36 (#$ . 22318)])
#@85 Interpret INLINETASK element as Org syntax.
CONTENTS is the contents of inlinetask.
(defalias 'org-element-inlinetask-interpreter #[(inlinetask contents) "\306\307	A@\n\"*\310\307	A@\n\"*\311\307	A@\n\"*\312\313\307	A@\n\"*!\314\307	A@\n\"*\211 \205M\315\316\317\320 \321#\")!\322\323\"\f\205[\324\fP
\205e\315\325\326
!\"\205n\324PR\211\"!\205\261\327#!\203\206\315\330!\"\202\261#\331W\203\243\322\332#\"G!G#[\333]\334\"!P\202\261\322#\"GZ\333]\334\"!P$\205\277\335$\322\323\"\336RQ.\207" [inlinetask element property level todo priority :level plist-get :todo-keyword :priority org-element-interpret-data :title :tags format ":%s:" mapconcat identity ":" make-string 42 " " " [#%s]" char-to-string zerop " %s" 0 + 1 32 "\n" " END" title tag-list tags task org-tags-column contents] 8 (#$ . 24864)])
#@468 Parse an item.

STRUCT is the structure of the plain list.

Return a list whose CAR is `item' and CDR is a plist containing
`:bullet', `:begin', `:end', `:contents-begin', `:contents-end',
`:checkbox', `:counter', `:tag', `:structure', `:hiddenp' and
`:post-blank' keywords.

When optional argument RAW-SECONDARY-P is non-nil, item's tag, if
any, will not be parsed as a secondary string, but as a plain
string instead.

Assume point is at the beginning of the item.
(defalias 'org-element-item-parser #[(limit struct &optional raw-secondary-p) "\212\306 \210\307!\210`\310\311\312\n\"*\313\311\312\n\"*\211\314\232\203(\315\2029
\316\232\2032\317\2029
\320\232\2059\321)5\322\311\312\n\"*6\323 7\324\2166\204V\311\202z\325\3266\"\203k\327\330\3316\"\226!\332Z\202z\325\3336\"\205z\334\330\3316\"!+8\212\335	9\"b\210n\204\214\311y\210`):\336\224\203\250\323 7\337\216\325\340\f\"*\203\250\336\224\202\252\331\225b\210\341;w\210\342 	U\203\274`\202\276\342 <\311y\210`:U?\205\315\343 =:b\210\341\311x\210\311y\210`>\344\345\f\346	\347:\350<>^\351<>]\3525\3538\354=\3559\356\357>:\"\257D\211$\360	99$\361$99?\211@?9\2368-\211A\205k
B\2035
A\202k
\362A\344\211C9\203E
C\202c
C\211C:\204X
C;\205b
\363\202b
C@9\205b
C@)D\236A)$#)EF\211C:\203\206
CA\364CA@FE#\240\210C.
\207" [org-list-full-item-re begin string num bullet box beginning-of-line looking-at 1 nil match-string-no-properties 3 "[ ]" off "[X]" on "[-]" trans 2 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "[A-Za-z]" string-to-char match-string 0 64 "[0-9]+" string-to-number org-list-get-item-end 4 ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "[.)]" " 
	\n" point-at-bol org-invisible-p2 item :bullet :begin :end :contents-begin :contents-end :checkbox :counter :hiddenp :structure :post-blank count-lines :tag 5 org-element-parse-secondary-string plain-text plist-put checkbox c save-match-data-internal counter struct end limit contents-begin hidden contents-end key n raw-tag raw-secondary-p element org-element-object-restrictions value property] 24 (#$ . 25727)])
#@80 Interpret ITEM element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-item-interpreter #[(item contents) "\306\307	A@\n\"*\310 \311\216
\203 \312
\"\203 \313\202!\314'\312\315\"\210\316'\317\211\320%,\321\307	A@\n\"*(\322\307	A@\n\"*)\323\307	A@\n\"*\211*\205a\324*!)*\325G\326\"+\211:\205u	AA)@\211:\204\206	;\205\216\327\202\216	@9\205\216	@)\330=,)\205\236\331\332)\"\333(\334\"\203\252\335\202\277\333(\336\"\203\266\337\202\277\333(\340\"\205\277\341*\205\311\331\342*\"\343\344+-\317\211\320&-,\203\342\345-!\202\346\346-P)\260.\207" [item element property bullet save-match-data-internal org-list-two-spaces-after-bullet-regexp :bullet plist-get match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "  " " " "\\S-+\\([ 	]*\\)" replace-match nil 1 :checkbox :counter :tag org-element-interpret-data make-string 32 plain-text paragraph format "[@%d] " eql on "[X] " off "[ ] " trans "[-] " "%s :: " replace-regexp-in-string "\\(^\\)[ 	]*\\S-" org-trim "\n" spaces checkbox counter tag ind item-starts-with-par-p contents] 12 (#$ . 27960)])
#@339 Parse a plain list.

Optional argument STRUCTURE, when non-nil, is the structure of
the plain list being parsed.

Return a list whose CAR is `plain-list' and CDR is a plist
containing `:type', `:begin', `:end', `:contents-begin' and
`:contents-end', `:structure' and `:post-blank' keywords.

Assume point is at the beginning of the list.
(defalias 'org-element-plain-list-parser #[(limit &optional structure) "\212\206\306 \307	!\310	!\311`	\n#`\312 \211@\313`	\n#b\210n\204.\314y\210`\315w\210\316\314x\210n\203B`\202D\317 \320\321\f\322\323\324
\325\326	\327\330\"\257\211A@)\244.\nD\207" [structure struct prevs parents type contents-begin org-list-struct org-list-prevs-alist org-list-parents-alist org-list-get-list-type org-element--collect-affiliated-keywords org-list-get-list-end nil " 
	\n" " 	" line-end-position plain-list :type :begin :end :contents-begin :contents-end :structure :post-blank count-lines keywords begin contents-end limit end x] 18 (#$ . 29167)])
#@86 Interpret PLAIN-LIST element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-plain-list-interpreter #[(plain-list contents) "\302\303!rq\210\304\216	c\210eb\210\305 \210\306 +\207" [#1=#:temp-buffer contents generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) org-list-repair buffer-string] 2 (#$ . 30186)])
#@261 Parse a quote block.

LIMIT bounds the search.

Return a list whose CAR is `quote-block' and CDR is a plist
containing `:begin', `:end', `:hiddenp', `:contents-begin',
`:contents-end' and `:post-blank' keywords.

Assume point is at the beginning of the block.
(defalias 'org-element-quote-block-parser #[(limit) "\306\212\307\310	\306#)\204\311	!\202q\312\224\212\313 \211@\314y\210`\nW\205&`\211\205,\n\315 \nb\210\314y\210`\316	w\210\317\314x\210n\203K`\202M\320 \321\322\f\323\324\325
\326\327\330\"\257\f\211A@)\244.	D)\207" [case-fold-search limit block-end-line keywords begin contents-begin t re-search-forward "^[ 	]*#\\+END_QUOTE[ 	]*$" org-element-paragraph-parser 0 org-element--collect-affiliated-keywords nil org-invisible-p2 " 
	\n" " 	" line-end-position quote-block :begin :end :hiddenp :contents-begin :contents-end :post-blank count-lines contents-end hidden pos-before-blank end x] 16 (#$ . 30592)])
#@87 Interpret QUOTE-BLOCK element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-quote-block-interpreter #[(quote-block contents) "\301\302\"\207" [contents format "#+BEGIN_QUOTE\n%s#+END_QUOTE"] 3 (#$ . 31550)])
#@192 Parse a section.

LIMIT bounds the search.

Return a list whose CAR is `section' and CDR is a plist
containing `:begin', `:end', `:contents-begin', `contents-end'
and `:post-blank' keywords.
(defalias 'org-element-section-parser #[(limit) "\212`\306\307 \211\310	P\311 \210,`\312\313x\210\313y\210`\314\315\316
\317\320\f\321\322\f
\"\257\n,D\207" [org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol pos-before-blank end t org-get-limited-outline-regexp "^" outline-next-heading " 
	\n" nil section :begin :end :contents-begin :contents-end :post-blank count-lines begin] 14 (#$ . 31799)])
#@83 Interpret SECTION element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-section-interpreter #[(section contents) "\207" [contents] 1 (#$ . 32444)])
#@274 Parse a special block.

LIMIT bounds the search.

Return a list whose CAR is `special-block' and CDR is a plist
containing `:type', `:begin', `:end', `:hiddenp',
`:contents-begin', `:contents-end' and `:post-blank' keywords.

Assume point is at the beginning of the block.
(defalias 'org-element-special-block-parser #[(limit) "\306\307\310!\210\311\312!\226\212\313\314\315	\"\n\306#)\204\316\n!\202\201\317\224\212\320 \211@\321y\210`W\2052`\211\2059 \322 !b\210\321y\210`\"\323\nw\210\324\321x\210n\203X`\202Z\325 #\326\327	\330
\331#\332!\333\334 \335\336\"#\"\257\f\211$A@)\244.	D*\207" [case-fold-search type limit block-end-line keywords begin t looking-at "[ 	]*#\\+BEGIN_\\(S-+\\)" match-string-no-properties 1 re-search-forward format "^[ 	]*#\\+END_%s[ 	]*$" org-element-paragraph-parser 0 org-element--collect-affiliated-keywords nil org-invisible-p2 " 
	\n" " 	" line-end-position special-block :type :begin :end :hiddenp :contents-begin :contents-end :post-blank count-lines contents-begin contents-end hidden pos-before-blank end x] 18 (#$ . 32633)])
#@89 Interpret SPECIAL-BLOCK element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-special-block-interpreter #[(special-block contents) "\305\306	A@\n\"*\307\310\f$)\207" [special-block element property block-type contents :type plist-get format "#+BEGIN_%s\n%s#+END_%s"] 5 (#$ . 33735)])
#@175 Parse a babel call.

LIMIT bounds the search.

Return a list whose CAR is `babel-call' and CDR is a plist
containing `:begin', `:end', `:info' and `:post-blank' as
keywords.
(defalias 'org-element-babel-call-parser #[(limit) "\212\306\307!\210\310 \311 \312y\210`\313	w\210\314\312x\210n\203`\202 \315 \316\317\f\320\n\321
\322\323\n\"\257.D\207" [org-babel-block-lob-one-liner-regexp limit end pos-before-blank begin info t looking-at org-babel-lob-get-info point-at-bol nil " 
	\n" " 	" line-end-position babel-call :begin :end :info :post-blank count-lines case-fold-search] 11 (#$ . 34065)])
#@62 Interpret BABEL-CALL element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-babel-call-interpreter #[(babel-call contents) "\306\307	A@\n\"*\211@A@\310\311\312\f\"\204\f\202(\313\314\315\f\"\316\211\f$
\2050\317\320
\"Q+\207" [babel-call element property babel-info main post-options :info plist-get "#+CALL: " string-match "\\[\\(\\[.*?\\]\\)\\]" replace-match match-string 1 nil format "[%s]"] 7 (#$ . 34680)])
#@186 Parse a clock.

LIMIT bounds the search.

Return a list whose CAR is `clock' and CDR is a plist containing
`:status', `:value', `:time', `:begin', `:end' and `:post-blank'
as keywords.
(defalias 'org-element-clock-parser #[(limit) "\212\306`\307\n\310 \311#\210\312 \210\313\314!\210\315\306\316\f\"*\315\225b\210\313\317!\2050\320\306\316\f\"*\211\203:\321\202;\322\306y\210`\323 w\210\324\306x\210n\204S\306\210\325`\")!`\"\326\327\330
\331\332	\333\"\334!\257\f.D\207" [case-fold-search begin org-clock-string string num value nil search-forward line-end-position t org-skip-whitespace looking-at "\\[.*\\]" 0 match-string-no-properties " +=> +\\(\\S-+\\)[ 	]*$" 1 closed running " 
	\n" " 	" count-lines clock :status :value :time :begin :end :post-blank time status before-blank limit post-blank end] 14 (#$ . 35119)])
#@57 Interpret CLOCK element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-clock-interpreter #[(clock contents) "\305\306	\307\nA@\"*\310	\307\nA@\"*\211\205'\311\312\313\314\315\f\316\"#P)R\207" [org-clock-string clock element property time " " :value plist-get :time " => " apply format "%2s:%02s" org-split-string ":"] 11 (#$ . 35981)])
#@206 Parse a comment.

LIMIT bounds the search.

Return a list whose CAR is `comment' and CDR is a plist
containing `:begin', `:end', `:value' and `:post-blank'
keywords.

Assume point is at comment beginning.
(defalias 'org-element-comment-parser #[(limit) "\212\306 \211@\307\310!\210\311\312\225\313 \"\314y\210`W\2031\307\315!\2031\n\316\311\312\225\313 \"Q\314y\210\202`\211b\210\317w\210\320\314x\210n\203F`\202H\313 \321\322	\323
\324\n\325\326\f
\"\257\211A@)\244.D\207" [keywords begin value limit com-end end org-element--collect-affiliated-keywords looking-at "[ 	]*# ?" buffer-substring-no-properties 0 line-end-position nil "[ 	]*#\\( \\|$\\)" "\n" " 
	\n" " 	" comment :begin :end :value :post-blank count-lines x] 12 (#$ . 36341)])
#@59 Interpret COMMENT element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-comment-interpreter #[(comment contents) "\303\304\305\306\307	A@\n\"*#\207" [comment element property replace-regexp-in-string "^" "# " :value plist-get] 6 (#$ . 37108)])
#@236 Parse an export block.

LIMIT bounds the search.

Return a list whose CAR is `comment-block' and CDR is a plist
containing `:begin', `:end', `:hiddenp', `:value' and
`:post-blank' keywords.

Assume point is at comment block beginning.
(defalias 'org-element-comment-block-parser #[(limit) "\306\212\307\310	\306#)\204\311	!\202h\312\224\212\313 \211@\314y\210`\315 \nb\210\314y\210`\316	w\210\317\314x\210n\203>`\202@\320 \321
\n\"\322\323\f\324\325\326\327\330\"\257\n\211A@)\244.	D)\207" [case-fold-search limit contents-end keywords begin contents-begin t re-search-forward "^[ 	]*#\\+END_COMMENT[ 	]*$" org-element-paragraph-parser 0 org-element--collect-affiliated-keywords nil org-invisible-p2 " 
	\n" " 	" line-end-position buffer-substring-no-properties comment-block :begin :end :value :hiddenp :post-blank count-lines hidden pos-before-blank end value x] 14 (#$ . 37371)])
#@65 Interpret COMMENT-BLOCK element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-comment-block-interpreter #[(comment-block contents) "\303\304\305\306\307	A@\n\"*!\"\207" [comment-block element property format "#+BEGIN_COMMENT\n%s#+END_COMMENT" org-remove-indentation :value plist-get] 6 (#$ . 38291)])
#@289 Parse an example block.

LIMIT bounds the search.

Return a list whose CAR is `example-block' and CDR is a plist
containing `:begin', `:end', `:number-lines', `:preserve-indent',
`:retain-labels', `:use-labels', `:label-fmt', `:hiddenp',
`:switches', `:value' and `:post-blank' keywords.
(defalias 'org-element-example-block-parser #[(limit) "\306\212\307\310	\306#)\204\311	!\202\360\312\224\212\313\314!\210\315\316\317\f\"*\211\204,\316\202?\320\321
\"\2037\322\202?\320\323
\"\205?\324.
\205I\320\325
\"/
?\206a\320\326
\"?\206a.\205a\320\327
\"0
?\206r0\205r\320\327
\"?1
\205\203\320\330
\"\205\203\331\315
\"2\332 \2113@4\316y\210`5\333 6\334\3355\n\"!7\nb\210\316y\210`8\336	w\210\337\316x\210n\203\271`\202\273\340 9\341\3424\3439\3447\345
\346.\347/\3500\3511\3522\3536\354\35589\"\2573\211:A@)\244.D)\207" [case-fold-search limit contents-end string num switches t re-search-forward "^[ 	]*#\\+END_EXAMPLE[ 	]*$" org-element-paragraph-parser 0 looking-at "^[ 	]*#\\+BEGIN_EXAMPLE\\(?: +\\(.*\\)\\)?" 1 nil match-string-no-properties string-match "-n\\>" new "+n\\>" continued "-i\\>" "-r\\>" "-k\\>" "-l +\"\\([^\"\n]+\\)\"" match-string org-element--collect-affiliated-keywords org-invisible-p2 org-unescape-code-in-string buffer-substring-no-properties " 
	\n" " 	" line-end-position example-block :begin :end :value :switches :number-lines :preserve-indent :retain-labels :use-labels :label-fmt :hiddenp :post-blank count-lines number-lines preserve-indent retain-labels use-labels label-fmt keywords begin contents-begin hidden value pos-before-blank end x] 26 (#$ . 38611)])
#@65 Interpret EXAMPLE-BLOCK element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-example-block-interpreter #[(example-block contents) "\304\305	A@\n\"*\306\205\307P\310\311\312\313\305	A@\n\"*!!\314\260)\207" [example-block element property switches :switches plist-get "#+BEGIN_EXAMPLE" " " "\n" org-remove-indentation org-escape-code-in-string :value "#+END_EXAMPLE"] 8 (#$ . 40262)])
#@243 Parse an export block.

LIMIT bounds the search.

Return a list whose CAR is `export-block' and CDR is a plist
containing `:begin', `:end', `:type', `:hiddenp', `:value' and
`:post-blank' keywords.

Assume point is at export-block beginning.
(defalias 'org-element-export-block-parser #[(limit) "\306\307\310!\210\311\312\313\n	\"*\226\212\314\315\316\"\f\306#)\204$\317\f!\202\202\320\224\212\321 \211@ \312y\210`!\322 \"
b\210\312y\210`#\323\fw\210\324\312x\210n\203S`\202U\325 $\326!
\"%\327\330 \331$\332\333%\334\"\335\336#$\"\257\f\211&A@)\244.	D*\207" [case-fold-search string num type limit contents-end t looking-at "[ 	]*#\\+BEGIN_\\(\\S-+\\)" 1 nil match-string-no-properties re-search-forward format "^[ 	]*#\\+END_%s[ 	]*$" org-element-paragraph-parser 0 org-element--collect-affiliated-keywords org-invisible-p2 " 
	\n" " 	" line-end-position buffer-substring-no-properties export-block :begin :end :type :value :hiddenp :post-blank count-lines keywords begin contents-begin hidden pos-before-blank end value x] 16 (#$ . 40674)])
#@64 Interpret EXPORT-BLOCK element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-export-block-interpreter #[(export-block contents) "\304\305	A@\n\"*\306\307\"\310\305	A@\n\"*\306\311\"Q)\207" [export-block element property type :type plist-get format "#+BEGIN_%s\n" :value "#+END_%s"] 5 (#$ . 41753)])
#@242 Parse a fixed-width section.

LIMIT bounds the search.

Return a list whose CAR is `fixed-width' and CDR is a plist
containing `:begin', `:end', `:value' and `:post-blank' keywords.

Assume point is at the beginning of the fixed-width area.
(defalias 'org-element-fixed-width-parser #[(limit) "\212\306 \211@\307`W\203%\310\311!\203%\n\312\313\225\314 \"\315Q\307y\210\202	`\316w\210\317\307x\210n\2037`\2029\320 \321\322	\323
\324\n\325\326\f
\"\257\211A@)\244.D\207" [keywords begin value limit end-area end org-element--collect-affiliated-keywords nil looking-at "[ 	]*:\\( \\|$\\)" buffer-substring-no-properties 0 point-at-eol "\n" " 
	\n" " 	" line-end-position fixed-width :begin :end :value :post-blank count-lines x] 12 (#$ . 42077)])
#@63 Interpret FIXED-WIDTH element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-fixed-width-interpreter #[(fixed-width contents) "\303\304\305\306\307	A@\n\"*\310\311O#\207" [fixed-width element property replace-regexp-in-string "^" ": " :value plist-get 0 -1] 6 (#$ . 42845)])
#@174 Parse an horizontal rule.

LIMIT bounds the search.

Return a list whose CAR is `horizontal-rule' and CDR is a plist
containing `:begin', `:end' and `:post-blank' keywords.
(defalias 'org-element-horizontal-rule-parser #[(limit) "\212\306 \211@\307y\210`\310w\210\311\307x\210n\203`\202\312 \313\314	\315\f\316\317\n\f\"\257\211A@)\244-D\207" [keywords begin post-hr limit end x org-element--collect-affiliated-keywords nil " 
	\n" " 	" line-end-position horizontal-rule :begin :end :post-blank count-lines] 10 (#$ . 43138)])
#@67 Interpret HORIZONTAL-RULE element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-horizontal-rule-interpreter #[(horizontal-rule contents) "\300\207" ["-----"] 1 (#$ . 43682)])
#@184 Parse a keyword at point.

LIMIT bounds the search.

Return a list whose CAR is `keyword' and CDR is a plist
containing `:key', `:value', `:begin', `:end' and `:post-blank'
keywords.
(defalias 'org-element-keyword-parser #[(limit) "\212\306`\307\310!\210\311\312\313\n\"*\226\314\315\316\225\317 \"!\312y\210`\320w\210\321\312x\210n\2034`\2026\322 \323\324\f\325
\326	\327\330\331\"\257\n.D\207" [case-fold-search begin string num key value t looking-at "[ 	]*#\\+\\(\\S-+\\):" 1 nil match-string-no-properties org-trim buffer-substring-no-properties 0 point-at-eol " 
	\n" " 	" line-end-position keyword :key :value :begin :end :post-blank count-lines pos-before-blank limit end] 13 (#$ . 43873)])
#@59 Interpret KEYWORD element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-keyword-interpreter #[(keyword contents) "\303\304\305\306	A@\n\"*\307\306	A@\n\"*#\207" [keyword element property format "#+%s: %s" :key plist-get :value] 6 (#$ . 44600)])
#@247 Parse a LaTeX environment.

LIMIT bounds the search.

Return a list whose CAR is `latex-environment' and CDR is a plist
containing `:begin', `:end', `:value' and `:post-blank'
keywords.

Assume point is at the beginning of the latex environment.
(defalias 'org-element-latex-environment-parser #[(limit) "\212\306`\307 \211@\310\311!\210\312\313\314!!\315\316\317\f\"
\306#\210\320y\210`\321	\"\322
w\210\323\320x\210n\203;`\202=\324 \325\326\327\330\331\332\"\257\n\211A@)\244.	D\207" [case-fold-search code-begin keywords begin env limit t org-element--collect-affiliated-keywords looking-at "^[ 	]*\\\\begin{\\([A-Za-z0-9]+\\*?\\)}" regexp-quote match-string 1 re-search-forward format "^[ 	]*\\\\end{%s}[ 	]*$" nil buffer-substring-no-properties " 
	\n" " 	" line-end-position latex-environment :begin :end :value :post-blank count-lines code-end value end x] 12 (#$ . 44867)])
#@69 Interpret LATEX-ENVIRONMENT element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-latex-environment-interpreter #[(latex-environment contents) "\303\304	A@\n\"*\207" [latex-environment element property :value plist-get] 3 (#$ . 45782)])
#@252 Parse a paragraph.

LIMIT bounds the search.

Return a list whose CAR is `paragraph' and CDR is a plist
containing `:begin', `:end', `:contents-begin' and
`:contents-end' and `:post-blank' keywords.

Assume point is at the beginning of the paragraph.
(defalias 'org-element-paragraph-parser #[(limit) "\212`n?\211?\205
\306 	\203\202\n@\307\310\210\311
%\312#\204-%\210\202\252\313 \210\314\315!\204\252\314\316!\204\252\314&!\203N\212\311\317%\307#)\204\252\314\320!\204\252\314'!\203f\212\311\321%\307#)\204\252\314\322!\203|\212\311\323\324\325\326!\"%\307#)\204\252\314\327!\203\222\212\311\323\330\325\326!\"%\307#)\204\252\314\331!\204\252\310\210\311
%\312#\203\252\313 \210\2020`%U\203\266%\202\271\332 b)(\333x\210\310y\210`)\333%w\210\334\310x\210n\203\327`\202\331\335 *\336\337\340*\341\342)\343\344(*\"\257\n\n\211+A@)\244.D\207" [contents-begin inner-par-p keywords begin case-fold-search org-element-paragraph-separate org-element--collect-affiliated-keywords t nil re-search-forward m beginning-of-line looking-at "[ 	]*\\(?:[^:#]\\|$\\)" "[ 	]*:\\(?: \\|$\\)" "^[ 	]*:END:[ 	]*$" "[ 	]*#\\(?: \\|$\\)" "^[ 	]*#\\+END:?[ 	]*$" "[ 	]*#\\+BEGIN_\\(\\S-+\\)" format "^[ 	]*#\\+END_%s[ 	]*$" match-string 1 "^[ 	]*\\\\begin{\\([A-Za-z0-9]+\\*?\\)}[ 	]*$" "^[ 	]*\\\\end{%s}[ 	]*$" "[ 	]*#\\+\\S-+:" line-beginning-position " 
	\n" " 	" line-end-position paragraph :begin :end :contents-begin :contents-end :post-blank count-lines limit org-drawer-regexp org-dblock-start-re before-blank contents-end end x] 14 (#$ . 46038)])
#@85 Interpret PARAGRAPH element as Org syntax.
CONTENTS is the contents of the element.
(defalias 'org-element-paragraph-interpreter #[(paragraph contents) "\207" [contents] 1 (#$ . 47638)])
#@197 Parse a planning.

LIMIT bounds the search.

Return a list whose CAR is `planning' and CDR is a plist
containing `:closed', `:deadline', `:scheduled', `:begin', `:end'
and `:post-blank' keywords.
(defalias 'org-element-planning-parser #[(limit) "\212\306`\306y\210`\307w\210\310\306x\210n\204\306\210\311\n`\")`\306\211\306	b\210\312\313 \314#\203r\315\225b\210\316 \210\317`T\320\225S\"\321\315!\232\203[\202n \232\203j\202n*\202-\322\323\324\325\326	\327
\330\f\257\f.D\207" [case-fold-search begin before-blank limit post-blank end nil " 
	\n" " 	" count-lines re-search-forward line-end-position t 1 org-skip-whitespace buffer-substring-no-properties 0 match-string planning :closed :deadline :scheduled :begin :end :post-blank closed deadline scheduled org-keyword-time-not-clock-regexp keyword time org-closed-string org-deadline-string] 14 (#$ . 47833)])
#@60 Interpret PLANNING element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-planning-interpreter #[(planning contents) "\306\307\310\311\312\313	A@\n\"*\211\205\f\314\315R)\316\313	A@\n\"*\211\2050\317
\320R)\321\313	A@\n\"*\211\205I\317\320R)E\"\322#\207" [planning element property closed org-closed-string deadline mapconcat identity delq nil :closed plist-get " [" "]" :deadline " <" ">" :scheduled " " org-deadline-string scheduled org-scheduled-string] 11 (#$ . 48754)])
#@294 Parse a property drawer.

LIMIT bounds the search.

Return a list whose CAR is `property-drawer' and CDR is a plist
containing `:begin', `:end', `:hiddenp', `:contents-begin',
`:contents-end', `:properties' and `:post-blank' keywords.

Assume point is at the beginning of the property drawer.
(defalias 'org-element-property-drawer-parser #[(limit) "\212\306`\307y\210`\310 \307\311\312!\2042\311\313!\203,\314\307\315\n	\"*\316\317\320\225\321 \"!BB\307y\210\202)\322\323\306#\210\324 \307y\210`\325w\210\326\307x\210n\203P`\202R\327  !\"#$\330\331#\332\f\333!\334 \335\336
\f\"\257\n.	D\207" [val string num limit end pos-before-blank t nil org-invisible-p2 looking-at "^[ 	]*:END:[ 	]*$" "[ 	]*:\\([A-Za-z][-_A-Za-z0-9]*\\):" 1 match-string-no-properties org-trim buffer-substring-no-properties 0 point-at-eol re-search-forward "^[ 	]*:END:" point-at-bol " 
	\n" " 	" line-end-position property-drawer :begin :end :hiddenp :properties :post-blank count-lines prop-end properties hidden prop-begin begin case-fold-search] 13 (#$ . 49268)])
#@67 Interpret PROPERTY-DRAWER element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-property-drawer-interpreter #[(property-drawer contents) "\304\305	A@\n\"*\306\307\310\237\311#\312Q)\207" [property-drawer element property props :properties plist-get ":PROPERTIES:\n" mapconcat #[(p) "\302\302\303	@\"	A#\207" [org-property-format p format ":%s:"] 5] "\n" "\n:END:"] 5 (#$ . 50342)])
#@225 Parse a quote section.

LIMIT bounds the search.

Return a list whose CAR is `quote-section' and CDR is a plist
containing `:begin', `:end', `:value' and `:post-blank' keywords.

Assume point is at beginning of the section.
(defalias 'org-element-quote-section-parser #[(limit) "\212`\306\307 \211\310\nP\311 \210,`\312\313x\210\313y\210`\314\"\315\316\317
\320\321\322
\"\257-D\207" [begin org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol end t org-get-limited-outline-regexp "^" outline-next-heading " 
	\n" nil buffer-substring-no-properties quote-section :begin :end :value :post-blank count-lines pos-before-blank value] 12 (#$ . 50746)])
#@65 Interpret QUOTE-SECTION element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-quote-section-interpreter #[(quote-section contents) "\303\304	A@\n\"*\207" [quote-section element property :value plist-get] 3 (#$ . 51454)])
#@356 Parse a src block.

LIMIT bounds the search.

Return a list whose CAR is `src-block' and CDR is a plist
containing `:language', `:switches', `:parameters', `:begin',
`:end', `:hiddenp', `:number-lines', `:retain-labels',
`:use-labels', `:label-fmt', `:preserve-indent', `:value' and
`:post-blank' keywords.

Assume point is at the beginning of the block.
(defalias 'org-element-src-block-parser #[(limit) "\306\212\307\310	\306#)\204\311	!\202+
\312\224\212\313 \211@\314\315!\210\316\3174\3204
\"*5\321\3174\3204
\"*6\322\3174\3204
\"*76\204P\317\202e\323\3246\"\203\\\325\202e\323\3266\"\205e\32786\205q\323\3306\"96\205\205\323\3316\"\205\205\332\3166\":6?\206\240\323\3336\"?\206\2408\205\240\323\3346\";6?\206\263;\205\263\323\3346\"?<\317y\210\335 =\336\337`\n\"!>\nb\210\317y\210`?\340	w\210\341\317x\210n\203\335`\202\337\342 @\343\3445\345\3466!\205\361\3476!\350\3467!\205\375\3477!\351\f\352@\3538\3549\355;\356<\357:\360=\361>\362\363?@\"\257\211AA@)\244.D)\207" [case-fold-search limit contents-end keywords begin string t re-search-forward "^[ 	]*#\\+END_SRC[ 	]*$" org-element-paragraph-parser 0 org-element--collect-affiliated-keywords looking-at "^[ 	]*#\\+BEGIN_SRC\\(?: +\\(\\S-+\\)\\)?\\(\\(?: +\\(?:-l \".*?\"\\|[-+][A-Za-z]\\)\\)+\\)?\\(.*\\)[ 	]*$" 1 nil match-string-no-properties 2 3 string-match "-n\\>" new "+n\\>" continued "-i\\>" "-l +\"\\([^\"\n]+\\)\"" match-string "-r\\>" "-k\\>" org-invisible-p2 org-unescape-code-in-string buffer-substring-no-properties " 
	\n" " 	" line-end-position src-block :language :switches org-string-nw-p org-trim :parameters :begin :end :number-lines :preserve-indent :retain-labels :use-labels :label-fmt :hiddenp :value :post-blank count-lines num language switches parameters number-lines preserve-indent label-fmt retain-labels use-labels hidden value pos-before-blank end x] 30 (#$ . 51694)])
#@61 Interpret SRC-BLOCK element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-src-block-interpreter #[(src-block contents) "\306\307	A@\n\"*\310\307	A@\n\"*\311\307	A@\n\"*\312\307	A@\n\"*\f\2035\202T\313
!\203A\314!\202T\315
\316\"\317\320\314!\321\211\322&))\323\324\205h\325P\205q\325P\205z\325PQ\"\326!\327Q,\207" [src-block element property val org-src-preserve-indentation org-edit-src-content-indentation :language plist-get :switches :parameters :value zerop org-remove-indentation make-string 32 replace-regexp-in-string "\\(^\\)[ 	]*\\S-" nil 1 format "#+BEGIN_SRC%s\n" " " org-escape-code-in-string "#+END_SRC" ind value params switches lang] 10 (#$ . 53639)])
#@275 Parse a table at point.

LIMIT bounds the search.

Return a list whose CAR is `table' and CDR is a plist containing
`:begin', `:end', `:tblfm', `:type', `:contents-begin',
`:contents-end', `:value' and `:post-blank' keywords.

Assume point is at the beginning of the table.
(defalias 'org-element-table-parser #[(limit) "\212\306`\307 \203\310\202\311\312 \211@\313
!\314#\203%\315\224b\202&`\"\316#\317\320!\203I\321\316$%\322%$\"*#B#\316y\210\202+#)&`'\323!w\210\324\316x\210n\203b`\202d\325 (\326\327\f\330(\331\n\332&\333\n\311=\205y	\334\n\311=\205\202\"\335\n\310=\205\216\336	\"\"\337\340'(\"\257\211)A@)\244.\nD\207" [case-fold-search table-begin type keywords begin org-table-any-border-regexp t org-at-table\.el-p table\.el org org-element--collect-affiliated-keywords re-search-forward m 0 nil looking-at "[ 	]*#\\+TBLFM: +\\(.*\\)[ 	]*$" 1 match-string-no-properties " 
	\n" " 	" line-end-position table :begin :end :type :tblfm :contents-begin :contents-end :value buffer-substring-no-properties :post-blank count-lines limit table-end acc string num tblfm pos-before-blank end x] 20 (#$ . 54373)])
#@57 Interpret TABLE element as Org syntax.
CONTENTS is nil.
(defalias 'org-element-table-interpreter #[(table contents) "\305\306	A@\n\"*\307=\203\310\311\306	A@\n\"*!\207\312\313!rq\210\314\216\fc\210\315 \210\316 +\317\320\321\322\306	A@\n\"*!\323#P\207" [table element property #1=#:temp-buffer contents :type plist-get table\.el org-remove-indentation :value generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) org-table-align buffer-string mapconcat #[(fm) "\301P\207" [fm "#+TBLFM: "] 2] reverse :tblfm "\n"] 7 (#$ . 55532)])
#@213 Parse table row at point.

LIMIT bounds the search.

Return a list whose CAR is `table-row' and CDR is a plist
containing `:begin', `:end', `:contents-begin', `:contents-end',
`:type' and `:post-blank' keywords.
(defalias 'org-element-table-row-parser #[(limit) "\212\305\306!\203\307\202\f\310`\310=\205\311\312!\205`\310=\205+\313\210\314\313x\210`\313y\210`\315\316\317	\320\f\321\n\322\323\324\257\f.D\207" [type begin contents-begin contents-end end looking-at "^[ 	]*|-" rule standard search-forward "|" nil " 	" table-row :type :begin :end :contents-begin :contents-end :post-blank 0] 13 (#$ . 56139)])
#@87 Interpret TABLE-ROW element as Org syntax.
CONTENTS is the contents of the table row.
(defalias 'org-element-table-row-interpreter #[(table-row contents) "\304\305	A@\n\"*\306=\203\307\207\310P\207" [table-row element property contents :type plist-get rule "|-" "| "] 3 (#$ . 56774)])
#@257 Parse a verse block.

LIMIT bounds the search.

Return a list whose CAR is `verse-block' and CDR is a plist
containing `:begin', `:end', `:contents-begin', `:contents-end',
`:hiddenp' and `:post-blank' keywords.

Assume point is at beginning of the block.
(defalias 'org-element-verse-block-parser #[(limit) "\306\212\307\310	\306#)\204\311	!\202c\312\224\212\313 \211@\314y\210\315 `\nb\210\314y\210`\316	w\210\317\314x\210n\203>`\202@\320 \321\322\f\323\324\325\n\326
\327\330\"\257\f\211A@)\244.D)\207" [case-fold-search limit contents-end keywords begin hidden t re-search-forward "^[ 	]*#\\+END_VERSE[ 	]*$" org-element-paragraph-parser 0 org-element--collect-affiliated-keywords nil org-invisible-p2 " 
	\n" " 	" line-end-position verse-block :begin :end :contents-begin :contents-end :hiddenp :post-blank count-lines contents-begin pos-before-blank end x] 16 (#$ . 57072)])
#@80 Interpret VERSE-BLOCK element as Org syntax.
CONTENTS is verse block contents.
(defalias 'org-element-verse-block-interpreter #[(verse-block contents) "\301\302\"\207" [contents format "#+BEGIN_VERSE\n%s#+END_VERSE"] 3 (#$ . 57987)])
#@215 Parse bold object at point.

Return a list whose CAR is `bold' and CDR is a plist with
`:begin', `:end', `:contents-begin' and `:contents-end' and
`:post-blank' keywords.

Assume point is at the first star marker.
(defalias 'org-element-bold-parser #[nil "\212n\204\306u\210\307!\210\310\224\311\224\311\225\310\225b\210\312\313w`\314\315
\316	\317\f\320\321\n\257\n.D\207" [org-emph-re end post-blank contents-end contents-begin begin -1 looking-at 2 4 " 	" nil bold :begin :end :contents-begin :contents-end :post-blank] 11 (#$ . 58229)])
#@78 Interpret BOLD object as Org syntax.
CONTENTS is the contents of the object.
(defalias 'org-element-bold-interpreter #[(bold contents) "\301\302\"\207" [contents format "*%s*"] 3 (#$ . 58786)])
#@226 Search for the next text-markup object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is a symbol among `bold',
`italic', `underline', `strike-through', `code' and `verbatim'
and CDR is beginning position.
(defalias 'org-element-text-markup-successor #[(limit) "\212n\204\303u\210\304	\305#\205Y\306\307!\211\310\232\203\311\202U\n\312\232\203(\313\202U\n\314\232\2032\315\202U\n\316\232\203<\317\202U\n\320\232\203F\321\202U\n\322\232\203P\323\202U\324\325\307\224\"\326\224)B)\207" [org-emph-re limit marker -1 re-search-forward t match-string 3 "*" bold "/" italic "_" underline "+" strike-through "~" code "=" verbatim error "Unknown marker at %d" 2] 5 (#$ . 58988)])
#@187 Parse code object at point.

Return a list whose CAR is `code' and CDR is a plist with
`:value', `:begin', `:end' and `:post-blank' keywords.

Assume point is at the first tilde marker.
(defalias 'org-element-code-parser #[nil "\212n\204\306u\210\307!\210\310\224\311\312\313\n	\"*\310\225b\210\314\312w`\315\316
\317\320\321\f\257-D\207" [org-emph-re string num end post-blank value -1 looking-at 2 4 nil match-string-no-properties " 	" code :value :begin :end :post-blank begin] 9 (#$ . 59704)])
#@55 Interpret CODE object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-code-interpreter #[(code contents) "\303\304\305\306	A@\n\"*\"\207" [code element property format "~%s~" :value plist-get] 5 (#$ . 60222)])
#@265 Parse entity at point.

Return a list whose CAR is `entity' and CDR a plist with
`:begin', `:end', `:latex', `:latex-math-p', `:html', `:latin1',
`:utf-8', `:ascii', `:use-brackets-p' and `:post-blank' as
keywords.

Assume point is at the beginning of the entity.
(defalias 'org-element-entity-parser #[nil "\212\306\307!\210\310\311!\312	\"\206\312\n\")\313\224\310\314!\315\230\311\225b\210
\203*\314u\210\316\317w `!\320\321@\322A@\323\3148\324\3258\326\3278\330\3318\332\3338\334\f\335!\336
\337 \257.D\207" [name org-entities-user org-entities value begin bracketsp looking-at "\\\\\\(there4\\|sup[123]\\|frac[13][24]\\|[a-zA-Z]+\\)\\($\\|{}\\|[^[:alpha:]]\\)" match-string 1 assoc 0 2 "{}" " 	" nil entity :name :latex :latex-math-p :html 3 :ascii 4 :latin1 5 :utf-8 6 :begin :end :use-brackets-p :post-blank post-blank end] 23 (#$ . 60449)])
#@57 Interpret ENTITY object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-entity-interpreter #[(entity contents) "\303\304\305	A@\n\"*\306\305	A@\n\"*\205\307Q\207" [entity element property "\\" :name plist-get :use-brackets-p "{}"] 5 (#$ . 61326)])
#@182 Search for the next latex-fragment or entity object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `entity' or
`latex-fragment' and CDR is beginning position.
(defalias 'org-element-latex-or-entity-successor #[(limit) "\212n\204\306u\210\307\310\311\312\"\"\313\314\315\316\n\317#\317	Q\320#\205O\321\224b\210\322	!\203J\323\324!\325\f
\"\206;\325\f\")\203C\326\202D\327\321\224B\202O\327\330\331\215B+\207" [org-format-latex-options entity-re matchers limit name org-entities-user -1 remove "begin" plist-get :matchers "\\\\\\(there4\\|sup[123]\\|frac[13][24]\\|[a-zA-Z]+\\)\\($\\|{}\\|[^[:alpha:]]\\)" re-search-forward mapconcat #[(e) "\302	\"A@\207" [e org-latex-regexps assoc] 3] "\\|" t 0 looking-at match-string 1 assoc entity latex-fragment return (byte-code "\301\302\"\210`\207" [matchers mapc #[(e) "\302\303	\"A@!\205\304\305\306\303	\"8\224\"\207" [e org-latex-regexps looking-at assoc throw return 2] 6]] 3) org-entities] 5 (#$ . 61596)])
#@219 Parse export snippet at point.

Return a list whose CAR is `export-snippet' and CDR a plist with
`:begin', `:end', `:back-end', `:value' and `:post-blank' as
keywords.

Assume point is at the beginning of the snippet.
(defalias 'org-element-export-snippet-parser #[nil "\212\306\307\310\311#\210\312\224\313\310\314\n	\"*\315`\306\316\310\311#\210\312\224\"\317\310w`\320\321\322\f\323\324\325
\257\n.D\207" [begin string num back-end value post-blank re-search-forward "@@\\([-A-Za-z0-9]+\\):" nil t 0 1 match-string-no-properties buffer-substring-no-properties "@@" " 	" export-snippet :back-end :value :begin :end :post-blank end] 11 (#$ . 62599)])
#@65 Interpret EXPORT-SNIPPET object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-export-snippet-interpreter #[(export-snippet contents) "\303\304\305\306	A@\n\"*\307\306	A@\n\"*#\207" [export-snippet element property format "@@%s:%s@@" :back-end plist-get :value] 6 (#$ . 63270)])
#@161 Search for the next export-snippet object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `export-snippet' and CDR
its beginning position.
(defalias 'org-element-export-snippet-successor #[(limit) "\212\302\303\304	\305#\205\306\224\211\205\307\310	\305#\205\311B*\207" [beg limit nil re-search-forward "@@[-A-Za-z0-9]+:" t 0 search-forward "@@" export-snippet] 4 (#$ . 63570)])
#@195 Parse footnote reference at point.

Return a list whose CAR is `footnote-reference' and CDR a plist
with `:label', `:type', `:inline-definition', `:begin', `:end'
and `:post-blank' as keywords.
(defalias 'org-element-footnote-reference-parser #[nil "\212\306!\210`\307\310\311\n\"*\2060\312\310\311\n\"*\2060\313\314!\2050\315\314\310\311\n\"*P\211\203;\313\314!\203?\316\202@\317\320\225 \314!\310u\210!\320V\203t\321\322\310\323#\203t\313\320!\324\232\203k!T\211!\202M!S\211!\202M`S)\211\"Tb\210\325\310w#`$\326\327\f\330
\331	\332$\333#\257\nD\211\334
\316=\205\330\335 \"{\326\211%9\203\262%\202\320%\211%:\204\305%;\205\317\336\202\317%@9\205\317%@)&\236A)#'(\211%:\203\362%A\337%A@('#\240\210%.\f\207" [org-footnote-re begin string num label type looking-at 2 nil match-string-no-properties 3 match-string 1 "fn:" inline standard 0 re-search-forward "[][]" t "[" " 	" footnote-reference :label :type :begin :end :post-blank :inline-definition org-element-parse-secondary-string plain-text plist-put inner-begin count inner-end post-blank end element org-element-object-restrictions value property] 12 (#$ . 63986)])
#@69 Interpret FOOTNOTE-REFERENCE object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-footnote-reference-interpreter #[(footnote-reference contents) "\306\307	A@\n\"*\206\310\311\307	A@\n\"*\211\204#\312\202(\313\314!P)\315\316
\fP\"*\207" [footnote-reference element property inline-def def label :label plist-get "fn:" :inline-definition "" ":" org-element-interpret-data format "[%s]"] 5 (#$ . 65180)])
#@168 Search for the next footnote-reference object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `footnote-reference' and
CDR is beginning position.
(defalias 'org-element-footnote-reference-successor #[(limit) "\212\300\301\215)\207" [exit (byte-code "\304	\305#\205>\212\306\224\307\310u\210\304\311	\305#\203:\312\306!\313\232\203'\nT\202*\nS\314\n!\203\315\316\317B\"\210\202+\202\207" [org-footnote-re limit count beg re-search-forward t 0 1 -1 "[][]" match-string "[" zerop throw exit footnote-reference] 4)] 2 (#$ . 65612)])
#@214 Parse inline babel call at point.

Return a list whose CAR is `inline-babel-call' and CDR a plist
with `:begin', `:end', `:info' and `:post-blank' as keywords.

Assume point is at the beginning of the babel call.
(defalias 'org-element-inline-babel-call-parser #[nil "\212n\204\306u\210\307!\210\310 \311\216\312 *\313\225\314\225b\210\315\316w`\317\320\f\321\n\322
\323\257-D\207" [org-babel-inline-lob-one-liner-regexp save-match-data-internal end post-blank begin info -1 looking-at match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) org-babel-lob-get-info 1 0 " 	" nil inline-babel-call :begin :end :info :post-blank] 9 (#$ . 66185)])
#@68 Interpret INLINE-BABEL-CALL object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-inline-babel-call-interpreter #[(inline-babel-call contents) "\306\307	A@\n\"*\211@A@\310\311\312\f\"\203'\313\314\315\f\"\316\211\f$\202(\f
\2050\317\320
\"Q+\207" [inline-babel-call element property babel-info main-source post-options :info plist-get "call_" string-match "\\[\\(\\[.*?\\]\\)\\]" replace-match match-string 1 nil format "[%s]"] 7 (#$ . 66886)])
#@166 Search for the next inline-babel-call object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `inline-babel-call' and
CDR is beginning position.
(defalias 'org-element-inline-babel-call-successor #[(limit) "\212\301\302\303#\205
\304\305\224B)\207" [limit re-search-forward "call_\\([^()\n]+?\\)\\(?:\\[.*?\\]\\)?([^\n]*?)\\(\\[.*?\\]\\)?" t inline-babel-call 0] 4 (#$ . 67356)])
#@276 Parse inline source block at point.

LIMIT bounds the search.

Return a list whose CAR is `inline-src-block' and CDR a plist
with `:begin', `:end', `:language', `:value', `:parameters' and
`:post-blank' as keywords.

Assume point is at the beginning of the inline src block.
(defalias 'org-element-inline-src-block-parser #[nil "\212n\204\306u\210\307!\210\310\224\311\312\313\n	\"*\314\312\313\n	\"*\315\312\313\n	\"*\316\225b\210\317\312w`\320\321\322
\323\324\325\326\f\257\f.D\207" [org-babel-inline-src-block-regexp string num end post-blank value -1 looking-at 1 2 nil match-string-no-properties 4 5 0 " 	" inline-src-block :language :value :parameters :begin :end :post-blank parameters language begin] 13 (#$ . 67765)])
#@67 Interpret INLINE-SRC-BLOCK object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-inline-src-block-interpreter #[(inline-src-block contents) "\306\307	A@\n\"*\310\307	A@\n\"*\311\307	A@\n\"*\312\313
\f\2032\312\314\f\"\2023\315$+\207" [inline-src-block element property body arguments language :language plist-get :parameters :value format "src_%s%s{%s}" "[%s]" ""] 6 (#$ . 68525)])
#@167 Search for the next inline-babel-call element.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `inline-babel-call' and
CDR is beginning position.
(defalias 'org-element-inline-src-block-successor #[(limit) "\212n\204\302u\210\303	\304#\205\305\306\224B)\207" [org-babel-inline-src-block-regexp limit -1 re-search-forward t inline-src-block 1] 4 (#$ . 68937)])
#@220 Parse italic object at point.

Return a list whose CAR is `italic' and CDR is a plist with
`:begin', `:end', `:contents-begin' and `:contents-end' and
`:post-blank' keywords.

Assume point is at the first slash marker.
(defalias 'org-element-italic-parser #[nil "\212n\204\306u\210\307!\210\310\224\311\224\311\225\310\225b\210\312\313w`\314\315
\316	\317\f\320\321\n\257\n.D\207" [org-emph-re end post-blank contents-end contents-begin begin -1 looking-at 2 4 " 	" nil italic :begin :end :contents-begin :contents-end :post-blank] 11 (#$ . 69329)])
#@80 Interpret ITALIC object as Org syntax.
CONTENTS is the contents of the object.
(defalias 'org-element-italic-interpreter #[(italic contents) "\301\302\"\207" [contents format "/%s/"] 3 (#$ . 69895)])
#@214 Parse latex fragment at point.

Return a list whose CAR is `latex-fragment' and CDR a plist with
`:value', `:begin', `:end', and `:post-blank' as keywords.

Assume point is at the beginning of the latex fragment.
(defalias 'org-element-latex-fragment-parser #[nil "\212`\305\306\215\307	!	\225b\210\310\311w`\312\313\n\314\315\f\316\257.D\207" [begin substring-match value post-blank end exit (byte-code "\301\302\303\304\"\"\210\305\306!\210\307\207" [org-format-latex-options mapc #[(e) "\303	\"A@\304\n!\204o?\205&\212\305u\210\304\n!)\205&\306\307\310\303	\"8\")\207" [e org-latex-regexps latex-regexp assoc looking-at -1 throw exit 2] 6] plist-get :matchers looking-at "\\\\[a-zA-Z]+\\*?\\(\\(\\[[^][\n{}]*\\]\\)\\|\\({[^{}\n]*}\\)\\)*" 0] 5) match-string-no-properties " 	" nil latex-fragment :value :begin :end :post-blank] 9 (#$ . 70103)])
#@65 Interpret LATEX-FRAGMENT object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-latex-fragment-interpreter #[(latex-fragment contents) "\303\304	A@\n\"*\207" [latex-fragment element property :value plist-get] 3 (#$ . 70974)])
#@189 Parse line break at point.

Return a list whose CAR is `line-break', and CDR a plist with
`:begin', `:end' and `:post-blank' keywords.

Assume point is at the beginning of the line break.
(defalias 'org-element-line-break-parser #[nil "\300\301`\302\303 \304\305\257D\207" [line-break :begin :end point-at-eol :post-blank 0] 7 (#$ . 71217)])
#@61 Interpret LINE-BREAK object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-line-break-interpreter #[(line-break contents) "\300\207" ["\\\\"] 1 (#$ . 71566)])
#@152 Search for the next line-break object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `line-break' and CDR is
beginning position.
(defalias 'org-element-line-break-successor #[(limit) "\212\302\303\304#\205\f\305\224b\211\205\306\307\310 \304#\205\311	B*\207" [limit beg re-search-forward "[^\\\\]\\(\\\\\\\\\\)[ 	]*$" t 1 re-search-backward "\\S-" point-at-bol line-break] 5 (#$ . 71740)])
#@240 Parse link at point.

Return a list whose CAR is `link' and CDR a plist with `:type',
`:path', `:raw-link', `:begin', `:end', `:contents-begin',
`:contents-end' and `:post-blank' as keywords.

Assume point is at the beginning of the link.
(defalias 'org-element-link-parser #[nil "\212`\306\211\211\211\211\211\211\211\211'()*+\203;\307+!\203;\310\311\225\311\306,-\312-,\"*\202+
\307.!\203\307\313\224(\313\225'\311\225\314\306,-\312-,\"*\315\316\317	!!!\320!\204p\321\322\"\203w\323\202+
\321/\"\203\214\324\314\"\324\325\"\202+
\321\326\"\203\235\327\324\314\"\202+
\321\330\"\203\256\331\324\314\"\202+
\311H\332U\203\300\333\314\306O\202+
\334\202+
\3070!\203\376\311\306,-\312-,\"*\314\306,-\312-,\"*\325\306,-\312-,\"*\311\225\202+
\3071!\203+
\335\314\224\325\225\"\314\306,-\312-,\"*\325\306,-\312-,\"*\311\225
b\210\336\306w`)\300\337\n\340\341	\206@
\342*\343)\344(\345'\346\f\257.D\207" [link raw-link type path post-blank link-end nil looking-at "radio" 0 match-string-no-properties 3 1 org-translate-link org-link-expand-abbrev org-link-unescape file-name-absolute-p string-match "^\\.\\.?/" "file" match-string 2 "^id:\\([-a-f0-9]+\\)" "id" "^(\\(.*\\))$" "coderef" 35 "custom-id" "fuzzy" buffer-substring-no-properties " 	" :type :path :raw-link :begin :end :contents-begin :contents-end :post-blank contents-end contents-begin end begin org-target-link-regexp string num org-bracket-link-regexp org-link-re-with-space3 org-plain-link-re org-angle-link-re] 17 (#$ . 72166)])
#@86 Interpret LINK object as Org syntax.
CONTENTS is the contents of the object, or nil.
(defalias 'org-element-link-interpreter #[(link contents) "\306\307	A@\n\"*\310\307	A@\n\"*\211\311\230\203\"\2022\312\313
\2030\312\314
\"\2021\315#*\207" [link element property raw-link type contents :type plist-get :raw-link "radio" format "[[%s]%s]" "[%s]" ""] 7 (#$ . 73768)])
#@140 Search for the next link object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `link' and CDR is
beginning position.
(defalias 'org-element-link-successor #[(limit) "\212\204		\202
	\304Q\305\n\306#\205\307\310\224B*\207" [org-target-link-regexp org-any-link-re link-regexp limit "\\|" re-search-forward t link 0] 4 (#$ . 74156)])
#@186 Parse macro at point.

Return a list whose CAR is `macro' and CDR a plist with `:key',
`:args', `:begin', `:end', `:value' and `:post-blank' as
keywords.

Assume point is at the macro.
(defalias 'org-element-macro-parser #[nil "\212\306\307!\210`\310\311\312	\"*\227\313\311\312	\"*\313\225b\210\314\311w`\315\311\312	\"*\311\211\205i\316\317\"\203d\320\321@\"\203YA@\313\322O\317A@Q\240\210\211A@\210\202:\211A@\nB\2026\323\324\n\237\"*\325\326\327\330\331\332\f\333
\257\f.D\207" [string num args2 args end post-blank looking-at "{{{\\([a-zA-Z][-a-zA-Z0-9_]*\\)\\(([ 	\n]*\\([^]*?\\))\\)?}}}" 1 nil match-string-no-properties 0 " 	" 3 split-string "," string-match "\\\\\\'" -1 mapcar org-trim macro :key :value :args :begin :end :post-blank value key begin] 14 (#$ . 74524)])
#@56 Interpret MACRO object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-macro-interpreter #[(macro contents) "\303\304	A@\n\"*\207" [macro element property :value plist-get] 3 (#$ . 75355)])
#@140 Search for the next macro object.

LIMIT bounds the search.

Return value is cons cell whose CAR is `macro' and CDR is
beginning position.
(defalias 'org-element-macro-successor #[(limit) "\212\301\302\303#\205
\304\305\224B)\207" [limit re-search-forward "{{{\\([a-zA-Z][-a-zA-Z0-9_]*\\)\\(([ 	\n]*\\([^]*?\\))\\)?}}}" t macro 0] 4 (#$ . 75562)])
#@226 Parse radio target at point.

Return a list whose CAR is `radio-target' and CDR a plist with
`:begin', `:end', `:contents-begin', `:contents-end', `:value'
and `:post-blank' as keywords.

Assume point is at the radio target.
(defalias 'org-element-radio-target-parser #[nil "\212\306!\210`\307\224\307\225\307\310\311\n	\"*\312\225b\210\313\310w`\314\315\316\317\320\321\f\322
\257\f.D\207" [org-radio-target-regexp string num end post-blank value looking-at 1 nil match-string-no-properties 0 " 	" radio-target :begin :end :contents-begin :contents-end :post-blank :value contents-end contents-begin begin] 13 (#$ . 75920)])
#@80 Interpret TARGET object as Org syntax.
CONTENTS is the contents of the object.
(defalias 'org-element-radio-target-interpreter #[(target contents) "\301\302Q\207" [contents "<<<" ">>>"] 3 (#$ . 76572)])
#@156 Search for the next radio-target object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `radio-target' and CDR
is beginning position.
(defalias 'org-element-radio-target-successor #[(limit) "\212\302	\303#\205
\304\305\224B)\207" [org-radio-target-regexp limit re-search-forward t radio-target 0] 4 (#$ . 76783)])
#@220 Parse statistics cookie at point.

Return a list whose CAR is `statistics-cookie', and CDR a plist
with `:begin', `:end', `:value' and `:post-blank' keywords.

Assume point is at the beginning of the statistics-cookie.
(defalias 'org-element-statistics-cookie-parser #[nil "\212\304\305!\210`\306\307\224\307\225\"\307\225b\210\310\311w`\312\313\314\315	\316\n\257-D\207" [begin value post-blank end looking-at "\\[[0-9]*\\(%\\|/[0-9]*\\)\\]" buffer-substring-no-properties 0 " 	" nil statistics-cookie :begin :end :value :post-blank] 9 (#$ . 77127)])
#@68 Interpret STATISTICS-COOKIE object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-statistics-cookie-interpreter #[(statistics-cookie contents) "\303\304	A@\n\"*\207" [statistics-cookie element property :value plist-get] 3 (#$ . 77692)])
#@166 Search for the next statistics cookie object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `statistics-cookie' and
CDR is beginning position.
(defalias 'org-element-statistics-cookie-successor #[(limit) "\212\301\302\303#\205
\304\305\224B)\207" [limit re-search-forward "\\[[0-9]*\\(%\\|/[0-9]*\\)\\]" t statistics-cookie 0] 4 (#$ . 77947)])
#@240 Parse strike-through object at point.

Return a list whose CAR is `strike-through' and CDR is a plist
with `:begin', `:end', `:contents-begin' and `:contents-end' and
`:post-blank' keywords.

Assume point is at the first plus sign marker.
(defalias 'org-element-strike-through-parser #[nil "\212n\204\306u\210\307!\210\310\224\311\224\311\225\310\225b\210\312\313w`\314\315
\316	\317\f\320\321\n\257\n.D\207" [org-emph-re end post-blank contents-end contents-begin begin -1 looking-at 2 4 " 	" nil strike-through :begin :end :contents-begin :contents-end :post-blank] 11 (#$ . 78322)])
#@88 Interpret STRIKE-THROUGH object as Org syntax.
CONTENTS is the contents of the object.
(defalias 'org-element-strike-through-interpreter #[(strike-through contents) "\301\302\"\207" [contents format "+%s+"] 3 (#$ . 78924)])
#@227 Parse subscript at point.

Return a list whose CAR is `subscript' and CDR a plist with
`:begin', `:end', `:contents-begin', `:contents-end',
`:use-brackets-p' and `:post-blank' as keywords.

Assume point is at the underscore.
(defalias 'org-element-subscript-parser #[nil "\212n\204\306u\210\307!\203\310\202\307	!?\311\224\312\224\206\313\224\312\225\206&\313\225\314\225b\210\315\316w`\317\320\321\n\322\323
\324\f\325\257\f.D\207" [org-match-substring-with-braces-regexp org-match-substring-regexp end post-blank contents-end contents-begin -1 looking-at t 2 5 3 0 " 	" nil subscript :begin :end :use-brackets-p :contents-begin :contents-end :post-blank begin bracketsp] 13 (#$ . 79156)])
#@83 Interpret SUBSCRIPT object as Org syntax.
CONTENTS is the contents of the object.
(defalias 'org-element-subscript-interpreter #[(subscript contents) "\304\305\306	A@\n\"*\203\307\202\310\"\207" [subscript element property contents format :use-brackets-p plist-get "_{%s}" "_%s"] 4 (#$ . 79878)])
#@180 Search for the next sub/superscript object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is either `subscript' or
`superscript' and CDR is beginning position.
(defalias 'org-element-sub/superscript-successor #[(limit) "\212n\204\302u\210\303	\304#\205 \305\306!\307\230\203\310\202\311\306\224B)\207" [org-match-substring-regexp limit -1 re-search-forward t match-string 2 "_" subscript superscript] 4 (#$ . 80190)])
#@226 Parse superscript at point.

Return a list whose CAR is `superscript' and CDR a plist with
`:begin', `:end', `:contents-begin', `:contents-end',
`:use-brackets-p' and `:post-blank' as keywords.

Assume point is at the caret.
(defalias 'org-element-superscript-parser #[nil "\212n\204\306u\210\307!\203\310\202\307	!?\311\224\312\224\206\313\224\312\225\206&\313\225\314\225b\210\315\316w`\317\320\321\n\322\323
\324\f\325\257\f.D\207" [org-match-substring-with-braces-regexp org-match-substring-regexp end post-blank contents-end contents-begin -1 looking-at t 2 5 3 0 " 	" nil superscript :begin :end :use-brackets-p :contents-begin :contents-end :post-blank begin bracketsp] 13 (#$ . 80642)])
#@85 Interpret SUPERSCRIPT object as Org syntax.
CONTENTS is the contents of the object.
(defalias 'org-element-superscript-interpreter #[(superscript contents) "\304\305\306	A@\n\"*\203\307\202\310\"\207" [superscript element property contents format :use-brackets-p plist-get "^{%s}" "^%s"] 4 (#$ . 81367)])
#@180 Parse table cell at point.

Return a list whose CAR is `table-cell' and CDR is a plist
containing `:begin', `:end', `:contents-begin', `:contents-end'
and `:post-blank' keywords.
(defalias 'org-element-table-cell-parser #[nil "\304\305!\210\306\224\306\225\307\224\307\225\310\311\312	\313\n\314\315\306\257\n,D\207" [begin end contents-begin contents-end looking-at "[ 	]*\\(.*?\\)[ 	]*|" 0 1 table-cell :begin :end :contents-begin :contents-end :post-blank] 11 (#$ . 81687)])
#@91 Interpret TABLE-CELL element as Org syntax.
CONTENTS is the contents of the cell, or nil.
(defalias 'org-element-table-cell-interpreter #[(table-cell contents) "\301\302Q\207" [contents " " " |"] 3 (#$ . 82177)])
#@152 Search for the next table-cell object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `table-cell' and CDR is
beginning position.
(defalias 'org-element-table-cell-successor #[(limit) "\300\301!\205	\302`B\207" [looking-at "[ 	]*.*?[ 	]+|" table-cell] 2 (#$ . 82398)])
#@172 Parse target at point.

Return a list whose CAR is `target' and CDR a plist with
`:begin', `:end', `:value' and `:post-blank' as keywords.

Assume point is at the target.
(defalias 'org-element-target-parser #[nil "\212\306!\210`\307\310\311\n	\"*\312\225b\210\313\310w`\314\315\316\317
\320\f\257-D\207" [org-target-regexp string num end post-blank value looking-at 1 nil match-string-no-properties 0 " 	" target :begin :end :value :post-blank begin] 9 (#$ . 82696)])
#@57 Interpret TARGET object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-target-interpreter #[(target contents) "\303\304\305\306	A@\n\"*\"\207" [target element property format "<<%s>>" :value plist-get] 5 (#$ . 83183)])
#@144 Search for the next target object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `target' and CDR is
beginning position.
(defalias 'org-element-target-successor #[(limit) "\212\302	\303#\205
\304\305\224B)\207" [org-target-regexp limit re-search-forward t target 0] 4 (#$ . 83420)])
#@206 Parse time stamp at point.

Return a list whose CAR is `timestamp', and CDR a plist with
`:type', `:begin', `:end', `:value' and `:post-blank' keywords.

Assume point is at the beginning of the timestamp.
(defalias 'org-element-timestamp-parser #[nil "\212`\306f\307=\310\311!\210\312\313!\312\314!\315\316!\203\317\202;	\203*\203*\320\202;	\2032\321\202;\203:\322\202;\323\324\225b\210\325\306w`\326\327\f\330\n\331\332\333\334
\257\f.D\207" [begin activep main-value range-end type post-blank nil 60 looking-at "[<[]\\(\\(%%\\)?.*?\\)[]>]\\(?:--[<[]\\(.*?\\)[]>]\\)?" match-string-no-properties 1 3 match-string 2 diary active-range active inactive-range inactive 0 " 	" timestamp :type :value :range-end :begin :end :post-blank end] 13 (#$ . 83734)])
#@60 Interpret TIMESTAMP object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-timestamp-interpreter #[(timestamp contents) "\305\306	A@\n\"*\307\310>\203\311\202\312\313\306	A@\n\"*\"\314\306	A@\n\"*\211\205D\315\307\316=\203@\311\202A\312\f\"P)P)\207" [timestamp element property type range-end :type plist-get format (inactive inactive-range) "[%s]" "<%s>" :value :range-end "--" inactive-range] 6 (#$ . 84519)])
#@150 Search for the next timestamp object.

LIMIT bounds the search.

Return value is a cons cell whose CAR is `timestamp' and CDR is
beginning position.
(defalias 'org-element-timestamp-successor #[(limit) "\212\302\303\304\303\305\260	\306#\205\307\310\224B)\207" [org-ts-regexp-both limit re-search-forward "\\|" "\\(?:<[0-9]+-[0-9]+-[0-9]+[^>\n]+?\\+[0-9]+[dwmy]>\\)" "\\(?:<%%\\(?:([^>\n]+)\\)>\\)" t timestamp 0] 6 (#$ . 84965)])
#@231 Parse underline object at point.

Return a list whose CAR is `underline' and CDR is a plist with
`:begin', `:end', `:contents-begin' and `:contents-end' and
`:post-blank' keywords.

Assume point is at the first underscore marker.
(defalias 'org-element-underline-parser #[nil "\212n\204\306u\210\307!\210\310\224\311\224\311\225\310\225b\210\312\313w`\314\315
\316	\317\f\320\321\n\257\n.D\207" [org-emph-re end post-blank contents-end contents-begin begin -1 looking-at 2 4 " 	" nil underline :begin :end :contents-begin :contents-end :post-blank] 11 (#$ . 85407)])
#@83 Interpret UNDERLINE object as Org syntax.
CONTENTS is the contents of the object.
(defalias 'org-element-underline-interpreter #[(underline contents) "\301\302\"\207" [contents format "_%s_"] 3 (#$ . 85990)])
#@200 Parse verbatim object at point.

Return a list whose CAR is `verbatim' and CDR is a plist with
`:value', `:begin', `:end' and `:post-blank' keywords.

Assume point is at the first equal sign marker.
(defalias 'org-element-verbatim-parser #[nil "\212n\204\306u\210\307!\210\310\224\311\312\313\n	\"*\310\225b\210\314\312w`\315\316
\317\320\321\f\257-D\207" [org-emph-re string num end post-blank value -1 looking-at 2 4 nil match-string-no-properties " 	" verbatim :value :begin :end :post-blank begin] 9 (#$ . 86207)])
#@59 Interpret VERBATIM object as Org syntax.
CONTENTS is nil.
(defalias 'org-element-verbatim-interpreter #[(verbatim contents) "\303\304\305\306	A@\n\"*\"\207" [verbatim element property format "=%s=" :value plist-get] 5 (#$ . 86746)])
#@818 Parse the element starting at point.

LIMIT bounds the search.

Return value is a list like (TYPE PROPS) where TYPE is the type
of the element and PROPS a plist of properties associated to the
element.

Possible types are defined in `org-element-all-elements'.

Optional argument GRANULARITY determines the depth of the
recursion.  Allowed values are `headline', `greater-element',
`element', `object' or nil.  When it is broader than `object' (or
nil), secondary values will not be parsed, since they only
contain objects.

Optional argument SPECIAL, when non-nil, can be either
`first-section', `section', `quote-section', `table-row' and
`item'.

If STRUCTURE isn't provided but SPECIAL is set to `item', it will
be computed.

This function assumes point is always at the beginning of the
element it has to parse.
(defalias 'org-element--current-element #[(limit &optional granularity special structure) "\212\306!\203`\306!\203\307y\210\202	\306\310!\203	b\210)\311\n\205(\n\312=?
\313=\203:\314@A#\202\375

\315=\203G\316@!\202\375
\311B\317 \211CD\320CPE\321 ,\203e\322@\"\202\375

\323=\203r\324@!\202\375

\325=\203\326@!\202\375

\327=\203\243\324\212\311B\317 \211CD\320CPE\330 -\206\237@!\202\375
n\204\256\331@!\202\375
\306F!\203\314\332\333!G\232\203\305\334@!\202\375
\335@!\202\375
\321 \203\331\336@\"\202\375
\306\337!\203\376\212\340\341\342\343\332\333!!\"\307\311#)\203\367\344@!\202\375
\331@!\202\375
\306H!\2031
\332\333!I\212\340\345\307\311#)\204
\331@!\202-
I\346\232\203)
\347@!\202-
\350@!)\202\375
\306\351!\203>
\352@!\202\375
\306\353!\203\272
\354\225b\210\306\355!\203X
\356 \210\357@!\202\375
\306\360!\203\200
\356 \210\361\332\333!\226J\"\211K\203x
KA@!\202|
\362@!)\202\375
\306\363!\203\220
\356 \210\364@!\202\375
\306\365!\203\240
\356 \210\366@!\202\375
\306\367!\203\260
\356 \210\370@!\202\375
\356 \210\331@!\202\375
\306L!\203\310
\371@!\202\375
\306\372!\203\325
\373@!\202\375
\374\311!\203\342
\375@!\202\375
\306\376 !\203\371
\377@A\206\365
\201M \"\202\375
\331@!+\207" [org-element--affiliated-re opoint granularity raw-secondary-p case-fold-search special looking-at nil "[ 	]*$" t object item org-element-item-parser table-row org-element-table-row-parser org-get-limited-outline-regexp "^" org-at-heading-p org-element-headline-parser section org-element-section-parser quote-section org-element-quote-section-parser first-section outline-next-heading org-element-paragraph-parser match-string 1 org-element-clock-parser org-element-planning-parser org-element-inlinetask-parser "[ 	]*\\\\begin{\\([A-Za-z0-9*]+\\)}" re-search-forward format "[ 	]*\\\\end{%s}[ 	]*" regexp-quote org-element-latex-environment-parser "^[ 	]*:END:[ 	]*$" "PROPERTIES" org-element-property-drawer-parser org-element-drawer-parser "[ 	]*:\\( \\|$\\)" org-element-fixed-width-parser "[ 	]*#" 0 "\\(?: \\|$\\)" beginning-of-line org-element-comment-parser "\\+BEGIN_\\(\\S-+\\)" assoc org-element-special-block-parser "\\+CALL:" org-element-babel-call-parser "\\+BEGIN:? " org-element-dynamic-block-parser "\\+\\S-+:" org-element-keyword-parser org-element-footnote-definition-parser "[ 	]*-\\{5,\\}[ 	]*$" org-element-horizontal-rule-parser org-at-table-p org-element-table-parser org-item-re org-element-plain-list-parser limit structure org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol org-planning-or-clock-line-re org-clock-string org-drawer-regexp name org-element-block-name-alist parser org-footnote-definition-re org-list-struct] 7 (#$ . 86989)])
#@1254 Collect affiliated keywords before point.

Optional argument KEY-RE is a regexp matching keywords, which
puts matched keyword in group 1.  It defaults to
`org-element--affiliated-re'.

TRANS-LIST is an alist where key is the keyword and value the
property name it should be translated to, without the colons.  It
defaults to `org-element-keyword-translation-alist'.

CONSED is a list of strings.  Any keyword belonging to that list
will have its value consed.  The check is done after keyword
translation.  It defaults to `org-element-multiple-keywords'.

PARSED is a list of strings.  Any keyword member of this list
will have its value parsed.  The check is done after keyword
translation.  If a keyword is a member of both CONSED and PARSED,
it's value will be a list of parsed strings.  It defaults to
`org-element-parsed-keywords'.

DUALS is a list of strings.  Any keyword member of this list can
have two parts: one mandatory and one optional.  Its value is
a cons cell whose CAR is the former, and the CDR the latter.  If
a keyword is a member of both PARSED and DUALS, both values will
be parsed.  It defaults to `org-element-dual-keywords'.

Return a list whose CAR is the position at the first of them and
CDR a plist of keywords and values.
(defalias 'org-element--collect-affiliated-keywords #[(&optional key-re trans-list consed parsed duals) "\212\306\206	\n\206\f\f\206
\206 \206!\307\211\"9\203,\"\202J\"\211\":\204?\";\205I\310\202I\"@9\205I\"@)#\236A)\311$% &o\204&
o\204
\312y\210\313!\203
\314\315!\226'\316'\n\"A\206'(\317 )\320\216\321\322\323\225\324 \"!**( \235\205\301\325\311+,\326,+\"*\211-\203\265(\235\204\272-\202\300\327-%\").(\205\317\330\331(\227P!/(\235\203\341\327*%\"*( \235\203\365*\205\363*.B*(\f\235\204
\332\333(\"\203
*\334$/\"B*\335$/*#$-\202a\313!\204&
\315y\210`$.	D\207" [key-re org-element--affiliated-re trans-list org-element-keyword-translation-alist consed org-element-multiple-keywords t keyword plain-text nil -1 looking-at match-string 1 assoc match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) org-trim buffer-substring-no-properties 0 point-at-eol 2 match-string-no-properties org-element-parse-secondary-string intern ":" string-match "^ATTR_" plist-get plist-put parsed org-element-parsed-keywords duals org-element-dual-keywords element org-element-object-restrictions output restrict case-fold-search raw-kwd kwd save-match-data-internal value string num sec dual-value kwd-sym] 9 (#$ . 90606)])
#@1841 Recursively parse the buffer and return structure.
If narrowing is in effect, only parse the visible part of the
buffer.

Optional argument GRANULARITY determines the depth of the
recursion.  It can be set to the following symbols:

`headline'          Only parse headlines.
`greater-element'   Don't recurse into greater elements excepted
		    headlines and sections.  Thus, elements
		    parsed are the top-level ones.
`element'           Parse everything but objects and plain text.
`object'            Parse the complete buffer (default).

When VISIBLE-ONLY is non-nil, don't parse contents of hidden
elements.

An element or an objects is represented as a list with the
pattern (TYPE PROPERTIES CONTENTS), where :

  TYPE is a symbol describing the element or object.  See
  `org-element-all-elements' and `org-element-all-objects' for an
  exhaustive list of such symbols.  One can retrieve it with
  `org-element-type' function.

  PROPERTIES is the list of attributes attached to the element or
  object, as a plist.  Although most of them are specific to the
  element or object type, all types share `:begin', `:end',
  `:post-blank' and `:parent' properties, which respectively
  refer to buffer position where the element or object starts,
  ends, the number of white spaces or blank lines after it, and
  the element or object containing it.  Properties values can be
  obtained by using `org-element-property' function.

  CONTENTS is a list of elements, objects or raw strings
  contained in the current element or object, when applicable.
  One can access them with `org-element-contents' function.

The Org buffer has `org-data' as type and nil as properties.
`org-element-map' function can be used to find specific elements
or objects within the parse tree.

This function assumes that current major mode is `org-mode'.
(defalias 'org-element-parse-buffer #[(&optional granularity visible-only) "\212eb\210\302 \210\303\304 d\305\306	\307\306D&)\207" [granularity visible-only org-skip-whitespace org-element--parse-elements point-at-bol first-section nil org-data] 9 (#$ . 93219)])
#@303 Recursively parse objects in STRING and return structure.

RESTRICTION is a symbol limiting the object types that will be
looked after.

Optional argument PARENT, when non-nil, is the element or object
containing the secondary string.  It is used to set correctly
`:parent' property within the string.
(defalias 'org-element-parse-secondary-string #[(string restriction &optional parent) "\304\305!rq\210\306\216	c\210\307ed\310\n$\311\312\",\207" [#1=#:temp-buffer string restriction secondary generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) org-element--parse-objects nil mapc #[(obj) "\305	\211:\203\fA\306\fA@\n#\240\210\f+\207" [obj parent value property element :parent plist-put] 6]] 5 (#$ . 95331)])
#@1887 Map a function on selected elements or objects.

DATA is an Org buffer parse tree, as returned by, i.e.,
`org-element-parse-buffer'.  TYPES is a symbol or list of symbols
of elements or objects types (see `org-element-all-elements' and
`org-element-all-objects' for a complete list of types).  FUN is
the function called on the matching element or object.  It has to
accept one argument: the element or object itself.

When optional argument INFO is non-nil, it should be a plist
holding export options.  In that case, parts of the parse tree
not exportable according to that property list will be skipped.

When optional argument FIRST-MATCH is non-nil, stop at the first
match for which FUN doesn't return nil, and return that value.

Optional argument NO-RECURSION is a symbol or a list of symbols
representing elements or objects types.  `org-element-map' won't
enter any recursive element or object whose type belongs to that
list.  Though, FUN can still be applied on them.

Nil values returned from FUN do not appear in the results.


Examples:
--------

Assuming TREE is a variable containing an Org buffer parse tree,
the following example will return a flat list of all `src-block'
and `example-block' elements in it:

  (org-element-map tree '(example-block src-block) 'identity)

The following snippet will find the first headline with a level
of 1 and a "phone" tag, and will return its beginning position:

  (org-element-map
   tree 'headline
   (lambda (hl)
     (and (= (org-element-property :level hl) 1)
          (member "phone" (org-element-property :tags hl))
          (org-element-property :begin hl)))
   nil t)

Eventually, this last example will return a flat list of all
`bold' type objects containing a `latex-snippet' type object:

  (org-element-map
   tree 'bold
   (lambda (b)
     (and (org-element-map b 'latex-snippet 'identity nil t)
          b)))
(defalias 'org-element-map #[(data types fun &optional info first-match no-recursion) "<\204C	<\204	C\305\306\215\307\211\310\311\312\215,\207" [types no-recursion --category --acc --walk-tree found (byte-code "\302\303\304	\"\210)\207" [category types greater-elements mapc #[(type) "	>\204\f\304=\203\305\306\307\"\207\n>?\205\"\310=?\205\"\310\211\207" [type org-element-all-objects org-element-greater-elements category plain-text throw found objects elements] 3]] 3) nil #[(--data) "\211:\204	;\205\306\202	@9\205	@)?\206\335\203,\307\310\">\206\335\n\204=\f\311=\205\335\312
\"\202\335\n\313=\203T\312
\211:\205O	AA)\"\202\335\n>\203{!\211\203z\203s\314\315\"\210\202zB)\f\311=\203\236\n\236\211\203\235
A\307	A@\"*!\210)\n>\206\335\211:\205\257	AA)?\206\335\f\316=\203\302\n>?\206\335\f\317=\203\317\n>\206\335\312
\211:\205\333	AA)\")\207" [--data element --type info --category --walk-tree plain-text plist-get :ignore-list objects mapc org-data throw --map-first-match greater-elements elements types fun result first-match --acc org-element-secondary-value-alist sec-prop property no-recursion org-element-greater-elements org-element-all-objects] 5] --map-first-match (byte-code "	!\210\n\237\207" [--walk-tree data --acc] 2)] 3 (#$ . 96120)])
#@474 Parse elements between BEG and END positions.

SPECIAL prioritize some elements over the others.  It can be set
to `first-section', `quote-section', `section' `item' or
`table-row'.

When value is `item', STRUCTURE will be used as the current list
structure.

GRANULARITY determines the depth of the recursion.  See
`org-element-parse-buffer' for more information.

When VISIBLE-ONLY is non-nil, don't parse contents of hidden
elements.

Elements are accumulated into ACC.
(defalias 'org-element--parse-elements #[(beg end special structure granularity visible-only acc) "\212b\210	\306=\203\307 \204\310\311 \211\312P\313 \210,`&W\203\243
\314&	'($\211)\211):\204B);\205L\315\202L)@9\205L)@)*\316))+\317)A@+\"*,\320))+\317)A@+\"*b\210-\203\213\321))+\317)A@+\"*\204m
,\203m
*.>\203
	\322>\204\262	\323=\203\253*\324=\204\262*\306=\203
\325,\326))+\317)A@+\"*\327*\306\"\203\350\330))+\317)A@+\"*\203\344\331\202\375\324\202\375\327*\332\"\203\364\333\202\375\327*\334\"\205\375\335*\336>\205
\337))+\317)A@+\"*	-)&\210\202m
	\340>\203m
\341,\326))+\317)A@+\"*)*\211)9\203H
)\202f
)\211):\204[
);\205e
\315\202e
)@9\205e
)@)/\236A)$\2100)C1\2112\204
1\202\235
\342\3431\"\210\344\3452\211)\211:\205\225
)AA)1\244#\2102*\210+\2020)\207" [beg granularity org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol headline org-at-heading-p t org-get-limited-outline-regexp "^" outline-next-heading org-element--current-element plain-text :contents-begin plist-get :end :hiddenp (element object nil) greater-element section org-element--parse-elements :contents-end eql :quotedp quote-section plain-list item table table-row (item plain-list) :structure (object nil) org-element--parse-objects mapc #[(child) ";?\205\305	\211:\203\fA\306\fA@\n#\240\210\f+\207" [child parent value property element :parent plist-put] 6] apply org-element-set-contents end special structure element type property cbeg visible-only org-element-greater-elements org-element-object-restrictions acc children parent] 9 (#$ . 99374)])
#@180 Parse objects between BEG and END and return recursive structure.

Objects are accumulated in ACC.

RESTRICTION is a list of object types which are allowed in the
current object.
(defalias 'org-element--parse-objects #[(beg end acc restriction) "\306\212	b\210`\nW\203:
\307\n#\211\203:
\310\311\312\313\"\"\212\fb\210\314\315\316\317\f\"@\"! *\320
 \321A@ \"*!`!U\204\205\"\322\323\324#\325\"\326`!\"#C$\211%\204d$\202\202\327\330$\"\210\310\331%\211\211:\205zAA)$\244#\210%*\")\332
 \321A@ \"*\333
 \321A@ \"*&'&\203

@(>\203
\214&\334
 \321A@ \"*}\210\335ed
\211\2119\203\332\202\370\211:\204\355;\205\367\336\202\367@9\205\367@))\236A)$\210)\"
C$\211%\204
$\202/
\327\330$\"\210\310\331%\211\211:\205'
AA)$\244#\210%*\"'b\210+\202`\nU\204}
\"\322\323\324#\325\"\326`\n\"#C$\211%\204\\
$\202z
\327\330$\"\210\310\331%\211\211:\205r
AA)$\244#\210%*\"\"*\207" [candidates beg end restriction pos next-object nil org-element--get-next-object-candidates apply min mapcar cdr intern format "org-element-%s-parser" rassq :begin plist-get replace-regexp-in-string "	" make-string 32 buffer-substring-no-properties mapc #[(child) ";?\205\305	\211:\203\fA\306\fA@\n#\240\210\f+\207" [child parent value property element :parent plist-put] 6] org-element-set-contents :end :contents-begin :contents-end org-element--parse-objects plain-text element property obj-beg acc tab-width children parent cont-beg obj-end org-element-recursive-objects org-element-object-restrictions] 8 (#$ . 101543)])
#@264 Return an alist of candidates for the next object.

LIMIT bounds the search, and RESTRICTION narrows candidates to
some object types.

Return value is an alist whose CAR is position and CDR the object
type, as a symbol.

OBJECTS is the previous candidates alist.
(defalias 'org-element--get-next-object-candidates #[(limit restriction objects) "\304\305\"\306\211\204\202\307\310\"\210\307\311	\"\210\n*\207" [objects types-to-search next-candidates restriction org-remove-if-not #[(obj) "@\211\n\236A\206	>)\207" [obj type org-element-object-successor-alist restriction] 3] nil mapc #[(obj) "A`W\203@	B\211\207\nB\211\207" [obj types-to-search next-candidates] 2] #[(type) "\306\307\310	\236A\206\"!\211!\211\205\f
B\211*\207" [type org-element-object-successor-alist successor-fun limit obj next-candidates intern format "org-element-%s-successor"] 6]] 3 (#$ . 103160)])
#@259 Interpret DATA as Org syntax.

DATA is a parse tree, an element, an object or a secondary string
to interpret.

Optional argument PARENT is used for recursive calls.  It contains
the element or object containing data, or nil.

Return Org syntax as a string.
(defalias 'org-element-interpret-data #[(data &optional parent) "\211:\204	;\205\306\202	@9\205	@)\211\204&\307\310\311#\202\331\n\312=\203>\307\313\211:\2058	AA)\311#\202\331;\203G\202\331\211:\205Q	AA)\204a\314\315\316\n\"!\317\"\202\331\n>\211?\205m\n
>\307\320\f\204z\203~\202\265\321\n\322=\205\264\211:\205\222	AA)@\232\205\264\211:\204\251	;\205\261\306\202\261	@9\205\261	@)\323>\"\211:\205\276	AA)\311#\314\315\316\n\"!\f\203\325\321!\202\327\"+ \n\324>\203\346 \202
\325!\326	A@!\"*\206\367\327\"\n#>\203
 \330\"\331\"P\202
\332!\333 !\330\"\334\"Q)*\207" [data element type org-element-greater-elements greaterp org-element-recursive-objects plain-text mapconcat #[(obj) "\302	\"\207" [obj parent org-element-interpret-data] 3] "" org-data #[(obj) "\302	\"\207" [obj parent org-element-interpret-data] 3] intern format "org-element-%s-interpreter" nil #[(obj) "\302	\"\207" [obj data org-element-interpret-data] 3] org-element-normalize-contents paragraph (footnote-definition item) (org-data plain-text nil) :post-blank plist-get 0 make-string 32 org-element--interpret-affiliated-keywords org-element-normalize-string 10 objectp parent contents results property post-blank org-element-all-objects] 7 (#$ . 104074)])
#@113 Return ELEMENT's affiliated keywords as Org syntax.
If there is no affiliated keyword, return the empty string.
(defalias 'org-element--interpret-affiliated-keywords #[(element) "\306\307\310	A@\311\211\n:\203D\n@\312!\313\311O\226\314\315
\"\2060
\235\2050\316
\"?)\2038\fB\n\211AA)\211\202
\f\237+\317#)\207" [keyword-to-org element #1=#:--cl-var-- prop #2=#:--cl-var-- keyword #[(key value) "\305	\n\235\203A@\306	\205\307\310\311!\"\312	\f\235\203'\311!\202(\313\260)\207" [dual key org-element-dual-keywords value org-element-parsed-keywords nil "#+" format "[%s]" org-element-interpret-data ": " "\n"] 6] mapconcat #[(prop) "	\306	A@\n\"*\307!\310\311O\226\211\2052
\235\204%\312\313\"\203-\314\315\f\316#\2022\f\"*\207" [prop element property keyword value org-element-multiple-keywords plist-get symbol-name 1 nil string-match "^ATTR_" mapconcat #[(line) "	\n\"\207" [keyword-to-org keyword line] 3] #3="" keyword-to-org] 5] nil symbol-name 1 string-match "^ATTR_" assoc #3# org-element-affiliated-keywords org-element-keyword-translation-alist x] 6 (#$ . 105655)])
#@211 Ensure string S ends with a single newline character.

If S isn't a string return it unchanged.  If S is the empty
string, return it.  Otherwise, return a new string with a single
newline character at its end.
(defalias 'org-element-normalize-string #[(s) ";\204\207\301\230\203\301\207\302\303\"\205\304\305\306\211$\207" [s "" string-match "\\(\n[ 	]*\\)*\\'" replace-match "\n" nil] 5 (#$ . 106789)])
#@384 Normalize plain text in ELEMENT's contents.

ELEMENT must only contain plain text and objects.

If optional argument IGNORE-FIRST is non-nil, ignore first line's
indentation to compute maximal common indentation.

Return the normalized element that is element with global
indentation removed from its contents.  The function assumes that
indentation is not done with TAB characters.
(defalias 'org-element-normalize-contents #[(element &optional ignore-first) "\305\211\306\307\310\215\210\204\n\202 \305\311\211\n\312\313\"\f?#*+\207" [ind-list collect-inds element build ignore-first nil #[(blob first-flag) "\302\303\211:\205\f	AA)\"\207" [blob element mapc #[(object) "\203+	;\203+\306\307\310	\"\210\311\312	\"G\313\n!\203&\314\315\306\211\"\210\202*\nB)	;\203T\316\307\317	\f#\205R\311\320	\"\321\232?\205R\316\225\311\312	\"GB\2022)\207	\211:\204d
;\205l\322\202l
@9\205l
@)>\205x	\"\207" [first-flag object len ind-list start element nil string-match "\\`\\( *\\)" match-string 1 zerop throw zero 0 "\n\\( *\\)\\(.\\)" 2 " " plain-text org-element-recursive-objects collect-inds] 5]] 4] zero (byte-code "	\n?\"\207" [collect-inds element ignore-first] 3) #[(blob mci first-flag) "A\302\303\211:\205	AA)\"\241\210\207" [blob element mapcar #[(object) "\203	;\203\306\307\310\311\n\"\312	#	;\203\"\307\310\313\n\"\314	#\207	\211:\2042;\205:\315\202:@9\205:@)\f>\203F
	\n#\207	\207" [first-flag object mci element org-element-recursive-objects build nil replace-regexp-in-string format "\\` \\{%d\\}" "" "\n \\{%d\\}" "\n" plain-text] 5]] 5] apply min] 6 (#$ . 107211)])
#@931 Determine closest element around point.

Return value is a list like (TYPE PROPS) where TYPE is the type
of the element and PROPS a plist of properties associated to the
element.

Possible types are defined in `org-element-all-elements'.
Properties depend on element or object type, but always include
`:begin', `:end', `:parent' and `:post-blank' properties.

As a special case, if point is at the very beginning of a list or
sub-list, returned element will be that list instead of the first
item.  In the same way, if point is at the beginning of the first
row of a table, returned element will be the table instead of the
first row.

If optional argument KEEP-TRAIL is non-nil, the function returns
a list of elements leading to element at point.  The list's CAR
is always the element at point.  The following positions contain
element's siblings, then parents, siblings of parents, until the
first element of current section.
(defalias 'org-element-at-point #[(&optional keep-trail) "\212\214~\210\306\307 \211\310	P\311 ,\203+\312 \210\f\204#\313d\306\"\202\212\313d\306\"C\202\212`\212\306\307 \211\310	P\314 \210,`)\315\211\211\211\211\211\211\306\307 \211\310	P\306\307 \211\310	P\316 ,\203xeb\210\202~\317 \210\315y\210,\320 \210\312 \210\321\322\215.	*\207" [org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol keep-trail parent t org-get-limited-outline-regexp "^" org-at-heading-p beginning-of-line org-element-headline-parser outline-next-heading nil org-before-first-heading-p org-back-to-heading org-skip-whitespace exit (byte-code "\306\303	\n$\211@\307
\211:\203$A\310A@#\240\210+\210\2032B\311\312A@\"*\211W\204XU\205[U?\205[b)\204\f >\204x\313\314\203r\202s\"\210\202\315\312A@\"*\316\312A@\"*!\211\"\203\313!\203\313\"V\204\313!W\204\313\"U\203\275\f\317>\204\313!U\203\335\f\320>\203\335\313\314\203\327\202\330\"\210\202,
\321\f\322\"\203\371\323\324\312A@\"*\202%
\321\f\323\"\203
\325\202%
\321\f\326\"\203
\327\325\202%
\321\f\330\"\203!
\331\325\202%
\325\211!\"b\210*\202" [end special-flag struct element type parent org-element--current-element :parent plist-put :end plist-get throw exit :contents-begin :contents-end (plain-list table) (center-block drawer dynamic-block inlinetask item plain-list quote-block special-block) eql plain-list item :structure nil property-drawer node-property table table-row value property keep-trail trail elem-end origin org-element-greater-elements cend cbeg] 6) prevs struct trail special-flag type element end origin] 10 (#$ . 108861)])
#@389 Return closest element or object around point.

Return value is a list like (TYPE PROPS) where TYPE is the type
of the element or object and PROPS a plist of properties
associated to it.

Possible types are defined in `org-element-all-elements' and
`org-element-all-objects'.  Properties depend on element or
object type, but always include `:begin', `:end', `:parent' and
`:post-blank'.
(defalias 'org-element-context #[nil "\212\214~\210`\306 \211@\307\n\310=\203B\311	\312	A@\f\"*\211\205>\313 \210\314
\315 \"\210\316\224b\210`Y\205>\316\225T\211X)\204\224\n\317>\203V\313 \210\320\307w\210\315 \211\204\224\n\321>\203\220\322	\312	A@\f\"*\323	\312	A@\f\"*Y\205\214X\205\214b\210\211*\204\224	\202\311	\2119\203\237	\202\270	\211:\204\257	;\205\267\324\202\267	@9\205\267	@)\236A)	\307\325\326\215+.\207" [origin element type end property tag org-element-at-point nil item :tag plist-get beginning-of-line search-forward point-at-eol 0 (headline inlinetask) "* " (paragraph table-row verse-block) :contents-begin :contents-end plain-text exit (byte-code "\306	\n#\211\203B
\307\310\311\312\313\n\"\"\n\"\211A\fV\203$\314\315
\"\210\202>
Ab\210\316\317\320@\"! \321\322A@\"*\323\322A@\"*\324\322A@\"*\211\fX\203\244U\204|b\210\202=
\314\315\325
\211:\203\234A\326A@#\240\210+\"\210\202=
\203\267\fV\204\267\fW\203\337\314\315\325
\211:\203\327A\326A@#\240\210+\"\210\202=
b\210\325
\211:\203

A\326A@#\240\210+\210\2119\203
\2024
\211:\204)
;\2053
\327\2023
@9\2053
@)\236A),)\202
\207" [end restriction candidates closest-cand origin parent org-element--get-next-object-candidates rassq apply min mapcar cdr throw exit intern format "org-element-%s-parser" :contents-begin plist-get :contents-end :end :parent plist-put plain-text object element property cbeg cend obj-end value org-element-object-restrictions] 8) cend cbeg org-element-object-restrictions candidates parent restriction] 5 (#$ . 111578)])
#@53 Non-nil when elements ELEM-A and ELEM-B are nested.
(defalias 'org-element-nested-p #[(elem-A elem-B) "\306\307	A@\n\"*\306\307	A@\n\"*\310\307	A@\n\"*\310\307	A@\n\"*	\211\n	Y\203?
\fX\206J	\nY\205J\f
X,\207" [elem-A element property elem-B end-B end-A :begin plist-get :end beg-B beg-A] 7 (#$ . 113698)])
(put 'org-element-nested-p 'byte-optimizer 'byte-compile-inline-expand)
#@114 Swap elements ELEM-A and ELEM-B.
Assume ELEM-B is after ELEM-A in the buffer.  Leave point at the
end of ELEM-A.
(defalias 'org-element-swap-A-B #[(elem-A elem-B) "\306\307	A@\n\"*b\210n?\211\203P\f\211:\204$	;\205,\310\202,	@9\205,	@)\311=\203L\306\f\307	A@\n\"*\312\f\307	A@\n\"*U\204P\313\314!\210\205c\306\f\307	A@\n\"*b\210\315 \306\307	A@\n\"*\212\316\307	A@\n\"*b\210\317\320x\210\321 )\306\f\307	A@\n\"* \212\316\f\307	A@\n\"*b\210\317\320x\210\321 )!\322\323\324\"\"\322\325\324 !\"\"B\"{#\326 !\"$ b\210\203\344\327\330\331$#$\332
!\210#c\210 Z%\333\334\"@\"\210b\210|\210$c\210\333\335\"A\"\210)\316\f\307	A@\n\"*b.	\207" [elem-A element property specialp elem-B ind-B :begin plist-get plain-text paragraph :contents-begin error "Cannot swap elements" org-get-indentation :end " 
	\n" nil point-at-eol mapcar #[(ov) "\301!\302!E\207" [ov overlay-start overlay-end] 4] overlays-in #[(ov) "\301!\302!E\207" [ov overlay-start overlay-end] 4] delete-and-extract-region replace-regexp-in-string "\\`[ 	]*" "" org-indent-to-column mapc #[(ov) "\302@A@	\\\3038	\\#\207" [ov offset move-overlay 2] 5] #[(ov) "\302@A@	Z\3038	Z#\207" [ov offset move-overlay 2] 5] beg-A end-A beg-B end-B overlays body-A body-B offset] 7 (#$ . 114106)])
(provide 'org-element)