emacs-orgmode@gnu.org archives
 help / color / mirror / code / Atom feed
* still seeing semi-regular lockups
@ 2014-05-14  8:39 Eric Abrahamsen
  2014-05-15  9:21 ` Bastien
  0 siblings, 1 reply; 70+ messages in thread
From: Eric Abrahamsen @ 2014-05-14  8:39 UTC (permalink / raw)
  To: emacs-orgmode

Hey there,

After Nicolas made the last round of improvements to the caching
mechanism I got far fewer hangs with Org, but they are still happening.
Maybe once a day or so, on average, editing something in an Org buffer
causes emacs to hang, and my fans to spin up, and there we are until I
kill emacs.

It happens often enough that I guess it's worth running emacs under some
kind of debugger -- at least, I assume that's the best way of catching
the bug. I'm not really sure how to go hunting, though, so if anyone had
any advice in this direction, that would be great.

In the meantime, is there any way of interrupting emacs so it quits
whatever its doing, without having to kill it? I've played around with
sending different signals using "kill", just for fun, but everything
I've tried either does nothing, or kills emacs altogether.

Cheers,
Eric

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-14  8:39 still seeing semi-regular lockups Eric Abrahamsen
@ 2014-05-15  9:21 ` Bastien
  2014-05-15  9:30   ` Daimrod
  0 siblings, 1 reply; 70+ messages in thread
From: Bastien @ 2014-05-15  9:21 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

Hi Eric,

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> After Nicolas made the last round of improvements to the caching
> mechanism I got far fewer hangs with Org, but they are still happening.
> Maybe once a day or so, on average, editing something in an Org buffer
> causes emacs to hang, and my fans to spin up, and there we are until I
> kill emacs.

I've seen hiccups here and there, but generally, what happens is an
error, not an infinite hanging.

> It happens often enough that I guess it's worth running emacs under some
> kind of debugger -- at least, I assume that's the best way of catching
> the bug. I'm not really sure how to go hunting, though, so if anyone had
> any advice in this direction, that would be great.

I'd hunt for some infloop in parsing -- but cannot detail more than
that, problably Nicolas could.

> In the meantime, is there any way of interrupting emacs so it quits
> whatever its doing, without having to kill it? I've played around with
> sending different signals using "kill", just for fun, but everything
> I've tried either does nothing, or kills emacs altogether.

I have no suggestion here either, sorry :/

-- 
 Bastien

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-15  9:21 ` Bastien
@ 2014-05-15  9:30   ` Daimrod
  2014-05-15  9:46     ` Bastien
                       ` (3 more replies)
  0 siblings, 4 replies; 70+ messages in thread
From: Daimrod @ 2014-05-15  9:30 UTC (permalink / raw)
  To: Bastien; +Cc: Eric Abrahamsen, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 2813 bytes --]

Bastien <bzg@gnu.org> writes:

> Hi Eric,
>
> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> After Nicolas made the last round of improvements to the caching
>> mechanism I got far fewer hangs with Org, but they are still happening.
>> Maybe once a day or so, on average, editing something in an Org buffer
>> causes emacs to hang, and my fans to spin up, and there we are until I
>> kill emacs.
>
> I've seen hiccups here and there, but generally, what happens is an
> error, not an infinite hanging.
>
>> It happens often enough that I guess it's worth running emacs under some
>> kind of debugger -- at least, I assume that's the best way of catching
>> the bug. I'm not really sure how to go hunting, though, so if anyone had
>> any advice in this direction, that would be great.
>
> I'd hunt for some infloop in parsing -- but cannot detail more than
> that, problably Nicolas could.
>
>> In the meantime, is there any way of interrupting emacs so it quits
>> whatever its doing, without having to kill it? I've played around with
>> sending different signals using "kill", just for fun, but everything
>> I've tried either does nothing, or kills emacs altogether.
>
> I have no suggestion here either, sorry :/

I have also semi-regular lockup with org-mode. I have opened a bug on
debbugs and here is what Stefan told me to try to debug this:

> You can try `debug-on-event'.
> 
> There's jit-lock-debug-mode but it doesn't disable inhibit-quit.
> So you'll need to additionally use
> 
>    (advice-add 'jit-lock--debug-fontify :around
>      (lambda (fun &rest args)
>        (with-local-quit (apply fun args))))
> 
> Of course sometimes this doesn't work because jit-lock-debug-mode
> changes the way things are executed and the bug may not manifest itself
> any more, but it's worth a try.
> 
> Another source of info is to
> 
>   M-x trace-function RET org-adaptive-fill-function RET
>   M-x trace-function RET org-element-at-point RET
>   M-x trace-function RET org-element--cache-sync RET
>   M-x trace-function RET org-element--cache-process-request RET
> 
> Then reproduce the hang, then break the hang somehow (maybe with the
> jit-lock-debug hack above, or maybe with debug-on-event, or with C-g C-g
> C-g, ...), then look at the *trace..* buffer.

I'll try to see what I can find this week end and report back.

By the way, if you want to see in which part the infloop occurs, you can
attach a gdb debugger to the running emacs, source the
<path-to-emacs-source>/src/.gdbinit file and use the `xbacktrace' command.

$ gdb <path-to-emacs-executable> <emacs-pid>
gdb) source <path-to-emacs-source>/src/.gdbinit
...
gdb) xbacktrace

You can also use the `bt' command but it contains much more noise.

-- 
Daimrod/Greg

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 835 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-15  9:30   ` Daimrod
@ 2014-05-15  9:46     ` Bastien
  2014-05-15 10:31     ` Eric Abrahamsen
                       ` (2 subsequent siblings)
  3 siblings, 0 replies; 70+ messages in thread
From: Bastien @ 2014-05-15  9:46 UTC (permalink / raw)
  To: Daimrod; +Cc: Eric Abrahamsen, emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> I'll try to see what I can find this week end and report back.

Great -- thanks for the guidance!

-- 
 Bastien

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-15  9:30   ` Daimrod
  2014-05-15  9:46     ` Bastien
@ 2014-05-15 10:31     ` Eric Abrahamsen
  2014-05-15 10:37       ` Daimrod
  2014-05-19 14:21     ` Daimrod
  2014-06-04  4:47     ` Eric Abrahamsen
  3 siblings, 1 reply; 70+ messages in thread
From: Eric Abrahamsen @ 2014-05-15 10:31 UTC (permalink / raw)
  To: emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> Bastien <bzg@gnu.org> writes:
>
>> Hi Eric,
>>
>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>
>>> After Nicolas made the last round of improvements to the caching
>>> mechanism I got far fewer hangs with Org, but they are still happening.
>>> Maybe once a day or so, on average, editing something in an Org buffer
>>> causes emacs to hang, and my fans to spin up, and there we are until I
>>> kill emacs.

[...]

> I have also semi-regular lockup with org-mode. I have opened a bug on
> debbugs and here is what Stefan told me to try to debug this:
>
>> You can try `debug-on-event'.
>> 
>> There's jit-lock-debug-mode but it doesn't disable inhibit-quit.
>> So you'll need to additionally use
>> 
>>    (advice-add 'jit-lock--debug-fontify :around
>>      (lambda (fun &rest args)
>>        (with-local-quit (apply fun args))))
>> 
>> Of course sometimes this doesn't work because jit-lock-debug-mode
>> changes the way things are executed and the bug may not manifest itself
>> any more, but it's worth a try.
>> 
>> Another source of info is to
>> 
>>   M-x trace-function RET org-adaptive-fill-function RET
>>   M-x trace-function RET org-element-at-point RET
>>   M-x trace-function RET org-element--cache-sync RET
>>   M-x trace-function RET org-element--cache-process-request RET
>> 
>> Then reproduce the hang, then break the hang somehow (maybe with the
>> jit-lock-debug hack above, or maybe with debug-on-event, or with C-g C-g
>> C-g, ...), then look at the *trace..* buffer.
>
> I'll try to see what I can find this week end and report back.
>
> By the way, if you want to see in which part the infloop occurs, you can
> attach a gdb debugger to the running emacs, source the
> <path-to-emacs-source>/src/.gdbinit file and use the `xbacktrace' command.
>
> $ gdb <path-to-emacs-executable> <emacs-pid>
> gdb) source <path-to-emacs-source>/src/.gdbinit
> ...
> gdb) xbacktrace
>
> You can also use the `bt' command but it contains much more noise.

Thanks! This is the sort of thing I assumed I'd have to do, and it's
good to have an actual recipe. If you're on it, I might take the lazy
option and spectate for now... :)

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-15 10:31     ` Eric Abrahamsen
@ 2014-05-15 10:37       ` Daimrod
  2014-05-15 10:43         ` Eric Abrahamsen
  0 siblings, 1 reply; 70+ messages in thread
From: Daimrod @ 2014-05-15 10:37 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> Daimrod <daimrod@gmail.com> writes:
>
>> Bastien <bzg@gnu.org> writes:
>>
>>> Hi Eric,
>>>
>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>
>>>> After Nicolas made the last round of improvements to the caching
>>>> mechanism I got far fewer hangs with Org, but they are still happening.
>>>> Maybe once a day or so, on average, editing something in an Org buffer
>>>> causes emacs to hang, and my fans to spin up, and there we are until I
>>>> kill emacs.
>
> [...]
>
>> I have also semi-regular lockup with org-mode. I have opened a bug on
>> debbugs and here is what Stefan told me to try to debug this:
>>
>>> You can try `debug-on-event'.
>>> 
>>> There's jit-lock-debug-mode but it doesn't disable inhibit-quit.
>>> So you'll need to additionally use
>>> 
>>>    (advice-add 'jit-lock--debug-fontify :around
>>>      (lambda (fun &rest args)
>>>        (with-local-quit (apply fun args))))
>>> 
>>> Of course sometimes this doesn't work because jit-lock-debug-mode
>>> changes the way things are executed and the bug may not manifest itself
>>> any more, but it's worth a try.
>>> 
>>> Another source of info is to
>>> 
>>>   M-x trace-function RET org-adaptive-fill-function RET
>>>   M-x trace-function RET org-element-at-point RET
>>>   M-x trace-function RET org-element--cache-sync RET
>>>   M-x trace-function RET org-element--cache-process-request RET
>>> 
>>> Then reproduce the hang, then break the hang somehow (maybe with the
>>> jit-lock-debug hack above, or maybe with debug-on-event, or with C-g C-g
>>> C-g, ...), then look at the *trace..* buffer.
>>
>> I'll try to see what I can find this week end and report back.
>>
>> By the way, if you want to see in which part the infloop occurs, you can
>> attach a gdb debugger to the running emacs, source the
>> <path-to-emacs-source>/src/.gdbinit file and use the `xbacktrace' command.
>>
>> $ gdb <path-to-emacs-executable> <emacs-pid>
>> gdb) source <path-to-emacs-source>/src/.gdbinit
>> ...
>> gdb) xbacktrace
>>
>> You can also use the `bt' command but it contains much more noise.
>
> Thanks! This is the sort of thing I assumed I'd have to do, and it's
> good to have an actual recipe. If you're on it, I might take the lazy
> option and spectate for now... :)

No problem, but could you attach gdb during a lockup, source .gdbitinit
and use the `xbacktrace' command to see if the lockup happens at the
same place?

-- 
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-15 10:37       ` Daimrod
@ 2014-05-15 10:43         ` Eric Abrahamsen
  0 siblings, 0 replies; 70+ messages in thread
From: Eric Abrahamsen @ 2014-05-15 10:43 UTC (permalink / raw)
  To: emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> Daimrod <daimrod@gmail.com> writes:
>>
>>> Bastien <bzg@gnu.org> writes:
>>>
>>>> Hi Eric,
>>>>
>>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>>
>>>>> After Nicolas made the last round of improvements to the caching
>>>>> mechanism I got far fewer hangs with Org, but they are still happening.
>>>>> Maybe once a day or so, on average, editing something in an Org buffer
>>>>> causes emacs to hang, and my fans to spin up, and there we are until I
>>>>> kill emacs.
>>
>> [...]
>>
>>> I have also semi-regular lockup with org-mode. I have opened a bug on
>>> debbugs and here is what Stefan told me to try to debug this:
>>>
>>>> You can try `debug-on-event'.
>>>> 
>>>> There's jit-lock-debug-mode but it doesn't disable inhibit-quit.
>>>> So you'll need to additionally use
>>>> 
>>>>    (advice-add 'jit-lock--debug-fontify :around
>>>>      (lambda (fun &rest args)
>>>>        (with-local-quit (apply fun args))))
>>>> 
>>>> Of course sometimes this doesn't work because jit-lock-debug-mode
>>>> changes the way things are executed and the bug may not manifest itself
>>>> any more, but it's worth a try.
>>>> 
>>>> Another source of info is to
>>>> 
>>>>   M-x trace-function RET org-adaptive-fill-function RET
>>>>   M-x trace-function RET org-element-at-point RET
>>>>   M-x trace-function RET org-element--cache-sync RET
>>>>   M-x trace-function RET org-element--cache-process-request RET
>>>> 
>>>> Then reproduce the hang, then break the hang somehow (maybe with the
>>>> jit-lock-debug hack above, or maybe with debug-on-event, or with C-g C-g
>>>> C-g, ...), then look at the *trace..* buffer.
>>>
>>> I'll try to see what I can find this week end and report back.
>>>
>>> By the way, if you want to see in which part the infloop occurs, you can
>>> attach a gdb debugger to the running emacs, source the
>>> <path-to-emacs-source>/src/.gdbinit file and use the `xbacktrace' command.
>>>
>>> $ gdb <path-to-emacs-executable> <emacs-pid>
>>> gdb) source <path-to-emacs-source>/src/.gdbinit
>>> ...
>>> gdb) xbacktrace
>>>
>>> You can also use the `bt' command but it contains much more noise.
>>
>> Thanks! This is the sort of thing I assumed I'd have to do, and it's
>> good to have an actual recipe. If you're on it, I might take the lazy
>> option and spectate for now... :)
>
> No problem, but could you attach gdb during a lockup, source .gdbitinit
> and use the `xbacktrace' command to see if the lockup happens at the
> same place?

Most definitely. Saving the instructions now...

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-15  9:30   ` Daimrod
  2014-05-15  9:46     ` Bastien
  2014-05-15 10:31     ` Eric Abrahamsen
@ 2014-05-19 14:21     ` Daimrod
  2014-05-20  8:25       ` Eric Abrahamsen
  2014-05-29  3:01       ` Daimrod
  2014-06-04  4:47     ` Eric Abrahamsen
  3 siblings, 2 replies; 70+ messages in thread
From: Daimrod @ 2014-05-19 14:21 UTC (permalink / raw)
  To: Bastien; +Cc: Eric Abrahamsen, emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> I have also semi-regular lockup with org-mode. I have opened a bug on
> debbugs and here is what Stefan told me to try to debug this:
>
>> You can try `debug-on-event'.
>> 
>> There's jit-lock-debug-mode but it doesn't disable inhibit-quit.
>> So you'll need to additionally use
>> 
>>    (advice-add 'jit-lock--debug-fontify :around
>>      (lambda (fun &rest args)
>>        (with-local-quit (apply fun args))))
>> 
>> Of course sometimes this doesn't work because jit-lock-debug-mode
>> changes the way things are executed and the bug may not manifest itself
>> any more, but it's worth a try.
>> 
>> Another source of info is to
>> 
>>   M-x trace-function RET org-adaptive-fill-function RET
>>   M-x trace-function RET org-element-at-point RET
>>   M-x trace-function RET org-element--cache-sync RET
>>   M-x trace-function RET org-element--cache-process-request RET
>> 
>> Then reproduce the hang, then break the hang somehow (maybe with the
>> jit-lock-debug hack above, or maybe with debug-on-event, or with C-g C-g
>> C-g, ...), then look at the *trace..* buffer.
>
> I'll try to see what I can find this week end and report back.

Ok, so the good news is the `debug-on-event' trick works. If you got a
lockup, you can get a classic elisp backtrace by sending the SIGUSR2 to
the Emacs process.

The bad news is that I don't know yet how to reproduce the lockup. It
seems to happen mostly (if not only) when I use org-mode +
visual-line-mode + adaptive-wrap-prefix-mode + an input-method like
latin-postfix.

And it probably has to do with the cache mechanism. I'll try to
reproduce it with the cache disabled but it hard to test because, as I
said, I don't know how to reproduce it yet.

I'll keep testing and see if I can reproduce it reliably.

Stay tuned!

-- 
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-19 14:21     ` Daimrod
@ 2014-05-20  8:25       ` Eric Abrahamsen
  2014-05-20  8:55         ` Daimrod
  2014-05-29  3:01       ` Daimrod
  1 sibling, 1 reply; 70+ messages in thread
From: Eric Abrahamsen @ 2014-05-20  8:25 UTC (permalink / raw)
  To: Daimrod; +Cc: Bastien, emacs-orgmode


On 05/19/14 23:21 PM, Daimrod wrote:
> Daimrod <daimrod@gmail.com> writes:
>
>> I have also semi-regular lockup with org-mode. I have opened a bug on
>> debbugs and here is what Stefan told me to try to debug this:
>>
>>> You can try `debug-on-event'.
>>> 
>>> There's jit-lock-debug-mode but it doesn't disable inhibit-quit.
>>> So you'll need to additionally use
>>> 
>>>    (advice-add 'jit-lock--debug-fontify :around
>>>      (lambda (fun &rest args)
>>>        (with-local-quit (apply fun args))))
>>> 
>>> Of course sometimes this doesn't work because jit-lock-debug-mode
>>> changes the way things are executed and the bug may not manifest itself
>>> any more, but it's worth a try.
>>> 
>>> Another source of info is to
>>> 
>>>   M-x trace-function RET org-adaptive-fill-function RET
>>>   M-x trace-function RET org-element-at-point RET
>>>   M-x trace-function RET org-element--cache-sync RET
>>>   M-x trace-function RET org-element--cache-process-request RET
>>> 
>>> Then reproduce the hang, then break the hang somehow (maybe with the
>>> jit-lock-debug hack above, or maybe with debug-on-event, or with C-g C-g
>>> C-g, ...), then look at the *trace..* buffer.
>>
>> I'll try to see what I can find this week end and report back.
>
> Ok, so the good news is the `debug-on-event' trick works. If you got a
> lockup, you can get a classic elisp backtrace by sending the SIGUSR2 to
> the Emacs process.
>
> The bad news is that I don't know yet how to reproduce the lockup. It
> seems to happen mostly (if not only) when I use org-mode +
> visual-line-mode + adaptive-wrap-prefix-mode + an input-method like
> latin-postfix.
>
> And it probably has to do with the cache mechanism. I'll try to
> reproduce it with the cache disabled but it hard to test because, as I
> said, I don't know how to reproduce it yet.
>
> I'll keep testing and see if I can reproduce it reliably.
>
> Stay tuned!

Of course I haven't gotten a single lock-up since reporting in last time...

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-20  8:25       ` Eric Abrahamsen
@ 2014-05-20  8:55         ` Daimrod
  2014-05-20 11:16           ` Eric Abrahamsen
  0 siblings, 1 reply; 70+ messages in thread
From: Daimrod @ 2014-05-20  8:55 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: Bastien, emacs-orgmode

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> On 05/19/14 23:21 PM, Daimrod wrote:
>> Daimrod <daimrod@gmail.com> writes:
>>
>>> I have also semi-regular lockup with org-mode. I have opened a bug on
>>> debbugs and here is what Stefan told me to try to debug this:
>>>
>>>> You can try `debug-on-event'.
>>>> 
>>>> There's jit-lock-debug-mode but it doesn't disable inhibit-quit.
>>>> So you'll need to additionally use
>>>> 
>>>>    (advice-add 'jit-lock--debug-fontify :around
>>>>      (lambda (fun &rest args)
>>>>        (with-local-quit (apply fun args))))
>>>> 
>>>> Of course sometimes this doesn't work because jit-lock-debug-mode
>>>> changes the way things are executed and the bug may not manifest itself
>>>> any more, but it's worth a try.
>>>> 
>>>> Another source of info is to
>>>> 
>>>>   M-x trace-function RET org-adaptive-fill-function RET
>>>>   M-x trace-function RET org-element-at-point RET
>>>>   M-x trace-function RET org-element--cache-sync RET
>>>>   M-x trace-function RET org-element--cache-process-request RET
>>>> 
>>>> Then reproduce the hang, then break the hang somehow (maybe with the
>>>> jit-lock-debug hack above, or maybe with debug-on-event, or with C-g C-g
>>>> C-g, ...), then look at the *trace..* buffer.
>>>
>>> I'll try to see what I can find this week end and report back.
>>
>> Ok, so the good news is the `debug-on-event' trick works. If you got a
>> lockup, you can get a classic elisp backtrace by sending the SIGUSR2 to
>> the Emacs process.
>>
>> The bad news is that I don't know yet how to reproduce the lockup. It
>> seems to happen mostly (if not only) when I use org-mode +
>> visual-line-mode + adaptive-wrap-prefix-mode + an input-method like
>> latin-postfix.
>>
>> And it probably has to do with the cache mechanism. I'll try to
>> reproduce it with the cache disabled but it hard to test because, as I
>> said, I don't know how to reproduce it yet.
>>
>> I'll keep testing and see if I can reproduce it reliably.
>>
>> Stay tuned!
>
> Of course I haven't gotten a single lock-up since reporting in last time...

:D

Do you have a similar setup? That is visual-line-mode,
adaptive-wrap-prefix-mode, input-method?

-- 
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-20  8:55         ` Daimrod
@ 2014-05-20 11:16           ` Eric Abrahamsen
  2014-06-24  8:48             ` Nicolas Goaziou
  0 siblings, 1 reply; 70+ messages in thread
From: Eric Abrahamsen @ 2014-05-20 11:16 UTC (permalink / raw)
  To: emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> On 05/19/14 23:21 PM, Daimrod wrote:
>>> Daimrod <daimrod@gmail.com> writes:
>>>
>>>> I have also semi-regular lockup with org-mode. I have opened a bug on
>>>> debbugs and here is what Stefan told me to try to debug this:
>>>>
>>>>> You can try `debug-on-event'.
>>>>> 
>>>>> There's jit-lock-debug-mode but it doesn't disable inhibit-quit.
>>>>> So you'll need to additionally use
>>>>> 
>>>>>    (advice-add 'jit-lock--debug-fontify :around
>>>>>      (lambda (fun &rest args)
>>>>>        (with-local-quit (apply fun args))))
>>>>> 
>>>>> Of course sometimes this doesn't work because jit-lock-debug-mode
>>>>> changes the way things are executed and the bug may not manifest itself
>>>>> any more, but it's worth a try.
>>>>> 
>>>>> Another source of info is to
>>>>> 
>>>>>   M-x trace-function RET org-adaptive-fill-function RET
>>>>>   M-x trace-function RET org-element-at-point RET
>>>>>   M-x trace-function RET org-element--cache-sync RET
>>>>>   M-x trace-function RET org-element--cache-process-request RET
>>>>> 
>>>>> Then reproduce the hang, then break the hang somehow (maybe with the
>>>>> jit-lock-debug hack above, or maybe with debug-on-event, or with C-g C-g
>>>>> C-g, ...), then look at the *trace..* buffer.
>>>>
>>>> I'll try to see what I can find this week end and report back.
>>>
>>> Ok, so the good news is the `debug-on-event' trick works. If you got a
>>> lockup, you can get a classic elisp backtrace by sending the SIGUSR2 to
>>> the Emacs process.
>>>
>>> The bad news is that I don't know yet how to reproduce the lockup. It
>>> seems to happen mostly (if not only) when I use org-mode +
>>> visual-line-mode + adaptive-wrap-prefix-mode + an input-method like
>>> latin-postfix.
>>>
>>> And it probably has to do with the cache mechanism. I'll try to
>>> reproduce it with the cache disabled but it hard to test because, as I
>>> said, I don't know how to reproduce it yet.
>>>
>>> I'll keep testing and see if I can reproduce it reliably.
>>>
>>> Stay tuned!
>>
>> Of course I haven't gotten a single lock-up since reporting in last time...
>
> :D
>
> Do you have a similar setup? That is visual-line-mode,
> adaptive-wrap-prefix-mode, input-method?

None of those three, I'm afraid! It was hanging on a variety of editing
operations that, as far as I can tell, had little in common. There's a
possibility that they were list-item-related, but really there wasn't
much commonality.

E

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-19 14:21     ` Daimrod
  2014-05-20  8:25       ` Eric Abrahamsen
@ 2014-05-29  3:01       ` Daimrod
  2014-05-30  9:17         ` Nicolas Goaziou
  1 sibling, 1 reply; 70+ messages in thread
From: Daimrod @ 2014-05-29  3:01 UTC (permalink / raw)
  To: Bastien; +Cc: Eric Abrahamsen, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 2209 bytes --]

Daimrod <daimrod@gmail.com> writes:

> Daimrod <daimrod@gmail.com> writes:
>
>> I have also semi-regular lockup with org-mode. I have opened a bug on
>> debbugs and here is what Stefan told me to try to debug this:
>>
>>> You can try `debug-on-event'.
>>> 
>>> There's jit-lock-debug-mode but it doesn't disable inhibit-quit.
>>> So you'll need to additionally use
>>> 
>>>    (advice-add 'jit-lock--debug-fontify :around
>>>      (lambda (fun &rest args)
>>>        (with-local-quit (apply fun args))))
>>> 
>>> Of course sometimes this doesn't work because jit-lock-debug-mode
>>> changes the way things are executed and the bug may not manifest itself
>>> any more, but it's worth a try.
>>> 
>>> Another source of info is to
>>> 
>>>   M-x trace-function RET org-adaptive-fill-function RET
>>>   M-x trace-function RET org-element-at-point RET
>>>   M-x trace-function RET org-element--cache-sync RET
>>>   M-x trace-function RET org-element--cache-process-request RET
>>> 
>>> Then reproduce the hang, then break the hang somehow (maybe with the
>>> jit-lock-debug hack above, or maybe with debug-on-event, or with C-g C-g
>>> C-g, ...), then look at the *trace..* buffer.
>>
>> I'll try to see what I can find this week end and report back.
>
> Ok, so the good news is the `debug-on-event' trick works. If you got a
> lockup, you can get a classic elisp backtrace by sending the SIGUSR2 to
> the Emacs process.
>
> The bad news is that I don't know yet how to reproduce the lockup. It
> seems to happen mostly (if not only) when I use org-mode +
> visual-line-mode + adaptive-wrap-prefix-mode + an input-method like
> latin-postfix.
>
> And it probably has to do with the cache mechanism. I'll try to
> reproduce it with the cache disabled but it hard to test because, as I
> said, I don't know how to reproduce it yet.

Grr, I still don't know how to reproduce this bug.

As I said above, I only had this bug with visual-line-mode +
adaptive-wrap-prefix-mode and input-method = latin-postfix.

It seems to happen with different configurationsa but it takes longer
(maybe days of editing) before it is triggered.

I've attached part of the traces (the whole traces are way too big) and
the backtraces.


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: crash-dat.org --]
[-- Type: text/x-org, Size: 99789 bytes --]

* 1

#+BEGIN_EXAMPLE
Debugger entered--beginning evaluation of function call form:
* (funcall #[0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" [org-element--cache-sync nil #[0 "\300\207" [""] 1 "\n\n(fn)"] (nil) inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)"])
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-sync "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))) #<buffer test.org> 652)
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-sync "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))) (#<buffer test.org> 652))
  org-element--cache-sync(#<buffer test.org> 652)
  (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin))
  (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))
  (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin))))
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  (lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin)))))))()
  apply((lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin))))))) nil)
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element-at-point "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin))))))))
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element-at-point "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin))))))) nil)
  org-element-at-point()
  (progn (org-element-at-point))
  (condition-case nil (progn (org-element-at-point)) (error nil))
  (or (condition-case nil (progn (org-element-at-point)) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos (point))))
  (save-excursion (beginning-of-line) (or (condition-case nil (progn (org-element-at-point)) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos (point)))))
  (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or (condition-case nil (progn (org-element-at-point)) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos (point)))))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type (quote comment)) (save-excursion (beginning-of-line) (looking-at "[ 	]*") (concat (match-string 0) "# "))) ((eql type (quote footnote-definition)) "") ((memql type (quote (item plain-list))) (make-string (org-list-item-body-column (or post-affiliated (org-element-property :begin element))) 32)) ((eql type (quote paragraph)) (let ((parent (org-element-property :parent element))) (save-excursion (beginning-of-line) (cond (... ...) (...) (... ...) (t ""))))) ((eql type (quote comment-block)) (let* ((cbeg (save-excursion ... ... ...)) (cend (save-excursion ... ... ...))) (if (and (>= p cbeg) (< p cend)) (progn (if ... ... ""))))))))
  (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or (condition-case nil (progn ...) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos ...))))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type (quote comment)) (save-excursion (beginning-of-line) (looking-at "[ 	]*") (concat (match-string 0) "# "))) ((eql type (quote footnote-definition)) "") ((memql type (quote (item plain-list))) (make-string (org-list-item-body-column (or post-affiliated ...)) 32)) ((eql type (quote paragraph)) (let ((parent ...)) (save-excursion (beginning-of-line) (cond ... ... ... ...)))) ((eql type (quote comment-block)) (let* ((cbeg ...) (cend ...)) (if (and ... ...) (progn ...))))))))
  (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or (condition-case nil ... ...) (user-error "An element cannot be parsed line %d" ...)))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type (quote comment)) (save-excursion (beginning-of-line) (looking-at "[ 	]*") (concat ... "# "))) ((eql type (quote footnote-definition)) "") ((memql type (quote ...)) (make-string (org-list-item-body-column ...) 32)) ((eql type (quote paragraph)) (let (...) (save-excursion ... ...))) ((eql type (quote comment-block)) (let* (... ...) (if ... ...))))))))
  (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or (not ...) (looking-at orgtbl-line-start-regexp)) (throw (quote exit) nil)) ((looking-at message-cite-prefix-regexp) (throw (quote exit) (match-string-no-properties 0))) ((looking-at org-outline-regexp) (throw (quote exit) (make-string ... 32))))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or ... ...))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type ...) (save-excursion ... ... ...)) ((eql type ...) "") ((memql type ...) (make-string ... 32)) ((eql type ...) (let ... ...)) ((eql type ...) (let* ... ...))))))))
  (lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...))))))))()
  apply((lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...)))))))) nil)
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-adaptive-fill-function "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...)))))))))
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-adaptive-fill-function "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...)))))))) nil)
  org-adaptive-fill-function()
  fill-match-adaptive-prefix()
  fill-context-prefix(652 729)
  adaptive-wrap-fill-context-prefix(652 729)
  adaptive-wrap-prefix-function(652 730)
  run-hook-with-args(adaptive-wrap-prefix-function 652 730)
  #[0 "\302\303\300\242\301\242#\207" [(652) (730) run-hook-with-args jit-lock-functions] 4 "\n\n(fn)"]()
  funcall(#[0 "\302\303\300\242\301\242#\207" [(652) (730) run-hook-with-args jit-lock-functions] 4 "\n\n(fn)"])
  jit-lock-fontify-now(652 1152)
  jit-lock-function(652)
  redisplay_internal\ \(C\ function\)()
  read-key-sequence(nil nil nil t)
  quail-start-translation(97)
  quail-input-method(97)
#+END_EXAMPLE

#+BEGIN_EXAMPLE
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 652)
| | | 4 -> (org-element--cache-process-request [726 nil 1 nil 2] 727 652 nil)
| | | 4 <- org-element--cache-process-request: t
| | | 4 -> (org-element--cache-process-request [727 nil 5 nil 2] 9750 652 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 652 :end 728 :contents-begin 652 :contents-end 727 :post-blank 1 :post-affiliated 652 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| 2 <- org-element-at-point: (headline (:raw-value #1="This is another test" :begin 728 :end 9766 :pre-blank 1 :contents-begin 752 :contents-end 9766 :level 1 :priority nil :tags nil :todo-keyword nil :todo-type nil :post-blank 0 :footnote-section-p nil :archivedp nil :commentedp nil :CATEGORY nil :title #1#))
1 <- org-adaptive-fill-function: nil
======================================================================
1 -> (org-element--cache-sync #<buffer test.org>)
| 2 -> (org-element--cache-process-request [932 nil 5 nil 2] 9750 nil (21381 47609 398931 512000))
| 2 <- org-element--cache-process-request: nil
1 <- org-element--cache-sync: [nil 0 0 608541 nil org-element--cache-sync (#<buffer test.org>) idle 676000]
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 652)
| | | 4 -> (org-element--cache-process-request [1626 nil 5 nil 2] 9750 652 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 652 :end 728 :contents-begin 652 :contents-end 727 :post-blank 1 :post-affiliated 652 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-element--cache-sync #<buffer test.org> 726)
| 2 -> (org-element--cache-process-request [9628 nil 5 nil 2] 9750 726 nil)
| 2 <- org-element--cache-process-request: t
| 2 -> (org-element--cache-process-request [9750 nil 7 nil 2] nil 726 nil)
| 2 <- org-element--cache-process-request: t
1 <- org-element--cache-sync: #s(hash-table size 65 test eq weakness key rehash-size 1.5 rehash-threshold 0.8 data ())
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 652)
| | | 4 -> (org-element--cache-process-request [153 740 1 nil 0] nil 652 nil)
#+END_EXAMPLE

* 2
#+BEGIN_EXAMPLE
Debugger entered--beginning evaluation of function call form:
* (funcall #[0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" [org-element--cache-process-request nil #[0 "\300\207" [""] 1 "\n\n(fn)"] (nil) inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)"])
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-process-request "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda (request next threshold time-limit) "Process synchronization REQUEST for all entries before NEXT.\n\nREQUEST is a vector, built by `org-element--cache-submit-request'.\n\nNEXT is a cache key, as returned by `org-element--cache-key'.\n\nWhen non-nil, THRESHOLD is a buffer position.  Synchronization\nstops as soon as a shifted element begins after it.\n\nWhen non-nil, TIME-LIMIT is a time value.  Synchronization stops\nafter this time or when Emacs exits idle state.\n\nReturn nil if the process stops before completing the request,\nt otherwise." (catch (quote quit) (if (= (aref request 4) 0) (progn (catch (quote end-phase) (let ((beg ...) (end ...) (deleted-parent ...)) (while t (if ... ...) (let ... ... ...)))))) (if (= (aref request 4) 1) (progn (catch (quote end-phase) (if (equal (aref request 0) next) (progn (throw ... t))) (let ((limit ...)) (if (and threshold ...) (progn ...)) (let (...) (if ... ... ... ... ...)))))) (let ((start (aref request 0)) (offset (aref request 2)) (parent (aref request 3)) (node (org-element--cache-root)) (stack (list nil)) (leftp t) exit-flag) (if (and (not parent) (zerop offset)) (progn (throw (quote quit) t))) (while node (let* ((data (progn ...)) (key (org-element--cache-key data))) (if (and leftp (progn ...) (not ...)) (progn (setq stack ...) (setq node ...)) (if (org-element--cache-key-less-p key start) nil (if ... ...) (if ... ...) (if ... nil ... ...) (let ... ... ... ...)) (setq node (if ... ... ...))))) t))) [(1983 1152921504606846975) 2221 1 nil 0] 9763 2060 nil)
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-process-request "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda (request next threshold time-limit) "Process synchronization REQUEST for all entries before NEXT.\n\nREQUEST is a vector, built by `org-element--cache-submit-request'.\n\nNEXT is a cache key, as returned by `org-element--cache-key'.\n\nWhen non-nil, THRESHOLD is a buffer position.  Synchronization\nstops as soon as a shifted element begins after it.\n\nWhen non-nil, TIME-LIMIT is a time value.  Synchronization stops\nafter this time or when Emacs exits idle state.\n\nReturn nil if the process stops before completing the request,\nt otherwise." (catch (quote quit) (if (= (aref request 4) 0) (progn (catch (quote end-phase) (let ((beg ...) (end ...) (deleted-parent ...)) (while t (if ... ...) (let ... ... ...)))))) (if (= (aref request 4) 1) (progn (catch (quote end-phase) (if (equal (aref request 0) next) (progn (throw ... t))) (let ((limit ...)) (if (and threshold ...) (progn ...)) (let (...) (if ... ... ... ... ...)))))) (let ((start (aref request 0)) (offset (aref request 2)) (parent (aref request 3)) (node (org-element--cache-root)) (stack (list nil)) (leftp t) exit-flag) (if (and (not parent) (zerop offset)) (progn (throw (quote quit) t))) (while node (let* ((data (progn ...)) (key (org-element--cache-key data))) (if (and leftp (progn ...) (not ...)) (progn (setq stack ...) (setq node ...)) (if (org-element--cache-key-less-p key start) nil (if ... ...) (if ... ...) (if ... nil ... ...) (let ... ... ... ...)) (setq node (if ... ... ...))))) t))) ([(1983 1152921504606846975) 2221 1 nil 0] 9763 2060 nil))
  org-element--cache-process-request([(1983 1152921504606846975) 2221 1 nil 0] 9763 2060 nil)
  (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration))) (throw (quote interrupt) t))
  (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration))) (throw (quote interrupt) t)) (if next (progn (let* ((v next)) (aset v 2 (+ (aref v 2) (aref request 2)))) (aset next 1 (aref request 1)) (aset next 4 (aref request 4)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))
  (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration))) (throw (quote interrupt) t)) (if next (progn (let* ((v next)) (aset v 2 (+ (aref v 2) (aref request 2)))) (aset next 1 (aref request 1)) (aset next 4 (aref request 4)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests))))
  (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration))) (throw (quote interrupt) t)) (if next (progn (let* ((v next)) (aset v 2 (+ ... ...))) (aset next 1 (aref request 1)) (aset next 4 (aref request 4)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys)))
  (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add ... org-element-cache-sync-duration))) (throw (quote interrupt) t)) (if next (progn (let* (...) (aset v 2 ...)) (aset next 1 (aref request 1)) (aset next 4 (aref request 4)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))
  (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next ...) threshold (and ... ...)) (throw (quote interrupt) t)) (if next (progn (let* ... ...) (aset next 1 ...) (aset next 4 ...))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys)))))
  (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request ... threshold ...) (throw ... t)) (if next (progn ... ... ...)) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))
  (lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys)))))))(#<buffer test.org> 2060)
  apply((lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))) (#<buffer test.org> 2060))
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-sync "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))) #<buffer test.org> 2060)
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-sync "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))) (#<buffer test.org> 2060))
  org-element--cache-sync(#<buffer test.org> 2060)
  (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin))
  (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))
  (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin))))
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  (lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin)))))))()
  apply((lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin))))))) nil)
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element-at-point "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin))))))))
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element-at-point "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin))))))) nil)
  org-element-at-point()
  (progn (org-element-at-point))
  (condition-case nil (progn (org-element-at-point)) (error nil))
  (or (condition-case nil (progn (org-element-at-point)) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos (point))))
  (save-excursion (beginning-of-line) (or (condition-case nil (progn (org-element-at-point)) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos (point)))))
  (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or (condition-case nil (progn (org-element-at-point)) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos (point)))))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type (quote comment)) (save-excursion (beginning-of-line) (looking-at "[ 	]*") (concat (match-string 0) "# "))) ((eql type (quote footnote-definition)) "") ((memql type (quote (item plain-list))) (make-string (org-list-item-body-column (or post-affiliated (org-element-property :begin element))) 32)) ((eql type (quote paragraph)) (let ((parent (org-element-property :parent element))) (save-excursion (beginning-of-line) (cond (... ...) (...) (... ...) (t ""))))) ((eql type (quote comment-block)) (let* ((cbeg (save-excursion ... ... ...)) (cend (save-excursion ... ... ...))) (if (and (>= p cbeg) (< p cend)) (progn (if ... ... ""))))))))
  (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or (condition-case nil (progn ...) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos ...))))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type (quote comment)) (save-excursion (beginning-of-line) (looking-at "[ 	]*") (concat (match-string 0) "# "))) ((eql type (quote footnote-definition)) "") ((memql type (quote (item plain-list))) (make-string (org-list-item-body-column (or post-affiliated ...)) 32)) ((eql type (quote paragraph)) (let ((parent ...)) (save-excursion (beginning-of-line) (cond ... ... ... ...)))) ((eql type (quote comment-block)) (let* ((cbeg ...) (cend ...)) (if (and ... ...) (progn ...))))))))
  (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or (condition-case nil ... ...) (user-error "An element cannot be parsed line %d" ...)))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type (quote comment)) (save-excursion (beginning-of-line) (looking-at "[ 	]*") (concat ... "# "))) ((eql type (quote footnote-definition)) "") ((memql type (quote ...)) (make-string (org-list-item-body-column ...) 32)) ((eql type (quote paragraph)) (let (...) (save-excursion ... ...))) ((eql type (quote comment-block)) (let* (... ...) (if ... ...))))))))
  (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or (not ...) (looking-at orgtbl-line-start-regexp)) (throw (quote exit) nil)) ((looking-at message-cite-prefix-regexp) (throw (quote exit) (match-string-no-properties 0))) ((looking-at org-outline-regexp) (throw (quote exit) (make-string ... 32))))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or ... ...))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type ...) (save-excursion ... ... ...)) ((eql type ...) "") ((memql type ...) (make-string ... 32)) ((eql type ...) (let ... ...)) ((eql type ...) (let* ... ...))))))))
  (lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...))))))))()
  apply((lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...)))))))) nil)
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-adaptive-fill-function "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...)))))))))
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-adaptive-fill-function "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...)))))))) nil)
  org-adaptive-fill-function()
  fill-match-adaptive-prefix()
  fill-context-prefix(2060 2221)
  adaptive-wrap-fill-context-prefix(2060 2221)
  adaptive-wrap-prefix-function(2060 2222)
  run-hook-with-args(adaptive-wrap-prefix-function 2060 2222)
  #[0 "\302\303\300\242\301\242#\207" [(2060) (2222) run-hook-with-args jit-lock-functions] 4 "\n\n(fn)"]()
  funcall(#[0 "\302\303\300\242\301\242#\207" [(2060) (2222) run-hook-with-args jit-lock-functions] 4 "\n\n(fn)"])
  jit-lock-fontify-now(2060 2560)
  jit-lock-function(2060)
  redisplay_internal\ \(C\ function\)()
#+END_EXAMPLE

#+BEGIN_EXAMPLE
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2063)
| | | 4 -> (org-element--cache-process-request [1984 2172 -14 nil 1] 1989 2063 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 2063 :end 2224 :contents-begin 2063 :contents-end 2223 :post-blank 1 :post-affiliated 2063 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-element--cache-sync #<buffer test.org> 2062)
| 2 -> (org-element--cache-process-request [1984 2172 -14 nil 1] 1989 2062 nil)
| 2 <- org-element--cache-process-request: nil
1 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2060)
| | | 4 -> (org-element--cache-process-request [(1983 1152921504606846975) 2063 -1 nil 0] 1984 2060 nil)
| | | 4 <- org-element--cache-process-request: t
| | | 4 -> (org-element--cache-process-request [1984 2172 -15 nil 1] 1989 2060 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 1858 :end 2223 :contents-begin 1858 :contents-end 2222 :post-blank 1 :post-affiliated 1858 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2062)
| | | 4 -> (org-element--cache-process-request [1984 2172 -15 nil 1] 1989 2062 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 1858 :end 2223 :contents-begin 1858 :contents-end 2222 :post-blank 1 :post-affiliated 1858 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-element--cache-sync #<buffer test.org> 2061)
| 2 -> (org-element--cache-process-request [1984 2172 -15 nil 1] 1989 2061 nil)
| 2 <- org-element--cache-process-request: nil
1 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2061)
| | | 4 -> (org-element--cache-process-request [(1983 1152921504606846975) 2223 -1 nil 0] 1984 2061 nil)
| | | 4 <- org-element--cache-process-request: t
| | | 4 -> (org-element--cache-process-request [1984 2172 -16 nil 1] 1989 2061 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 2061 :end 2222 :contents-begin 2061 :contents-end 2221 :post-blank 1 :post-affiliated 2061 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2061)
| | | 4 -> (org-element--cache-process-request [1984 2172 -16 nil 1] 1989 2061 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 2061 :end 2222 :contents-begin 2061 :contents-end 2221 :post-blank 1 :post-affiliated 2061 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-element--cache-sync #<buffer test.org> 2061)
| 2 -> (org-element--cache-process-request [1984 2172 -16 nil 1] 1989 2061 nil)
| 2 <- org-element--cache-process-request: nil
1 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2060)
| | | 4 -> (org-element--cache-process-request [(1983 1152921504606846975) 2222 -1 nil 0] 1984 2060 nil)
| | | 4 <- org-element--cache-process-request: t
| | | 4 -> (org-element--cache-process-request [1984 2172 -17 nil 1] 1989 2060 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 1858 :end 2221 :contents-begin 1858 :contents-end 2220 :post-blank 1 :post-affiliated 1858 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2221)
| | | 4 -> (org-element--cache-process-request [1984 2172 -17 nil 1] 1989 2221 nil)
| | | 4 <- org-element--cache-process-request: t
| | | 4 -> (org-element--cache-process-request [1989 2172 77 nil 2] nil 2221 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 2221 :end 2292 :contents-begin 2221 :contents-end 2291 :post-blank 1 :post-affiliated 2221 :parent (paragraph (:begin 2155 :end 2316 :contents-begin 2155 :contents-end 2315 :post-blank 1 :post-affiliated 2155 :parent (paragraph (:begin 1858 :end 2221 :contents-begin 1858 :contents-end 2220 :post-blank 1 :post-affiliated 1858 :parent nil))))))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-element--cache-sync #<buffer test.org> 2060)
| 2 -> (org-element--cache-process-request [2558 2172 77 nil 2] nil 2060 nil)
| 2 <- org-element--cache-process-request: nil
1 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2060)
| | | 4 -> (org-element--cache-process-request [(1983 1152921504606846975) 2221 1 nil 0] 9763 2060 nil)
#+END_EXAMPLE

* 3
#+BEGIN_EXAMPLE
Debugger entered--beginning evaluation of function call form:
* (funcall #[0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" [org-element--cache-process-request nil #[0 "\300\207" [""] 1 "\n\n(fn)"] (nil) inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)"])
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-process-request "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda (request next threshold time-limit) "Process synchronization REQUEST for all entries before NEXT.\n\nREQUEST is a vector, built by `org-element--cache-submit-request'.\n\nNEXT is a cache key, as returned by `org-element--cache-key'.\n\nWhen non-nil, THRESHOLD is a buffer position.  Synchronization\nstops as soon as a shifted element begins after it.\n\nWhen non-nil, TIME-LIMIT is a time value.  Synchronization stops\nafter this time or when Emacs exits idle state.\n\nReturn nil if the process stops before completing the request,\nt otherwise." (catch (quote quit) (if (= (aref request 4) 0) (progn (catch (quote end-phase) (let ((beg ...) (end ...) (deleted-parent ...)) (while t (if ... ...) (let ... ... ...)))))) (if (= (aref request 4) 1) (progn (catch (quote end-phase) (if (equal (aref request 0) next) (progn (throw ... t))) (let ((limit ...)) (if (and threshold ...) (progn ...)) (let (...) (if ... ... ... ... ...)))))) (let ((start (aref request 0)) (offset (aref request 2)) (parent (aref request 3)) (node (org-element--cache-root)) (stack (list nil)) (leftp t) exit-flag) (if (and (not parent) (zerop offset)) (progn (throw (quote quit) t))) (while node (let* ((data (progn ...)) (key (org-element--cache-key data))) (if (and leftp (progn ...) (not ...)) (progn (setq stack ...) (setq node ...)) (if (org-element--cache-key-less-p key start) nil (if ... ...) (if ... ...) (if ... nil ... ...) (let ... ... ... ...)) (setq node (if ... ... ...))))) t))) [2191 2672 1 nil 0] 2542 2440 nil)
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-process-request "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda (request next threshold time-limit) "Process synchronization REQUEST for all entries before NEXT.\n\nREQUEST is a vector, built by `org-element--cache-submit-request'.\n\nNEXT is a cache key, as returned by `org-element--cache-key'.\n\nWhen non-nil, THRESHOLD is a buffer position.  Synchronization\nstops as soon as a shifted element begins after it.\n\nWhen non-nil, TIME-LIMIT is a time value.  Synchronization stops\nafter this time or when Emacs exits idle state.\n\nReturn nil if the process stops before completing the request,\nt otherwise." (catch (quote quit) (if (= (aref request 4) 0) (progn (catch (quote end-phase) (let ((beg ...) (end ...) (deleted-parent ...)) (while t (if ... ...) (let ... ... ...)))))) (if (= (aref request 4) 1) (progn (catch (quote end-phase) (if (equal (aref request 0) next) (progn (throw ... t))) (let ((limit ...)) (if (and threshold ...) (progn ...)) (let (...) (if ... ... ... ... ...)))))) (let ((start (aref request 0)) (offset (aref request 2)) (parent (aref request 3)) (node (org-element--cache-root)) (stack (list nil)) (leftp t) exit-flag) (if (and (not parent) (zerop offset)) (progn (throw (quote quit) t))) (while node (let* ((data (progn ...)) (key (org-element--cache-key data))) (if (and leftp (progn ...) (not ...)) (progn (setq stack ...) (setq node ...)) (if (org-element--cache-key-less-p key start) nil (if ... ...) (if ... ...) (if ... nil ... ...) (let ... ... ... ...)) (setq node (if ... ... ...))))) t))) ([2191 2672 1 nil 0] 2542 2440 nil))
  org-element--cache-process-request([2191 2672 1 nil 0] 2542 2440 nil)
  (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration))) (throw (quote interrupt) t))
  (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration))) (throw (quote interrupt) t)) (if next (progn (let* ((v next)) (aset v 2 (+ (aref v 2) (aref request 2)))) (aset next 1 (aref request 1)) (aset next 4 (aref request 4)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))
  (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration))) (throw (quote interrupt) t)) (if next (progn (let* ((v next)) (aset v 2 (+ (aref v 2) (aref request 2)))) (aset next 1 (aref request 1)) (aset next 4 (aref request 4)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests))))
  (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration))) (throw (quote interrupt) t)) (if next (progn (let* ((v next)) (aset v 2 (+ ... ...))) (aset next 1 (aref request 1)) (aset next 4 (aref request 4)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys)))
  (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add ... org-element-cache-sync-duration))) (throw (quote interrupt) t)) (if next (progn (let* (...) (aset v 2 ...)) (aset next 1 (aref request 1)) (aset next 4 (aref request 4)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))
  (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request (and next ...) threshold (and ... ...)) (throw (quote interrupt) t)) (if next (progn (let* ... ...) (aset next 1 ...) (aset next 4 ...))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys)))))
  (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (or (org-element--cache-process-request request ... threshold ...) (throw ... t)) (if next (progn ... ... ...)) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))
  (lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys)))))))(#<buffer test.org> 2440)
  apply((lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))) (#<buffer test.org> 2440))
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-sync "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))) #<buffer test.org> 2440)
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element--cache-sync "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda (buffer &optional threshold) "Synchronize cache with recent modification in BUFFER.\nWhen optional argument THRESHOLD is non-nil, do the\nsynchronization for all elements starting before or at threshold,\nthen exit.  Otherwise, synchronize cache for as long as\n`org-element-cache-sync-duration' or until Emacs leaves idle\nstate." (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request ... next ...) (or ... ...) (if next ...) (setq org-element--cache-sync-requests ...))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))) (#<buffer test.org> 2440))
  org-element--cache-sync(#<buffer test.org> 2440)
  (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin))
  (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))
  (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin))))
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  (lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin)))))))()
  apply((lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin))))))) nil)
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element-at-point "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin))))))))
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-element-at-point "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda nil "Determine closest element around point.\n\nReturn value is a list like (TYPE PROPS) where TYPE is the type\nof the element and PROPS a plist of properties associated to the\nelement.\n\nPossible types are defined in `org-element-all-elements'.\nProperties depend on element or object type, but always include\n`:begin', `:end', `:parent' and `:post-blank' properties.\n\nAs a special case, if point is at the very beginning of the first\nitem in a list or sub-list, returned element will be that list\ninstead of the item.  Likewise, if point is at the beginning of\nthe first row of a table, returned element will be the table\ninstead of the first row.\n\nWhen point is at the end of the buffer, return the innermost\nelement ending there." (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* (... ... ... ...) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn ...)) (org-element--parse-to origin))))))) nil)
  org-element-at-point()
  (progn (org-element-at-point))
  (condition-case nil (progn (org-element-at-point)) (error nil))
  (or (condition-case nil (progn (org-element-at-point)) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos (point))))
  (save-excursion (beginning-of-line) (or (condition-case nil (progn (org-element-at-point)) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos (point)))))
  (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or (condition-case nil (progn (org-element-at-point)) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos (point)))))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type (quote comment)) (save-excursion (beginning-of-line) (looking-at "[ 	]*") (concat (match-string 0) "# "))) ((eql type (quote footnote-definition)) "") ((memql type (quote (item plain-list))) (make-string (org-list-item-body-column (or post-affiliated (org-element-property :begin element))) 32)) ((eql type (quote paragraph)) (let ((parent (org-element-property :parent element))) (save-excursion (beginning-of-line) (cond (... ...) (...) (... ...) (t ""))))) ((eql type (quote comment-block)) (let* ((cbeg (save-excursion ... ... ...)) (cend (save-excursion ... ... ...))) (if (and (>= p cbeg) (< p cend)) (progn (if ... ... ""))))))))
  (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or (condition-case nil (progn ...) (error nil)) (user-error "An element cannot be parsed line %d" (line-number-at-pos ...))))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type (quote comment)) (save-excursion (beginning-of-line) (looking-at "[ 	]*") (concat (match-string 0) "# "))) ((eql type (quote footnote-definition)) "") ((memql type (quote (item plain-list))) (make-string (org-list-item-body-column (or post-affiliated ...)) 32)) ((eql type (quote paragraph)) (let ((parent ...)) (save-excursion (beginning-of-line) (cond ... ... ... ...)))) ((eql type (quote comment-block)) (let* ((cbeg ...) (cend ...)) (if (and ... ...) (progn ...))))))))
  (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or (condition-case nil ... ...) (user-error "An element cannot be parsed line %d" ...)))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type (quote comment)) (save-excursion (beginning-of-line) (looking-at "[ 	]*") (concat ... "# "))) ((eql type (quote footnote-definition)) "") ((memql type (quote ...)) (make-string (org-list-item-body-column ...) 32)) ((eql type (quote paragraph)) (let (...) (save-excursion ... ...))) ((eql type (quote comment-block)) (let* (... ...) (if ... ...))))))))
  (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or (not ...) (looking-at orgtbl-line-start-regexp)) (throw (quote exit) nil)) ((looking-at message-cite-prefix-regexp) (throw (quote exit) (match-string-no-properties 0))) ((looking-at org-outline-regexp) (throw (quote exit) (make-string ... 32))))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion (beginning-of-line) (or ... ...))) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond ((eql type ...) (save-excursion ... ... ...)) ((eql type ...) "") ((memql type ...) (make-string ... 32)) ((eql type ...) (let ... ...)) ((eql type ...) (let* ... ...))))))))
  (lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...))))))))()
  apply((lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...)))))))) nil)
  #[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-adaptive-fill-function "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"]((lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...)))))))))
  apply(#[385 "\fT\306\301!\307\303 \x01\x1d\x02\x1e\x18\x03\x1c\x0e\x19\204@\0r\x0e\x18q\210\310\311!\210\312\x16	\302\204)\0\313\x0e\x18!\210db\210\f\314U\2036\0\x0e\x1ac\210\315\300\f\x06\a\x04$c\210)\307C\316\317\320\321\322\323\300\302\303\x06	$\324\"\325\326%DC\216\211\327\x06\b\x06\b\"C\240\210)\211\242@\262\x01+\207" [org-adaptive-fill-function "*trace-output*" nil #[0 "\300\207" [""] 1 "\n\n(fn)"] trace-level deactivate-mark get-buffer-create nil make-local-variable window-point-insertion-type t trace--display-buffer 1 trace-entry-message funcall make-byte-code 0 "\f?\205,\0\302 r\rq\210\301\204\x13\0\306\r!\210db\210\307\300\x0e	\303\242\203%\0\303\242@\202&\0\310\x04$c)\262\x01\207" vconcat vector [inhibit-trace trace-buffer trace--display-buffer trace-exit-message !non-local\ exit! trace-level] 6 "\n\n(fn)" apply trace-buffer inhibit-trace trace-separator] 17 "\n\n(fn BODY &rest ARGS)"] (lambda nil "Compute a fill prefix for the current line.\nReturn fill prefix, as a string, or nil if current line isn't\nmeant to be filled.  For convenience, if `adaptive-fill-regexp'\nmatches in paragraphs or comments, use it." (catch (quote exit) (if (derived-mode-p (quote message-mode)) (progn (save-excursion (beginning-of-line) (cond ((or ... ...) (throw ... nil)) ((looking-at message-cite-prefix-regexp) (throw ... ...)) ((looking-at org-outline-regexp) (throw ... ...)))))) (save-excursion (save-restriction (widen) (let* ((p (line-beginning-position)) (element (save-excursion ... ...)) (type (org-element-type element)) (post-affiliated (org-element-property :post-affiliated element))) (if (and post-affiliated (< p post-affiliated)) nil (cond (... ...) (... "") (... ...) (... ...) (... ...)))))))) nil)
  org-adaptive-fill-function()
  fill-match-adaptive-prefix()
  fill-context-prefix(2440 2513)
  adaptive-wrap-fill-context-prefix(2440 2513)
  adaptive-wrap-prefix-function(2440 2514)
  run-hook-with-args(adaptive-wrap-prefix-function 2440 2514)
  #[0 "\302\303\300\242\301\242#\207" [(2440) (2514) run-hook-with-args jit-lock-functions] 4 "\n\n(fn)"]()
  funcall(#[0 "\302\303\300\242\301\242#\207" [(2440) (2514) run-hook-with-args jit-lock-functions] 4 "\n\n(fn)"])
  jit-lock-fontify-now(2440 2940)
  jit-lock-function(2440)
  redisplay_internal\ \(C\ function\)()
  read-key-sequence(nil nil nil t)
  quail-start-translation(107)
  quail-input-method(107)
#+END_EXAMPLE

#+BEGIN_EXAMPLE
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2440)
| | | 4 -> (org-element--cache-process-request [2510 nil 1 nil 2] 2511 2440 nil)
| | | 4 <- org-element--cache-process-request: t
| | | 4 -> (org-element--cache-process-request [2511 nil 5 nil 2] 2542 2440 nil)
| | | 4 <- org-element--cache-process-request: t
| | | 4 -> (org-element--cache-process-request [2542 nil 26 nil 2] nil 2440 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 2440 :end 2512 :contents-begin 2440 :contents-end 2511 :post-blank 1 :post-affiliated 2440 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| 2 <- org-element-at-point: (headline (:raw-value #1="This is another test" :begin 2512 :end 11714 :pre-blank 1 :contents-begin 2536 :contents-end 11714 :level 1 :priority nil :tags nil :todo-keyword nil :todo-type nil :post-blank 0 :footnote-section-p nil :archivedp nil :commentedp nil :CATEGORY nil :title #1#))
1 <- org-adaptive-fill-function: nil
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2440)
| | | 4 -> (org-element--cache-process-request [2542 nil 26 nil 2] nil 2440 nil)
| | | 4 <- org-element--cache-process-request: nil
| | 3 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
| 2 <- org-element-at-point: (paragraph (:begin 2440 :end 2512 :contents-begin 2440 :contents-end 2511 :post-blank 1 :post-affiliated 2440 :parent nil))
1 <- org-adaptive-fill-function: ""
======================================================================
1 -> (org-element--cache-sync #<buffer test.org> 2510)
| 2 -> (org-element--cache-process-request [2542 nil 26 nil 2] nil 2510 nil)
| 2 <- org-element--cache-process-request: nil
1 <- org-element--cache-sync: [nil 0 0 400000 nil org-element--cache-sync (#<buffer test.org>) idle 0]
======================================================================
1 -> (org-adaptive-fill-function)
| 2 -> (org-element-at-point)
| | 3 -> (org-element--cache-sync #<buffer test.org> 2440)
| | | 4 -> (org-element--cache-process-request [2191 2672 1 nil 0] 2542 2440 nil)
#+END_EXAMPLE

[-- Attachment #3: Type: text/plain, Size: 18 bytes --]


-- 
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-29  3:01       ` Daimrod
@ 2014-05-30  9:17         ` Nicolas Goaziou
  2014-05-30 14:35           ` Daimrod
  0 siblings, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-05-30  9:17 UTC (permalink / raw)
  To: Daimrod; +Cc: Bastien, Eric Abrahamsen, emacs-orgmode

Hello,

Daimrod <daimrod@gmail.com> writes:

> I've attached part of the traces (the whole traces are way too big) and
> the backtraces.

Thanks for looking into this. However, you are running a compiled Org,
which renders backtraces less useful.

Also, you may want to disable cache refresh on idle time with, e.g.,

  (setq org-element-cache-sync-idle-time 3600)

It could make the bug easier to reproduce.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-30  9:17         ` Nicolas Goaziou
@ 2014-05-30 14:35           ` Daimrod
  2014-06-11 11:53             ` Daimrod
  0 siblings, 1 reply; 70+ messages in thread
From: Daimrod @ 2014-05-30 14:35 UTC (permalink / raw)
  To: Nicolas Goaziou; +Cc: Bastien, Eric Abrahamsen, emacs-orgmode

Nicolas Goaziou <n.goaziou@gmail.com> writes:

> Hello,
>
> Daimrod <daimrod@gmail.com> writes:
>
>> I've attached part of the traces (the whole traces are way too big) and
>> the backtraces.
>
> Thanks for looking into this. However, you are running a compiled Org,
> which renders backtraces less useful.

Ok, I was wondering why the backtraces was so ugly, I didn't think about
byte-compilation... Thanks for the tip.

> Also, you may want to disable cache refresh on idle time with, e.g.,
>
>   (setq org-element-cache-sync-idle-time 3600)
>
> It could make the bug easier to reproduce.

Thanks, I'll try again this w.e.

Best,

-- 
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-15  9:30   ` Daimrod
                       ` (2 preceding siblings ...)
  2014-05-19 14:21     ` Daimrod
@ 2014-06-04  4:47     ` Eric Abrahamsen
  2014-06-05  4:29       ` Daimrod
  3 siblings, 1 reply; 70+ messages in thread
From: Eric Abrahamsen @ 2014-06-04  4:47 UTC (permalink / raw)
  To: emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> Bastien <bzg@gnu.org> writes:
>
>> Hi Eric,
>>
>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>
>>> After Nicolas made the last round of improvements to the caching
>>> mechanism I got far fewer hangs with Org, but they are still happening.
>>> Maybe once a day or so, on average, editing something in an Org buffer
>>> causes emacs to hang, and my fans to spin up, and there we are until I
>>> kill emacs.

[...]

> By the way, if you want to see in which part the infloop occurs, you can
> attach a gdb debugger to the running emacs, source the
> <path-to-emacs-source>/src/.gdbinit file and use the `xbacktrace' command.
>
> $ gdb <path-to-emacs-executable> <emacs-pid>
> gdb) source <path-to-emacs-source>/src/.gdbinit
> ...
> gdb) xbacktrace
>
> You can also use the `bt' command but it contains much more noise.

I got another one just now (while moving from one org table cell to the
next), and that was the gdb backtrace:

"avl-tree--do-delete" (0xbfffe858)
"avl-tree-delete" (0xbfffe998)
"byte-code" (0xbfffeaa0)
"byte-code" (0xbfffec30)
"org-element--cache-process-request" (0xbfffedd8)
"byte-code" (0xbfffeef0)
"org-element--cache-sync" (0xbffff0a8)
"org-element-at-point" (0xbffff1e8)
"org-mode-flyspell-verify" (0xbffff338)
"flyspell-word" (0xbffff478)
"byte-code" (0xbffff580)
"flyspell-post-command-hook" (0xbffff784)

Not much, and probably not that useful. I'll start running org
uncompiled, and try the debug-on-event trick.

FWIW, this was the first lockup that *didn't* occur in a logbook
drawer -- that's where I usually get them. Either a full lockup, or else
the cache goes wonky so that adding log notes (or even just navigating
in the drawer) gives me that "bound on wrong side of point" you get when
you try to search forwards, backwards.

E

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-04  4:47     ` Eric Abrahamsen
@ 2014-06-05  4:29       ` Daimrod
  0 siblings, 0 replies; 70+ messages in thread
From: Daimrod @ 2014-06-05  4:29 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> Daimrod <daimrod@gmail.com> writes:
>
>> Bastien <bzg@gnu.org> writes:
>>
>>> Hi Eric,
>>>
>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>
>>>> After Nicolas made the last round of improvements to the caching
>>>> mechanism I got far fewer hangs with Org, but they are still happening.
>>>> Maybe once a day or so, on average, editing something in an Org buffer
>>>> causes emacs to hang, and my fans to spin up, and there we are until I
>>>> kill emacs.
>
> [...]
>
>> By the way, if you want to see in which part the infloop occurs, you can
>> attach a gdb debugger to the running emacs, source the
>> <path-to-emacs-source>/src/.gdbinit file and use the `xbacktrace' command.
>>
>> $ gdb <path-to-emacs-executable> <emacs-pid>
>> gdb) source <path-to-emacs-source>/src/.gdbinit
>> ...
>> gdb) xbacktrace
>>
>> You can also use the `bt' command but it contains much more noise.
>
> I got another one just now (while moving from one org table cell to the
> next), and that was the gdb backtrace:
>
> "avl-tree--do-delete" (0xbfffe858)
> "avl-tree-delete" (0xbfffe998)
> "byte-code" (0xbfffeaa0)
> "byte-code" (0xbfffec30)
> "org-element--cache-process-request" (0xbfffedd8)
> "byte-code" (0xbfffeef0)
> "org-element--cache-sync" (0xbffff0a8)
> "org-element-at-point" (0xbffff1e8)
> "org-mode-flyspell-verify" (0xbffff338)
> "flyspell-word" (0xbffff478)
> "byte-code" (0xbffff580)
> "flyspell-post-command-hook" (0xbffff784)

It seems the lockup also happens in `org-element--cache-...'.

> Not much, and probably not that useful. I'll start running org
> uncompiled, and try the debug-on-event trick.

Thanks for you time!

> FWIW, this was the first lockup that *didn't* occur in a logbook
> drawer -- that's where I usually get them. Either a full lockup, or else
> the cache goes wonky so that adding log notes (or even just navigating
> in the drawer) gives me that "bound on wrong side of point" you get when
> you try to search forwards, backwards.

That's weird (in my cases it usually mess up with the input-method).

-- 
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-30 14:35           ` Daimrod
@ 2014-06-11 11:53             ` Daimrod
  2014-06-11 21:30               ` Nicolas Goaziou
  0 siblings, 1 reply; 70+ messages in thread
From: Daimrod @ 2014-06-11 11:53 UTC (permalink / raw)
  To: Nicolas Goaziou; +Cc: Bastien, Eric Abrahamsen, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 1757 bytes --]

Daimrod <daimrod@gmail.com> writes:

> Nicolas Goaziou <n.goaziou@gmail.com> writes:
>
>> Hello,
>>
>> Daimrod <daimrod@gmail.com> writes:
>>
>>> I've attached part of the traces (the whole traces are way too big) and
>>> the backtraces.
>>
>> Thanks for looking into this. However, you are running a compiled Org,
>> which renders backtraces less useful.
>
> Ok, I was wondering why the backtraces was so ugly, I didn't think about
> byte-compilation... Thanks for the tip.
>
>> Also, you may want to disable cache refresh on idle time with, e.g.,
>>
>>   (setq org-element-cache-sync-idle-time 3600)
>>
>> It could make the bug easier to reproduce.
>
> Thanks, I'll try again this w.e.

Okay, so I've found a more or less reliable way to reproduce this bug (on my
machine at least).

1. $ emacs -Q -l debug.el test.org
2. Expand headline (<S-TAB>)
3. go below the first headline (C-n)
4. press `i' a couple of seconds ~10 chars
5. delete the line (C-a C-k)
6. goto 4 until if locks up

As I said, it's not completely reliable but so far the lockup always
happens. Sometimes it happens after the third iteration, sometimes after
the tenth iteration, but it always happen.

I've attached `debug.el' and `test.org'.

`debug.el' setup the "environment" to reproduce the bug, you may need to
change the path to your orgmode source base and you'll need
`adaptive-wrap-prefix-mode' (available on ELPA).

I've been able to reproduce the bug without `adaptive-wrap-prefix-mode'
though other people have reported the same symptoms without using it.


`test.org' is a simple org file with two headlines. It seems that two
headlines are required to trigger the cache mechanism (with
`org-element-cache--sync').


Do you confirm the lockup with this setting?

Best,



[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: test.org --]
[-- Type: text/x-org, Size: 11 bytes --]

* i

* i
i

[-- Attachment #3: debug.el --]
[-- Type: application/emacs-lisp, Size: 965 bytes --]

[-- Attachment #4: Type: text/plain, Size: 19 bytes --]



-- 
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-11 11:53             ` Daimrod
@ 2014-06-11 21:30               ` Nicolas Goaziou
  2014-06-11 22:18                 ` Daimrod
  0 siblings, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-06-11 21:30 UTC (permalink / raw)
  To: Daimrod; +Cc: Bastien, Eric Abrahamsen, emacs-orgmode

Hello,

Daimrod <daimrod@gmail.com> writes:

> Okay, so I've found a more or less reliable way to reproduce this bug (on my
> machine at least).
>
> 1. $ emacs -Q -l debug.el test.org
> 2. Expand headline (<S-TAB>)
> 3. go below the first headline (C-n)
> 4. press `i' a couple of seconds ~10 chars
> 5. delete the line (C-a C-k)
> 6. goto 4 until if locks up
>
> As I said, it's not completely reliable but so far the lockup always
> happens. Sometimes it happens after the third iteration, sometimes after
> the tenth iteration, but it always happen.
>
> I've attached `debug.el' and `test.org'.
>

[...]

> Do you confirm the lockup with this setting?

Yes, I do. I will investigate on this soon. Thank you for providing this
recipe.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-11 21:30               ` Nicolas Goaziou
@ 2014-06-11 22:18                 ` Daimrod
  2014-06-14  7:43                   ` Nicolas Goaziou
  0 siblings, 1 reply; 70+ messages in thread
From: Daimrod @ 2014-06-11 22:18 UTC (permalink / raw)
  To: Bastien; +Cc: Eric Abrahamsen, emacs-orgmode

Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:

> Hello,
>
> Daimrod <daimrod@gmail.com> writes:
>
>> Okay, so I've found a more or less reliable way to reproduce this bug (on my
>> machine at least).
>>
>> 1. $ emacs -Q -l debug.el test.org
>> 2. Expand headline (<S-TAB>)
>> 3. go below the first headline (C-n)
>> 4. press `i' a couple of seconds ~10 chars
>> 5. delete the line (C-a C-k)
>> 6. goto 4 until if locks up
>>
>> As I said, it's not completely reliable but so far the lockup always
>> happens. Sometimes it happens after the third iteration, sometimes after
>> the tenth iteration, but it always happen.
>>
>> I've attached `debug.el' and `test.org'.
>>
>
> [...]
>
>> Do you confirm the lockup with this setting?
>
> Yes, I do. I will investigate on this soon. Thank you for providing this
> recipe.

Cool!

Also, I should have mentioned that I didn't trace the function
`org-element--cache-key-less-p' because when I do so, Emacs stays locked
even when I send it the signal SIGUSR2. However, this function appears
in the backtrace produced by `xbacktrace' in a gdb session if I call it
during a lockup.

My guess is that the lockup happens in `org-element--cache-key-less-p',
called by `org-element--cache-process-request'.

Best,

-- 
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-11 22:18                 ` Daimrod
@ 2014-06-14  7:43                   ` Nicolas Goaziou
  2014-06-14 23:55                     ` Daimrod
  0 siblings, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-06-14  7:43 UTC (permalink / raw)
  To: Daimrod; +Cc: Bastien, Eric Abrahamsen, emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> My guess is that the lockup happens in `org-element--cache-key-less-p',
> called by `org-element--cache-process-request'.

Probably, but it doesn't mean that this particular function is buggy.
The lockup happens there because the cache gets corrupted at some point.

After investigating a little while, it appears that switching
input-method to "latin-postfix" alone is sufficient to corrupt it.
Though, setting `org-element-cache-sync-idle-time' to a high value
prevents the problem, which means that the corruption happens only when
cache is synchronized during idle time.

That's where I am for the time being. I don't know much about input
methods, so I have no clue about the reasons behind this. I'm still
investigating.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-14  7:43                   ` Nicolas Goaziou
@ 2014-06-14 23:55                     ` Daimrod
  2014-06-22  7:58                       ` Nicolas Goaziou
  0 siblings, 1 reply; 70+ messages in thread
From: Daimrod @ 2014-06-14 23:55 UTC (permalink / raw)
  To: Bastien; +Cc: Eric Abrahamsen, emacs-orgmode

Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:

> Daimrod <daimrod@gmail.com> writes:
>
>> My guess is that the lockup happens in `org-element--cache-key-less-p',
>> called by `org-element--cache-process-request'.
>
> Probably, but it doesn't mean that this particular function is buggy.
> The lockup happens there because the cache gets corrupted at some point.

I see.

> After investigating a little while, it appears that switching
> input-method to "latin-postfix" alone is sufficient to corrupt it.
> Though, setting `org-element-cache-sync-idle-time' to a high value
> prevents the problem, which means that the corruption happens only when
> cache is synchronized during idle time.

Ok.

> That's where I am for the time being. I don't know much about input
> methods, so I have no clue about the reasons behind this. I'm still
> investigating.

I would help if I knew about input-methods or the caching mechanism, but
I do not. :-(

Thanks for investigating.

Best,

-- 
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-14 23:55                     ` Daimrod
@ 2014-06-22  7:58                       ` Nicolas Goaziou
  0 siblings, 0 replies; 70+ messages in thread
From: Nicolas Goaziou @ 2014-06-22  7:58 UTC (permalink / raw)
  To: Daimrod; +Cc: Bastien, Eric Abrahamsen, emacs-orgmode

Hello,

Daimrod <daimrod@gmail.com> writes:

> Thanks for investigating.

I made some progress. Alas I didn't find a definitive answer yet.

The problem is related to `quail-input-method', which let-binds
`inhibit-modifications-hooks' to t. This is usually done around
a function that modifies text properties in a buffer.

However, in that case, it calls `quail-start-translation',
`quail-self-insert-command', `quail-self-insert-command' and eventually
`quail-update-translation', which modifies the _contents_ of the buffer
(twice actually, with `quail-delete-region' at line 1555 in
"quail.el.gz" and with `insert' at line 1579).

Since these modifications happen when `inhibit-modifications-hooks' is
non-nil, `after-change-functions' are never called, and the cache cannot
be updated properly, ending in a corrupted state.

There is a workaround for this: if `input-method-use-echo-area' is
non-nil, these modifications happen in the minibuffer, and, thus, the
buffer is not modified.

I also tried to set `inhibit-modifications-hooks' to nil around the two
locations where the buffer is modified (see above), but something odd
happens. Indeed, in that case, `after-change-functions' are called once
too many (i.e, the same buffer modification triggers these calls twice),
corrupting again the buffer. Unfortunately, I have no explanation about
this yet.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-20 11:16           ` Eric Abrahamsen
@ 2014-06-24  8:48             ` Nicolas Goaziou
  2014-06-24 14:28               ` Eric Abrahamsen
  0 siblings, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-06-24  8:48 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

Hello,

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> None of those three, I'm afraid! It was hanging on a variety of editing
> operations that, as far as I can tell, had little in common. There's a
> possibility that they were list-item-related, but really there wasn't
> much commonality.

FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
lockups. Hopefully, it may be related to your problem (which is
different from Daimrod's).


Regards,

[fn:1] 77e234e5785f5aaa60f1e316863a2571de64bbd4

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-24  8:48             ` Nicolas Goaziou
@ 2014-06-24 14:28               ` Eric Abrahamsen
  2014-06-25  4:09                 ` Matt Lundin
  2014-06-28 19:27                 ` Eric Abrahamsen
  0 siblings, 2 replies; 70+ messages in thread
From: Eric Abrahamsen @ 2014-06-24 14:28 UTC (permalink / raw)
  To: emacs-orgmode

Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:

> Hello,
>
> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> None of those three, I'm afraid! It was hanging on a variety of editing
>> operations that, as far as I can tell, had little in common. There's a
>> possibility that they were list-item-related, but really there wasn't
>> much commonality.
>
> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
> lockups. Hopefully, it may be related to your problem (which is
> different from Daimrod's).

Thanks for the followup! I was watching Daimrod's thread, and also
Matt's most recent posting -- that also seemed more relevant to my
problems, which were almost solely confined to log/state notes. I've
pulled the fix, and will let you know if I see any more problems.

Thanks
Eric

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-24 14:28               ` Eric Abrahamsen
@ 2014-06-25  4:09                 ` Matt Lundin
  2014-06-25  5:39                   ` Matt Lundin
                                     ` (2 more replies)
  2014-06-28 19:27                 ` Eric Abrahamsen
  1 sibling, 3 replies; 70+ messages in thread
From: Matt Lundin @ 2014-06-25  4:09 UTC (permalink / raw)
  To: emacs-orgmode

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:
>
>> Hello,
>>
>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>
>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>> operations that, as far as I can tell, had little in common. There's a
>>> possibility that they were list-item-related, but really there wasn't
>>> much commonality.
>>
>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>> lockups. Hopefully, it may be related to your problem (which is
>> different from Daimrod's).
>
> Thanks for the followup! I was watching Daimrod's thread, and also
> Matt's most recent posting -- that also seemed more relevant to my
> problems, which were almost solely confined to log/state notes. I've
> pulled the fix, and will let you know if I see any more problems.

With the latest git, I've experienced three lock-ups/freezes this
evening when a) archiving a subtree to a file, b) changing a todo state
with repeating timestamp, and 3) calling C-c C-c in an org-capture
buffer. (I don't think this is due to a recent change - I've been
running into these lockups sporadically for several months.)

The freezes are very difficult to replicate reliably. When they happen,
emacs is unresponsive and can only be killed from the outside. Any tips
on how to debug this would be greatly appreciated.

Matt

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-25  4:09                 ` Matt Lundin
@ 2014-06-25  5:39                   ` Matt Lundin
  2014-06-25  7:32                   ` Sebastien Vauban
  2014-06-25  7:38                   ` Daimrod
  2 siblings, 0 replies; 70+ messages in thread
From: Matt Lundin @ 2014-06-25  5:39 UTC (permalink / raw)
  To: emacs-orgmode

Matt Lundin <mdl@imapmail.org> writes:

> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:
>>
>>> Hello,
>>>
>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>
>>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>>> operations that, as far as I can tell, had little in common. There's a
>>>> possibility that they were list-item-related, but really there wasn't
>>>> much commonality.
>>>
>>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>>> lockups. Hopefully, it may be related to your problem (which is
>>> different from Daimrod's).
>>
>> Thanks for the followup! I was watching Daimrod's thread, and also
>> Matt's most recent posting -- that also seemed more relevant to my
>> problems, which were almost solely confined to log/state notes. I've
>> pulled the fix, and will let you know if I see any more problems.
>
> With the latest git, I've experienced three lock-ups/freezes this
> evening when a) archiving a subtree to a file, b) changing a todo state
> with repeating timestamp, and 3) calling C-c C-c in an org-capture
> buffer. (I don't think this is due to a recent change - I've been
> running into these lockups sporadically for several months.)
>
> The freezes are very difficult to replicate reliably. When they happen,
> emacs is unresponsive and can only be killed from the outside. Any tips
> on how to debug this would be greatly appreciated.

FWIW, Emacs just locked up again when I attempted to refile a subtree
from one org file to another (using org-refile).

GNU Emacs 24.3.1 (x86_64-unknown-linux-gnu, GTK+ Version 3.12.2) of 2014-06-11 on var-lib-archbuild-staging-x86_64-jgc
Org-mode version beta_8.3 (beta_8.3-26-g1c3bdb @/home/user123/org-mode/lisp/)

Matt

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-25  4:09                 ` Matt Lundin
  2014-06-25  5:39                   ` Matt Lundin
@ 2014-06-25  7:32                   ` Sebastien Vauban
  2014-06-27 13:00                     ` Nicolas Goaziou
  2014-06-25  7:38                   ` Daimrod
  2 siblings, 1 reply; 70+ messages in thread
From: Sebastien Vauban @ 2014-06-25  7:32 UTC (permalink / raw)
  To: emacs-orgmode-mXXj517/zsQ

Matt Lundin wrote:
> Eric Abrahamsen <eric-5ibeKGLO59aIK5dEoMBc7KxOck334EZe@public.gmane.org> writes:
>> Nicolas Goaziou <mail-Gpy5sJQTEQHwkn9pgDnJRVAUjnlXr6A1@public.gmane.org> writes:
>>> Eric Abrahamsen <eric-5ibeKGLO59aIK5dEoMBc7KxOck334EZe@public.gmane.org> writes:
>>>
>>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>>> operations that, as far as I can tell, had little in common. There's a
>>>> possibility that they were list-item-related, but really there wasn't
>>>> much commonality.
>>>
>>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>>> lockups. Hopefully, it may be related to your problem (which is
>>> different from Daimrod's).
>>
>> Thanks for the followup! I was watching Daimrod's thread, and also
>> Matt's most recent posting -- that also seemed more relevant to my
>> problems, which were almost solely confined to log/state notes. I've
>> pulled the fix, and will let you know if I see any more problems.
>
> With the latest git, I've experienced three lock-ups/freezes this
> evening when a) archiving a subtree to a file, b) changing a todo state
> with repeating timestamp, and 3) calling C-c C-c in an org-capture
> buffer. (I don't think this is due to a recent change - I've been
> running into these lockups sporadically for several months.)
>
> The freezes are very difficult to replicate reliably. When they happen,
> emacs is unresponsive and can only be killed from the outside. Any tips
> on how to debug this would be greatly appreciated.

I also still experience semi-regular Emacs infloops, particularly when
editing clocking entries manually (with the arrow keys), in the LOGBOOK
drawer. It's quite often in such a situation, though not 100%
reproducible.

Unluckily, these infloops are not stoppable via C-g, as it seems to
occur in portions of code where "quit" is inhibited (see recent comments
from Stefan).

Current environment:

- GNU Emacs 24.4.50.1 (i686-pc-mingw32) of 2014-06-15 on LEG570

- Org-mode version 8.2.7 (release_8.2.7-1119-gfcc51c/) -- though I'll
  update right now!

Best regards,
  Seb

-- 
Sebastien Vauban

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-25  4:09                 ` Matt Lundin
  2014-06-25  5:39                   ` Matt Lundin
  2014-06-25  7:32                   ` Sebastien Vauban
@ 2014-06-25  7:38                   ` Daimrod
  2014-06-25  8:22                     ` Eric Abrahamsen
                                       ` (2 more replies)
  2 siblings, 3 replies; 70+ messages in thread
From: Daimrod @ 2014-06-25  7:38 UTC (permalink / raw)
  To: Matt Lundin; +Cc: emacs-orgmode

Matt Lundin <mdl@imapmail.org> writes:

> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:
>>
>>> Hello,
>>>
>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>
>>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>>> operations that, as far as I can tell, had little in common. There's a
>>>> possibility that they were list-item-related, but really there wasn't
>>>> much commonality.
>>>
>>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>>> lockups. Hopefully, it may be related to your problem (which is
>>> different from Daimrod's).
>>
>> Thanks for the followup! I was watching Daimrod's thread, and also
>> Matt's most recent posting -- that also seemed more relevant to my
>> problems, which were almost solely confined to log/state notes. I've
>> pulled the fix, and will let you know if I see any more problems.
>
> With the latest git, I've experienced three lock-ups/freezes this
> evening when a) archiving a subtree to a file, b) changing a todo state
> with repeating timestamp, and 3) calling C-c C-c in an org-capture
> buffer. (I don't think this is due to a recent change - I've been
> running into these lockups sporadically for several months.)
>
> The freezes are very difficult to replicate reliably. When they happen,
> emacs is unresponsive and can only be killed from the outside. Any tips
> on how to debug this would be greatly appreciated.

See my previous post:
http://thread.gmane.org/gmane.emacs.orgmode/86255/focus=86263

You can wrap `jit-lock--debug-fontify' with:

(advice-add 'jit-lock--debug-fontify :around
            (lambda (fun &rest args)
              (with-local-quit (apply fun args))))

and then force emacs to break and display a backtrace by sending the
SIGUSR2 to the emacs process.

Best,

--
Daimrod/Greg

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-25  7:38                   ` Daimrod
@ 2014-06-25  8:22                     ` Eric Abrahamsen
  2014-06-25  8:30                       ` Bastien
  2014-06-25 13:47                     ` Matt Lundin
  2014-06-26  2:58                     ` Matt Lundin
  2 siblings, 1 reply; 70+ messages in thread
From: Eric Abrahamsen @ 2014-06-25  8:22 UTC (permalink / raw)
  To: emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> Matt Lundin <mdl@imapmail.org> writes:
>
>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>
>>> Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:
>>>
>>>> Hello,
>>>>
>>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>>
>>>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>>>> operations that, as far as I can tell, had little in common. There's a
>>>>> possibility that they were list-item-related, but really there wasn't
>>>>> much commonality.
>>>>
>>>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>>>> lockups. Hopefully, it may be related to your problem (which is
>>>> different from Daimrod's).
>>>
>>> Thanks for the followup! I was watching Daimrod's thread, and also
>>> Matt's most recent posting -- that also seemed more relevant to my
>>> problems, which were almost solely confined to log/state notes. I've
>>> pulled the fix, and will let you know if I see any more problems.
>>
>> With the latest git, I've experienced three lock-ups/freezes this
>> evening when a) archiving a subtree to a file, b) changing a todo state
>> with repeating timestamp, and 3) calling C-c C-c in an org-capture
>> buffer. (I don't think this is due to a recent change - I've been
>> running into these lockups sporadically for several months.)
>>
>> The freezes are very difficult to replicate reliably. When they happen,
>> emacs is unresponsive and can only be killed from the outside. Any tips
>> on how to debug this would be greatly appreciated.
>
> See my previous post:
> http://thread.gmane.org/gmane.emacs.orgmode/86255/focus=86263
>
> You can wrap `jit-lock--debug-fontify' with:
>
> (advice-add 'jit-lock--debug-fontify :around
>             (lambda (fun &rest args)
>               (with-local-quit (apply fun args))))
>
> and then force emacs to break and display a backtrace by sending the
> SIGUSR2 to the emacs process.

I think the advice here was also to run Org uncompiled, as that produces
a more useful backtrace, is that right? A couple of times I've gotten
SIGUSR2 to knock emacs out of a lock, but it was only while I was
running a compiled org. The one time I was running uncompiled and got a
lock, even SIGUSR2 couldn't bring it back...

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-25  8:22                     ` Eric Abrahamsen
@ 2014-06-25  8:30                       ` Bastien
  2014-06-25  8:40                         ` Eric Abrahamsen
  0 siblings, 1 reply; 70+ messages in thread
From: Bastien @ 2014-06-25  8:30 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

Hi Eric,

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> I think the advice here was also to run Org uncompiled, as that produces
> a more useful backtrace, is that right?

Yes, that's right -- generally, backtraces from compiled Org are
mungled, while backtraces from an uncompiled Org are readable.

> A couple of times I've gotten
> SIGUSR2 to knock emacs out of a lock, but it was only while I was
> running a compiled org. The one time I was running uncompiled and got a
> lock, even SIGUSR2 couldn't bring it back...

Yes, compilation does not affect whether or not you can escape a lock.

-- 
 Bastien

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-25  8:30                       ` Bastien
@ 2014-06-25  8:40                         ` Eric Abrahamsen
  0 siblings, 0 replies; 70+ messages in thread
From: Eric Abrahamsen @ 2014-06-25  8:40 UTC (permalink / raw)
  To: emacs-orgmode

Bastien <bzg@gnu.org> writes:

> Hi Eric,
>
> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> I think the advice here was also to run Org uncompiled, as that produces
>> a more useful backtrace, is that right?
>
> Yes, that's right -- generally, backtraces from compiled Org are
> mungled, while backtraces from an uncompiled Org are readable.
>
>> A couple of times I've gotten
>> SIGUSR2 to knock emacs out of a lock, but it was only while I was
>> running a compiled org. The one time I was running uncompiled and got a
>> lock, even SIGUSR2 couldn't bring it back...
>
> Yes, compilation does not affect whether or not you can escape a lock.

Right, I didn't mean to imply that, just that SIGUSR2 doesn't always
bring it back from the dead...

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-25  7:38                   ` Daimrod
  2014-06-25  8:22                     ` Eric Abrahamsen
@ 2014-06-25 13:47                     ` Matt Lundin
  2014-06-26  2:58                     ` Matt Lundin
  2 siblings, 0 replies; 70+ messages in thread
From: Matt Lundin @ 2014-06-25 13:47 UTC (permalink / raw)
  To: Daimrod; +Cc: emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> Matt Lundin <mdl@imapmail.org> writes:
>
>>
>> The freezes are very difficult to replicate reliably. When they happen,
>> emacs is unresponsive and can only be killed from the outside. Any tips
>> on how to debug this would be greatly appreciated.
>
> See my previous post:
> http://thread.gmane.org/gmane.emacs.orgmode/86255/focus=86263
>
> You can wrap `jit-lock--debug-fontify' with:
>
> (advice-add 'jit-lock--debug-fontify :around
>             (lambda (fun &rest args)
>               (with-local-quit (apply fun args))))
>
> and then force emacs to break and display a backtrace by sending the
> SIGUSR2 to the emacs process.
>

Thanks, that's helpful. It seems jit-lock--debug-fontify is the
development emacs. I'll build that in a moment...

For the record, I've been seeing these lockups with stable releases of
emacs (currently 24.3).

Thanks,
Matt

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-25  7:38                   ` Daimrod
  2014-06-25  8:22                     ` Eric Abrahamsen
  2014-06-25 13:47                     ` Matt Lundin
@ 2014-06-26  2:58                     ` Matt Lundin
  2014-06-26  3:00                       ` Matt Lundin
  2014-06-27 12:56                       ` Nicolas Goaziou
  2 siblings, 2 replies; 70+ messages in thread
From: Matt Lundin @ 2014-06-26  2:58 UTC (permalink / raw)
  To: Daimrod; +Cc: emacs-orgmode

Daimrod <daimrod@gmail.com> writes:

> Matt Lundin <mdl@imapmail.org> writes:
>>
>> With the latest git, I've experienced three lock-ups/freezes this
>> evening when a) archiving a subtree to a file, b) changing a todo state
>> with repeating timestamp, and 3) calling C-c C-c in an org-capture
>> buffer. (I don't think this is due to a recent change - I've been
>> running into these lockups sporadically for several months.)
>>
>> The freezes are very difficult to replicate reliably. When they happen,
>> emacs is unresponsive and can only be killed from the outside. Any tips
>> on how to debug this would be greatly appreciated.
>
> See my previous post:
> http://thread.gmane.org/gmane.emacs.orgmode/86255/focus=86263
>
> You can wrap `jit-lock--debug-fontify' with:
>
> (advice-add 'jit-lock--debug-fontify :around
>             (lambda (fun &rest args)
>               (with-local-quit (apply fun args))))
>
> and then force emacs to break and display a backtrace by sending the
> SIGUSR2 to the emacs process.

O.K., I built the most emacs development from bzr and used the advice
above.

With "killall -USR2 emacs", the following backtrace popped up, which
highlights flyspell as the culrpit. Note: I have flyspell turned on in
all text buffers, but I have (for several months) only experienced
lockups when using org-mode. I spend more time in TeX buffers than in
org-mode, and I have never had a lockup with AUCTeX.

--8<---------------cut here---------------start------------->8---
* (setq quit-flag t)
  (condition-case nil (let ((inhibit-quit nil)) (let ((command
  this-command) deactivate-mark) (if (flyspell-check-pre-word-p)
  (save-excursion (quote (flyspell-debug-signal-pre-word-checked))
  (goto-char flyspell-pre-point) (flyspell-word))) (if
  (flyspell-check-word-p) (progn (quote
  (flyspell-debug-signal-word-checked)) (flyspell-word) (setq
  flyspell-pre-pre-buffer (current-buffer)) (setq flyspell-pre-pre-point
  (point))) (setq flyspell-pre-pre-buffer nil) (setq
  flyspell-pre-pre-point nil) (if (and (symbolp this-command) (get
  this-command (quote flyspell-delayed))) (progn (setq
  flyspell-word-cache-end -1) (setq flyspell-word-cache-result (quote
  _))))) (while (and (not (input-pending-p)) (consp flyspell-changes))
  (let ((start (car ...)) (stop (cdr ...))) (if
  (flyspell-check-changed-word-p start stop) (save-excursion (quote ...)
  (goto-char start) (flyspell-word))) (setq flyspell-changes (cdr
  flyspell-changes)))) (setq flyspell-previous-command command))) (quit
  (setq quit-flag t) (eval (quote (ignore nil)))))
    (progn (condition-case nil (let ((inhibit-quit nil)) (let ((command
    this-command) deactivate-mark) (if (flyspell-check-pre-word-p)
    (save-excursion (quote (flyspell-debug-signal-pre-word-checked))
    (goto-char flyspell-pre-point) (flyspell-word))) (if
    (flyspell-check-word-p) (progn (quote
    (flyspell-debug-signal-word-checked)) (flyspell-word) (setq
    flyspell-pre-pre-buffer (current-buffer)) (setq
    flyspell-pre-pre-point (point))) (setq flyspell-pre-pre-buffer nil)
    (setq flyspell-pre-pre-point nil) (if (and (symbolp this-command)
    (get this-command ...)) (progn (setq flyspell-word-cache-end -1)
    (setq flyspell-word-cache-result ...)))) (while (and (not
    (input-pending-p)) (consp flyspell-changes)) (let ((start ...) (stop
    ...)) (if (flyspell-check-changed-word-p start stop) (save-excursion
    ... ... ...)) (setq flyspell-changes (cdr flyspell-changes)))) (setq
    flyspell-previous-command command))) (quit (setq quit-flag t) (eval
    (quote (ignore nil))))))
      (if flyspell-mode (progn (condition-case nil (let ((inhibit-quit
      nil)) (let ((command this-command) deactivate-mark) (if
      (flyspell-check-pre-word-p) (save-excursion (quote ...) (goto-char
      flyspell-pre-point) (flyspell-word))) (if (flyspell-check-word-p)
      (progn (quote ...) (flyspell-word) (setq flyspell-pre-pre-buffer
      ...) (setq flyspell-pre-pre-point ...)) (setq
      flyspell-pre-pre-buffer nil) (setq flyspell-pre-pre-point nil) (if
      (and ... ...) (progn ... ...))) (while (and (not ...) (consp
      flyspell-changes)) (let (... ...) (if ... ...) (setq
      flyspell-changes ...))) (setq flyspell-previous-command command)))
      (quit (setq quit-flag t) (eval (quote (ignore nil)))))))
        flyspell-post-command-hook()
          recursive-edit()
--8<---------------cut here---------------end--------------->8---

Matt

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-26  2:58                     ` Matt Lundin
@ 2014-06-26  3:00                       ` Matt Lundin
  2014-06-27 12:56                       ` Nicolas Goaziou
  1 sibling, 0 replies; 70+ messages in thread
From: Matt Lundin @ 2014-06-26  3:00 UTC (permalink / raw)
  To: Daimrod; +Cc: emacs-orgmode

Matt Lundin <mdl@imapmail.org> writes:

> With "killall -USR2 emacs", the following backtrace popped up, which
> highlights flyspell as the culrpit.
                             ~~~~~~~
And, of course, I had flyspell turned off when writing this email. :)

Matt

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-26  2:58                     ` Matt Lundin
  2014-06-26  3:00                       ` Matt Lundin
@ 2014-06-27 12:56                       ` Nicolas Goaziou
  2014-06-27 13:37                         ` Alan Schmitt
  1 sibling, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-06-27 12:56 UTC (permalink / raw)
  To: Matt Lundin; +Cc: Daimrod, emacs-orgmode

Hello,

Matt Lundin <mdl@imapmail.org> writes:

> With "killall -USR2 emacs", the following backtrace popped up, which
> highlights flyspell as the culrpit. Note: I have flyspell turned on in
> all text buffers, but I have (for several months) only experienced
> lockups when using org-mode. I spend more time in TeX buffers than in
> org-mode, and I have never had a lockup with AUCTeX.
>
> * (setq quit-flag t)
>   (condition-case nil (let ((inhibit-quit nil)) (let ((command
>   this-command) deactivate-mark) (if (flyspell-check-pre-word-p)
>   (save-excursion (quote (flyspell-debug-signal-pre-word-checked))
>   (goto-char flyspell-pre-point) (flyspell-word))) (if

[...]

Thank you for the report.

Unfortunately, this backtrace doesn't help much. Even if it referred
explicitly to a cache-related function, it would likely not explain the
reasons behind the cache corruption. I need an ECM (even if the bug
isn't 100 % reproducible) for that.

In the meantime, if you can, please update Org regularly, as I'm
reviewing the code and will probably make changes along the way.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-25  7:32                   ` Sebastien Vauban
@ 2014-06-27 13:00                     ` Nicolas Goaziou
  0 siblings, 0 replies; 70+ messages in thread
From: Nicolas Goaziou @ 2014-06-27 13:00 UTC (permalink / raw)
  To: Sebastien Vauban; +Cc: public-emacs-orgmode-mXXj517/zsQ



Hello,

Sebastien Vauban <sva-news-D0wtAvR13HarG/iDocfnWg@public.gmane.org>
writes:

> I also still experience semi-regular Emacs infloops, particularly when
> editing clocking entries manually (with the arrow keys), in the LOGBOOK
> drawer. It's quite often in such a situation, though not 100%
> reproducible.

I tried but couldn't reproduce it. Please provide an ECM (even without
100 % success) if you can.

> - Org-mode version 8.2.7 (release_8.2.7-1119-gfcc51c/) -- though I'll
>   update right now!

Please do. I made some changes to the code recently.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-27 12:56                       ` Nicolas Goaziou
@ 2014-06-27 13:37                         ` Alan Schmitt
  2014-06-27 22:31                           ` Nicolas Goaziou
  0 siblings, 1 reply; 70+ messages in thread
From: Alan Schmitt @ 2014-06-27 13:37 UTC (permalink / raw)
  To: Matt Lundin; +Cc: Daimrod, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 2181 bytes --]

I've also just been bitten by this bug, as I was doing my weekly
review. I'll try to see if I can write an ECM, but for the record this
is what I was doing: I was in an agenda view sorted by the value of
a LAST_REVIEW property, and I was repeatedly calling this function on
the entries of the view:

#+begin_src emacs-lisp
(defun org-review-insert-last-review (&optional prompt)
  "Insert the current date as last review. If prefix argument:
prompt the user for the date. If `org-review-sets-next-date' is
set to `t', also insert a next review date."
  (interactive "P")
  (let ((ts (if prompt
                (concat "<" (org-read-date) ">")
              (format-time-string (car org-time-stamp-formats)))))
    (org-review-insert-date org-review-last-property-name
			    org-review-last-timestamp-format
			    ts)
    (when org-review-sets-next-date
      (org-review-insert-date
       org-review-next-property-name
       org-review-next-timestamp-format
       (format-time-string (car org-time-stamp-formats)
			   (org-review-last-planned 
			    ts
			    (or (org-review-review-delay-prop
				 (if (equal (buffer-name) org-agenda-buffer-name)
				     (or (org-get-at-bol 'org-marker)
					 (org-agenda-error))
				   (point)))
				org-review-delay)))))))
#+end_src

the `org-review-insert-date` is defined as follows

#+begin_src emacs-lisp
(defun org-review-insert-date (propname fmt date)
  "Insert the DATE under property PROPNAME, in the format
specified by FMT."
  (org-entry-put
   (if (equal (buffer-name) org-agenda-buffer-name)
       (or (org-get-at-bol 'org-marker)
	   (org-agenda-error))
     (point))
   propname
   (cond
    ((eq fmt 'inactive)
     (concat "[" (substring date 1 -1) "]"))
    ((eq fmt 'active) date)
    (t (substring date 1 -1)))))
#+end_src

I could get out of the loop using "ctrl-G" but any further interaction
with the todo buffer (expanding the task to see its properties, or
changing the todo state) would result in further lockup. Restarting
emacs let me do a few more entries (about a dozen) before it locked up
again.

Alan

-- 
OpenPGP Key ID : 040D0A3B4ED2E5C7

[-- Attachment #2: Type: application/pgp-signature, Size: 494 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-27 13:37                         ` Alan Schmitt
@ 2014-06-27 22:31                           ` Nicolas Goaziou
  0 siblings, 0 replies; 70+ messages in thread
From: Nicolas Goaziou @ 2014-06-27 22:31 UTC (permalink / raw)
  To: Alan Schmitt; +Cc: Daimrod, Matt Lundin, emacs-orgmode

Hello,

Alan Schmitt <alan.schmitt@polytechnique.org> writes:

> I've also just been bitten by this bug, as I was doing my weekly
> review. I'll try to see if I can write an ECM, but for the record this
> is what I was doing: I was in an agenda view sorted by the value of
> a LAST_REVIEW property, and I was repeatedly calling this function on
> the entries of the view:

[...]

> I could get out of the loop using "ctrl-G" but any further interaction
> with the todo buffer (expanding the task to see its properties, or
> changing the todo state) would result in further lockup. Restarting
> emacs let me do a few more entries (about a dozen) before it locked up
> again.

This bug should be fixed (`org-entry-put' corrupted the cache). Thank
you for reporting it.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-24 14:28               ` Eric Abrahamsen
  2014-06-25  4:09                 ` Matt Lundin
@ 2014-06-28 19:27                 ` Eric Abrahamsen
  2014-06-29  1:39                   ` York Zhao
  1 sibling, 1 reply; 70+ messages in thread
From: Eric Abrahamsen @ 2014-06-28 19:27 UTC (permalink / raw)
  To: emacs-orgmode

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:
>
>> Hello,
>>
>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>
>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>> operations that, as far as I can tell, had little in common. There's a
>>> possibility that they were list-item-related, but really there wasn't
>>> much commonality.
>>
>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>> lockups. Hopefully, it may be related to your problem (which is
>> different from Daimrod's).
>
> Thanks for the followup! I was watching Daimrod's thread, and also
> Matt's most recent posting -- that also seemed more relevant to my
> problems, which were almost solely confined to log/state notes. I've
> pulled the fix, and will let you know if I see any more problems.

After feeling like I was running behind the bus for a few weeks, I may
have finally gotten something useful.

FWIW I *haven't* seen any log-drawer related lockups for a while now,
not since Nicolas said he fixed some things in that direction. But in
the past couple of days I have had a few flyspell-related lockups, and
finally got an uncompiled backtrace.

This has happened the same way a few times now. A longish, text-heavy
file, with only three top-level headlines (one of them a footnote
section), and no drawers of any sort anywhere in the document -- very
little Org markup at all, actually. The lockup starts at random, and
SIGUSR2 shows me a very short backtrace related to a flyspell-mode
related advice somewhere (I didn't save this one, it's byte-compiled, if
it's important I'll clean out more compiled files and try to get it
again).

I recover from that lock, turn off flyspell-mode in my org buffer, and
within three or four commands Org locks up again. This time the
backtrace is related to org cache, here's the one I just got, after
calling org-end-of-line:

http://pastebin.com/Q0g8DmUa

Hope that's useful! Let me know if I can provide anything else.

E

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-28 19:27                 ` Eric Abrahamsen
@ 2014-06-29  1:39                   ` York Zhao
  2014-06-29  2:23                     ` Eric Abrahamsen
  2014-06-29 13:58                     ` Nicolas Goaziou
  0 siblings, 2 replies; 70+ messages in thread
From: York Zhao @ 2014-06-29  1:39 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

My experience of using `org-mode' (git commit "2824502" and previous versions)
with Emacs 24.3.91 (git commit "0f0917d") had been a nightmare. I got bitten by
this bug frequently, I was mad. Some of my `org-drill' entires might have been
damaged to some extent. This was a problem with Emacs 24.3.1 ("3a1ce06") too but
was much better, at least not damaging my `org-drill' flies. I will have to go
back to Emacs 24.3.1. Appears to me that Emacs 24.4 may have some bad issues.

On Sat, Jun 28, 2014 at 3:27 PM, Eric Abrahamsen
<eric@ericabrahamsen.net> wrote:
> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>
>> Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:
>>
>>> Hello,
>>>
>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>
>>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>>> operations that, as far as I can tell, had little in common. There's a
>>>> possibility that they were list-item-related, but really there wasn't
>>>> much commonality.
>>>
>>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>>> lockups. Hopefully, it may be related to your problem (which is
>>> different from Daimrod's).
>>
>> Thanks for the followup! I was watching Daimrod's thread, and also
>> Matt's most recent posting -- that also seemed more relevant to my
>> problems, which were almost solely confined to log/state notes. I've
>> pulled the fix, and will let you know if I see any more problems.
>
> After feeling like I was running behind the bus for a few weeks, I may
> have finally gotten something useful.
>
> FWIW I *haven't* seen any log-drawer related lockups for a while now,
> not since Nicolas said he fixed some things in that direction. But in
> the past couple of days I have had a few flyspell-related lockups, and
> finally got an uncompiled backtrace.
>
> This has happened the same way a few times now. A longish, text-heavy
> file, with only three top-level headlines (one of them a footnote
> section), and no drawers of any sort anywhere in the document -- very
> little Org markup at all, actually. The lockup starts at random, and
> SIGUSR2 shows me a very short backtrace related to a flyspell-mode
> related advice somewhere (I didn't save this one, it's byte-compiled, if
> it's important I'll clean out more compiled files and try to get it
> again).
>
> I recover from that lock, turn off flyspell-mode in my org buffer, and
> within three or four commands Org locks up again. This time the
> backtrace is related to org cache, here's the one I just got, after
> calling org-end-of-line:
>
> http://pastebin.com/Q0g8DmUa
>
> Hope that's useful! Let me know if I can provide anything else.
>
> E
>
>

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-29  1:39                   ` York Zhao
@ 2014-06-29  2:23                     ` Eric Abrahamsen
  2014-06-30  1:15                       ` York Zhao
  2014-06-29 13:58                     ` Nicolas Goaziou
  1 sibling, 1 reply; 70+ messages in thread
From: Eric Abrahamsen @ 2014-06-29  2:23 UTC (permalink / raw)
  To: emacs-orgmode

York Zhao <gtdplatform@gmail.com> writes:

> My experience of using `org-mode' (git commit "2824502" and previous versions)
> with Emacs 24.3.91 (git commit "0f0917d") had been a nightmare. I got bitten by
> this bug frequently, I was mad. Some of my `org-drill' entires might have been
> damaged to some extent. This was a problem with Emacs 24.3.1 ("3a1ce06") too but
> was much better, at least not damaging my `org-drill' flies. I will have to go
> back to Emacs 24.3.1. Appears to me that Emacs 24.4 may have some bad issues.

Yeah, I'm using git emacs, labeled 24.4.50.1.

> On Sat, Jun 28, 2014 at 3:27 PM, Eric Abrahamsen
> <eric@ericabrahamsen.net> wrote:
>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>
>>> Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:
>>>
>>>> Hello,
>>>>
>>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>>
>>>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>>>> operations that, as far as I can tell, had little in common. There's a
>>>>> possibility that they were list-item-related, but really there wasn't
>>>>> much commonality.
>>>>
>>>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>>>> lockups. Hopefully, it may be related to your problem (which is
>>>> different from Daimrod's).
>>>
>>> Thanks for the followup! I was watching Daimrod's thread, and also
>>> Matt's most recent posting -- that also seemed more relevant to my
>>> problems, which were almost solely confined to log/state notes. I've
>>> pulled the fix, and will let you know if I see any more problems.
>>
>> After feeling like I was running behind the bus for a few weeks, I may
>> have finally gotten something useful.
>>
>> FWIW I *haven't* seen any log-drawer related lockups for a while now,
>> not since Nicolas said he fixed some things in that direction. But in
>> the past couple of days I have had a few flyspell-related lockups, and
>> finally got an uncompiled backtrace.
>>
>> This has happened the same way a few times now. A longish, text-heavy
>> file, with only three top-level headlines (one of them a footnote
>> section), and no drawers of any sort anywhere in the document -- very
>> little Org markup at all, actually. The lockup starts at random, and
>> SIGUSR2 shows me a very short backtrace related to a flyspell-mode
>> related advice somewhere (I didn't save this one, it's byte-compiled, if
>> it's important I'll clean out more compiled files and try to get it
>> again).
>>
>> I recover from that lock, turn off flyspell-mode in my org buffer, and
>> within three or four commands Org locks up again. This time the
>> backtrace is related to org cache, here's the one I just got, after
>> calling org-end-of-line:
>>
>> http://pastebin.com/Q0g8DmUa
>>
>> Hope that's useful! Let me know if I can provide anything else.
>>
>> E
>>
>>

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-29  1:39                   ` York Zhao
  2014-06-29  2:23                     ` Eric Abrahamsen
@ 2014-06-29 13:58                     ` Nicolas Goaziou
  1 sibling, 0 replies; 70+ messages in thread
From: Nicolas Goaziou @ 2014-06-29 13:58 UTC (permalink / raw)
  To: York Zhao; +Cc: Eric Abrahamsen, emacs-orgmode

Hello,

York Zhao <gtdplatform@gmail.com> writes:

> My experience of using `org-mode' (git commit "2824502" and previous versions)
> with Emacs 24.3.91 (git commit "0f0917d") had been a nightmare. I got bitten by
> this bug frequently, I was mad.

I'm sorry about this.

However, just saying that "it had been a nightmare" doesn't help much.
If you can, please try to provide an ECM. I will gladly fix any bug
I can reproduce.

> This was a problem with Emacs 24.3.1 ("3a1ce06") too

Note that this is an entirely different issue, since maint branch
doesn't have a cache. Reporting bugs found there is even more critical
as it is the version that will be shipped with next Emacs release.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-29  2:23                     ` Eric Abrahamsen
@ 2014-06-30  1:15                       ` York Zhao
  2014-06-30  1:43                         ` York Zhao
  0 siblings, 1 reply; 70+ messages in thread
From: York Zhao @ 2014-06-30  1:15 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

> Yeah, I'm using git emacs, labeled 24.4.50.1

Did you compile Emacs from git? I have never seen the tag 24.4.50.1, are you
sure you didn't have a typo here?

On Sat, Jun 28, 2014 at 10:23 PM, Eric Abrahamsen
<eric@ericabrahamsen.net> wrote:
> York Zhao <gtdplatform@gmail.com> writes:
>
>> My experience of using `org-mode' (git commit "2824502" and previous versions)
>> with Emacs 24.3.91 (git commit "0f0917d") had been a nightmare. I got bitten by
>> this bug frequently, I was mad. Some of my `org-drill' entires might have been
>> damaged to some extent. This was a problem with Emacs 24.3.1 ("3a1ce06") too but
>> was much better, at least not damaging my `org-drill' flies. I will have to go
>> back to Emacs 24.3.1. Appears to me that Emacs 24.4 may have some bad issues.
>
> Yeah, I'm using git emacs, labeled 24.4.50.1.
>
>> On Sat, Jun 28, 2014 at 3:27 PM, Eric Abrahamsen
>> <eric@ericabrahamsen.net> wrote:
>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>
>>>> Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:
>>>>
>>>>> Hello,
>>>>>
>>>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>>>
>>>>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>>>>> operations that, as far as I can tell, had little in common. There's a
>>>>>> possibility that they were list-item-related, but really there wasn't
>>>>>> much commonality.
>>>>>
>>>>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>>>>> lockups. Hopefully, it may be related to your problem (which is
>>>>> different from Daimrod's).
>>>>
>>>> Thanks for the followup! I was watching Daimrod's thread, and also
>>>> Matt's most recent posting -- that also seemed more relevant to my
>>>> problems, which were almost solely confined to log/state notes. I've
>>>> pulled the fix, and will let you know if I see any more problems.
>>>
>>> After feeling like I was running behind the bus for a few weeks, I may
>>> have finally gotten something useful.
>>>
>>> FWIW I *haven't* seen any log-drawer related lockups for a while now,
>>> not since Nicolas said he fixed some things in that direction. But in
>>> the past couple of days I have had a few flyspell-related lockups, and
>>> finally got an uncompiled backtrace.
>>>
>>> This has happened the same way a few times now. A longish, text-heavy
>>> file, with only three top-level headlines (one of them a footnote
>>> section), and no drawers of any sort anywhere in the document -- very
>>> little Org markup at all, actually. The lockup starts at random, and
>>> SIGUSR2 shows me a very short backtrace related to a flyspell-mode
>>> related advice somewhere (I didn't save this one, it's byte-compiled, if
>>> it's important I'll clean out more compiled files and try to get it
>>> again).
>>>
>>> I recover from that lock, turn off flyspell-mode in my org buffer, and
>>> within three or four commands Org locks up again. This time the
>>> backtrace is related to org cache, here's the one I just got, after
>>> calling org-end-of-line:
>>>
>>> http://pastebin.com/Q0g8DmUa
>>>
>>> Hope that's useful! Let me know if I can provide anything else.
>>>
>>> E
>>>
>>>
>
>

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-30  1:15                       ` York Zhao
@ 2014-06-30  1:43                         ` York Zhao
  2014-06-30 20:20                           ` Alan Schmitt
  2014-07-01  0:43                           ` York Zhao
  0 siblings, 2 replies; 70+ messages in thread
From: York Zhao @ 2014-06-30  1:43 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

I know that doesn't help much except for confirming the problem other people was
suffering. Sorry for the rant. I was too busy and too frustrated.

By the way, what does ECM stands for?

> This is an entirely different issue, since maint branch doesn't have a cache.

I must clarify that what I meant was that I used exactly the same version of
`org-mode', from git repository, with the two Emacs versions. That said, I never
used the `org-mode' version bundled with Emacs. I'm sorry for the confusion.

1. Sometimes when Emacs hangs in `org-mode', "C-g" wouldn't work. Waited
patiently for awhile and "C-g" work again. Pressing "C-g" produced the error
message: "Error in post-command-hook (zfill-post-command-function): (quit)".
Emacs hanged again, waited patiently for awhile until "C-g" worked again and
Emacs revived, but in an unstable state.

2. Other times when Emacs hangs in `org-mode', "C-g" wouldn't work until after
perhaps 20 seconds or so, hitting "C-g" breaks out. Emacs enters a useless
state, nothing works even "C-x C-c" doesn't work, but produces error: "Variable
bind exceeds maximum level" or something.

A few hours ago I switched back to Emacs 24.3.1, problem 1 happened once, but
never had problem 2. And editing in `org-mode' was several times more smooth and
faster. Way better. Again, I want to stress, I was using the same `org-mode'
from git repository (commit "2824502").

Hope this would help a little bit.

On Sun, Jun 29, 2014 at 9:15 PM, York Zhao <gtdplatform@gmail.com> wrote:
>> Yeah, I'm using git emacs, labeled 24.4.50.1
>
> Did you compile Emacs from git? I have never seen the tag 24.4.50.1, are you
> sure you didn't have a typo here?
>
> On Sat, Jun 28, 2014 at 10:23 PM, Eric Abrahamsen
> <eric@ericabrahamsen.net> wrote:
>> York Zhao <gtdplatform@gmail.com> writes:
>>
>>> My experience of using `org-mode' (git commit "2824502" and previous versions)
>>> with Emacs 24.3.91 (git commit "0f0917d") had been a nightmare. I got bitten by
>>> this bug frequently, I was mad. Some of my `org-drill' entires might have been
>>> damaged to some extent. This was a problem with Emacs 24.3.1 ("3a1ce06") too but
>>> was much better, at least not damaging my `org-drill' flies. I will have to go
>>> back to Emacs 24.3.1. Appears to me that Emacs 24.4 may have some bad issues.
>>
>> Yeah, I'm using git emacs, labeled 24.4.50.1.
>>
>>> On Sat, Jun 28, 2014 at 3:27 PM, Eric Abrahamsen
>>> <eric@ericabrahamsen.net> wrote:
>>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>>
>>>>> Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:
>>>>>
>>>>>> Hello,
>>>>>>
>>>>>> Eric Abrahamsen <eric@ericabrahamsen.net> writes:
>>>>>>
>>>>>>> None of those three, I'm afraid! It was hanging on a variety of editing
>>>>>>> operations that, as far as I can tell, had little in common. There's a
>>>>>>> possibility that they were list-item-related, but really there wasn't
>>>>>>> much commonality.
>>>>>>
>>>>>> FYI, I recently fixed a bug[fn:1] that could introduce uncommon random
>>>>>> lockups. Hopefully, it may be related to your problem (which is
>>>>>> different from Daimrod's).
>>>>>
>>>>> Thanks for the followup! I was watching Daimrod's thread, and also
>>>>> Matt's most recent posting -- that also seemed more relevant to my
>>>>> problems, which were almost solely confined to log/state notes. I've
>>>>> pulled the fix, and will let you know if I see any more problems.
>>>>
>>>> After feeling like I was running behind the bus for a few weeks, I may
>>>> have finally gotten something useful.
>>>>
>>>> FWIW I *haven't* seen any log-drawer related lockups for a while now,
>>>> not since Nicolas said he fixed some things in that direction. But in
>>>> the past couple of days I have had a few flyspell-related lockups, and
>>>> finally got an uncompiled backtrace.
>>>>
>>>> This has happened the same way a few times now. A longish, text-heavy
>>>> file, with only three top-level headlines (one of them a footnote
>>>> section), and no drawers of any sort anywhere in the document -- very
>>>> little Org markup at all, actually. The lockup starts at random, and
>>>> SIGUSR2 shows me a very short backtrace related to a flyspell-mode
>>>> related advice somewhere (I didn't save this one, it's byte-compiled, if
>>>> it's important I'll clean out more compiled files and try to get it
>>>> again).
>>>>
>>>> I recover from that lock, turn off flyspell-mode in my org buffer, and
>>>> within three or four commands Org locks up again. This time the
>>>> backtrace is related to org cache, here's the one I just got, after
>>>> calling org-end-of-line:
>>>>
>>>> http://pastebin.com/Q0g8DmUa
>>>>
>>>> Hope that's useful! Let me know if I can provide anything else.
>>>>
>>>> E
>>>>
>>>>
>>
>>

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-30  1:43                         ` York Zhao
@ 2014-06-30 20:20                           ` Alan Schmitt
  2014-07-01  0:43                           ` York Zhao
  1 sibling, 0 replies; 70+ messages in thread
From: Alan Schmitt @ 2014-06-30 20:20 UTC (permalink / raw)
  To: York Zhao; +Cc: Eric Abrahamsen, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 431 bytes --]

On 2014-06-30 03:43, York Zhao <gtdplatform@gmail.com> writes:

> I know that doesn't help much except for confirming the problem other people was
> suffering. Sorry for the rant. I was too busy and too frustrated.
>
> By the way, what does ECM stands for?

Exemple Complet Minimal (French for minimal complete example)

http://orgmode.org/worg/org-faq.html#ecm

Best,

Alan

-- 
OpenPGP Key ID : 040D0A3B4ED2E5C7

[-- Attachment #2: Type: application/pgp-signature, Size: 494 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-06-30  1:43                         ` York Zhao
  2014-06-30 20:20                           ` Alan Schmitt
@ 2014-07-01  0:43                           ` York Zhao
  2014-07-01  7:38                             ` Nicolas Goaziou
  2014-07-15  2:30                             ` York Zhao
  1 sibling, 2 replies; 70+ messages in thread
From: York Zhao @ 2014-07-01  0:43 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 209 bytes --]

I got the problem today, with org-mode version "815c218" in Emacs 24.3.1. The
error message is: if: Lisp nesting exceeds `max-lisp-eval-depth'. Attached is
the backtrace saved in a file.

Hope this will help.

[-- Attachment #2: backtrace.txt --]
[-- Type: text/plain, Size: 542327 bytes --]

Debugger entered--Lisp error: (error "Lisp nesting exceeds `max-lisp-eval-depth'")
  (progn (cancel-timer org-element--cache-sync-timer))
  (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer)))
  (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration)) (or extra 0)) (if next (progn (let* ((v next)) (aset v 3 (+ ... ...))) (aset next 2 (aref request 2)) (aset next 5 (aref request 5)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys)))
  (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add (current-time) org-element-cache-sync-duration)) (or extra 0)) (if next (progn (let* (...) (aset v 3 ...)) (aset next 2 (aref request 2)) (aset next 5 (aref request 5)))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))
  (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (org-element--cache-process-request request (and next (aref next 0)) threshold (and (not threshold) (time-add ... org-element-cache-sync-duration)) (or extra 0)) (if next (progn (let* ... ...) (aset next 2 ...) (aset next 5 ...))) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys)))))
  (if (buffer-live-p buffer) (progn (save-current-buffer (set-buffer buffer) (let ((inhibit-quit t) request next) (if org-element--cache-sync-timer (progn (cancel-timer org-element--cache-sync-timer))) (catch (quote interrupt) (while org-element--cache-sync-requests (setq request (car org-element--cache-sync-requests) next (nth 1 org-element--cache-sync-requests)) (org-element--cache-process-request request (and next ...) threshold (and ... ...) (or extra 0)) (if next (progn ... ... ...)) (setq org-element--cache-sync-requests (cdr org-element--cache-sync-requests)))) (if org-element--cache-sync-requests (org-element--cache-set-timer buffer) (clrhash org-element--cache-sync-keys))))))
  org-element--cache-sync(#<buffer English.org> 257280)
  (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin))
  (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))
  (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin))))
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p (org-element-property :parent p)) (not (eq ... ...)))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while (< ... end) (if ... ...) (forward-line))))))))
  (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and (setq p ...) (not ...))) (not p))) (progn (let ((end (org-element-property :contents-end drawer))) (if end (progn (forward-line) (while ... ... ...))))))))
  (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let ((p drawer)) (while (and ... ...)) (not p))) (progn (let ((end ...)) (if end (progn ... ...))))))) plist)
  (let ((end (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-next-heading)) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let ((drawer (org-element-at-point))) (if (and (eq (org-element-type drawer) (quote property-drawer)) (let (...) (while ...) (not p))) (progn (let (...) (if end ...)))))) plist))
  (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion (let* ... ...) (point))) plist) (save-excursion (while (and (null plist) (re-search-forward org-property-start-re end t)) (let (...) (if ... ...))) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let (... plist) (while ... ... ... ...) plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat (regexp-quote org-comment-string) "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank (if ... 0 ...) :contents-begin contents-begin :contents-end contents-end :level level :priority (nth 3 components) :tags tags :todo-keyword todo :todo-type todo-type :post-blank (count-lines ... end) :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title (org-element-parse-secondary-string alt-title ... headline)))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline)))))
  (save-excursion (let* ((components (org-heading-components)) (level (nth 1 components)) (todo (nth 2 components)) (todo-type (and todo (if (member todo org-done-keywords) (quote done) (quote todo)))) (tags (let ((raw-tags (nth 5 components))) (and raw-tags (org-split-string raw-tags ":")))) (raw-value (or (nth 4 components) "")) (commentedp (let ((case-fold-search nil)) (string-match (format "^%s\\( \\|$\\)" org-comment-string) raw-value))) (archivedp (member org-archive-tag tags)) (footnote-section-p (and org-footnote-section (string= org-footnote-section raw-value))) (standard-props (let ((end (save-excursion ... ...)) plist) (save-excursion (while (and ... ...) (let ... ...)) plist))) (time-props (save-excursion (forward-line) (if (looking-at org-planning-or-clock-line-re) (progn (let ... ... plist))))) (begin (point)) (end (min (save-excursion (org-end-of-subtree t t)) limit)) (pos-after-head (progn (forward-line) (point))) (contents-begin (save-excursion (skip-chars-forward " \r	\n" end) (and (/= (point) end) (line-beginning-position)))) (contents-end (and contents-begin (progn (goto-char end) (skip-chars-backward " \r	\n") (forward-line) (point))))) (if commentedp (progn (let ((case-fold-search nil)) (setq raw-value (replace-regexp-in-string (concat ... "\\(?: \\|$\\)") "" raw-value))))) (if archivedp (progn (setq tags (delete org-archive-tag tags)))) (let ((headline (list (quote headline) (nconc (list :raw-value raw-value :begin begin :end end :pre-blank ... :contents-begin contents-begin :contents-end contents-end :level level :priority ... :tags tags :todo-keyword todo :todo-type todo-type :post-blank ... :footnote-section-p footnote-section-p :archivedp archivedp :commentedp commentedp) time-props standard-props)))) (let ((alt-title (org-element-property :ALT_TITLE headline))) (if alt-title (progn (org-element-put-property headline :alt-title (if raw-secondary-p alt-title ...))))) (org-element-put-property headline :title (if raw-secondary-p raw-value (org-element-parse-secondary-string raw-value (org-element-restriction (quote headline)) headline))))))
  org-element-headline-parser(257706 t)
  (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[     ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal (match-string 1) "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[   ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)") (beginning-of-line) (org-element-comment-parser limit affiliated)) ((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (let ... ...)) ((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated)) ((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit affiliated)))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure (org-element--list-struct limit)))) (t (org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* (... ... ... ...) (outline-next-heading))) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and (cdr affiliated) (>= ... limit)) (goto-char (car affiliated)) (org-element-keyword-parser limit nil)) ((looking-at "[        ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if (equal ... "PROPERTIES") (org-element-property-drawer-parser limit affiliated) (org-element-drawer-parser limit affiliated))) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (... ... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[   ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at (org-item-re)) (org-element-plain-list-parser limit affiliated (or structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq granularity (quote object)))))) (cond ((eq special (quote item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq special (quote table-row)) (org-element-table-row-parser limit)) ((eq special (quote node-property)) (org-element-node-property-parser limit)) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (org-element-headline-parser limit raw-secondary-p)) ((eq special (quote section)) (org-element-section-parser limit)) ((eq special (quote first-section)) (org-element-section-parser (or (save-excursion (let* ... ...)) limit))) ((not (bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at org-planning-or-clock-line-re) (if (equal (match-string 1) org-clock-string) (org-element-clock-parser limit) (org-element-planning-parser limit))) ((org-at-heading-p) (org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated (org-element--collect-affiliated-keywords limit))) (cond ((and ... ...) (goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at "[      ]*\\\\begin{[A-Za-z0-9*]+}\\(\\[.*?\\]\\|{.*?}\\)*[     ]*$") (org-element-latex-environment-parser limit affiliated)) ((looking-at org-drawer-regexp) (if ... ... ...)) ((looking-at "[        ]*:\\( \\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at "[     ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at org-footnote-definition-re) (org-element-footnote-definition-parser limit affiliated)) ((looking-at "[       ]*-\\{5,\\}[    ]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(") (org-element-diary-sexp-parser limit affiliated)) ((org-at-table-p t) (org-element-table-parser limit affiliated)) ((looking-at ...) (org-element-plain-list-parser limit affiliated ...)) (t (org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(257706 element nil nil)
  (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg (org-element-property :contents-begin element)) (cend (org-element-property :contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn (goto-char ...) (setq next nil special-flag ... parent element end cend))))) (t (throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit) parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote interrupt) nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ... ...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos) (goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next (point))))))) (let ((end (or (org-element-property :end element) (save-excursion (let* (... ... ... ...) (outline-next-heading)) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond ((= ... pos) (throw ... parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil))))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and (<= elem-end pos) (/= ... elem-end)) (goto-char elem-end)) ((not (memq type org-element-greater-elements)) (throw (quote exit) element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element)))) (setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos (if ... ... pos))) (goto-char (or (org-element-property :contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond ((not up)) ((eobp) (setq element up)) (t (setq element up next ...)))))) (let ((end (or (org-element-property :end element) (save-excursion (let* ... ...) (point)))) (parent element) special-flag) (while t (if syncp (progn (cond (... ...) (... ...)))) (if element nil (setq element (org-element--current-element end (quote element) special-flag (org-element-property :structure parent))) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end (org-element-property :end element)) (type (org-element-type element))) (cond ((and ... ...) (goto-char elem-end)) ((not ...) (throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* (... ... ... ...) (outline-previous-heading)) (progn (forward-line))) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp (org-element-property :parent cached) cached))) ((re-search-backward (let* (... ... ... ...) org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let ((up cached) (pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...) (... ...) (t ...))))) (let ((end (or (org-element-property :end element) (save-excursion ... ...))) (parent element) special-flag) (while t (if syncp (progn (cond ... ...))) (if element nil (setq element (org-element--current-element end ... special-flag ...)) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let ((elem-end ...) (type ...)) (cond (... ...) (... ...) (...) (t ...))) (setq element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached (and (org-element--cache-active-p) (org-element--cache-find pos nil))) (begin (org-element-property :begin cached)) element next) (cond ((not cached) (if (let* ... ...) (progn ...)) (skip-chars-forward " \r	\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ... cached))) ((re-search-backward (let* ... org-outline-regexp-bol) begin t) (forward-line) (skip-chars-forward " \r	\n") (beginning-of-line)) (t (let (... ...) (goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...)) (parent element) special-flag) (while t (if syncp (progn ...)) (if element nil (setq element ...) (org-element-put-property element :parent parent) (org-element--cache-put element)) (let (... ...) (cond ... ... ... ...)) (setq element nil)))))))
  org-element--parse-to(257280)
  (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync (current-buffer) origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp))) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if (not org-element--cache) (org-element-cache-reset) (org-element--cache-sync ... origin)))) (org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point))) (end-of-line) (skip-chars-backward " \r	\n") (cond ((bobp) nil) ((let* ((org-called-with-limited-levels t) (org-outline-regexp ...) (outline-regexp org-outline-regexp) (org-outline-regexp-bol ...)) (org-at-heading-p)) (beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if (org-element--cache-active-p) (progn (if ... ... ...))) (org-element--parse-to origin))))))
  org-element-at-point()
  org-cycle-hide-drawers(all)
  org-drill-entry()
  byte-code("\306 \205\227\0\b\203\x13\0	\203\x13\0\307	!\204\x18\0\310 \202^[\0\311\x10	\211\x1a\x11\n\204&\0\312\313!\210\212\314\n!\210\315 \204;\0\316\317!\210\320\321!\210\202\223\0\322 \211^[\204P\0\316\323!\210\324\x14\325\326\311\"\210\202\222\0\327\v\330\"\203b\0\331 \x14\325\326\311\"\210\202\222\0\327\v\332\"\203n\0\311\x11\202\222\0\v\rX\203\212\0\x0e\x1d\203\x7f\0\333\x0e\x1d!\x16\x1d\334\x0e\x1d\nC\"\x16\x1d\202\220\0\n\x0e\x1eB\x16\x1e\311\x11)*\202\0\0\207" [resuming-p *org-drill-current-item* m result end-pos org-drill-failure-quality org-drill-entries-pending-p org-drill-entry-p org-drill-pop-next-pending-entry nil error "Unexpectedly ran out of pending drill items" org-drill-goto-entry org-drill-entry-due-p message "Entry no longer due, skipping..." sit-for 0.3 org-drill-entry "Quit" :quit throw --cl-block-org-drill-entries-- eql edit point-marker skip shuffle-list append *org-drill-again-entries* *org-drill-done-entries*] 4)
  org-drill-entries(t)
  org-drill(nil nil t)
  org-drill-resume()
  call-interactively(org-drill-resume record nil)
  command-execute(org-drill-resume record)
  helm-M-x()
  call-interactively(helm-M-x nil nil)

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-01  0:43                           ` York Zhao
@ 2014-07-01  7:38                             ` Nicolas Goaziou
  2014-07-01 17:14                               ` York Zhao
  2014-07-15  2:30                             ` York Zhao
  1 sibling, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-07-01  7:38 UTC (permalink / raw)
  To: York Zhao; +Cc: Eric Abrahamsen, emacs-orgmode

Hello,

York Zhao <gtdplatform@gmail.com> writes:

> I got the problem today, with org-mode version "815c218" in Emacs 24.3.1. The
> error message is: if: Lisp nesting exceeds `max-lisp-eval-depth'. Attached is
> the backtrace saved in a file.

Please update, if you can. I pushed a couple of fixes a few hours ago.
It may solve the problem.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-01  7:38                             ` Nicolas Goaziou
@ 2014-07-01 17:14                               ` York Zhao
  2014-07-01 21:15                                 ` York Zhao
  2014-07-03 15:31                                 ` York Zhao
  0 siblings, 2 replies; 70+ messages in thread
From: York Zhao @ 2014-07-01 17:14 UTC (permalink / raw)
  To: York Zhao, Eric Abrahamsen, emacs-orgmode

> Please update, if you can. I pushed a couple of fixes a few hours ago. It may
> solve the problem.

I noticed the new commits after my previous report. I'm now using commit
"126e2bc", this morning I did experience some funny things which I had never
experienced before. Unfortunately I let them go. I will keep an eye on the new
problems.

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-01 17:14                               ` York Zhao
@ 2014-07-01 21:15                                 ` York Zhao
  2014-07-02  8:01                                   ` Nicolas Goaziou
  2014-07-03 15:31                                 ` York Zhao
  1 sibling, 1 reply; 70+ messages in thread
From: York Zhao @ 2014-07-01 21:15 UTC (permalink / raw)
  To: York Zhao, Eric Abrahamsen, emacs-orgmode

Just suffered from extreme slowness. My Emacs had been running for about 1 hour
and I was having two org-mode buffers, one file has 3800 lines, 168 KB bytes.
And the other has 76,600 lines, 4,267,327 KB bytes. Both files had been opened
for awhile. Didn't have problem in the beginning, but then typing in the bigger
buffer became extremely slow, took at least one to two seconds for a typed
character to be displayed on the screen. Killed the buffer and then reopen it
didn't help at all. At the same time typing in the other smaller buffer didn't
have the same slowness issue. Restarted Emacs and the issue disappeared.

One of the problem I have noticed for a long time is that org-mode could become
slower and slower with use, which was exactly what I had been experiencing just
now.

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-01 21:15                                 ` York Zhao
@ 2014-07-02  8:01                                   ` Nicolas Goaziou
  2014-07-03  1:03                                     ` York Zhao
  0 siblings, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-07-02  8:01 UTC (permalink / raw)
  To: York Zhao; +Cc: Eric Abrahamsen, emacs-orgmode

Hello,

York Zhao <gtdplatform@gmail.com> writes:

> Just suffered from extreme slowness. My Emacs had been running for about 1 hour
> and I was having two org-mode buffers, one file has 3800 lines, 168 KB bytes.
> And the other has 76,600 lines, 4,267,327 KB bytes. Both files had been opened
> for awhile. Didn't have problem in the beginning, but then typing in the bigger
> buffer became extremely slow, took at least one to two seconds for a typed
> character to be displayed on the screen. Killed the buffer and then reopen it
> didn't help at all. At the same time typing in the other smaller buffer didn't
> have the same slowness issue. Restarted Emacs and the issue disappeared.
>
> One of the problem I have noticed for a long time is that org-mode could become
> slower and slower with use, which was exactly what I had been experiencing just
> now.

OK. If you experience it again, please do

  M-x org-element-cache-reset

in the slow buffer and see if it is responsive again.

Another interesting test would be to try reproducing the problem with `org-element-use-cache'
set to nil.

I'm not totally sure this is related to the cache, as killing the buffer
should have solved the problem.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-02  8:01                                   ` Nicolas Goaziou
@ 2014-07-03  1:03                                     ` York Zhao
  2014-07-06  7:28                                       ` Nicolas Goaziou
  0 siblings, 1 reply; 70+ messages in thread
From: York Zhao @ 2014-07-03  1:03 UTC (permalink / raw)
  To: York Zhao, Eric Abrahamsen, emacs-orgmode

> OK. If you experience it again, please do
>
>   M-x org-element-cache-reset
>
> in the slow buffer and see if it is responsive again.
>
> Another interesting test would be to try reproducing the problem with
> `org-element-use-cache' set to nil.

The exact same slowness problem happened just now. "M-x org-element-cache-reset"
didn't have any effect. Nor did setting `org-element-use-cache' to nil. Again,
killed the buffer and reopened didn't help.

I couldn't remember whether the big file was already opened, but I think it was
not opened yet, i.e., when the problem occurred, the file might just be opened.
What I did was that I started Emacs, run `org-drill' across 8 files (in one
session). Total size of these files was 730 KB bytes. The good thing was that
the session was finished successfully, no "max-lisp-eval-depth" error, and I
really hope this deadly error will never happen.

One thing I didn't do, unfortunately, was that I reset cache only for the buffer
where the slowness manifested. I think I should try reseting cache for all the 8
buffers too right?

York

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-01 17:14                               ` York Zhao
  2014-07-01 21:15                                 ` York Zhao
@ 2014-07-03 15:31                                 ` York Zhao
  2014-07-03 15:55                                   ` York Zhao
  2014-07-06  7:19                                   ` Nicolas Goaziou
  1 sibling, 2 replies; 70+ messages in thread
From: York Zhao @ 2014-07-03 15:31 UTC (permalink / raw)
  To: York Zhao, Eric Abrahamsen, emacs-orgmode

> I'm now using commit "126e2bc", this morning I did experience some funny
> things which I had never experienced before. Unfortunately I let them go. I
> will keep an eye on the new problems.

I'm now using commit "fdc673d". The problem I experienced 2 days ago happened
again. The direct operations I did was that I programmatically deleted a few
table line in one table and inserted them in another table which is in the
subtree immediately following the current table. But I ended up having more
lines in the new table, most of them were duplicated. Here is roughly the
snippet of the command I used:

(defun yhj-drop-something ()
  (interactive)
  (save-excursion
    (let* ((beg (line-beginning-position))
           (end (1+ (line-end-position)))
           (line (buffer-substring beg end)))
      (kill-region beg end)
      (unless (re-search-forward "^\\*+[ \t]+Newtable[ \t]*$"
                                 (save-excursion
                                   (org-end-of-subtree t)) t)
        (error "Incompatible contents format"))
      (forward-line 4)
      (unless (org-at-table-p 'any)
        (error "Incompatible contents format"))
      (beginning-of-line)
      (insert line)
      (org-table-align)
      (org-table-sort-lines nil ?a))))

I can't post everything here because the command operates on my personal
contents. I have been using this snippet for years without problem. I executed
this command several times with point moved to different lines in the first
table. Each time this command is executed it is supposed to "move" one table
line to another table.

Hope this will help a bit and I will pay close attention next time to give more
details.

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-03 15:31                                 ` York Zhao
@ 2014-07-03 15:55                                   ` York Zhao
  2014-07-06  7:19                                   ` Nicolas Goaziou
  1 sibling, 0 replies; 70+ messages in thread
From: York Zhao @ 2014-07-03 15:55 UTC (permalink / raw)
  To: York Zhao, Eric Abrahamsen, emacs-orgmode

> I'm now using commit "fdc673d". The problem I experienced 2 days ago happened
> again. The direct operations I did was that I programmatically deleted a few
> table line in one table and inserted them in another table which is in the
> subtree immediately following the current table. But I ended up having more
> lines in the new table, most of them were duplicated. Here is roughly the
> snippet of the command I used:
>
> (defun yhj-drop-something ()
>   (interactive)
>   (save-excursion
>     (let* ((beg (line-beginning-position))
>            (end (1+ (line-end-position)))
>            (line (buffer-substring beg end)))
>       (kill-region beg end)
>       (unless (re-search-forward "^\\*+[ \t]+Newtable[ \t]*$"
>                                  (save-excursion
>                                    (org-end-of-subtree t)) t)
>         (error "Incompatible contents format"))
>       (forward-line 4)
>       (unless (org-at-table-p 'any)
>         (error "Incompatible contents format"))
>       (beginning-of-line)
>       (insert line)
>       (org-table-align)
>       (org-table-sort-lines nil ?a))))

I just noticed these errors in my "*messages*" buffer:

user-error: Not in table data field
2 lines sorted, based on column 1
Starting "egrep" process...
3 lines sorted, based on column 1
4 lines sorted, based on column 1
After 0 kbd macro iterations: let: Wrong type argument: number-or-marker-p, nil
Error in post-command-hook (zfill-post-command-function): (user-error
"An element cannot be parsed line 76823")
Error in pre-command-hook (zfill-pre-command-function): (user-error
"An element cannot be parsed line 76823")
6 lines sorted, based on column 1

I'm not sure if the `(user-error "An element cannot be parsed line 76823")' can
be of any help. Line 76823 was the last line in the table where the table lines
were being moved to (the "Destination Table"). This table looks like thin:

*** Source Table
|---------+---------+---------+---------+---|
| COL1    | COL2    | COL3    | COL4    |   |
|---------+---------+---------+---------+---|
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
|---------+---------+---------+---------+---|

**** Destination Table
|---------+---------+---------+---------+---|
| COL1    | COL2    | COL3    | COL4    |   |
|---------+---------+---------+---------+---|
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
| Content | Content | Content | Content | A |
|---------+---------+---------+---------+---|

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-03 15:31                                 ` York Zhao
  2014-07-03 15:55                                   ` York Zhao
@ 2014-07-06  7:19                                   ` Nicolas Goaziou
  2014-07-06 14:29                                     ` York Zhao
  1 sibling, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-07-06  7:19 UTC (permalink / raw)
  To: York Zhao; +Cc: Eric Abrahamsen, emacs-orgmode

Hello,

York Zhao <gtdplatform@gmail.com> writes:

> I'm now using commit "fdc673d". The problem I experienced 2 days ago happened
> again. The direct operations I did was that I programmatically deleted a few
> table line in one table and inserted them in another table which is in the
> subtree immediately following the current table. But I ended up having more
> lines in the new table, most of them were duplicated. Here is roughly the
> snippet of the command I used:

[...]

> I can't post everything here because the command operates on my personal
> contents. I have been using this snippet for years without problem. I executed
> this command several times with point moved to different lines in the first
> table. Each time this command is executed it is supposed to "move" one table
> line to another table.
>
> Hope this will help a bit and I will pay close attention next time to give more
> details.

Thank you for the report. I wasn't able to reproduce it with latest
commit (df9ccbd). Could you try again and see if it fixes your problem?


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-03  1:03                                     ` York Zhao
@ 2014-07-06  7:28                                       ` Nicolas Goaziou
  2014-07-06 14:40                                         ` York Zhao
  0 siblings, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-07-06  7:28 UTC (permalink / raw)
  To: York Zhao; +Cc: Eric Abrahamsen, emacs-orgmode

Hello,

York Zhao <gtdplatform@gmail.com> writes:

> The exact same slowness problem happened just now. "M-x org-element-cache-reset"
> didn't have any effect. Nor did setting `org-element-use-cache' to nil. Again,
> killed the buffer and reopened didn't help.

It looks like the problem isn't related to the cache then. Anyway, you
could try to do some profiling (see `profiler-start').

> One thing I didn't do, unfortunately, was that I reset cache only for the buffer
> where the slowness manifested. I think I should try reseting cache for all the 8
> buffers too right?

Cache is buffer dependent, so you don't need to reset cache for all of
them (though it's simply C-u M-x org-element-cache-reset).


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-06  7:19                                   ` Nicolas Goaziou
@ 2014-07-06 14:29                                     ` York Zhao
  0 siblings, 0 replies; 70+ messages in thread
From: York Zhao @ 2014-07-06 14:29 UTC (permalink / raw)
  To: York Zhao, Eric Abrahamsen, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 264 bytes --]

> Thank you for the report. I wasn't able to reproduce it with latest commit
> (df9ccbd). Could you try again and see if it fixes your problem?

I haven't experienced this problem since July 3, hopefully it has been
fixed.
Thank you very much for your work.

York

[-- Attachment #2: Type: text/html, Size: 328 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-06  7:28                                       ` Nicolas Goaziou
@ 2014-07-06 14:40                                         ` York Zhao
  2014-07-06 21:05                                           ` York Zhao
  2014-07-07  1:43                                           ` York Zhao
  0 siblings, 2 replies; 70+ messages in thread
From: York Zhao @ 2014-07-06 14:40 UTC (permalink / raw)
  To: York Zhao, Eric Abrahamsen, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 905 bytes --]

> > The exact same slowness problem happened just now. "M-x
org-element-cache-reset"
> > didn't have any effect. Nor did setting `org-element-use-cache' to nil.
Again,
> > killed the buffer and reopened didn't help.
> It looks like the problem isn't related to the cache then. Anyway, you
> could try to do some profiling (see `profiler-start').
>
> > One thing I didn't do, unfortunately, was that I reset cache only for
the buffer
> > where the slowness manifested. I think I should try reseting cache for
all the 8
> > buffers too right?
> Cache is buffer dependent, so you don't need to reset cache for all of
> them (though it's simply C-u M-x org-element-cache-reset).

I haven't experienced this problem (I'm now using "df9ccbd") since last
time I
reported (July 2 I guess), really hope that this problem has been fixed.
Thank
you very much for all the hard work you have done on this issue.

York

[-- Attachment #2: Type: text/html, Size: 1102 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-06 14:40                                         ` York Zhao
@ 2014-07-06 21:05                                           ` York Zhao
  2014-07-06 21:31                                             ` Nicolas Goaziou
  2014-07-07  1:43                                           ` York Zhao
  1 sibling, 1 reply; 70+ messages in thread
From: York Zhao @ 2014-07-06 21:05 UTC (permalink / raw)
  To: York Zhao, Eric Abrahamsen, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 331 bytes --]

The extreme slowness happened again just know. When this happened,
`org-end-of-line' command took forever until "C-g". M-x
org-element-cache-reset
worked this time, i.e., after running `org-element-cache-reset' command
`org-end-of-line' became fast again.

I was using commit "ca6ecf9", and the buffer was 38xx lines 168K in size.

[-- Attachment #2: Type: text/html, Size: 410 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-06 21:05                                           ` York Zhao
@ 2014-07-06 21:31                                             ` Nicolas Goaziou
  2014-07-07  0:16                                               ` York Zhao
  0 siblings, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-07-06 21:31 UTC (permalink / raw)
  To: York Zhao; +Cc: Eric Abrahamsen, emacs-orgmode

Hello,

York Zhao <gtdplatform@gmail.com> writes:

> The extreme slowness happened again just know. When this happened,
> `org-end-of-line' command took forever until "C-g". M-x
> org-element-cache-reset
> worked this time, i.e., after running `org-element-cache-reset' command
> `org-end-of-line' became fast again.
>
> I was using commit "ca6ecf9", and the buffer was 38xx lines 168K in
> size.

This sounds more like an infloop. Could you send me the document you
were working on[fn:1], in private, and describe what you were doing
before it froze?


Regards,

[fn:1] or at least an equivalent file structure wise, calling the
following function in that document:

  (defun ngz-scramble-contents ()
    (interactive)
    (let ((tree (org-element-parse-buffer)))
      (org-element-map tree '(code comment comment-block example-block fixed-width
                                   keyword link node-property plain-text verbatim)
        (lambda (obj)
          (case (org-element-type obj)
            ((code comment comment-block example-block fixed-width keyword
                   node-property verbatim)
             (let ((value (org-element-property :value obj)))
               (org-element-put-property
                obj :value (replace-regexp-in-string "[[:alnum:]]" "x" value))))
            (link
             (unless (string= (org-element-property :type obj) "radio")
               (org-element-put-property obj :raw-link "http://orgmode.org")))
            (plain-text
             (org-element-set-element
              obj (replace-regexp-in-string "[[:alnum:]]" "x" obj)))))
        nil nil nil t)
      (let ((buffer (get-buffer-create "*Scrambled text*")))
        (with-current-buffer buffer
          (insert (org-element-interpret-data tree))
          (goto-char (point-min)))
        (switch-to-buffer buffer))))

If you can reproduce the problem in this new buffer, that's fine too.

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-06 21:31                                             ` Nicolas Goaziou
@ 2014-07-07  0:16                                               ` York Zhao
  2014-07-07  5:27                                                 ` Nicolas Goaziou
  0 siblings, 1 reply; 70+ messages in thread
From: York Zhao @ 2014-07-07  0:16 UTC (permalink / raw)
  To: York Zhao, Eric Abrahamsen, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 497 bytes --]

> Could you send me the document you were working on, in private, and
describe
> what you were doing before it froze?

I'm sorry but I really shouldn't send this document to anyone other than a
lawyer :-)

> or at least an equivalent file structure wise, calling the following
function
> in that document ... If you can reproduce the problem in this new buffer,
> that's fine too.

Just want to confirm that you want me to run this command in that buffer
and see
if the problem can be reproduced?

[-- Attachment #2: Type: text/html, Size: 591 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-06 14:40                                         ` York Zhao
  2014-07-06 21:05                                           ` York Zhao
@ 2014-07-07  1:43                                           ` York Zhao
  2014-07-07  5:33                                             ` Nicolas Goaziou
  1 sibling, 1 reply; 70+ messages in thread
From: York Zhao @ 2014-07-07  1:43 UTC (permalink / raw)
  To: York Zhao, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 6775 bytes --]

> > The exact same slowness problem happened just now. "M-x
org-element-cache-reset"
> > didn't have any effect. Nor did setting `org-element-use-cache' to nil.
Again,
> > killed the buffer and reopened didn't help.
> It looks like the problem isn't related to the cache then. Anyway, you
> could try to do some profiling (see `profiler-start').
>
> > One thing I didn't do, unfortunately, was that I reset cache only for
the buffer
> > where the slowness manifested. I think I should try reseting cache for
all the 8
> > buffers too right?
> Cache is buffer dependent, so you don't need to reset cache for all of
> them (though it's simply C-u M-x org-element-cache-reset).

This problem happened again just now. Again, M-x org-element-cache-reset
didn't
help, nor did C-u M-x org-element-cache-reset. And it seemed that only
typing
characters were slow, took 1 or 2 seconds for a typed character to appear
on the
screen.

Again, this happened in the big buffer that has 77,xxx lines, freshly
opened. I
restarted Emacs and finished `org-drill' session on 8 files before opening
this
big file.

I then `M-x profile-start', typed a few letters and `M-x profile-report',
here's
the memory report:

+ #<compiled 0x138b231>                                    11,320,032  43%
+ call-interactively                                        4,857,849  18%
+ #<compiled 0x1444275>                                     2,170,499   8%
+ timer-event-handler                                       1,428,527   5%
+ #<compiled 0xa6e561>                                      1,299,957   5%
+ helm                                                      1,058,503   4%
+ redisplay_internal (C function)                             869,652   3%
+ ac-handle-post-command                                      695,448   2%
+ helm-M-x                                                    517,012   2%
+ helm-check-new-input                                        215,112   0%
+ #<compiled 0x1391c7d>                                       211,328   0%
+ helm-let-internal                                           182,580   0%
+ helm-read-pattern-maybe                                     109,907   0%
+ helm-process-filtered-candidate-transformer                  97,992   0%
+ helm-get-cached-candidates                                   87,872   0%
+ cl-mapcar                                                    82,880   0%
+ helm-update                                                  81,536   0%
+ helm-funcall-with-source                                     72,380   0%
+ read-from-minibuffer                                         70,224   0%
+ funcall                                                      69,721   0%
+ apply                                                        34,618   0%
+ #<compiled 0xfe8ee9>                                         33,140   0%
+ helm--compute-sources                                        31,988   0%
+ yas--post-command-handler                                    29,288   0%
+ org-element--parse-to                                        29,184   0%
+ #<compiled 0xfe83ad>                                         12,520   0%
+ helm-compute-matches                                         12,400   0%
+ let                                                          12,288   0%
+ byte-code                                                     9,320   0%
+ ac-handle-pre-command                                         9,298   0%
+ profiler-report-rerender-calltree                             8,188   0%
+ command-execute                                               8,188   0%
+ helm-check-minibuffer-input                                   8,152   0%
+ zfill-org-paragraph-boundary                                  7,240   0%
+ helm-internal                                                 7,000   0%
+ sp--self-insert-command                                       6,060   0%
+ helm-comp-read                                                5,200   0%
+ let*                                                          5,028   0%
+ catch                                                         4,204   0%
+ hl-paren-highlight                                            4,144   0%
+ zfill-pre-command-function                                    4,096   0%
+ save-restriction                                              4,096   0%
+ while                                                         4,096   0%
+ save-excursion                                                4,096   0%
+ helm-M-x-current-mode-map-alist                               3,144   0%
+ helm-display-buffer                                           2,080   0%
+ profiler-report-setup-buffer                                  1,066   0%
+ profiler-report                                               1,054   0%
+ org-element--cache-before-change                              1,024   0%

And CPU report:

+ ac-handle-post-command                                         2985  56%
+ timer-event-handler                                            1786  33%
+ redisplay_internal (C function)                                 131   2%
+ helm-M-x                                                        121   2%
  Automatic GC                                                     60   1%
+ call-interactively                                               42   0%
+ #<compiled 0x138b231>                                            24   0%
+ #<compiled 0xa6e561>                                             24   0%
+ apply                                                            23   0%
+ yas--table-all-keys                                              20   0%
+ helm-internal                                                    12   0%
+ helm--compute-sources                                            12   0%
+ #<compiled 0xfe83ad>                                             10   0%
+ #<compiled 0x1444275>                                             8   0%
+ funcall                                                           6   0%
+ #<compiled 0x1391c7d>                                             4   0%
+ helm-update                                                       4   0%
+ helm-check-new-input                                              4   0%
+ helm                                                              4   0%
+ helm-process-filtered-candidate-transformer                       4   0%
+ helm-get-candidates                                               3   0%
+ helm-let-internal                                                 3   0%

So I suspected the `auto-complete'. I tried M-x auto-complete to turn it off
which worked, the typing was fast again. M-x auto-complete to turn it back
on
and typing became extremely slow again.

Hope this will help a tiny bit.


York

[-- Attachment #2: Type: text/html, Size: 10541 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-07  0:16                                               ` York Zhao
@ 2014-07-07  5:27                                                 ` Nicolas Goaziou
  2014-07-25 14:33                                                   ` Sebastien Vauban
  0 siblings, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-07-07  5:27 UTC (permalink / raw)
  To: York Zhao; +Cc: Eric Abrahamsen, emacs-orgmode

Hello,

York Zhao <gtdplatform@gmail.com> writes:

> I'm sorry but I really shouldn't send this document to anyone other than a
> lawyer :-)

[...]

> Just want to confirm that you want me to run this command in that buffer
> and see
> if the problem can be reproduced?

Calling the provided command on your sensitive buffer will create a copy
in a temporary buffer with all its contents hidden, just preserving
structure.

If you can reproduce the problem in this new buffer and no information
leaked (the command is just a quick hack so be sure to check it is
fine), you can send its the contents. There are bonus points if you can
also explain me how to reproduce it.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-07  1:43                                           ` York Zhao
@ 2014-07-07  5:33                                             ` Nicolas Goaziou
  2014-07-07 15:10                                               ` York Zhao
  0 siblings, 1 reply; 70+ messages in thread
From: Nicolas Goaziou @ 2014-07-07  5:33 UTC (permalink / raw)
  To: York Zhao; +Cc: emacs-orgmode

York Zhao <gtdplatform@gmail.com> writes:

> Again, this happened in the big buffer that has 77,xxx lines, freshly
> opened. I
> restarted Emacs and finished `org-drill' session on 8 files before opening
> this
> big file.
>
> I then `M-x profile-start', typed a few letters and `M-x profile-report',
> here's
> the memory report:

[...]

> + zfill-org-paragraph-boundary                                  7,240   0%

What is that, if I may ask?

> + ac-handle-post-command                                         2985  56%
> + timer-event-handler                                            1786  33%
> + redisplay_internal (C function)                                 131   2%

[...]

> So I suspected the `auto-complete'. I tried M-x auto-complete to turn it off
> which worked, the typing was fast again. M-x auto-complete to turn it back
> on
> and typing became extremely slow again.

Indeed. auto-complete developers may be interested in your report. This
is not an Org bug, though.


Regards,

-- 
Nicolas Goaziou

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-07  5:33                                             ` Nicolas Goaziou
@ 2014-07-07 15:10                                               ` York Zhao
  0 siblings, 0 replies; 70+ messages in thread
From: York Zhao @ 2014-07-07 15:10 UTC (permalink / raw)
  To: York Zhao, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 1883 bytes --]

>> + zfill-org-paragraph-boundary                                  7,240
0%
> What is that, if I may ask?

That's in my `zfill-mode' based on `refill-mode', and the function is part
of
the machinery to handle the automatic refilling of org paragraph.

> + ac-handle-post-command                                         2985  56%
> + timer-event-handler                                            1786  33%
> + redisplay_internal (C function)                                 131   2%
[...]

> So I suspected the `auto-complete'. I tried M-x auto-complete to turn it
off
> which worked, the typing was fast again. M-x auto-complete to turn it
back on
> and typing became extremely slow again.

> Indeed. auto-complete developers may be interested in your report. This
is not
> an Org bug, though.

Yes, it is highly possible to be a bug in `auto-complete' and I will report
it
to the `auto-complete' developers as soon as I get a bit more time. And I
totally understand if you decide not to spend time on this until I can
further
prove that this is still an org-mode problem. However, I think it might be
too
early to draw the conclusion at this point that this has nothing to do with
org-mode. This is because `auto-complete' started to manifest the problem
after
doing a bunch of org-mode specific operations, more specifically, after
running
`org-drlll' on 8 `org-mode' buffers, which suggested the possibility of the
leftover side effect introduced by org-mode operations. And the problem
could be
in `org-drlll', but also very possibly be in org-mode core because
`org-drlll'
uses the APIs provided by `org-mode' core.

Anyways, the other one I reported yesterday seemed to be related to
org-element
cache stuff and I will follow your suggestion to try to reproduce it. But I
may
not have much time this week anymore. Will definitely try it this weekend
for
sure.

Regards,

York

[-- Attachment #2: Type: text/html, Size: 2277 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-01  0:43                           ` York Zhao
  2014-07-01  7:38                             ` Nicolas Goaziou
@ 2014-07-15  2:30                             ` York Zhao
  2014-07-19  3:17                               ` Matt Lundin
  1 sibling, 1 reply; 70+ messages in thread
From: York Zhao @ 2014-07-15  2:30 UTC (permalink / raw)
  To: Eric Abrahamsen; +Cc: emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 423 bytes --]

> On Mon, Jun 30, 2014 at 8:43 PM, York Zhao <gtdplatform@gmail.com> wrote:

> I got the problem today, with org-mode version "815c218" in Emacs 24.3.1.
The
> error message is: if: Lisp nesting exceeds `max-lisp-eval-depth'.
Attached is
> the backtrace saved in a file. Hope this will help.

Just an update. I haven't been bitten by this deadly problem for awhile,
highly
likely that it had been fixed. Thanks a lot.

York

[-- Attachment #2: Type: text/html, Size: 560 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-15  2:30                             ` York Zhao
@ 2014-07-19  3:17                               ` Matt Lundin
  2014-07-19 14:12                                 ` York Zhao
  0 siblings, 1 reply; 70+ messages in thread
From: Matt Lundin @ 2014-07-19  3:17 UTC (permalink / raw)
  To: York Zhao; +Cc: Eric Abrahamsen, emacs-orgmode

York Zhao <gtdplatform@gmail.com> writes:

>> On Mon, Jun 30, 2014 at 8:43 PM, York Zhao <gtdplatform@gmail.com>
> wrote:
>
>> I got the problem today, with org-mode version "815c218" in Emacs
> 24.3.1. The
>> error message is: if: Lisp nesting exceeds `max-lisp-eval-depth'.
> Attached is
>> the backtrace saved in a file. Hope this will help.
>
> Just an update. I haven't been bitten by this deadly problem for
> awhile, highly
> likely that it had been fixed. Thanks a lot.

FWIW, I'm still getting regular lockups with the cache. I'll dig into it
further when I have time.

Matt

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-19  3:17                               ` Matt Lundin
@ 2014-07-19 14:12                                 ` York Zhao
  0 siblings, 0 replies; 70+ messages in thread
From: York Zhao @ 2014-07-19 14:12 UTC (permalink / raw)
  To: Matt Lundin; +Cc: Eric Abrahamsen, emacs-orgmode

[-- Attachment #1: Type: text/plain, Size: 323 bytes --]

> FWIW, I'm still getting regular lockups with the cache. I'll dig into it
> further when I have time.

I'm still being locked up from time to time, maybe less than before I guess.
What I said was that I never got the deadly problem of "Lisp nesting exceeds
`max-lisp-eval-depth", and the fix had been a life saver for me.

[-- Attachment #2: Type: text/html, Size: 396 bytes --]

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-07-07  5:27                                                 ` Nicolas Goaziou
@ 2014-07-25 14:33                                                   ` Sebastien Vauban
  0 siblings, 0 replies; 70+ messages in thread
From: Sebastien Vauban @ 2014-07-25 14:33 UTC (permalink / raw)
  To: emacs-orgmode-mXXj517/zsQ

Nicolas Goaziou wrote:
> York Zhao <gtdplatform-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> writes:
>
>> I'm sorry but I really shouldn't send this document to anyone other than a
>> lawyer :-)
>
> [...]
>
>> Just want to confirm that you want me to run this command in that buffer
>> and see
>> if the problem can be reproduced?
>
> Calling the provided command on your sensitive buffer will create a copy
> in a temporary buffer with all its contents hidden, just preserving
> structure.
>
> If you can reproduce the problem in this new buffer and no information
> leaked (the command is just a quick hack so be sure to check it is
> fine), you can send its the contents. There are bonus points if you can
> also explain me how to reproduce it.

I tested your functions on my huge Org LP file for my Emacs config. It
does work as a charm, preserving code blocks (necessary for
reproducibility purpose).

I think this should clearly make its way into Org code base...

Best regards,
  Seb

-- 
Sebastien Vauban

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
  2014-05-14 11:06 dieter
@ 2014-05-15  2:29 ` Eric Abrahamsen
  0 siblings, 0 replies; 70+ messages in thread
From: Eric Abrahamsen @ 2014-05-15  2:29 UTC (permalink / raw)
  To: emacs-orgmode

dieter@schoen.or.at writes:

> hi,
>
> on my machine wanderlust hangs from time to time when i am inside the company net and
> the proxy has hiccups.
> then C-g (sometimes several) usually help.
>
> in the link below i found an interesting variable, debug-on-quit.
> when it is set, emacs enters the debugger when you hit C-g.

Whatever's going on here isn't network-related, it's pretty clearly
triggered by making editing changes to an org buffer. It's also
unsalvageable with C-g, or this whole thing would be much simpler!
There's an ongoing thread between Daimrod and Stephen that might
actually be the same issue, I'll check that out.

> sendings signal to emacs from external usually only kills it.
> the only signal which i am aware of that can be caught is SIGUSR1.
> i used to use it to notify emacs about network changes.

Good to know, thanks!

> hope this helps,
> dieter
>
> [1] http://www.gnu.org/software/emacs/manual/html_node/elisp/Infinite-Loops.html#Infinite-Loops
>
>
>
>>---- Original Message ----
>>From: Eric Abrahamsen <eric@ericabrahamsen.net>
>>To: emacs-orgmode@gnu.org
>>Sent: Wed, May 14, 2014, 10:36 AM
>>Subject: [O] still seeing semi-regular lockups
>>
>>Hey there,
>>
>>After Nicolas made the last round of improvements to the caching
>>mechanism I got far fewer hangs with Org, but they are still happening.
>>Maybe once a day or so, on average, editing something in an Org buffer
>>causes emacs to hang, and my fans to spin up, and there we are until I
>>kill emacs.
>>
>>It happens often enough that I guess it's worth running emacs under some
>>kind of debugger -- at least, I assume that's the best way of catching
>>the bug. I'm not really sure how to go hunting, though, so if anyone had
>>any advice in this direction, that would be great.
>>
>>In the meantime, is there any way of interrupting emacs so it quits
>>whatever its doing, without having to kill it? I've played around with
>>sending different signals using "kill", just for fun, but everything
>>I've tried either does nothing, or kills emacs altogether.
>>
>>Cheers,
>>Eric

^ permalink raw reply	[flat|nested] 70+ messages in thread

* Re: still seeing semi-regular lockups
@ 2014-05-14 11:06 dieter
  2014-05-15  2:29 ` Eric Abrahamsen
  0 siblings, 1 reply; 70+ messages in thread
From: dieter @ 2014-05-14 11:06 UTC (permalink / raw)
  To: emacs-orgmode

hi,

on my machine wanderlust hangs from time to time when i am inside the company net and
the proxy has hiccups.
then C-g (sometimes several) usually help.

in the link below i found an interesting variable, debug-on-quit.
when it is set, emacs enters the debugger when you hit C-g.

sendings signal to emacs from external usually only kills it.
the only signal which i am aware of that can be caught is SIGUSR1.
i used to use it to notify emacs about network changes.

hope this helps,
dieter

[1] http://www.gnu.org/software/emacs/manual/html_node/elisp/Infinite-Loops.html#Infinite-Loops



>---- Original Message ----
>From: Eric Abrahamsen <eric@ericabrahamsen.net>
>To: emacs-orgmode@gnu.org
>Sent: Wed, May 14, 2014, 10:36 AM
>Subject: [O] still seeing semi-regular lockups
>
>Hey there,
>
>After Nicolas made the last round of improvements to the caching
>mechanism I got far fewer hangs with Org, but they are still happening.
>Maybe once a day or so, on average, editing something in an Org buffer
>causes emacs to hang, and my fans to spin up, and there we are until I
>kill emacs.
>
>It happens often enough that I guess it's worth running emacs under some
>kind of debugger -- at least, I assume that's the best way of catching
>the bug. I'm not really sure how to go hunting, though, so if anyone had
>any advice in this direction, that would be great.
>
>In the meantime, is there any way of interrupting emacs so it quits
>whatever its doing, without having to kill it? I've played around with
>sending different signals using "kill", just for fun, but everything
>I've tried either does nothing, or kills emacs altogether.
>
>Cheers,
>Eric

^ permalink raw reply	[flat|nested] 70+ messages in thread

end of thread, other threads:[~2014-07-25 14:33 UTC | newest]

Thread overview: 70+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-05-14  8:39 still seeing semi-regular lockups Eric Abrahamsen
2014-05-15  9:21 ` Bastien
2014-05-15  9:30   ` Daimrod
2014-05-15  9:46     ` Bastien
2014-05-15 10:31     ` Eric Abrahamsen
2014-05-15 10:37       ` Daimrod
2014-05-15 10:43         ` Eric Abrahamsen
2014-05-19 14:21     ` Daimrod
2014-05-20  8:25       ` Eric Abrahamsen
2014-05-20  8:55         ` Daimrod
2014-05-20 11:16           ` Eric Abrahamsen
2014-06-24  8:48             ` Nicolas Goaziou
2014-06-24 14:28               ` Eric Abrahamsen
2014-06-25  4:09                 ` Matt Lundin
2014-06-25  5:39                   ` Matt Lundin
2014-06-25  7:32                   ` Sebastien Vauban
2014-06-27 13:00                     ` Nicolas Goaziou
2014-06-25  7:38                   ` Daimrod
2014-06-25  8:22                     ` Eric Abrahamsen
2014-06-25  8:30                       ` Bastien
2014-06-25  8:40                         ` Eric Abrahamsen
2014-06-25 13:47                     ` Matt Lundin
2014-06-26  2:58                     ` Matt Lundin
2014-06-26  3:00                       ` Matt Lundin
2014-06-27 12:56                       ` Nicolas Goaziou
2014-06-27 13:37                         ` Alan Schmitt
2014-06-27 22:31                           ` Nicolas Goaziou
2014-06-28 19:27                 ` Eric Abrahamsen
2014-06-29  1:39                   ` York Zhao
2014-06-29  2:23                     ` Eric Abrahamsen
2014-06-30  1:15                       ` York Zhao
2014-06-30  1:43                         ` York Zhao
2014-06-30 20:20                           ` Alan Schmitt
2014-07-01  0:43                           ` York Zhao
2014-07-01  7:38                             ` Nicolas Goaziou
2014-07-01 17:14                               ` York Zhao
2014-07-01 21:15                                 ` York Zhao
2014-07-02  8:01                                   ` Nicolas Goaziou
2014-07-03  1:03                                     ` York Zhao
2014-07-06  7:28                                       ` Nicolas Goaziou
2014-07-06 14:40                                         ` York Zhao
2014-07-06 21:05                                           ` York Zhao
2014-07-06 21:31                                             ` Nicolas Goaziou
2014-07-07  0:16                                               ` York Zhao
2014-07-07  5:27                                                 ` Nicolas Goaziou
2014-07-25 14:33                                                   ` Sebastien Vauban
2014-07-07  1:43                                           ` York Zhao
2014-07-07  5:33                                             ` Nicolas Goaziou
2014-07-07 15:10                                               ` York Zhao
2014-07-03 15:31                                 ` York Zhao
2014-07-03 15:55                                   ` York Zhao
2014-07-06  7:19                                   ` Nicolas Goaziou
2014-07-06 14:29                                     ` York Zhao
2014-07-15  2:30                             ` York Zhao
2014-07-19  3:17                               ` Matt Lundin
2014-07-19 14:12                                 ` York Zhao
2014-06-29 13:58                     ` Nicolas Goaziou
2014-05-29  3:01       ` Daimrod
2014-05-30  9:17         ` Nicolas Goaziou
2014-05-30 14:35           ` Daimrod
2014-06-11 11:53             ` Daimrod
2014-06-11 21:30               ` Nicolas Goaziou
2014-06-11 22:18                 ` Daimrod
2014-06-14  7:43                   ` Nicolas Goaziou
2014-06-14 23:55                     ` Daimrod
2014-06-22  7:58                       ` Nicolas Goaziou
2014-06-04  4:47     ` Eric Abrahamsen
2014-06-05  4:29       ` Daimrod
2014-05-14 11:06 dieter
2014-05-15  2:29 ` Eric Abrahamsen

Code repositories for project(s) associated with this inbox:

	https://git.savannah.gnu.org/cgit/emacs/org-mode.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).