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

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

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

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


(byte-code "\300\301!\210\300\302!\210\303\304\305\306\307\310\311\312&\210\313\314\315\316\311\304\317\320&\210\313\321\305\322\311\304\317\323&\210\313\324\315\325\311\304\317\326&\210\313\327\305\330\311\304\331\332\317\333&	\210\313\334\305\335\311\304\317\336&\210\313\337\305\340\311\304\317\333&\210\313\341\342\343\311\304\331\332\317\344&	\210\313\345\305\346\311\304\331\332\317\333&	\207" [require org-macs org-compat custom-declare-group org-plain-lists nil "Options concerning plain lists in Org-mode." :tag "Org Plain lists" :group org-structure custom-declare-variable org-cycle-include-plain-lists t "When t, make TAB cycle visibility on plain list items.\nCycling plain lists works only when the cursor is on a plain list\nitem.  When the cursor is on an outline heading, plain lists are\ntreated as text.  This is the most stable way of handling this,\nwhich is why it is the default.\n\nWhen this is the symbol `integrate', then integrate plain list\nitems when cycling, as if they were children of outline headings.\n\nThis setting can lead to strange effects when switching visibility\nto `children', because the first \"child\" in a subtree decides\nwhat children should be listed.  If that first \"child\" is a\nplain list item with an implied large level number, all true\nchildren and grand children of the outline heading will be\nexposed in a children' view." :type (choice (const :tag "Never" nil) (const :tag "With cursor in plain list (recommended)" t) (const :tag "As children of outline headings" integrate)) org-list-demote-modify-bullet "Default bullet type installed when demoting an item.\nThis is an association list, for each bullet type, this alist will point\nto the bullet that should be used when this item is demoted.\nFor example,\n\n (setq org-list-demote-modify-bullet\n       '((\"+\" . \"-\") (\"-\" . \"+\") (\"*\" . \"+\")))\n\nwill make\n\n  + Movies\n    + Silence of the Lambs\n    + My Cousin Vinny\n  + Books\n    + The Hunt for Red October\n    + The Road to Omaha\n\ninto\n\n  + Movies\n    - Silence of the Lambs\n    - My Cousin Vinny\n  + Books\n    - The Hunt for Red October\n    - The Road to Omaha" (repeat (cons (choice :tag "If the current bullet is  " (const "-") (const "+") (const "*") (const "1.") (const "1)")) (choice :tag "demotion will change it to" (const "-") (const "+") (const "*") (const "1.") (const "1)")))) org-plain-list-ordered-item-terminator "The character that makes a line with leading number an ordered list item.\nValid values are ?. and ?).  To get both terminators, use t." (choice (const :tag "dot like in \"2.\"" 46) (const :tag "paren like in \"2)\"" 41) (const :tag "both" t)) org-alphabetical-lists "Non-nil means single character alphabetical bullets are allowed.\nBoth uppercase and lowercase are handled.  Lists with more than\n26 items will fallback to standard numbering.  Alphabetical\ncounters like \"[@c]\" will be recognized." :version "24.1" boolean org-list-two-spaces-after-bullet-regexp "A regular expression matching bullets that should have 2 spaces after them.\nWhen nil, no bullet will have two spaces after them.  When\na string, it will be used as a regular expression.  When the\nbullet type of a list is changed, the new bullet type will be\nmatched against this regexp.  If it matches, there will be two\nspaces instead of one after the bullet in each item of the list." (choice (const :tag "never" nil) (regexp)) org-empty-line-terminates-plain-lists "Non-nil means an empty line ends all plain list levels.\nOtherwise, two of them will be necessary." org-list-automatic-rules '((checkbox . t) (indent . t)) "Non-nil means apply set of rules when acting on lists.\nBy default, automatic actions are taken when using\n \\[org-meta-return], \\[org-metaright], \\[org-metaleft],\n \\[org-shiftmetaright], \\[org-shiftmetaleft],\n \\[org-ctrl-c-minus], \\[org-toggle-checkbox] or\n \\[org-insert-todo-heading].  You can disable individually these\n rules by setting them to nil.  Valid rules are:\n\ncheckbox  when non-nil, checkbox statistics is updated each time\n          you either insert a new checkbox or toggle a checkbox.\nindent    when non-nil, indenting or outdenting list top-item\n          with its subtree will move the whole list and\n          outdenting a list whose bullet is * to column 0 will\n          change that bullet to \"-\"." (alist :tag "Sets of rules" :key-type (choice (const :tag "Checkbox" checkbox) (const :tag "Indent" indent)) :value-type (boolean :tag "Activate" :value t)) org-list-use-circular-motion "Non-nil means commands implying motion in lists should be cyclic.\n\nIn that case, the item following the last item is the first one,\nand the item preceding the first item is the last one.\n\nThis affects the behavior of \\[org-move-item-up],\n \\[org-move-item-down], \\[org-next-item] and\n \\[org-previous-item]."] 10)
#@246 Hook that is run whenever Org thinks checkbox statistics should be updated.
This hook runs even if checkbox rule in
`org-list-automatic-rules' does not apply, so it can be used to
implement alternative ways of collecting statistics
information.
(defvar org-checkbox-statistics-hook nil (#$ . 5444))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\313&\210\300\314\315\316\304\305\317\320\306\313&	\210\300\321\322\323\304\305\306\324&\207" [custom-declare-variable org-hierarchical-checkbox-statistics t "Non-nil means checkbox statistics counts only the state of direct children.\nWhen nil, all boxes below the cookie are counted.\nThis can be set to nil on a per-node basis using a COOKIE_DATA property\nwith the word \"recursive\" in the value." :group org-plain-lists :type boolean org-description-max-indent 20 "Maximum indentation for the second line of a description list.\nWhen the indentation would be larger than this, it will become\n5 characters instead." integer org-list-indent-offset 0 "Additional indentation for sub-items in a list.\nBy setting this to a small number, usually 1 or 2, one can more\nclearly distinguish sub-items in a list." :version "24.1" org-list-radio-list-templates '((latex-mode "% BEGIN RECEIVE ORGLST %n\n% END RECEIVE ORGLST %n\n\\begin{comment}\n#+ORGLST: SEND %n org-list-to-latex\n-\n\\end{comment}\n") (texinfo-mode "@c BEGIN RECEIVE ORGLST %n\n@c END RECEIVE ORGLST %n\n@ignore\n#+ORGLST: SEND %n org-list-to-texinfo\n-\n@end ignore\n") (html-mode "<!-- BEGIN RECEIVE ORGLST %n -->\n<!-- END RECEIVE ORGLST %n -->\n<!--\n#+ORGLST: SEND %n org-list-to-html\n-\n-->\n")) "Templates for radio lists in different major modes.\nAll occurrences of %n in a template will be replaced with the name of the\nlist, obtained by prompting the user." (repeat (list (symbol :tag "Major mode") (string :tag "Format")))] 10)
#@75 Names of blocks where lists are not allowed.
Names must be in lower case.
(defvar org-list-forbidden-blocks '("example" "verse" "src" "ascii" "beamer" "docbook" "html" "latex" "odt") (#$ . 7338))
#@207 Context types where lists will be interpreted during export.

Valid types are `drawer', `inlinetask' and `block'.  More
specifically, type `block' is determined by the variable
`org-list-forbidden-blocks'.
(defvar org-list-export-context '(block inlinetask) (#$ . 7541))
#@98 Regex corresponding to the end of a list.
It depends on `org-empty-line-terminates-plain-lists'.
(defconst org-list-end-re (byte-code "\203\301\207\302\207" [org-empty-line-terminates-plain-lists "^[ 	]*\n" "^[ 	]*\n[ 	]*\n"] 1) (#$ . 7818))
#@130 Matches a list item and puts everything into groups:
group 1: bullet
group 2: counter
group 3: checkbox
group 4: description tag
(defconst org-list-full-item-re "^[ 	]*\\(\\(?:[-+*]\\|\\(?:[0-9]+\\|[A-Za-z]\\)[.)]\\)\\(?:[ 	]+\\|$\\)\\)\\(?:\\[@\\(?:start:\\)?\\([0-9]+\\|[A-Za-z]\\)\\][ 	]*\\)?\\(?:\\(\\[[ X-]\\]\\)\\(?:[ 	]+\\|$\\)\\)?\\(?:\\(.*\\)[ 	]+::\\(?:[ 	]+\\|$\\)\\)?" (#$ . 8070))
#@56 Return the correct regular expression for plain lists.
(defalias 'org-item-re #[nil "\304=\203\n\305\202\306U\203\307\202\310U\203\311\202\305	\203'\312\202(\313\314\n\315\316\260*\207" [org-plain-list-ordered-item-terminator org-alphabetical-lists alpha term t "[.)]" 41 ")" 46 "\\." "\\|[A-Za-z]" "" "\\([ 	]*\\([-+]\\|\\(\\([0-9]+" "\\)" "\\)\\)\\|[ 	]+\\*\\)\\([ 	]+\\|$\\)"] 5 (#$ . 8470)])
#@53 Regexp matching the beginning of a plain list item.
(defalias 'org-item-beginning-re #[nil "\300\301 P\207" ["^" org-item-re] 2 (#$ . 8892)])
(put 'org-item-beginning-re 'byte-optimizer 'byte-compile-inline-expand)
#@51 Is point at a list item with REGEXP after bullet?
(defalias 'org-list-at-regexp-after-bullet-p #[(regexp) "\303 \205&\212\304\225b\210\305\203\306\202\307\310Q\311	!\203!\304\225b\210)\311\n!)\207" [org-alphabetical-lists counter-re regexp org-at-item-p 0 "\\(?:\\[@\\(?:start:\\)?" "\\([0-9]+\\|[A-Za-z]\\)" "[0-9]+" "\\][ 	]*\\)" looking-at] 3 (#$ . 9113)])
#@48 Is point in a context where lists are allowed?
(defalias 'org-list-in-valid-context-p #[nil "\301!?\207" [org-list-forbidden-blocks org-in-block-p] 2 (#$ . 9487)])
#@69 Return item beginning position when in a plain list, nil otherwise.
(defalias 'org-in-item-p #[nil "\212\306 \210\307\310 \211@\311\312\313\314#\315Q\316\317!\205\320 \321  \322\323!\2042
\2036\322
!\2036\324\2028\325 !\326	8\327=\203F\330\202\230\322 !\203Q`\202\230\331\332\330\"#$\333\334%#T#\211#\203p$T$\202Z\335%$\"\211\"\203\224`\"@Y\203\224`\"AW\203\224\"@b\210\332y\210+\336\337\215.\207" [case-fold-search context lim-up org-drawers drawers-re inlinetask-re beginning-of-line t org-list-context "^[ 	]*:\\(" mapconcat regexp-quote "\\|" "\\):[ 	]*$" featurep org-inlinetask org-inlinetask-outline-regexp org-item-re looking-at "^[ 	]*$" 10000 org-get-indentation 2 invalid nil 0 -1 string-match "[
\n]" org-in-regexp exit (byte-code "\306 \307	!\203\nW\203\310\311`\"\210\202\225`X\203%\310\311\312\"\210\202\225\307\f!\2033\310\311\312\"\210\202\225\307\313!\203A\314\315\316#\204\225\307\317!\203U\314
\316#\203U\320 \210\202\225\203j\307!\203j\321 \210\322y\210\202\225\307\323!\203v\322y\210\202\225\324!\203\204\310\311\312\"\210\202\225\nW\203\222\322y\210\202\225\322y\210)\202" [ind item-re ind-ref lim-up org-list-end-re drawers-re org-get-indentation looking-at throw exit nil "^[ 	]*#\\+end_" re-search-backward "^[ 	]*#\\+begin_" t "^[ 	]*:END:" beginning-of-line org-inlinetask-goto-beginning -1 "^[ 	]*$" zerop inlinetask-re] 4) item-re ind-ref end-bounds i hl org-list-end-re] 6 (#$ . 9658)])
#@52 Is point in a line starting a hand-formatted item?
(defalias 'org-at-item-p #[nil "\212\300 \210\301\302 !\205
\303 )\207" [beginning-of-line looking-at org-item-re org-list-in-valid-context-p] 2 (#$ . 11159)])
#@46 Is point at the bullet of a plain list item?
(defalias 'org-at-item-bullet-p #[nil "\300 \205\301f\302\235?\205`\303\225W\207" [org-at-item-p nil (32 9) 0] 2 (#$ . 11377)])
#@61 Is point at a line starting a plain list item with a timer?
(defalias 'org-at-item-timer-p #[nil "\300\301!\207" [org-list-at-regexp-after-bullet-p "\\([0-9]+:[0-9]+:[0-9]+\\)[ 	]+::[ 	]+"] 2 (#$ . 11560)])
#@38 Is point at a description list item?
(defalias 'org-at-item-description-p #[nil "\300\301!\207" [org-list-at-regexp-after-bullet-p "\\(\\S-.+\\)[ 	]+::\\([ 	]+\\|$\\)"] 2 (#$ . 11773)])
#@64 Is point at a line starting a plain-list item with a checklet?
(defalias 'org-at-item-checkbox-p #[nil "\300\301!\207" [org-list-at-regexp-after-bullet-p "\\(\\[[- X]\\]\\)[ 	]+"] 2 (#$ . 11965)])
#@63 Is point at a line starting a plain-list item with a counter?
(defalias 'org-at-item-counter-p #[nil "\301 \205\302!\205\303\304!\207" [org-list-full-item-re org-at-item-p looking-at match-string 2] 2 (#$ . 12168)])
#@286 Determine context, and its boundaries, around point.

Context will be a cell like (MIN MAX CONTEXT) where MIN and MAX
are boundaries and CONTEXT is a symbol among `drawer', `block',
`invalid', `inlinetask' and nil.

Contexts `block' and `invalid' refer to `org-list-forbidden-blocks'.
(defalias 'org-list-context #[nil "\306 \307\216\212\310\311 \211\312\nP\313 \210\310`\314\211\211\212\314\315\316\217\205\"`)\206'e\212\317 )\206/d*+,-./\320\321\322\3230\324#\325Q12\212\3261!?\205\211\3262!?\205\211\3271*\310#\205h\330 T\211-\205\211\3312
\310#\203}\332\224S\206~
\211,\205\211,.Y)\203\227-*,\333+*\334\31434\212\3264!?\205\364\3274*\310#\205\264\330 T\211-\205\364\326\335!\205\364\336\337!\227\2113\205\364-b\205\364\3314
\310#\203\337\340 S\206\340
\211,\205\364,.Y\205\364\336\337!\227\341\232)\203
-*,35\235\203
\342\202\f
\343+*\344\345!\203e
\212\346 \2111\347P2\326\350!?\205W
\3271*\310#\2053
\330 T\211-\205W
\3262!?\205W
\3312
\310#\205M
\332\224S\211,\205W
`.V+\203e
-*,\351+*
+E.\207" [save-match-data-internal org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol lim-down match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) t org-get-limited-outline-regexp "^" beginning-of-line nil (org-back-to-heading t) ((error)) outline-next-heading "^[ 	]*:END:" "^[ 	]*:\\(" mapconcat regexp-quote "\\|" "\\):[ 	]*$" looking-at re-search-backward point-at-eol re-search-forward 0 drawer "^[ 	]*#\\+\\(begin\\|end\\)_" "^[ 	]*#\\+begin_\\(\\S-+\\)" match-string 1 point-at-bol "end" invalid block featurep org-inlinetask org-inlinetask-outline-regexp "END[ 	]*$" "^\\*+" inlinetask lim-up context-type end beg pos case-fold-search org-drawers beg-re end-re type block-re org-list-forbidden-blocks] 9 (#$ . 12396)])
#@899 Return structure of list at point.

A list structure is an alist where key is point at item, and
values are:
1. indentation,
2. bullet with trailing whitespace,
3. bullet counter, if any,
4. checkbox, if any,
5. description tag, if any,
6. position at item end.

Thus the following list, where numbers in parens are
point-at-bol:

- [X] first item                             (1)
  1. sub-item 1                              (18)
  5. [@5] sub-item 2                         (34)
  some other text belonging to first item    (55)
- last item                                  (97)
  + tag :: description                       (109)
                                             (131)

will get the following structure:

((1 0 "- "  nil "[X]" nil 97)
 (18 2 "1. "  nil nil nil 34)
 (34 2 "5. " "5" nil nil 55)
 (97 0 "- "  nil nil nil 131)
 (109 2 "+ " nil nil "tag" 131)

Assume point is at an item.
(defalias 'org-list-struct #[nil "\212\306 \210\307\310 \211@	A@\311\312 \313\314\315\316#\317Q\320\321!\205(\322 `\323 B\324\211 !\324\211\"#\324\211$%\325&\326'\212\327\330\215\210)\327\331\215\210\332!\"\237A\"%\332#$\237A\"#\333%#\"\210%.\207" [case-fold-search context lim-up lim-down text-min-ind item-re beginning-of-line t org-list-context 10000 org-item-re "^[ 	]*:\\(" mapconcat regexp-quote "\\|" "\\):[ 	]*$" featurep org-inlinetask org-inlinetask-outline-regexp org-get-indentation nil #[(ind) "\304!\210\305\306!`\n	\305\307!\305\310!\311 \312\216\313\314	\"*\205!\305\315!\257)\207" [org-list-full-item-re bullet ind save-match-data-internal looking-at match-string-no-properties 1 2 3 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "[-+*]" 4] 8] #[nil "\301\302x\210\303 T^\207" [lim-down " 
	\n" nil point-at-eol] 2] exit (byte-code "\306`\307\"\206\310\311 \\`	X\203:\312\313\314\n!\203!\306`\315\"\203*@\f\236\f>\2023`B
!\fB\211\"\210\202\371\306`\315\"\203P\316\317 \315\320	$b\210\321y\210\202\371\314!\203f\312\313@\f\236\f>\211\"\210\202\371\314\n!\203\213
!\fB`BBW\203\205`B\321y\210\202\371\314\322!\203\231\323\324	\325#\204\371\314\326!\203\256\323	\325#\203\256\327 \210\202\371\203\303\314!\203\303\330 \210\321y\210\202\371\314\331!\203\317\321y\210\202\371\332!\203\344\312\313@\f\236\f>\211\"\210\202\371W\203\356`BB\321y\210)\202" [ind lim-up item-re beg-cell itm-lst assoc-at-point get-text-property original-indentation 0 org-get-indentation throw exit looking-at org-example previous-single-property-change point-at-eol nil -1 "^[ 	]*#\\+end_" re-search-backward "^[ 	]*#\\+begin_" t "^[ 	]*:END:" beginning-of-line org-inlinetask-goto-beginning "^[ 	]*$" zerop org-list-end-re end-lst text-min-ind drawers-re inlinetask-re] 5) (byte-code "\306`\307\"\206\310\311 \\`	Y\203!\312\313\310\n BB\211\"\210\202\305\306`\314\"\2033\315`\314\316	$b\210\202\305\317\f!\203G\312\313\310`BB\211\"\210\202\305\317
!\203b!B`BB\320y\210\202\305\203t\317!\203t\321 \210\202\305\317\322!\203\200\320y\210\202\305AX\203\227\312\313\310\n BB\211\"\210\202\305@A@X\203\247`BB\317\323!\203\265\324\325	\326#\204\302\317!\203\302\324\327	\326#\210\320y\210)\202" [ind lim-down end-before-blank end-lst-2 org-list-end-re item-re get-text-property original-indentation 0 org-get-indentation throw exit org-example next-single-property-change nil looking-at 1 org-inlinetask-goto-end "^[ 	]*$" "^[ 	]*#\\+begin_" re-search-forward "^[ 	]*#\\+end_" t "^[ 	]*:END:" assoc-at-point itm-lst-2 inlinetask-re beg-cell drawers-re] 5) append org-list-struct-assoc-end org-drawers drawers-re inlinetask-re beg-cell ind itm-lst itm-lst-2 end-lst end-lst-2 struct assoc-at-point end-before-blank] 6 (#$ . 14293)])
#@164 Associate proper ending point to items in STRUCT.

END-LIST is a pseudo-alist where car is indentation and cdr is
ending position.

This function modifies STRUCT.
(defalias 'org-list-struct-assoc-end #[(struct end-list) "\303\304\n\")\207" [end-list endings struct mapc #[(elt) "@A@\211@A)\nX\203\211A@\210\202\306\233\307	\310#\211\n\2031\n
\240\2029\311A
C\"\241,\207" [elt ind pos endings x new-end 6 assoc-default <= append old-end] 6]] 3 (#$ . 18142)])
#@56 Return alist between item and previous item in STRUCT.
(defalias 'org-list-prevs-alist #[(struct) "\302\303\"\302\304\")\207" [struct item-end-alist mapcar #[(e) "@\3018B\207" [e 6] 3] #[(e) "\303@	\"@@\n)B\207" [e item-end-alist prev rassq] 3]] 3 (#$ . 18629)])
#@49 Return alist between item and parent in STRUCT.
(defalias 'org-list-parents-alist #[(struct) "@A@CC\304!\211C\211\305\306A\"+B\207" [struct ind-to-ori top-item prev-pos org-list-get-top-point mapcar #[(item) "@A@	\211@@)\211B\fV\2031\f	\236	\235\206%\306\307\215
	\211@A)B\202T\fW\203LA@	\f	B	B
	)B\202T
	\211@A)B+\207" [item ind-to-ori x prev-ind ind pos exit (byte-code "\302\303\"\210	CC\207" [ind-to-ori ind mapc #[(e) "@	W\205
\303\304\n\235\"\207" [e ind ind-to-ori throw exit] 4]] 3) prev-pos origin] 4]] 5 (#$ . 18906)])
#@40 Return the Nth value of KEY in STRUCT.
(defalias 'org-list-get-nth #[(n key struct) "	\n\2368\207" [n key struct] 3 (#$ . 19477)])
(put 'org-list-get-nth 'byte-optimizer 'byte-compile-inline-expand)
#@76 Set the Nth value of KEY in STRUCT to NEW.

This function modifies STRUCT.
(defalias 'org-list-set-nth #[(n key struct new) "	\n\236\233\240\207" [n key struct new] 3 (#$ . 19683)])
#@39 Return indentation of ITEM in STRUCT.
(defalias 'org-list-get-ind #[(item struct) "\304	\211\n	\2368+\207" [item struct key n 1] 4 (#$ . 19873)])
(put 'org-list-get-ind 'byte-optimizer 'byte-compile-inline-expand)
#@75 Set indentation of ITEM in STRUCT to IND.

This function modifies STRUCT.
(defalias 'org-list-set-ind #[(item struct ind) "\303\304	\n$\207" [item struct ind org-list-set-nth 1] 5 (#$ . 20097)])
#@34 Return bullet of ITEM in STRUCT.
(defalias 'org-list-get-bullet #[(item struct) "\304	\211\n	\2368+\207" [item struct key n 2] 4 (#$ . 20299)])
(put 'org-list-get-bullet 'byte-optimizer 'byte-compile-inline-expand)
#@73 Set bullet of ITEM in STRUCT to BULLET.

This function modifies STRUCT.
(defalias 'org-list-set-bullet #[(item struct bullet) "\303\304	\n$\207" [item struct bullet org-list-set-nth 2] 5 (#$ . 20524)])
#@35 Return counter of ITEM in STRUCT.
(defalias 'org-list-get-counter #[(item struct) "\304	\211\n	\2368+\207" [item struct key n 3] 4 (#$ . 20733)])
(put 'org-list-get-counter 'byte-optimizer 'byte-compile-inline-expand)
#@43 Return checkbox of ITEM in STRUCT or nil.
(defalias 'org-list-get-checkbox #[(item struct) "\304	\211\n	\2368+\207" [item struct key n 4] 4 (#$ . 20961)])
(put 'org-list-get-checkbox 'byte-optimizer 'byte-compile-inline-expand)
#@77 Set checkbox of ITEM in STRUCT to CHECKBOX.

This function modifies STRUCT.
(defalias 'org-list-set-checkbox #[(item struct checkbox) "\303\304	\n$\207" [item struct checkbox org-list-set-nth 4] 5 (#$ . 21199)])
#@40 Return end position of ITEM in STRUCT.
(defalias 'org-list-get-tag #[(item struct) "\304	\211\n	\2368+\207" [item struct key n 5] 4 (#$ . 21418)])
(put 'org-list-get-tag 'byte-optimizer 'byte-compile-inline-expand)
#@40 Return end position of ITEM in STRUCT.
(defalias 'org-list-get-item-end #[(item struct) "\304	\211\n	\2368+\207" [item struct key n 6] 4 (#$ . 21643)])
#@97 Return point at end of ITEM in STRUCT, before any blank line.
Point returned is at end of line.
(defalias 'org-list-get-item-end-before-blank #[(item struct) "\212\302	\"b\210\303\304x\210\305 )\207" [item struct org-list-get-item-end " 
	\n" nil point-at-eol] 3 (#$ . 21805)])
#@136 Return parent of ITEM or nil.
STRUCT is the list structure.  PARENTS is the alist of parents,
as returned by `org-list-parents-alist'.
(defalias 'org-list-get-parent #[(item struct parents) "\206\303	!\n\236A)\207" [parents struct item org-list-parents-alist] 2 (#$ . 22091)])
#@121 Non-nil if ITEM has a child.

STRUCT is the list structure.

Value returned is the position of the first child of ITEM.
(defalias 'org-list-has-child-p #[(item struct) "	\306	\211\n	\2368-	\236	\235A@@\f\2054
\f	\306	\211\n	\2368-W\2054\f*\207" [item struct key n child-maybe ind 1] 4 (#$ . 22380)])
#@160 Return next item in same sub-list as ITEM, or nil.
STRUCT is the list structure.  PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(defalias 'org-list-get-next-item #[(item struct prevs) "\302	\"@\207" [item prevs rassq] 3 (#$ . 22705)])
#@164 Return previous item in same sub-list as ITEM, or nil.
STRUCT is the list structure.  PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(defalias 'org-list-get-prev-item #[(item struct prevs) "	\236A\207" [item prevs] 2 (#$ . 22979)])
#@88 List all items having ITEM as a common ancestor, or nil.
STRUCT is the list structure.
(defalias 'org-list-get-subtree #[(item struct) "\305	\"	\236	\235A\306\307\310\215\210\f\237+\207" [item struct item-end sub-struct subtree org-list-get-item-end nil exit (mapc #[(e) "@\211\nW\203	B\211\202\304\305\306\")\207" [e pos item-end subtree throw exit nil] 4] sub-struct)] 3 (#$ . 23248)])
#@154 List all items in the same sub-list as ITEM.
STRUCT is the list structure.  PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(defalias 'org-list-get-all-items #[(item struct prevs) "\211\306\211\307\f
\n#\211\203\f\nB\202\310
\n#\211\203,	B\202\311\nC	\237#,\207" [item after-item before-item next-item prev-item struct nil org-list-get-prev-item org-list-get-next-item append prevs] 4 (#$ . 23656)])
#@141 List all children of ITEM, or nil.
STRUCT is the list structure.  PARENTS is the alist of parents,
as returned by `org-list-parents-alist'.
(defalias 'org-list-get-children #[(item struct parents) "\304\211\305\n\"@\211\203\236\235A	B\202	\237*\207" [child all item parents nil rassq] 3 (#$ . 24113)])
#@66 Return point at beginning of list.
STRUCT is the list structure.
(defalias 'org-list-get-top-point #[(struct) "\211@@)\207" [struct x] 2 (#$ . 24435)])
#@63 Return point at bottom of list.
STRUCT is the list structure.
(defalias 'org-list-get-bottom-point #[(struct) "\301\302\303\304\"\"\207" [struct apply max mapcar #[(e) "\302@	\"\207" [e struct org-list-get-item-end] 3]] 5 (#$ . 24595)])
#@161 Return point at beginning of sub-list ITEM belongs.
STRUCT is the list structure.  PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(defalias 'org-list-get-list-begin #[(item struct prevs) "\305\306\n\f#\211\203	\202\n*\207" [item prev-item first-item struct prevs nil org-list-get-prev-item] 4 (#$ . 24841)])
(defalias 'org-list-get-first-item 'org-list-get-list-begin)
#@161 Return point at last item of sub-list ITEM belongs.
STRUCT is the list structure.  PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(defalias 'org-list-get-last-item #[(item struct prevs) "\305\306\n\f#\211\203	\202\n*\207" [item next-item last-item struct prevs nil org-list-get-next-item] 4 (#$ . 25257)])
#@155 Return point at end of sub-list ITEM belongs.
STRUCT is the list structure.  PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(defalias 'org-list-get-list-end #[(item struct prevs) "\303\304	\n#	\"\207" [item struct prevs org-list-get-item-end org-list-get-last-item] 5 (#$ . 25610)])
#@285 Return the type of the list containing ITEM, as a symbol.

STRUCT is the list structure.  PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.

Possible types are `descriptive', `ordered' and `unordered'.  The
type is determined by the first item of the list.
(defalias 'org-list-get-list-type #[(item struct prevs) "\306	\n#\307\310	\311	\211\f	\2368-\"\203 \312\2028	\313	\211\f	\2368-\2037\314\2028\315)\207" [item struct prevs first key n org-list-get-list-begin string-match "[[:alnum:]]" 2 ordered 5 descriptive unordered] 5 (#$ . 25931)])
#@295 Return ITEM's sequence number.

STRUCT is the list structure.  PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.  PARENTS is the
alist of ancestors, as returned by `org-list-parents-alist'.

Return value is a list of integers.  Counters have an impact on
that value.
(defalias 'org-list-get-item-number #[(item struct prevs parents) "\306\211	\n#C	\307\f\n#\211\203!\f\n#
B\202
+\207" [get-relative-number item struct prevs parent out #[(item struct prevs) "\306\307\n\f\310\f\211
\f\2368-\211\204-\311\n\f#\211\203-T\202	\2046T\202_\312\313	\"\203K\314\315\306	\"\226!\316Z\\\202_\312\317	\"\203]\320\315\306	\"!\\\202_T+\207" [item counter pos seq struct key 0 nil 3 org-list-get-prev-item string-match "[A-Za-z]" string-to-char match-string 64 "[0-9]+" string-to-number n prevs] 4] org-list-get-parent parents] 5 (#$ . 26528)])
#@134 Search a string in valid contexts for lists.
Arguments SEARCH, RE, BOUND and NOERR are similar to those used
in `re-search-forward'.
(defalias 'org-list-search-generic #[(search re bound noerr) "\300\301\215\207" [exit (byte-code "`	\n\f#\204\305\306\f\307>\203\202b\210\310\"\210\311 \203\305\306`\"\210\202" [origin search re bound noerr throw exit (t nil) nil org-list-in-valid-context-p] 4)] 2 (#$ . 27437)])
#@156 Like `re-search-backward' but stop only where lists are recognized.
Arguments REGEXP, BOUND and NOERROR are similar to those used in
`re-search-backward'.
(defalias 'org-list-search-backward #[(regexp &optional bound noerror) "\303\304	\206e\n$\207" [regexp bound noerror org-list-search-generic re-search-backward] 5 (#$ . 27871)])
#@154 Like `re-search-forward' but stop only where lists are recognized.
Arguments REGEXP, BOUND and NOERROR are similar to those used in
`re-search-forward'.
(defalias 'org-list-search-forward #[(regexp &optional bound noerror) "\303\304	\206d\n$\207" [regexp bound noerror org-list-search-generic re-search-forward] 5 (#$ . 28214)])
#@162 Return BULLET with the correct number of whitespaces.
It determines the number of whitespaces to append by looking at
`org-list-two-spaces-after-bullet-regexp'.
(defalias 'org-list-bullet-string #[(bullet) "\304 \305\216	\203\306	\n\"\203\307\202\310\306\311\n\"\210\312\313\211\n\314%+\207" [save-match-data-internal org-list-two-spaces-after-bullet-regexp bullet spaces match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "  " " " "\\S-+\\([ 	]*\\)" replace-match nil 1] 6 (#$ . 28553)])
(put 'org-list-bullet-string 'byte-optimizer 'byte-compile-inline-expand)
#@317 Swap item starting at BEG-A with item starting at BEG-B in STRUCT.

Blank lines at the end of items are left in place.  Item
visibility is preserved.  Return the new structure after the
changes.

Assume BEG-A is lesser than BEG-B and that BEG-A and BEG-B belong
to the same sub-list.

This function modifies STRUCT.
(defalias 'org-list-swap-items #[(beg-A beg-B struct) "\212\306	\"\306	\"\307	\"\307	\"\nZ\fZ\n{\f{\n{\310	\"B\310	\"B\311\312\313
\"\"\311\314\313\"\"Bb\210\f|\210Qc\210\315\316	\"\210\317	\320\"\315\321@\"\210\315\322A\"\210	.
\207" [beg-A struct end-A-no-blank beg-B end-B-no-blank end-A org-list-get-item-end-before-blank org-list-get-item-end org-list-get-subtree 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] mapc #[(e) "@\211\nW\206\221	>\2038\3068	
Z\\\240\210\306\233\f
Z\\\240\210\f	U\2054\306\233\n\240)\202\221	>\203p\3068	\n\\\fZ\240\210\306\233\f\n\fZ\\\240\210\f\nU\205l\306\233\307\n
	Z#\240)\202\221	\fW\205\221\3068	
Z\\\240\210\306\233\f
Z\\\240))\207" [e pos beg-A sub-A end-e end-B-no-blank 6 + end-A-no-blank end-A end-B sub-B beg-B size-B size-A] 7] sort #[(e1 e2) "@	@W\207" [e1 e2] 2] #[(ov) "\305@A@	\nZ\\\fZ\\\3068	\nZ\\\fZ\\#\207" [ov beg-B size-B size-A beg-A move-overlay 2] 7] #[(ov) "\303@A@	\nZ\\\3048	\nZ\\#\207" [ov beg-A beg-B move-overlay 2] 6] end-B size-A size-B body-A body-B between-A-no-blank-and-B sub-A sub-B overlays] 6 (#$ . 29191)])
#@350 Return number of blank lines that should separate items in list.

POS is the position of point where `org-list-insert-item' was called.

STRUCT is the list structure.  PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.

Assume point is at item's beginning.  If the item is alone, apply
some heuristics to guess the result.
(defalias 'org-list-separating-blank-lines-number #[(pos struct prevs) "\212`\306\236A\307\310
\204\204\311\202\312=\203\"\313\202\314\f#\211\2038b\210	 \202~\315\f#\203G	 \202~\316\f\"V\203e\212b\210	 \211)\311V\203e\n\202~\212\317!b\210\320\321\316\f\"\312#)\203}\313\202~\311)-\207" [org-blank-before-new-entry count-blanks usr-blank insert-blank-p item org-empty-line-terminates-plain-lists plain-list-item nil #[nil "\212\300\301 b\302\303x\210\303y\210`\")\207" [count-lines point-at-bol " 
	\n" nil] 4] 0 t 1 org-list-get-next-item org-list-get-prev-item org-list-get-item-end-before-blank org-list-get-top-point re-search-forward "^[ 	]*$" struct prevs next-p pos] 6 (#$ . 30798)])
#@459 Insert a new list item at POS and return the new structure.
If POS is before first character after bullet of the item, the
new item will be created before the current one.

STRUCT is the list structure.  PREVS is the the alist of previous
items, as returned by `org-list-prevs-alist'.

Insert a checkbox if CHECKBOX is non-nil, and string AFTER-BULLET
after the bullet.  Cursor will be after this text once the
function ends.

This function modifies STRUCT.
(defalias 'org-list-insert-item #[(pos struct prevs &optional checkbox after-bullet) "\306	b\210\307 b\310\n\"\311\n\"\3120!\210	\313\224\2033\314 1\315\216\316\317\320\321!\"*\2033\313\224\2025\322\225X23\302454\306=\203J\306\2025\306=\203U\306\202\32345\"\203h\32345\"A\202\3245\236A\2116<\203|\325\3266\"\202~6)*7\327	8#9\n\321\n4\211:4\2368-;<\203\263;=\245\330;=\"\\\202\265;>\n\331\n4\211:4\2368-?\314 1\332\216@\203\344\316@?\"\203\344\333\202\345\334A\316\335?\"\210\336A\326\211?\321%,?B\205\377\337C2?\205%
7\205%
	b\210\f	W\203
\fS\340 |\210\341\326x\210`\342	
\"D?C\2052
C\334PED\205M
\316\343D\"\203K
\336\344\306\211D$\202M
DRF\3459T\346\"G\347>FGGG#\211HDGZI\nb\210\350;!\210FG\261\210\351\352\"\210\n;?\326C\326\nH\\\257B\353\354\"2\203\241
\nb\210\202\263
\355\n\211H\\#\356\n\357!#b\210.\207" [case-fold-search pos item struct item-end item-end-no-blank t org-list-get-item-begin org-list-get-item-end org-list-get-item-end-before-blank looking-at 4 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "[.)]" match-string 1 0 assoc default delq nil org-list-separating-blank-lines-number mod 2 ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "  " " " "\\S-+\\([ 	]*\\)" replace-match "[ ]" point-at-eol " 
	\n" delete-and-extract-region "\\`[ 	]+" "" make-string 10 + org-indent-to-column mapc #[(e) "@\3068\211W\203	V\205\252\306\233	\f\\\240\202\252
\204&	\2048\n\n\\\240\210\306\233	\n\\\240\202\252\nW\203b\n\n\\\240\210	W\203X\306\233	\n\\\240\202\252\306\233	\f\\\240\202\252\n\fW\203\235\307\n\f\310
G##\240\210	\fU\203\212\306\233\n\\\240\202\252\306\233\307	\f\310
G##\240\202\252\n\f\\\240\210\306\233	\f\\\240*\207" [e end p item size-offset beforep 6 + - split-line-p item-size pos item-end item-sep] 9] sort #[(e1 e2) "@	@W\207" [e1 e2] 2] org-list-swap-items org-list-get-next-item org-list-prevs-alist org-list-full-item-re save-match-data-internal beforep org-M-RET-may-split-line key option r split-line-p prevs blank-nb n ind indent-tabs-mode tab-width ind-size bullet org-list-two-spaces-after-bullet-regexp spaces checkbox box text-cut after-bullet body item-sep item-size size-offset] 9 (#$ . 31892)])
#@88 Remove ITEM from the list and return the new structure.

STRUCT is the list structure.
(defalias 'org-list-delete-item #[(item struct) "\305	\"\306	!\nU\203\212b\210\307\310x\210\311 Td^)\202\211\n|\210\nZ\312\310\313\314	\"\"+\207" [item struct end beg size org-list-get-item-end org-list-get-bottom-point " 
	\n" nil point-at-eol delq mapcar #[(e) "@\211\nW\2034\3068\211\nW\203\2020\nU\203'\307\310!\fC\"\2020\307\310!
ZC\")\202O	\nW\203?\311\202O	
Z\307\310A!\3068
ZC\"B)\207" [e pos item end-e beg size 6 append butlast nil end] 6]] 6 (#$ . 34775)])
#@708 Send ITEM to destination DEST.

STRUCT is the list structure.

DEST can have various values.

If DEST is a buffer position, the function will assume it points
to another item in the same list as ITEM, and will move the
latter just before the former.

If DEST is `begin' (respectively `end'), ITEM will be moved at
the beginning (respectively end) of the list it belongs to.

If DEST is a string like "N", where N is an integer, ITEM will
be moved at the Nth position in the list.

If DEST is `kill', ITEM will be deleted and its body will be
added to the kill-ring.

If DEST is `delete', ITEM will be deleted.

Visibility of item is preserved.

This function returns, destructively, the new list structure.
(defalias 'org-list-send-item #[(item dest struct) "\306!\307\n\"\310\212\nb\210\311\312\313\n\314\n\211\f\2368-!P!\210\315\225){!+,\316=\206\261,\317=\206\261,\320=\203M\321\n	#\211,\202\261,\322=\203i\323\n	#,\212\324\n	#b\210\325 )\202\261\326\327,\"\203\257\330\n	#\211-G.\331\332,!.\"/\333/!\204\231/S-8\211,\202\253\323\n	#,\212\324\n	#b\210\325 )+\202\261,0\3341\335\n\"2,\317=\203\312\336\n\"\202D
,\316=\203\335\337+!\210\336\n\"\202D
,\250\203C
\n0U\204C
\340\n!\3410	\334+%\342\n!\343\342\n!\"B\307`\"\307\342\n!\"``\nZ34567\3174\236\"\344\345\346\3477\"\"\350\"-\351\3522\"\210\336\342\n!\"\n\334\211\223\210\202D
.\207" [struct prevs item item-end key n org-list-prevs-alist org-list-get-item-end org-trim looking-at "[ 	]*" regexp-quote 2 0 kill delete begin org-list-get-list-begin end org-list-get-list-end org-list-get-last-item point-at-eol string-match "\\`[0-9]+\\'" org-list-get-all-items mod string-to-number zerop nil overlays-in org-list-delete-item kill-new copy-marker org-list-insert-item marker-position org-list-get-subtree sort append mapcar #[(e) "	\236\211@\306\n8
\\\307\310\nA!\f	U\203\n\202\"\f
\\C\"+B\207" [e struct cell pos end shift 6 append butlast old-end new-end] 6] #[(e1 e2) "@	@W\207" [e1 e2] 2] mapc #[(ov) "\302\303!`	Z\\\304!`	Z\\#\207" [ov item move-overlay overlay-start overlay-end] 6] body dest all len index ins-point org-M-RET-may-split-line visibility shift new-item old-end new-end moved-items] 8 (#$ . 35369)])
#@195 Outdent items between positions START and END.

STRUCT is the list structure.  PARENTS is the alist of items'
parents, as returned by `org-list-parents-alist'.

START is included, END excluded.
(defalias 'org-list-struct-outdent #[(start end struct parents) "\303\304\305	\n\"*\207" [acc out parents nil #[(cell) "@A	W\203\202^	\fY\2030\n\205\n
\236\211	\203+		AB\202,)\202^\n\204:\306\307!\202^\nY\203J\n	B
B\202^\310\n\n#\f\n	B
B	\f)B*\207" [cell item parent start end acc error "Cannot outdent top-level items" org-list-get-parent convert struct parents grand-parent] 5] mapcar] 3 (#$ . 37650)])
#@368 Indent items between positions START and END.

STRUCT is the list structure.  PARENTS is the alist of parents
and PREVS is the alist of previous items, returned by,
respectively, `org-list-parents-alist' and
`org-list-prevs-alist'.

START is included and END excluded.

STRUCT may be modified if `org-list-demote-modify-bullet' matches
bullets between START and END.
(defalias 'org-list-struct-indent #[(start end struct parents prevs) "\305\306\307\310\311\f\",\207" [acc set-assoc change-bullet-maybe ind parents nil #[(cell) "	B\207" [cell acc] 2] #[(item) "\306\307	\310	\211\n	\2368-!\311\312\f\"\203\313\202W\311\314\f\"\203*\315\202W\311\316\f\"\2035\317\202W\311\320\f\"\203@\321\202W\311\322\f\"\203K\323\202W\311\324\f\"\203V\325\202W\f)
\"A\211\205g\326	#)\207" [item struct key n bul org-list-demote-modify-bullet assoc org-trim 2 string-match "[A-Z]\\." "A." "[A-Z])" "A)" "[a-z]\\." "a." "[a-z])" "a)" "[0-9]\\." "1." "[0-9])" "1)" org-list-set-bullet new-bul-p] 6] #[(cell) "@A	W\203\202s	\fY\203,\n
\236\211	\203'		AB\202()\202s\306	\n#\f
	!\210\f\204K\nW\203K\307\310!\202r\f\204W!\202r\fW\203h	\fB!\202r	\f
\236AB!)*\207" [cell item parent start end acc org-list-get-prev-item error "Cannot indent the first item of a list" convert struct prevs prev change-bullet-maybe set-assoc] 5] mapcar] 3 (#$ . 38289)])
#@171 Non-nil if list starting at FIRST can have alphabetical bullets.

STRUCT is list structure.  PREVS is the alist of previous items,
as returned by `org-list-prevs-alist'.
(defalias 'org-list-use-alpha-bul-p #[(first struct prevs) "\205\301\302\215\207" [org-alphabetical-lists exit (byte-code "\306\307\203b\f\310\f\211
\f\2368-\f\311\f\211
\f\2368-\203F\312\313\"\203F\314\226!\202I\nT\n\315V\203W\316\317\307\"\210\202^\320\f#*\202+\321\207" [first case-fold-search ascii item struct key 64 nil 2 3 string-match "[a-zA-Z]" string-to-char 90 throw exit org-list-get-next-item t n count bul prevs] 4)] 2 (#$ . 39700)])
#@33 Increment BULLET if applicable.
(defalias 'org-list-inc-bullet-maybe #[(bullet) "\302\303\304	\"\203\305\306\307\310\311	\"!T!\302\211	$\2023\303\312	\"\2032\305\313\314\310\311	\"!T!\302\211	$\2023	)\207" [case-fold-search bullet nil string-match "[0-9]+" replace-match number-to-string string-to-number match-string 0 "[A-Za-z]" char-to-string string-to-char] 6 (#$ . 40372)])
#@148 Verify and correct bullets in STRUCT.
PREVS is the alist of previous items, as returned by
`org-list-prevs-alist'.

This function modifies STRUCT.
(defalias 'org-list-struct-fix-bul #[(struct prevs) "\303\304\305\306\307\n\"\"*\207" [fix-bul case-fold-search struct nil #[(item) "\306	\n#\211\205	\307	\211\f	\2368-	\310	\211\f	\2368-	\307	\211\f	\2368- ?\205J\311	\n#!\312	\203\217\203\217\313\314\"\203\217\313\314\"\203\217\313\315\"\203v\227\202\201\313\316\"\205\201\226\"\317\"\320\211$)\202r
\203\263\203\263\313\321\"\203\263\313\321\"\203\263\317\320\211$\202r
\203\314\322	\307	\211\f	\2368-!\202r
\203
\311	\n#\203
\313\323\"\203
\313\323 \"\203
\313\315 \"\203\367\227\202
\313\316 \"\205
\226\"\317\"\320\211 $)\202r
\2030
\313\321\"\2030
\313\321 \"\2030
\317\320\211 $\202r
!\203G
\313\316 \"\203G
\317\324\320\211 $\202r
!\203^
\313\315 \"\203^
\317\325\320\211 $\202r
\313\326 \"\203p
\317\327\320\211 $\202r
  \330 #\331\216$\203\214
\313$ \"\203\214
\332\202\215
\333%\313\334 \"\210\317%\320\211 \335%,#-\207" [item struct prevs prev key n org-list-get-prev-item 2 3 org-list-use-alpha-bul-p org-list-set-bullet string-match "[a-zA-Z]" "[a-z]" "[A-Z]" replace-match nil "[0-9]+" org-list-inc-bullet-maybe "[A-Za-z]" "A" "a" "\\([0-9]+\\|[A-Za-z]\\)" "1" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "  " " " "\\S-+\\([ 	]*\\)" 1 prev-bul counter bullet alphap real-count save-match-data-internal org-list-two-spaces-after-bullet-regexp spaces] 10] mapc mapcar car] 5 (#$ . 40764)])
#@274 Verify and correct indentation in STRUCT.

PARENTS is the alist of parents, as returned by
`org-list-parents-alist'.

If numeric optional argument BULLET-SIZE is set, assume all
bullets in list have this length to determine new indentation.

This function modifies STRUCT.
(defalias 'org-list-struct-fix-ind #[(struct parents &optional bullet-size) "\306!\211\307\n\211\2368-\310\f\311\f\312\313A\"\"+\207" [struct ancestor item key n top-ind org-list-get-top-point 1 #[(item) "\306	\n#\211\203<\307	\310\f\206$	\311	\211
	\2368-G	\312	\211
	\2368-\f##\202B\307	
#)\207" [item struct parents parent bullet-size key org-list-get-parent org-list-set-ind + 2 1 n org-list-indent-offset top-ind] 9] mapc mapcar car new-ind] 6 (#$ . 42461)])
#@474 Verify and correct checkboxes in STRUCT.

PARENTS is the alist of parents and PREVS is the alist of
previous items, as returned by, respectively,
`org-list-parents-alist' and `org-list-prevs-alist'.

If ORDERED is non-nil, a checkbox can only be checked when every
checkbox before it is checked too.  If there was an attempt to
break this rule, the function will return the blocking item.  In
all others cases, the return value will be nil.

This function modifies STRUCT.
(defalias 'org-list-struct-fix-box #[(struct parents prevs &optional ordered) "\306\307\"\310\311\312\313\"\210\314	\315\"\312\n	\"\210\f\205L\306\316\"\317
\235\320\235\205KGGZ\312\321\233\"\210\322\311$\2108)*+\207" [struct parent-list set-parent-box all-items ordered box-list mapcar car #[(item) "\306\307\310	\n#\"\311	\312\235\203\313\235\203\314\202J\314\235\203&\314\202J\313\235\2030\313\202J\312\235\203:\312\202J	\315	\211\f	\2368-#)\207" [item struct parents box-list key n mapcar #[(child) "	\305\n	\211	\2368-\207" [child struct item key n 4] 3] org-list-get-children org-list-set-checkbox "[ ]" "[X]" "[-]" 4] 6] nil mapc #[(e) "\306	\n#\211	\307\f	\211
	\2368-\211	\205,\n>?\205,\nB\211\n*\207" [e struct parents parent item key org-list-get-parent 4 n parent-box-p parent-list] 5] sort #[(e1 e2) "	\306\n	\211	\2368-
	\306\n	\211	\2368-V\207" [e1 struct item key n e2 1] 4] #[(e) "	\305\n	\211	\2368-\207" [e struct item key n 4] 3] "[ ]" "[X]" #[(e) "	\305\n	\211	\2368-\205\306	\307#\207" [e struct item key n 4 org-list-set-checkbox "[ ]"] 4] org-list-struct-fix-box after-unchecked index parents prevs] 5 (#$ . 43245)])
#@86 Verify and correct each item end position in STRUCT.

This function modifies STRUCT.
(defalias 'org-list-struct-fix-item-end #[(struct) "\303\211\304\305\n\"\210\306	\307\"\310\n	\"*\207" [acc-end end-list struct nil mapc #[(e) "@\211\n\306\n\211\f\n\2368-\f\307	\n\"\211
\n\236\204N\310
\311#\211\203D\n\306\n\211\f\n\2368-\312\\\202E\313
BB)\f	BB
	BB\211+\207" [e pos struct item key n 1 org-list-get-item-end assoc-default > 2 0 ind-pos end-pos acc-end item-up end-list] 5] sort #[(e1 e2) "A	AW\207" [e1 e2] 2] org-list-struct-assoc-end] 3 (#$ . 44974)])
#@290 Apply set difference between STRUCT and OLD-STRUCT to the buffer.

OLD-STRUCT is the structure before any modifications, and STRUCT
the structure to be applied.  The function will only modify parts
of the list which have changed.

Initial position of cursor is restored after the changes.
(defalias 'org-list-struct-apply-struct #[(struct old-struct) "\306 \307\310!\205\311 \312 \313\314\315\211\211\211\211\316\317\"\210\320\321\322\323\"\324\322\323\"!\"\325\"A\203y\211A@@\236\203_\236A\202i\236A\236AE
B+\202:\316\326
\"\210-b\210\315\211\223-\207" [origin inlinetask-re item-re shift-body-ind modify-item sliced-struct point-marker featurep org-inlinetask org-inlinetask-outline-regexp org-item-re #[(end beg delta) "b\210\306\307x\210\310 \210`	V\204`	U\205K\311\n!?\205K\203-\311!\203-\312 \210\202E\313\314\311\f!*\203E\315 \316\\!\210)\317y\210\202\n\207" [end beg item-re inlinetask-re regexp inhibit-changing-match-data " 
	\n" nil beginning-of-line looking-at org-inlinetask-goto-beginning "^[ 	]*\\S-" t org-get-indentation org-indent-line-to -1 i delta] 3] #[(item) "b\210	\306	\211\n	\2368-\307 	\310	\211\n	\2368-\311 \312\216\203A\313\"\203A\314\202B\315\313\316\"\210\317\320\211\306%,\310	\211\n	\2368-	\321	\211\n	\2368- \322!!\210\232\204\221\317\320\211\211\306%\210\323\324! \232\204\345\323\324!\203\261 \203\261\317 \320\211\211\324%\210\202\345\323\324!\203\306\322\325!\210\317\326\320\211\211\306%\210\202\345\310\225\211\"\203\324\"T\202\326\306\225b\210 \"?\205\341\315Pc\210)\f
U?\205\370\327 b\330\320w\210`|\210\fj-\207" [item struct key n new-ind old-ind 1 org-get-indentation 2 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "  " " " "\\S-+\\([ 	]*\\)" replace-match nil 4 looking-at match-string 3 ".*?\\([ 	]*\\[[ X-]\\]\\)" "" point-at-bol " 	" bullet save-match-data-internal org-list-two-spaces-after-bullet-regexp spaces new-bul old-struct old-bul new-box org-list-full-item-re counterp] 7] nil mapc #[(e) "@\211\n\306\n\211\f\n\2368-	\f\306\n\211\f\n\2368-
	\n\307\n\211\f\n\2368-	\f\307\n\211\f\n\2368-G\\
G\\Z\310	\f\"	BB\f\236\204\210\311\312#BB)	BB\211.\207" [e pos struct item key n 1 2 org-list-get-item-end assoc-default > ind-pos old-struct ind-old bul-pos bul-old ind-shift end-pos itm-shift acc-end item-up end-list] 5] sort append mapcar car org-uniquify < #[(e) "\306\3078!\204
\310	\"\210A@\211\236\211?\206\f\n
\236\232?\205'	\n!*\207" [e shift-body-ind beg struct cell old-struct zerop 2 apply modify-item] 4] all-ends itm-shift acc-end end-list old-struct up down struct ind] 7 (#$ . 45584)])
#@347 Correct bullets, checkboxes and indentation in list at point.

STRUCT is the list structure.  PARENTS is the alist of parents,
as returned by `org-list-parents-alist'.

When non-nil, optional argument OLD-STRUCT is the reference
structure of the list.  It should be provided whenever STRUCT
doesn't correspond anymore to the real list in buffer.
(defalias 'org-list-write-struct #[(struct parents &optional old-struct) "\206\304	!\305	\n\306#\210\307	!\210\310	!\311	\"\210\305	\n\"\210\312	\n#\210)\313	\")\207" [old-struct struct parents prevs copy-tree org-list-struct-fix-ind 2 org-list-struct-fix-item-end org-list-prevs-alist org-list-struct-fix-bul org-list-struct-fix-box org-list-struct-apply-struct] 4 (#$ . 48464)])
#@468 Call FUNCTION on each item of the list at point.
FUNCTION must be called with at least one argument: INIT-VALUE,
that will contain the value returned by the function at the
previous item, plus ARGS extra arguments.

FUNCTION is applied on items in reverse order.

As an example, (org-apply-on-list (lambda (result) (1+ result)) 0)
will return the number of items in the current list.

Sublists of the list are skipped.  Cursor is always at the
beginning of the item.
(defalias 'org-apply-on-list #[(function init-value &rest args) "\306 \307!\310\311 !\312\313\n!	#\f\314\315\237\"\210\nb\210\n\316\211\223\210
-\207" [struct prevs item all init-value value org-list-struct org-list-prevs-alist copy-marker point-at-bol org-list-get-all-items marker-position mapc #[(e) "b\210\304	\n#\211\207" [e function value args apply] 4] nil] 4 (#$ . 49206)])
#@139 Set visibility of ITEM in STRUCT to VIEW.

Possible values are: `folded', `children' or `subtree'.  See
`org-cycle' for more information.
(defalias 'org-list-set-item-visibility #[(item struct view) "\306=\203\307	\n\"\310\212	b\210\311 )\312#)\207\305=\2034\313	\n\314#\210\315\n!\316	\n\f#\317\320
\"*\207\314=\205E\321	\n\"\310	\322#)\207" [view item struct item-end parents children folded org-list-get-item-end-before-blank outline-flag-region point-at-eol t org-list-set-item-visibility subtree org-list-parents-alist org-list-get-children mapc #[(e) "\302	\303#\207" [e struct org-list-set-item-visibility folded] 4] org-list-get-item-end nil] 4 (#$ . 50073)])
#@51 Return column at which body of ITEM should start.
(defalias 'org-list-item-body-column #[(item) "\306\211\211\211\212\fb\210\307\310!\210\311\224\312\225b\210i	b\210i\211\n
\\V\203,\n\313\\),\207" [tcol tpos bcol bpos item org-description-max-indent nil looking-at "[ 	]*\\(\\S-+\\)\\(.*[ 	]+::\\)?\\([ 	]+\\|$\\)" 1 0 5] 5 (#$ . 50761)])
(defalias 'org-list-get-item-begin 'org-in-item-p)
#@77 Go to the beginning of the current item.
Throw an error when not in a list.
(defalias 'org-beginning-of-item #[nil "\301 \211\203\fb\202\302\303!)\207" [begin org-in-item-p error "Not in an item"] 3 (#$ . 51169) nil])
#@93 Go to the beginning item of the current list or sublist.
Throw an error when not in a list.
(defalias 'org-beginning-of-item-list #[nil "\303 \211\204
\304\305!\202b\210\306 \307	!\310	\n#b*)\207" [begin struct prevs org-in-item-p error "Not in an item" org-list-struct org-list-prevs-alist org-list-get-list-begin] 5 (#$ . 51398) nil])
#@82 Go to the end of the current list or sublist.
Throw an error when not in a list.
(defalias 'org-end-of-item-list #[nil "\303 \211\204
\304\305!\202b\210\306 \307	!\310	\n#b*)\207" [begin struct prevs org-in-item-p error "Not in an item" org-list-struct org-list-prevs-alist org-list-get-list-end] 5 (#$ . 51749) nil])
#@71 Go to the end of the current item.
Throw an error when not in a list.
(defalias 'org-end-of-item #[nil "\302 \211\204
\303\304!\202b\210\305 \306	\"b))\207" [begin struct org-in-item-p error "Not in an item" org-list-struct org-list-get-item-end] 4 (#$ . 52081) nil])
#@171 Move to the beginning of the previous item.
Throw an error when not in a list.  Also throw an error when at
first item, unless `org-list-use-circular-motion' is non-nil.
(defalias 'org-previous-item #[nil "\305 \211\204
\306\307!\2027b\210\310 \311	!\312	\n#\211\203&b\2026\f\2033\313	\n#b\2026\306\314!+)\207" [item struct prevs prevp org-list-use-circular-motion org-in-item-p error "Not in an item" org-list-struct org-list-prevs-alist org-list-get-prev-item org-list-get-last-item "On first item"] 5 (#$ . 52363) nil])
#@166 Move to the beginning of the next item.
Throw an error when not in a list.  Also throw an error when at
last item, unless `org-list-use-circular-motion' is non-nil.
(defalias 'org-next-item #[nil "\305 \211\204
\306\307!\2027b\210\310 \311	!\312	\n#\211\203&b\2026\f\2033\313	\n#b\2026\306\314!+)\207" [item struct prevs prevp org-list-use-circular-motion org-in-item-p error "Not in an item" org-list-struct org-list-prevs-alist org-list-get-next-item org-list-get-first-item "On last item"] 5 (#$ . 52907) nil])
#@169 Move the item at point down, i.e. swap with following item.
Sub-items (items with larger indentation) are considered part of
the item, so this really moves item trees.
(defalias 'org-move-item-down #[nil "\306 \204	\307\310!\210i\311 \312 \313\n!\314\311 \n#\211\204(
\204(\307\315!\210\f\2045\316	\317\n#\202D\320	\f\n#\314	\n\313\n!#b\210\321\n\322\n!\"\210\323!-\207" [col item struct prevs next-item org-list-use-circular-motion org-at-item-p error "Not at an item" point-at-bol org-list-struct org-list-prevs-alist org-list-get-next-item "Cannot move this item further down" org-list-send-item begin org-list-swap-items org-list-write-struct org-list-parents-alist org-move-to-column] 6 (#$ . 53442) nil])
#@166 Move the item at point up, i.e. swap with previous item.
Sub-items (items with larger indentation) are considered part of
the item, so this really moves item trees.
(defalias 'org-move-item-up #[nil "\306 \204	\307\310!\210i\311 \312 \313\n!\314\311 \n#\211\204(
\204(\307\315!\210\f\2045\316	\317\n#\202;\320\f	\n#\321\n\322\n!\"\210\323!-\207" [col item struct prevs prev-item org-list-use-circular-motion org-at-item-p error "Not at an item" point-at-bol org-list-struct org-list-prevs-alist org-list-get-prev-item "Cannot move this item further up" org-list-send-item end org-list-swap-items org-list-write-struct org-list-parents-alist org-move-to-column] 5 (#$ . 54174) nil])
#@300 Insert a new item at the current level.
If cursor is before first character after bullet of the item, the
new item will be created before the current one.

If CHECKBOX is non-nil, add a checkbox next to the bullet.

Return t when things worked, nil when we are not in an item, or
item is invisible.
(defalias 'org-insert-item #[(&optional checkbox) "\306 `\211?\206\212	b\210\307 )?\205}\212	b\210\310 )\203&\311 \210\312\202}\212	b\210\313 )\314\n!\315	\n#\316=\205A\317\320!\321P\322\n
\f%\323\n\324\n!\"\210
\203X\325 \210\326!\210\327\224\203w\330  \331\216\332\333\334\335!\"*\203w\327\224\202y\336\225b\210+\312*\207" [pos itemp struct prevs desc checkbox org-in-item-p outline-invisible-p org-at-item-timer-p org-timer-item t org-list-struct org-list-prevs-alist org-list-get-list-type descriptive read-string "Term: " " :: " org-list-insert-item org-list-write-struct org-list-parents-alist org-update-checkbox-count-maybe looking-at 4 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "[.)]" match-string 1 0 org-list-full-item-re save-match-data-internal] 7 (#$ . 54877)])
#@63 Fix indentation, bullets and checkboxes is the list at point.
(defalias 'org-list-repair #[nil "\302 \204	\303\304!\210\305 \306!\307	\"*\207" [struct parents org-at-item-p error "This is not a list" org-list-struct org-list-parents-alist org-list-write-struct] 3 (#$ . 56048) nil])
#@311 Cycle through the different itemize/enumerate bullets.
This cycle the entire list level through the sequence:

   `-'  ->  `+'  ->  `*'  ->  `1.'  ->  `1)'

If WHICH is a valid string, use that as the new bullet.  If WHICH
is an integer, 0 means `-', 1 means `+' etc.  If WHICH is
`previous', cycle backwards.
(defalias 'org-cycle-list-bullet #[(&optional which) "\306 \204	\307\310!\210\212\311 \210\312 \313!\314!\315`\n#\211\316\f\2119
\2368-:\317\n#;\320<\321\322:\"\203G\323\202\207\321\324:\"\203S\325\202\207\321\326:\"\203_\327\202\207\321\330:\"\203k\331\202\207\321\332:\"\203w\333\202\207\321\334:\"\203\203\335\202\207\336:!=\337\340\341\342!?\205\223\343>\344=\206\234\345 ?\205\241\346>\347=\206\252\345 ?\205\257\350;?\206\276>\344=\206\276\345 ?\205\303\351;?\206\322>\347=\206\322\345 ?\205\327\352&\211?G\211@=?\235GZA\353BC?\235\203\371C\202
C\247\203
BC!\202
C\354=\203
BAS!\202
BAT!D\355!E\356D:\357 F\360\216G\203C
\321G:\"\203C
\361\202D
\362H\321\363:\"\210\364H\320\211:\365%,#\210\366\n\"\210\367	\"\210\370E\".\207" [struct parents prevs list-beg item key org-at-item-p error "Not at an item" beginning-of-line org-list-struct org-list-parents-alist org-list-prevs-alist org-list-get-first-item 2 org-list-use-alpha-bul-p nil string-match "[a-z]\\." "a." "[a-z])" "a)" "[A-Z]\\." "A." "[A-Z])" "A)" "\\." "1." ")" "1)" org-trim append ("-" "+") looking-at "\\S-" ("*") 41 org-at-item-description-p ("1.") 46 ("1)") ("a." "A.") ("a)" "A)") #[(index) "\303	\"\n8\207" [index len bullet-list mod] 3] previous copy-tree org-list-set-bullet match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "  " " " "\\S-+\\([ 	]*\\)" replace-match 1 org-list-struct-fix-bul org-list-struct-fix-ind org-list-struct-apply-struct n bullet alpha-p case-fold-search current org-plain-list-ordered-item-terminator bullet-list len item-index get-value which new old-struct save-match-data-internal org-list-two-spaces-after-bullet-regexp spaces] 10 (#$ . 56343) "P"])
#@468 Toggle the checkbox in the current line.
With prefix arg TOGGLE-PRESENCE, add or remove checkboxes.  With
double prefix, set checkbox to [-].

When there is an active region, toggle status or presence of the
first checkbox there, and make every item inside have the same
status or presence, respectively.

If the cursor is in a headline, apply this to all checkbox items
in the text below the heading, taking as reference the first item
in subtree, ignoring drawers.
(defalias 'org-toggle-checkbox #[(&optional toggle-presence) "\212\306\211\306\211\307\310\311\f\312#\313Q\314@\312A\312B\312C\315\316\260\nD\317\306\320\"E\321 \203W\322 F\323 b\210\324\325\326 PF\327#\203I\330 \202M\331\332!\210\333F!\211)\202\301\334 \203\253\212\335 \210`)F\336y\210\337
!\204t\337D!\203\213\337D!\203\201\336y\210\202g\340\341F\306#\210\202g\324\325\326 PF\327#\203\235\330 \202\241\331\342!\210\333F!\211)\202\301\343 \203\276\327\330 \333\344 !\211\202\301\331\345!G\nb\210\346 \205\316\347\336!HI\350\232\203\333\351\202\370I\352\232\203\354H?\205\370\353\202\370H\354\232\203\367\353\202\370\354)J\nb\210`W\203\263
\324\325\326 P\355#\203\263
\356 K\357K!L\360K!M\361K!N\333\362K!!O\363\364\365\366K\"\"P\367\370P\"\210\371KMNE$\203y
	\203y
\n	V\203y
\331\372	Q\212Q\203e
Qb\210n\203m
\336\202n
\373\374\336`\"\\*\"\210\202\235
	\203\235
\375\376	Q\212Q\203\214
Qb\210n\203\224
\336\202\225
\373\374\336`\"\\*\"\210Ob\210O\306\211\223\210\377KL\"\210.\202\376\306\211\223\210.\n\201R \207" [singlep block-item lim-up lim-down org-drawers drawer-re nil "^[ 	]*:\\(" mapconcat regexp-quote "\\|" "\\):[ 	]*$" "^[ 	]*\\<\\(" "\\)" " *[[<]\\([^]>]+\\)[]>]" org-entry-get "ORDERED" org-region-active-p region-end region-beginning org-list-search-forward "^" org-item-re t point-at-bol error "No item in region" copy-marker org-at-heading-p outline-next-heading 1 looking-at re-search-forward "^[ 	]*:END:" "No item in subtree" org-at-item-p point-at-eol "Not at an item or heading, and no active region" org-at-item-checkbox-p match-string (16) "[-]" (4) "[ ]" "[X]" move org-list-struct copy-tree org-list-parents-alist org-list-prevs-alist org-list-get-bottom-point org-remove-if #[(e) "	W\206	\nV\207" [e lim-up lim-down] 2] mapcar car mapc #[(e) "\306		\307\n	\211	\2368-\211\204	\310\232\203$\n\202%
)#\207" [e struct item key n cur-box org-list-set-checkbox 4 (4) toggle-presence ref-checkbox] 7] org-list-struct-fix-box "Checkbox blocked because of unchecked box at line %d" 0 count-lines message "Checkboxes were removed due to unchecked box at line %d" org-list-struct-apply-struct org-scheduled-string org-deadline-string org-closed-string org-clock-string keyword-re orderedp limit bounds cbox toggle-presence ref-checkbox struct struct-copy parents prevs bottom items-to-toggle pos org-update-checkbox-count-maybe] 11 (#$ . 58468) "P"])
#@43 Reset all checkboxes in an entry subtree.
(defalias 'org-reset-checkbox-state-subtree #[nil "\301 \203	\302\303!\207\214\212\304 \210\305 \210eb\210d`W\2030\306 \203)\307\310\311\211\312\313%\210\314\315!\210\202)\316\317!*\207" [end org-before-first-heading-p error "Not inside a tree" org-narrow-to-subtree org-show-subtree org-at-item-checkbox-p replace-match "[ ]" t nil 1 beginning-of-line 2 org-update-checkbox-count-maybe all] 6 (#$ . 61420) "*"])
#@223 Update the checkbox statistics in the current section.
This will find all statistic cookies like [57%] and [6/12] and
update them with the current numbers.

With optional prefix argument ALL, do this for the whole buffer.
(defalias 'org-update-checkbox-count #[(&optional all) "\212\306\307?\206\310\311\312\313\314\"\206\315\"	\203edB\202,\313\316\317\217\206%e\212\320 \210`)B\321\322\313\211\211@b\210\323A\324#\203V\325\326\215\210\202D\327\330\f\".\n\207" [org-hierarchical-checkbox-statistics all box-num structs-bak cookies-list backup-end "\\(\\(\\[[0-9]*%\\]\\)\\|\\(\\[[0-9]*/[0-9]*\\]\\)\\)" "^[ 	]*\\([-+*]\\|\\([0-9]+\\|[A-Za-z]\\)[.)]\\)[ 	]+\\(?:\\[@\\(?:start:\\)?\\([0-9]+\\|[A-Za-z]\\)\\][ 	]*\\)?\\(\\[[- X]\\]\\)" string-match "\\<recursive\\>" org-entry-get nil "COOKIE_DATA" #1="" (byte-code "\300\301!\210`\207" [org-back-to-heading t] 2) ((error)) outline-next-heading #[(item structs recursivep) "\303\211\304\305\n\"\210	*B\207" [c-all c-on structs 0 mapc #[(s) "\306!\307!\203\f\203\310\f\"\2025\203\"\311\312\"\2025\f\203.\313\f\n#\2025\314\315!	#\316\317\311\320
\"\"\211G\\\321\322\"\\\211,\207" [s pre par recursivep item items org-list-prevs-alist org-list-parents-alist org-list-get-subtree mapcar car org-list-get-children org-list-get-all-items org-list-get-top-point delq nil #[(e) "	\306\n\211\f\n\2368-\207" [e s struct item key n 4] 3] org-count "[X]" cookies c-all c-on] 6]] 3] 1 re-search-forward t skip (byte-code "\212\306\224\306\225\307\310!\311 \203#\312\313\314\315\316\"\206\317\227\"\203#\320\321\315\"\202\246\311 \203;\212\322 \210`)X\203;	\315\n#\202\246\311 \203m\212\322 \210`)\315\323\f\324#\203e\325 \326
!
\nBb\210*\202I	\315\n#\202\246\327 \203\211\330 W\203\211\310\331 8\204\211	\330 \n#\202\246\327 \203\242\325 \326
!
C)	\330 \n#\202\246\320\321\315\"FB)\315\207" [backup-end count-boxes structs-bak recursivep box-re struct 1 match-string 2 org-at-heading-p string-match "\\<todo\\>" org-entry-get nil "COOKIE_DATA" #1# throw skip outline-next-heading org-list-search-forward move org-list-struct org-list-get-bottom-point org-at-item-p point-at-bol org-list-context bottom cookies-list] 8) mapc #[(cookie) "@A@\3068\3078@\3078A\203&\310\311\f\312_\313
]\245\"\202+\310\314\f
#	b\210c\210``\n	Z\\|\210\205C\315 .\207" [cookie beg end percentp checked total 2 3 format "[%d%%]" 100 1 "[%d/%d]" org-fix-tags-on-the-fly new org-auto-align-tags] 5] count-boxes bounds recursivep box-re cookie-re] 9 (#$ . 61889) "P"])
#@140 Select the face for checkbox statistics.
The face will be `org-done' when all relevant boxes are checked.
Otherwise it will be `org-todo'.
(defalias 'org-get-checkbox-statistics-face #[nil "\300\225\203\301\300!\302\232\203\303\207\304\207\305\225\305\224V\203%\301\305!\301\306!\232\203%\303\207\304\207" [1 match-string "100%" org-checkbox-statistics-done org-checkbox-statistics-todo 2 3] 3 (#$ . 64508)])
#@119 Update checkbox statistics unless turned off by user.
With an optional argument ALL, update them in the whole buffer.
(defalias 'org-update-checkbox-count-maybe #[(&optional all) "\302\236A\203\303	!\210\304\305!\207" [org-list-automatic-rules all checkbox org-update-checkbox-count run-hooks org-checkbox-statistics-hook] 2 (#$ . 64930)])
(defvar org-last-indent-begin-marker (make-marker))
(defvar org-last-indent-end-marker (make-marker))
#@322 Indent a local list item including its children.
When number ARG is a negative, item will be outdented, otherwise
it will be indented.

If a region is active, all items inside will be moved.

If NO-SUBTREE is non-nil, only indent the item itself, not its
children.

STRUCT is the list structure.

Return t if successful.
(defalias 'org-list-indent-item-generic #[(arg no-subtree struct) "\212\306 \211\205\n\307 \205\310 \311!\312!\313!4?\205?\f\314 U\205?\3155\236A\205?6\203>\316\317!\202?\32078\321>\203O9\322>\204\211\203b:	\323\223\210;\n\323\223\210\202\211:\314 \323\223\210;7\203v\324!\202\2066\203\201\314 T\202\206\325\314 \"\323\223\210\326:!<\326;!=7\203L
\327 >?\330W\203\253>[\202\255>@<A\331AB\211CB\2368-D\332!ED@\\\330W\203\335\316\333!\210\202H
D@\\\330U\2037
\334\335<A\336AB\211CB\2368-\"\2037
\337<\340F\341 G\342\216H\203\"
\334HF\"\203\"
\343\202#
\344I\334\345F\"\210\346I\323\211F\331%,#\210\347\350\"\210\3514\"\210\352E\"\210,\202\252
?\330W\203\202
6\203d
\204d
\353<\"\204{
\354\355\356\"!\211J@@)K\353K\")\203\202
\316\357!\210\202\252
?\330W\203\224
\360<=
$\202\236
\361<=
4%L\362L\"\210)\363 \210.\n\320\207" [regionp rbeg rend struct top parents org-region-active-p region-beginning region-end org-list-get-top-point org-list-parents-alist org-list-prevs-alist point-at-bol indent error "First item of list cannot move without its subtree" t (org-shiftmetaright org-shiftmetaleft) (org-shiftmetaright org-shiftmetaleft) nil org-list-get-bottom-point org-list-get-item-end marker-position org-level-increment 0 1 copy-tree "Cannot outdent beyond margin" string-match "*" 2 org-list-set-bullet "-" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "  " " " "\\S-+\\([ 	]*\\)" replace-match mapc #[(e) "@	\306\n	\211	\2368-\307@	
\\#)\207" [e struct item key n ind 1 org-list-set-ind offset] 5] org-list-struct-fix-bul org-list-struct-apply-struct org-list-has-child-p reverse org-remove-if #[(e) "@	Y\207" [e end] 2] "Cannot outdent an item without its children" org-list-struct-outdent org-list-struct-indent org-list-write-struct org-update-checkbox-count-maybe prevs org-list-automatic-rules no-subtree specialp last-command this-command org-last-indent-begin-marker org-last-indent-end-marker beg end level-skip arg offset item key n top-ind old-struct bullet save-match-data-internal org-list-two-spaces-after-bullet-regexp spaces x last-item new-parents] 10 (#$ . 65382)])
#@105 Outdent a local list item, but not its children.
If a region is active, all items inside will be moved.
(defalias 'org-outdent-item #[nil "\302 \303 \204\2032\212\304 b\210\303 )\2032\204 \305 \202(\212\304 b\210\305 )\306\307\310	#)\202?\203<\311\312!\202?\311\313!)\207" [regionp struct org-region-active-p org-at-item-p region-beginning org-list-struct org-list-indent-item-generic -1 t error "Region not starting at an item" "Not at an item"] 4 (#$ . 67979) nil])
#@104 Indent a local list item, but not its children.
If a region is active, all items inside will be moved.
(defalias 'org-indent-item #[nil "\302 \303 \204\2032\212\304 b\210\303 )\2032\204 \305 \202(\212\304 b\210\305 )\306\307\310	#)\202?\203<\311\312!\202?\311\313!)\207" [regionp struct org-region-active-p org-at-item-p region-beginning org-list-struct org-list-indent-item-generic 1 t error "Region not starting at an item" "Not at an item"] 4 (#$ . 68468) nil])
#@106 Outdent a local list item including its children.
If a region is active, all items inside will be moved.
(defalias 'org-outdent-item-tree #[nil "\302 \303 \204\2032\212\304 b\210\303 )\2032\204 \305 \202(\212\304 b\210\305 )\306\307\310	#)\202?\203<\311\312!\202?\311\313!)\207" [regionp struct org-region-active-p org-at-item-p region-beginning org-list-struct org-list-indent-item-generic -1 nil error "Region not starting at an item" "Not at an item"] 4 (#$ . 68954) nil])
#@105 Indent a local list item including its children.
If a region is active, all items inside will be moved.
(defalias 'org-indent-item-tree #[nil "\302 \303 \204\2032\212\304 b\210\303 )\2032\204 \305 \202(\212\304 b\210\305 )\306\307\310	#)\202?\203<\311\312!\202?\311\313!)\207" [regionp struct org-region-active-p org-at-item-p region-beginning org-list-struct org-list-indent-item-generic 1 nil error "Region not starting at an item" "Not at an item"] 4 (#$ . 69451) nil])
#@271 Cycle levels of indentation of an empty item.
The first run indents the item, if applicable.  Subsequent runs
outdent it at meaningful levels in the list.  When done, item is
put back at its original position with its original bullet.

Return t at each successful move.
(defalias 'org-cycle-item-indentation #[nil "\306 \205\237\307\310 \311 	\312\n	\211	\2368-\313\311 \314 {!!\"\315=\204L\212\316 \210\317#!)\205\236\320\225\212\321\311 	\"b\210\322\307x\210`)Y\205\236\315$\"\315=\203\205\307\323\324\217\204\235
%@U\203l\307\325\326\217\204\235\311 \314 |\210\327%@!\210%A\330\261\210\331$\202\235
!B%\307\332\333\217\204\235\307\334\335\217\204\235\336\337!\210\340,\207" [org-adapt-indentation struct item key n ind org-at-item-p nil org-list-struct point-at-bol 1 org-trim point-at-eol org-cycle-item-indentation beginning-of-line looking-at 0 org-list-get-item-end " 
	\n" (org-list-indent-item-generic -1 t struct) ((error)) (org-list-indent-item-generic 1 t struct) ((error)) org-indent-to-column " " identity (org-list-indent-item-generic 1 t struct) ((error)) (org-list-indent-item-generic -1 t struct) ((error)) error "Cannot move item" t bullet last-command org-list-full-item-re this-command org-tab-ind-state] 4 (#$ . 69945)])
#@1206 Sort list items.
The cursor may be at any item of the list that should be sorted.
Sublists are not sorted.  Checkboxes, if any, are ignored.

Sorting can be alphabetically, numerically, by date/time as given
by a time stamp, by a property or by priority.

Comparing entries ignores case by default.  However, with an
optional argument WITH-CASE, the sorting considers case as well.

The command prompts for the sorting type unless it has been given
to the function through the SORTING-TYPE argument, which needs to
be a character, (?n ?N ?a ?A ?t ?T ?f ?F).  Here is the precise
meaning of each character:

n   Numerically, by converting the beginning of the item to a number.
a   Alphabetically.  Only the first line of item is checked.
t   By date/time, either the first active time stamp in the entry, if
    any, or by the first inactive one.  In a timer list, sort the timers.

Capital letters will reverse the sort order.

If the SORTING-TYPE is ?f or ?F, then GETKEY-FUNC specifies
a function to be called with point at the beginning of the
record.  It must return either a string or a number that should
serve as the sorting key for that record.  It will then use
COMPARE-FUNC to compare entries.
(defalias 'org-sort-list #[(&optional with-case sorting-type getkey-func compare-func) "\203\306\202	\307\310 \311\n!\312\313 \n#\314\313 \n#\315\316!\210\317 \211%\227\320U\205:\321\322\323&\324\325\326\211&!'\315\327!\210\214\f
}\210eb\210%\227(\326)\330 *(\331U\203_\332\202s(\320U\203k+\202s(\333U\205s\334,\335-\336.\337/\340(%U?-./\326,&\210\341 \210\342\343!\210\315\344!.\207" [with-case case-func struct prevs start end identity downcase org-list-struct org-list-prevs-alist org-list-get-list-begin point-at-bol org-list-get-list-end message "Sort plain list: [a]lpha  [n]umeric  [t]ime  [f]unc   A/N/T/F means reversed:" read-char-exclusive 102 intern org-icompleting-read "Sort using function: " fboundp t nil "Sorting items..." current-time 97 string< 116 < #[nil "\300\301w\210\302 \207" [" 
	\n" nil beginning-of-line] 2] #[nil "\301`\"b\207" [struct org-list-get-item-end-before-blank] 3] #[nil "\306\307!\205w\310U\203\311\312\225\313 {!\207\314U\203\"	\312\225\313 {!\207\315U\203O\316 \2033\317\320\321!!\207\322\n\313 \323#\204E\322\313 \323#\203K\324\320\312!!\207\325\f!\207\326U\203r
\203m
 \211;\203i	!\202k)\207\327\330
\"\207\327\331\"\207" [dcst case-func org-ts-regexp org-ts-regexp-both now getkey-func looking-at "[ 	]*[-+*0-9.)]+\\([ 	]+\\[[- X]\\]\\)?[ 	]+" 110 string-to-number 0 point-at-eol 97 116 org-at-item-timer-p org-timer-hms-to-secs match-string 1 re-search-forward t org-time-string-to-seconds org-float-time 102 error "Invalid key function `%s'" "Invalid sorting type `%c'" value sorting-type] 5] sort-subr org-list-repair run-hooks org-after-sorting-entries-or-items-hook "Sorting items...done" sorting-type obarray getkey-func dcst case-fold-search now compare-func sort-func next-record end-record value-to-sort] 9 (#$ . 71228) "P"])
#@648 Parse the list at point and maybe DELETE it.

Return a list whose car is a symbol of list type, among
`ordered', `unordered' and `descriptive'.  Then, each item is
a list whose car is counter, and cdr are strings and other
sub-lists.  Inside strings, check-boxes are replaced by
"[CBON]", "[CBOFF]" and "[CBTRANS]".

For example, the following list:

1. first item
   + sub-item one
   + [X] sub-item two
   more text in first item
2. [@3] last item

will be parsed as:

(ordered
  (nil "first item"
  (unordered
    (nil "sub-item one")
    (nil "[CBON] sub-item two"))
  "more text in first item")
  (3 "last item"))

Point is left at list end.
(defalias 'org-list-parse-list #[(&optional delete) "\306 \307!\310!\311!\312!\313\211\314\315\316\317	#!b\210\203G\f|\210\320\321!\204G\320!\203G\322\323!\210
.\n\207" [struct prevs parents top bottom out org-list-struct org-list-prevs-alist org-list-parents-alist org-list-get-top-point org-list-get-bottom-point nil #[(beg end) "\304	{!\305\306\n\"\2031\307\310\311\n\"\211\312\232\203\313\202(\314\232\203'\315\202(\316)\317\320\n\311%\2022\n)\207" [beg end text box org-trim string-match "\\`\\[\\([-X ]\\)\\]" replace-match match-string 1 " " "CBOFF" "-" "CBTRANS" "CBON" t nil] 7] #[(e) "\304@	\n#\305\"B\207" [e struct prevs parse-item org-list-get-list-type mapcar] 4] #[(e) "\212b\210\306\307!\210\310\225)	\311\n	\211	\2368-\211\204$\312\202D\313\314
\"\2037\315\316\310
\"\226!\317Z\202D\313\320
\"\205D\321\316\310
\"!)\322	\"\323	\"\203\314\324	#\"C\203\302@\325	 #!\326!!@\"\323\"	\"#$!!B\"\235A\211@\206\246#U\204\276#@\206\270\"B,\202l\237*B\202\326\"D,\207" [e struct item key n c looking-at "[ 	]*\\S-+\\([ 	]+\\[@\\(start:\\)?\\([0-9]+\\|[a-zA-Z]\\)\\]\\)?[ 	]*" 0 3 nil string-match "[A-Za-z]" string-to-char match-string 64 "[0-9]+" string-to-number org-list-has-child-p org-list-get-item-end org-list-get-children org-list-get-all-items last end childp counter start parents children get-text body first prevs sub last-c last-end parse-sublist] 7] org-list-get-all-items looking-at "[ 	]*$" replace-match "" parse-item get-text parse-sublist delete org-list-end-re] 6 (#$ . 74287)])
#@49 Convert the plain list at point into a subtree.
(defalias 'org-list-make-subtree #[nil "\301\302\303\217\204\304\305!\207\212\306\307!)\310!c)\207" [list nil (byte-code "\300 b\207" [org-in-item-p] 1) ((error)) error "Not in a list" org-list-parse-list t org-list-to-subtree] 3 (#$ . 76589) nil])
#@63 Insert a radio list template appropriate for this major mode.
(defalias 'org-list-insert-radio-list #[nil "	\236\211A@\306\211\n\204\307\310\"\210\311\312!\313\314\"\203*\315\f\316\211$\202n\2041\317c\210`c\210
b,\207" [major-mode org-list-radio-list-templates e txt name pos nil error "No radio list setup defined for %s" read-string "List name: " string-match "%n" replace-match t "\n"] 6 (#$ . 76896) nil])
#@148 Send a transformed version of this list to the receiver position.
With argument MAYBE, fail quietly if no transformation is defined
for this list.
(defalias 'org-list-send-list #[(&optional maybe) "\300\301\215\207" [exit (byte-code "\306 \204	\307\310!\210\212\311\312\313\314#\210\315\316!\204&\203\"\317\320\313\"\210\202&\307\321!\210)\322\323!\324\322\325!!\212\326\327\313\314#\210\330\224)\311\312\313\314#\210\326\331\332 P\314#\210\330\224\214\f}\210\333 )\313\211()\334\n!\204h\307\335\n\"\210\n
!)\212eb\210\326\336	\337Q\313\314#\204\200\307\340!\210\330\224b\210\341\325!\210`(\326\342	P\313\314#\204\231\307\343!\210(\344 |\210(b\210)\345\261\210*\346\347!.\207" [maybe name transform bottom-point top-point list org-at-item-p error "Not at a list item" re-search-backward "#\\+ORGLST" nil t looking-at "[ 	]*#\\+ORGLST[: 	][ 	]*SEND[ 	]+\\([^ 	
\n]+\\)[ 	]+\\([^ 	
\n]+\\)\\([ 	]+.*\\)?" throw exit "Don't know how to transform this list" match-string 1 intern 2 re-search-forward "\\(\\\\end{comment}\\|@end ignore\\|-->\\)" 0 "^" org-item-re org-list-parse-list fboundp "No such transformation function %s" "BEGIN RECEIVE ORGLST +" "\\([ 	]\\|$\\)" "Don't know where to insert translated list" beginning-of-line "END RECEIVE ORGLST +" "Cannot find end of insertion region" point-at-bol "\n" message "List converted and installed at receiver location" beg txt] 5)] 2 (#$ . 77331) nil])
#@34 Trim line breaks in a list ITEM.
(defalias 'org-list-item-trim-br #[(item) "\301\302\303#\211\207" [item replace-regexp-in-string "\n +" " "] 4 (#$ . 78763)])
(put 'org-list-item-trim-br 'byte-optimizer 'byte-compile-inline-expand)
#@1467 Convert a LIST parsed through `org-list-parse-list' to other formats.
Valid parameters PARAMS are:

:ustart	    String to start an unordered list
:uend	    String to end an unordered list

:ostart	    String to start an ordered list
:oend	    String to end an ordered list

:dstart	    String to start a descriptive list
:dend	    String to end a descriptive list
:dtstart    String to start a descriptive term
:dtend	    String to end a descriptive term
:ddstart    String to start a description
:ddend	    String to end a description

:splice	    When set to t, return only list body lines, don't wrap
	    them into :[u/o]start and :[u/o]end.  Default is nil.

:istart	    String to start a list item.
:icount     String to start an item with a counter.
:iend	    String to end a list item
:isep	    String to separate items
:lsep	    String to separate sublists
:csep	    String to separate text from a sub-list

:cboff      String to insert for an unchecked check-box
:cbon       String to insert for a checked check-box
:cbtrans    String to insert for a check-box in transitional state

:nobr       Non-nil means remove line breaks in lists items.

Alternatively, each parameter can also be a form returning
a string.  These sexp can use keywords `counter' and `depth',
representing respectively counter associated to the current
item, and depth of the current sub-list, starting at 0.
Obviously, `counter' is only available for parameters applying to
items.
(defalias 'org-list-to-generic #[(list params) "\306	\307\"\306	\310\"\306	\311\"\306	\312\"\306	\313\"!\306	\314\"\"\306	\315\"#\306	\316\"$\306	\317\"%\306	\320\"&\306	\321\"'\306	\322\"(\306	\323\")\306	\324\"*\306	\325\"+\306	\326\",\306	\327\"-\306	\330\".\306	\331\"/\306	\332\"0\306	\333\"1\3342\3353\336\21124\337\"\340P.\207" [params p splicep ostart oend ustart plist-get :splice :ostart :oend :ustart :uend :dstart :dend :dtstart :dtend :ddstart :ddend :istart :icount :iend :isep :lsep :csep :cbon :cboff :cbtrans :nobr nil #[(item type depth) "\211A@\n\306=\203*\307!\310\311\f\"\203 \312\313\314\211\f$\206!)\315\307
!Q\202B	\203=\n\316=\203=\307!!\315P\202B\307!\315P\307\"!P#@$\310\317$\"\203b\312%\314\211$$$\202\211\310\320$\"\203w\312&\314\211$$$\202\211\310\321$\"\203\211\312'\314\211$$$(\203\233$\322\323\324#\211)$\n\306=\203\351\310\325$\"\211)\203\275\326 *\327\216\330\331\332$\"!*\202\276\333+)\203\320\330$\334\225\335O!\202\322$,\307-!+\307.!\307/!,\260$+$\240\210\336#\337\340\3070!\206\374\313#\"+\207" [item counter type istart s ddend descriptive eval string-match "[ 	\n
]+\\'" replace-match #1="" t "%s" ordered "\\[CBON\\]" "\\[CBOFF\\]" "\\[CBTRANS\\]" replace-regexp-in-string "\n +" " " "^\\(.*\\)[ 	]+::" match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) org-trim match-string 1 "???" 0 nil format mapconcat #[(e) ";\203\207	\nT\"\207" [e export-sublist depth] 3] icount iend fmt first cbon cboff cbtrans nobr complete save-match-data-internal term desc dtstart dtend ddstart csep] 8] #[(sub depth) "@A\203\306\202<	\307=\203\310\f!\306\310
!Q\202<	\311=\2032\310!\306\310!Q\202<\310!\306\310!Q\310!P\312\313\314\n\310!\206Q\315#\"+\207" [sub type items splicep ostart oend "%s" ordered eval descriptive format mapconcat #[(e) "	\n#\207" [export-item e type depth] 4] #1# dstart dend ustart uend lsep fmt isep] 7] 0 "\n" uend dstart dend dtstart dtend ddstart ddend istart icount iend isep lsep csep cbon cboff cbtrans nobr export-sublist export-item list] 4 (#$ . 79005) nil])
#@160 Convert LIST into a LaTeX list.
LIST is as returned by `org-list-parse-list'.  PARAMS is a property list
with overruling parameters for `org-list-to-generic'.
(defalias 'org-list-to-latex #[(list &optional params) "\302\303\304	\"\"\207" [list params org-list-to-generic org-combine-plists (:splice nil :ostart "\\begin{enumerate}\n" :oend "\\end{enumerate}" :ustart "\\begin{itemize}\n" :uend "\\end{itemize}" :dstart "\\begin{description}\n" :dend "\\end{description}" :dtstart "[" :dtend "] " :istart "\\item " :iend "\n" :icount (let ((enum (nth depth '("i" "ii" "iii" "iv")))) (if enum (format "\\setcounter{enum%s}{%s}\n\\item " enum (1- counter)) "\\item ")) :csep "\n" :cbon "\\texttt{[X]}" :cboff "\\texttt{[ ]}" :cbtrans "\\texttt{[-]}")] 5 (#$ . 82678)])
#@159 Convert LIST into a HTML list.
LIST is as returned by `org-list-parse-list'.  PARAMS is a property list
with overruling parameters for `org-list-to-generic'.
(defalias 'org-list-to-html #[(list &optional params) "\302\303\304	\"\"\207" [list params org-list-to-generic org-combine-plists (:splice nil :ostart "<ol>\n" :oend "\n</ol>" :ustart "<ul>\n" :uend "\n</ul>" :dstart "<dl>\n" :dend "\n</dl>" :dtstart "<dt>" :dtend "</dt>\n" :ddstart "<dd>" :ddend "</dd>" :istart "<li>" :iend "</li>" :icount (format "<li value=\"%s\">" counter) :isep "\n" :lsep "\n" :csep "\n" :cbon "<code>[X]</code>" :cboff "<code>[ ]</code>" :cbtrans "<code>[-]</code>")] 5 (#$ . 83452)])
#@162 Convert LIST into a Texinfo list.
LIST is as returned by `org-list-parse-list'.  PARAMS is a property list
with overruling parameters for `org-list-to-generic'.
(defalias 'org-list-to-texinfo #[(list &optional params) "\302\303\304	\"\"\207" [list params org-list-to-generic org-combine-plists (:splice nil :ostart "@itemize @minus\n" :oend "@end itemize" :ustart "@enumerate\n" :uend "@end enumerate" :dstart "@table @asis\n" :dend "@end table" :dtstart " " :dtend "\n" :istart "@item\n" :iend "\n" :icount "@item\n" :csep "\n" :cbon "@code{[X]}" :cboff "@code{[ ]}" :cbtrans "@code{[-]}")] 5 (#$ . 84129)])
#@162 Convert LIST into an Org subtree.
LIST is as returned by `org-list-parse-list'.  PARAMS is a property list
with overruling parameters for `org-list-to-generic'.
(defalias 'org-list-to-subtree #[(list &optional params) "\306\236A\307\310 \206\f\311!	\312=\206!	\313=\205!\212\314 \210\315 )\316\317
\320\321\"\",\207" [org-blank-before-new-entry rule level blankp get-stars list heading org-reduced-level org-current-level 0 t auto outline-previous-heading org-previous-line-empty-p #[(d) "\304	\305#\306\203\n\307_S\202\n\310\"\311P)\207" [level d oddeven-level org-odd-levels-only + 1 make-string 2 42 " "] 4] org-list-to-generic org-combine-plists (:splice t :dtstart " " :dtend " " :istart (funcall get-stars depth) :icount (funcall get-stars depth) :isep (if blankp "\n\n" "\n") :csep (if blankp "\n\n" "\n") :cbon "DONE" :cboff "TODO" :cbtrans "TODO") params] 5 (#$ . 84746)])
(provide 'org-list)