ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/emacs-lisp/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/emacs-lisp/timer.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defalias 'timer--triggered--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--triggered (declare (side-effect-free t)) (aref cl-x 0)) nil] 7])
(put 'timer--triggered 'compiler-macro 'timer--triggered--cmacro)
(defalias 'timer--triggered #[(cl-x) "\301H\207" [cl-x 0] 2])
(function-put 'timer--triggered 'side-effect-free t)
(defalias 'timer--high-seconds--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--high-seconds (declare (side-effect-free t)) (aref cl-x 1)) nil] 7])
(put 'timer--high-seconds 'compiler-macro 'timer--high-seconds--cmacro)
(defalias 'timer--high-seconds #[(cl-x) "\301H\207" [cl-x 1] 2])
(function-put 'timer--high-seconds 'side-effect-free t)
(defalias 'timer--low-seconds--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--low-seconds (declare (side-effect-free t)) (aref cl-x 2)) nil] 7])
(put 'timer--low-seconds 'compiler-macro 'timer--low-seconds--cmacro)
(defalias 'timer--low-seconds #[(cl-x) "\301H\207" [cl-x 2] 2])
(function-put 'timer--low-seconds 'side-effect-free t)
(defalias 'timer--usecs--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--usecs (declare (side-effect-free t)) (aref cl-x 3)) nil] 7])
(put 'timer--usecs 'compiler-macro 'timer--usecs--cmacro)
(defalias 'timer--usecs #[(cl-x) "\301H\207" [cl-x 3] 2])
(function-put 'timer--usecs 'side-effect-free t)
(defalias 'timer--repeat-delay--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--repeat-delay (declare (side-effect-free t)) (aref cl-x 4)) nil] 7])
(put 'timer--repeat-delay 'compiler-macro 'timer--repeat-delay--cmacro)
(defalias 'timer--repeat-delay #[(cl-x) "\301H\207" [cl-x 4] 2])
(function-put 'timer--repeat-delay 'side-effect-free t)
(defalias 'timer--function--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--function (declare (side-effect-free t)) (aref cl-x 5)) nil] 7])
(put 'timer--function 'compiler-macro 'timer--function--cmacro)
(defalias 'timer--function #[(cl-x) "\301H\207" [cl-x 5] 2])
(function-put 'timer--function 'side-effect-free t)
(defalias 'timer--args--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--args (declare (side-effect-free t)) (aref cl-x 6)) nil] 7])
(put 'timer--args 'compiler-macro 'timer--args--cmacro)
(defalias 'timer--args #[(cl-x) "\301H\207" [cl-x 6] 2])
(function-put 'timer--args 'side-effect-free t)
(defalias 'timer--idle-delay--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--idle-delay (declare (side-effect-free t)) (aref cl-x 7)) nil] 7])
(put 'timer--idle-delay 'compiler-macro 'timer--idle-delay--cmacro)
(defalias 'timer--idle-delay #[(cl-x) "\301H\207" [cl-x 7] 2])
(function-put 'timer--idle-delay 'side-effect-free t)
(defalias 'timer--psecs--cmacro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block timer--psecs (declare (side-effect-free t)) (aref cl-x 8)) nil] 7])
(put 'timer--psecs 'compiler-macro 'timer--psecs--cmacro)
(defalias 'timer--psecs #[(cl-x) "\301H\207" [cl-x 8] 2])
(function-put 'timer--psecs 'side-effect-free t)
(defalias 'timer-create--cmacro #[(_cl-whole-arg) "\300\301\302\301\211\211%\207" [cl--defsubst-expand nil (cl-block timer-create "Constructor for objects of type `timer'." (declare (side-effect-free t)) (vector t nil nil nil nil nil nil nil nil))] 6])
(put 'timer-create 'compiler-macro 'timer-create--cmacro)
#@42 Constructor for objects of type `timer'.
(defalias 'timer-create #[nil "\300\301\302\211\211\211\211\211\211\211& \207" [vector t nil] 10 (#$ . 4199)])
(byte-code "\300\301\302\303#\210\304\305\306\211\307\306\310\311\312\306& \207" [function-put timer-create side-effect-free t cl-struct-define timer nil vector ((triggered t) (high-seconds) (low-seconds) (usecs) (repeat-delay) (function) (args) (idle-delay) (psecs)) cl-struct-timer-tags cl-struct-timer] 10)
#@32 Return t if OBJECT is a timer.
(defalias 'timerp #[(object) "\301!\205\n G\302U\207" [object vectorp 9] 2 (#$ . 4667)])
(defalias 'timer--check #[(timer) "\301!\206\f \302\303\301D\"\207" [timer timerp signal wrong-type-argument] 4])
(put 'timer--check 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'timer--time-setter #[(timer time) "\306!\206 \307\310\306D\")\210\211\311\n\211A\242I\210)\n\312\211 \n:\203> \n\211A\242\n\203> \n\211A\242\n\203> \n@\211 \313
I\210)\211 \314\fI\210)\211 \315 I\210)\n+\207" [timer #1=#:v time psecs usecs low timerp signal wrong-type-argument 1 0 2 3 8 #2=#:v #3=#:v #4=#:v] 5])
(defalias 'timer--time #[(timer) "\301H\302H\303H\304HF\207" [timer 1 2 3 8] 5])
(put 'timer--time 'gv-expander #[(do &rest args) "\302\303\304 $\207" [do args gv--defsetter timer--time #[(val &rest args) "\302\303 C\"B\207" [args val timer--time-setter append] 4]] 5])
#@222 Set the trigger time of TIMER to TIME.
TIME must be in the internal format returned by, e.g., `current-time'.
If optional third argument DELTA is a positive number, make the timer
fire repeatedly that many seconds apart.
(defalias 'timer-set-time #[(timer time &optional delta) "\305 \n\"\210)\211\306\f\247\205 \f\307V\205 \fI\210)\207" [timer #1=#:v time #2=#:v delta timer--time-setter 4 0] 5 (#$ . 5598)])
#@273 Set the trigger idle time of TIMER to SECS.
SECS may be an integer, floating point number, or the internal
time format returned by, e.g., `current-idle-time'.
If optional third argument REPEAT is non-nil, make the timer
fire each time Emacs is idle for that many seconds.
(defalias 'timer-set-idle-time #[(timer secs &optional repeat) "\305 \n:\203
\n\202 \306\n!\"\210)\211\307\fI\210)\207" [timer #1=#:v secs #2=#:v repeat timer--time-setter seconds-to-time 4] 5 (#$ . 6022)])
#@202 Yield the next value after TIME that is an integral multiple of SECS.
More precisely, the next value, after TIME, that is an integral multiple
of SECS seconds since the epoch. SECS may be a fraction.
(defalias 'timer-next-integral-multiple-of-time #[(time secs) "\306 A@\307 @_\\\310\n[ \" \n\311\f!\\ \311\310\f\312\"_! \313 8\206( \314\315\316 8_\\\211 Z
\nX\203P \314W\203P \310[ _\"\\
\317\"\\\310\"\317
\320\"\317\310
\320\"!\317\321\"\317\310\321\"!F.\207" [trillion time time-sec secs delta-sec next-sec 1000000000000.0 65536.0 mod ffloor 1 3 0 1000000.0 2 floor 65536 1000000 next-sec-psec sub-time-psec psec-diff] 8 (#$ . 6515)])
#@146 Advance TIME by SECS seconds and optionally USECS microseconds
and PSECS picoseconds. SECS may be either an integer or a
floating point number.
(defalias 'timer-relative-time #[(time secs &optional usecs psecs) "\n\204\n \203 \305 \306\211\n\206 \306 \206 \306F\"\305\f \")\207" [secs delta usecs psecs time time-add 0] 6 (#$ . 7194)])
#@55 Say whether time value T1 is less than time value T2.
(defalias 'timer--time-less-p #[(t1 t2) "\302\303!\303 !\"\207" [t1 t2 time-less-p timer--time] 4 (#$ . 7544)])
#@176 Increment the time set in TIMER by SECS seconds, USECS microseconds,
and PSECS picoseconds. SECS may be a fraction. If USECS or PSECS are
omitted, they are treated as zero.
(defalias 'timer-inc-time #[(timer secs &optional usecs psecs) "\305 \306\307!\n \f$\")\207" [timer #1=#:v secs usecs psecs timer--time-setter timer-relative-time timer--time] 7 (#$ . 7718)])
#@305 Set the trigger time of TIMER to TIME plus USECS.
TIME must be in the internal format returned by, e.g., `current-time'.
The microsecond count from TIME is ignored, and USECS is used instead.
If optional fourth argument DELTA is a positive number, make the timer
fire repeatedly that many seconds apart.
(defalias 'timer-set-time-with-usecs #[(timer time usecs &optional delta) "\306 \n\"\210)\211\307\fI\210)\211 \310\311I\210)\211 \312\f\247\205, \f\311V\205, \fI\210)\207" [timer #1=#:v time #2=#:v usecs #3=#:v timer--time-setter 3 8 0 4 #4=#:v delta] 5 (#$ . 8095)])
(make-obsolete 'timer-set-time-with-usecs "use `timer-set-time' and `timer-inc-time' instead." "22.1")
#@62 Make TIMER call FUNCTION with optional ARGS when triggering.
(defalias 'timer-set-function #[(timer function &optional args) "\305!\206 \306\307\305D\")\210\211\310\nI\210)\211\311\fI\210)\207" [timer #1=#:v function #2=#:v args timerp signal wrong-type-argument 5 6] 5 (#$ . 8787)])
(defalias 'timer--activate #[(timer &optional triggered-p reuse-cell idle) "\306!\203\222 \307H\250\203\222 \310H\250\203\222 \311H\250\203\222 \312H\250\203\222 \313H\203\222 \2030 \n\2021 \314 \211 \203I \315
@\"\203I
A\211\2048 \203[ \240\210
\241\210\202`
B\f\203p \f\211 \241\210)\202} \203z \202} \211 \316I\210)\211 \317 I\210+\314\207\320\321!\207" [timer idle timer-idle-list timer-list last timers timerp 1 2 3 8 5 nil timer--time-less-p 0 7 error "Invalid or uninitialized timer" reuse-cell #1=#:v #2=#:v triggered-p #3=#:v] 4])
#@397 Insert TIMER into `timer-list'.
If TRIGGERED-P is t, make TIMER inactive (put it on the list, but
mark it as already triggered). To remove it, use `cancel-timer'.
REUSE-CELL, if non-nil, is a cons cell to reuse when inserting
TIMER into `timer-list' (usually a cell removed from that list by
`cancel-timer-internal'; using this reduces consing for repeat
timers). If nil, allocate a new cell.
(defalias 'timer-activate #[(timer &optional triggered-p reuse-cell) "\303 \n\304$\207" [timer triggered-p reuse-cell timer--activate nil] 5 (#$ . 9668)])
#@743 Insert TIMER into `timer-idle-list'.
This arranges to activate TIMER whenever Emacs is next idle.
If optional argument DONT-WAIT is non-nil, set TIMER to activate
immediately (see below), or at the right time, if Emacs is
already idle.
REUSE-CELL, if non-nil, is a cons cell to reuse when inserting
TIMER into `timer-idle-list' (usually a cell removed from that
list by `cancel-timer-internal'; using this reduces consing for
repeat timers). If nil, allocate a new cell.
Using non-nil DONT-WAIT is not recommended when activating an
idle timer from an idle timer handler, if the timer being
activated has an idleness time that is smaller or equal to
the time of the current timer. That's because the activated
timer will fire right away.
(defalias 'timer-activate-when-idle #[(timer &optional dont-wait reuse-cell) "\303 ?\n\304$\207" [timer dont-wait reuse-cell timer--activate idle] 5 (#$ . 10227)])
(defalias 'disable-timeout 'cancel-timer)
#@46 Remove TIMER from the list of active timers.
(defalias 'cancel-timer #[(timer) "\303!\206 \304\305\303D\")\210\306 \"\306\n\"\307\207" [timer timer-list timer-idle-list timerp signal wrong-type-argument delq nil] 4 (#$ . 11182)])
#@155 Remove TIMER from the list of active timers or idle timers.
Only to be used in this file. It returns the cons cell
that was removed from the timer list.
(defalias 'cancel-timer-internal #[(timer) " >\n>\211 \203 \305 \" \203 \305\n\"\f\206 *\207" [timer timer-list timer-idle-list cell2 cell1 delq] 4 (#$ . 11428)])
#@178 Cancel all timers which would run FUNCTION.
This affects ordinary timers such as are scheduled by `run-at-time',
and idle timers such as are scheduled by `run-with-idle-timer'.
(defalias 'cancel-function-timers #[(function) "\305\211\203 \n@\211\306H =\203 \307 \"\nA\211\204 *\f\305\211\205@ \n@\211\306H =\2038 \307 \f\"\nA\211\204( \305*\207" [timer-list timer --dolist-tail-- function timer-idle-list nil 5 delq] 4 (#$ . 11763) "aCancel timers of function: "])
#@26 Last timer that was run.
(defvar timer-event-last nil (#$ . 12249))
#@34 Next-to-last timer that was run.
(defvar timer-event-last-1 nil (#$ . 12323))
#@35 Third-to-last timer that was run.
(defvar timer-event-last-2 nil (#$ . 12407))
#@306 Maximum number of times to repeat a timer, if many repeats are delayed.
Timer invocations can be delayed because Emacs is suspended or busy,
or because the system's time changes. If such an occurrence makes it
appear that many invocations are overdue, this variable controls
how many will really happen.
(custom-declare-variable 'timer-max-repeats 10 '(#$ . 12493) :type 'integer :group 'internal)
#@165 Calculate number of seconds from when TIMER will run, until TIME.
TIMER is a timer, and stands for the time when its next repeat is scheduled.
TIME is a time-list.
(defalias 'timer-until #[(timer time) "\302!\302\303 !!Z\207" [time timer float-time timer--time] 4 (#$ . 12899)])
#@97 Call the handler for the timer TIMER.
This function is called, by name, directly by the C code.
(defalias 'timer-event-handler #[(timer) "\n \306 \307 !\206 \310\311\307 D\")\210\312\313 !
\205\264 \314H\203t \315H\2038 \316 \312
#\210\202t \317 \211\314H\320#\210 \247\203k \320\321 \312\"W\203k \321 \312\" \314H\245\211 V\203j \317 \211\314H _\"\210)\322 \306
#\210\306 \3231\206 r\324 \325H \326H\")0\202\237 \327\330 \325H9\203\232 \331\332 \325H\"\202\233 \333 #)\210 \205\264 >\205\264 \211 !\320\312I)+\207" [timer-event-last-1 timer-event-last-2 timer-event-last timer inhibit-quit cell t timerp signal wrong-type-argument nil cancel-timer-internal 4 7 timer-activate-when-idle timer-inc-time 0 timer-until timer-activate (debug error) apply 5 6 message "Error running timer%s: %S" format-message " `%s'" "" retrigger timer-max-repeats repeats err timer-list #1=#:v] 7 (#$ . 13185)])
#@38 Non-nil if EVENT is a timeout event.
(defalias 'timeout-event-p #[(event) "<\205 @\301=\207" [event timer-event] 2 (#$ . 14110)])
#@910 Perform an action at time TIME.
Repeat the action every REPEAT seconds, if REPEAT is non-nil.
REPEAT may be an integer or floating point number.
TIME should be one of:
- a string giving today's time like "11:23pm"
(the acceptable formats are HHMM, H:MM, HH:MM, HHam, HHAM,
HHpm, HHPM, HH:MMam, HH:MMAM, HH:MMpm, or HH:MMPM;
a period `.' can be used instead of a colon `:' to separate
the hour and minute parts);
- a string giving a relative time like "90" or "2 hours 35 minutes"
(the acceptable forms are a number of seconds without units
or some combination of values using units in `timer-duration-words');
- nil, meaning now;
- a number of seconds from now;
- a value from `encode-time';
- or t (with non-nil REPEAT) meaning the next integral
multiple of REPEAT.
The action is to call FUNCTION with arguments ARGS.
This function returns a timer object which you can use in
`cancel-timer'.
(defalias 'run-at-time #[(time repeat function &rest args) "\203 \247\203 \306W\204 \307\310!\210 \204 \311 \312=\203* \203* \313\311 \" \247\2034 \314\315 \" ;\203G \316 !\211\203F \314\315\n\") ;\203u \317\320!\210\321 !\322 \211 \306Y\203t \323\306\f\324\246\f\324\245\325 8\326 8\327 8\330 8&* :\204~ \307\331!\210\332\312\315\211\211\211\211\211\211\211& \333
#\210\334
#\210\335
!\210
)\207" [repeat time secs now hhmm timer 0 error "Invalid repetition interval" current-time t timer-next-integral-multiple-of-time timer-relative-time nil timer-duration require diary-lib diary-entry-time decode-time encode-time 100 3 4 5 8 "Invalid time format" vector timer-set-time timer-set-function timer-activate function args] 11 (#$ . 14250) "sRun at time: \nNRepeat interval: \naFunction: "])
#@298 Perform an action after a delay of SECS seconds.
Repeat the action every REPEAT seconds, if REPEAT is non-nil.
SECS and REPEAT may be integers or floating point numbers.
The action is to call FUNCTION with arguments ARGS.
This function returns a timer object which you can use in `cancel-timer'.
(defalias 'run-with-timer #[(secs repeat function &rest args) "\304\305 \n %\207" [secs repeat function args apply run-at-time] 6 (#$ . 15983) "sRun after delay (seconds): \nNRepeat interval: \naFunction: "])
#@270 Add a timer to run SECS seconds from now, to call FUNCTION on OBJECT.
If REPEAT is non-nil, repeat the timer every REPEAT seconds.
This function returns a timer object which you can use in `cancel-timer'.
This function is for compatibility; see also `run-with-timer'.
(defalias 'add-timeout #[(secs function object &optional repeat) "\304 \n $\207" [secs repeat function object run-with-timer] 5 (#$ . 16497)])
#@719 Perform an action the next time Emacs is idle for SECS seconds.
The action is to call FUNCTION with arguments ARGS.
SECS may be an integer, a floating point number, or the internal
time format returned by, e.g., `current-idle-time'.
If Emacs is currently idle, and has been idle for N seconds (N < SECS),
then it will call FUNCTION in SECS - N seconds from now. Using
SECS <= N is not recommended if this function is invoked from an idle
timer, because FUNCTION will then be called immediately.
If REPEAT is non-nil, do the action each time Emacs has been idle for
exactly SECS seconds (that is, only once for each time Emacs becomes idle).
This function returns a timer object which you can use in `cancel-timer'.
(defalias 'run-with-idle-timer #[(secs repeat function &rest args) "\305\306\307\211\211\211\211\211\211\211& \310 \n#\210\311 \f#\210\312\306\"\210)\207" [timer function args secs repeat vector t nil timer-set-function timer-set-idle-time timer-activate-when-idle] 10 (#$ . 16917) (list (read-from-minibuffer "Run after idle (seconds): " nil nil t) (y-or-n-p "Repeat each time Emacs is idle? ") (intern (completing-read "Function: " obarray 'fboundp t)))])
#@68 List of all timers used by currently pending `with-timeout' calls.
(defvar with-timeout-timers nil (#$ . 18104))
#@410 Run BODY, but if it doesn't finish in SECONDS seconds, give up.
If we give up, we run the TIMEOUT-FORMS and return the value of the last one.
The timeout is checked whenever Emacs waits for some kind of external
event (such as keyboard input, input from subprocesses, or a certain time);
if the program loops without waiting in any way, the timeout will not
be detected.
(fn (SECONDS TIMEOUT-FORMS...) BODY)
(defalias 'with-timeout '(macro . #[(list &rest body) "@A\305\306!\307\310\311\312 D\313\314\315 \316\317\316\320\312 D\312 DEEFD\321B\322\323\fB\324BBEEDC\325\326\310\312 DE\323\nB\327BBBE+\207" [list timeout timeout-forms seconds body make-symbol "timeout" let -with-timeout-value- catch quote let* -with-timeout-timer- run-with-timer nil lambda throw ((with-timeout-timers (cons -with-timeout-timer- with-timeout-timers))) unwind-protect progn ((cancel-timer -with-timeout-timer-)) if eq (-with-timeout-value-)] 15 (#$ . 18224)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [function-put with-timeout lisp-indent-function 1 put edebug-form-spec ((form body) body)] 4)
#@283 Stop the clock for `with-timeout'. Used by debuggers.
The idea is that the time you spend in the debugger should not
count against these timeouts.
The value is a list that the debugger can pass to `with-timeout-unsuspend'
when it exits, to make these timers start counting again.
(defalias 'with-timeout-suspend #[nil "\301\302\"\207" [with-timeout-timers mapcar #[(timer) "\301!\210\302\303!\304\"D\207" [timer cancel-timer time-subtract timer--time nil] 4]] 3 (#$ . 19329)])
#@117 Restart the clock for `with-timeout'.
The argument should be a value previously returned by `with-timeout-suspend'.
(defalias 'with-timeout-unsuspend #[(timer-spec-list) "\305\211\205' \n@\211@ A@ \306\f\307\305 \"\"\210\310\f!\210*\nA\211\204 \305*\207" [timer-spec-list elt --dolist-tail-- delay timer nil timer-set-time time-add timer-activate] 6 (#$ . 19819)])
#@114 Like (y-or-n-p PROMPT), with a timeout.
If the user does not answer after SECONDS seconds, return DEFAULT-VALUE.
(defalias 'y-or-n-p-with-timeout #[(prompt seconds default-value) "\3062 \307\310\311#\211\nB\312\216\313 !+0\211 \306=\203
\202! \f)\207" [seconds -with-timeout-timer- with-timeout-timers prompt -with-timeout-value- default-value #1=#:timeout run-with-timer nil #[nil "\300\301\211\"\207" [throw #1#] 3] #[nil "\301!\207" [-with-timeout-timer- cancel-timer] 2] y-or-n-p] 5 (#$ . 20198)])
#@55 Alist mapping temporal words to durations in seconds.
(defconst timer-duration-words (byte-code "\300\301B\302\303B\304\305B\306\307B\310\311B\312\311B\313\314B\315\314B\316\317B\320\321B\322\323B\324\325B\326\327B\330\331B\257\207" ["microsec" 1e-06 "microsecond" 1e-06 "millisec" 0.001 "millisecond" 0.001 "sec" 1 "second" "min" 60 "minute" "hour" 3600 "day" 86400 "week" 604800 "fortnight" 1209600 "month" 2592000 "year" 31557600.0] 15) (#$ . 20713))
#@72 Return number of seconds specified by STRING, or nil if parsing fails.
(defalias 'timer-duration #[(string) "\306\211\307\310\311 #\203B \312\224\203 \313\314\312 \"!\202 \312\315\314\316 \"\f\"A
\2039 \306\225\n
_\\\202> \317 G*\202 GU\203M \n\202a \320 \317\307 \310#)\266\203\205a \313 !+\207" [case-fold-search start secs string timer-duration-words itemsize 0 t string-match "[ ]*\\([0-9.]+\\)?[ ]*\\([a-z]+[a-rt-z]\\)s?[ ]*" 1 string-to-number match-string assoc 2 nil "\\`[0-9.]+\\'" count inhibit-changing-match-data] 7 (#$ . 21174)])
#@65 Mark all idle-time timers as once again candidates for running.
(defalias 'internal-timer-start-idle #[nil "\304\211\205! \n@\305 !\203 \211\306\304I\210)\nA\211\204 \304*\207" [timer-idle-list timer --dolist-tail-- #1=#:v nil timerp 0] 4 (#$ . 21748)])
(provide 'timer)
Kontol Shell Bypass