From debbugs-submit-bounces@debbugs.gnu.org Tue Jul 05 02:41:14 2011 Received: (at submit) by debbugs.gnu.org; 5 Jul 2011 06:41:14 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1QdzJp-0005DP-Ny for submit@debbugs.gnu.org; Tue, 05 Jul 2011 02:41:14 -0400 Received: from eggs.gnu.org ([140.186.70.92]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1QdzJm-0005DC-1P for submit@debbugs.gnu.org; Tue, 05 Jul 2011 02:41:11 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1QdzJf-0006ms-7o for submit@debbugs.gnu.org; Tue, 05 Jul 2011 02:41:04 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,T_RP_MATCHES_RCVD autolearn=unavailable version=3.3.1 Received: from lists.gnu.org ([140.186.70.17]:34089) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QdzJe-0006mo-TY for submit@debbugs.gnu.org; Tue, 05 Jul 2011 02:41:03 -0400 Received: from eggs.gnu.org ([140.186.70.92]:42099) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QdzJd-0008S2-1l for bug-gnu-emacs@gnu.org; Tue, 05 Jul 2011 02:41:02 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1QdzJb-0006mW-7M for bug-gnu-emacs@gnu.org; Tue, 05 Jul 2011 02:41:00 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:41396) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1QdzJa-0006m8-NY for bug-gnu-emacs@gnu.org; Tue, 05 Jul 2011 02:40:59 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id E7C7A39E810F for ; Mon, 4 Jul 2011 23:40:48 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id S862p8nZlDtC for ; Mon, 4 Jul 2011 23:40:47 -0700 (PDT) Received: from [192.168.1.10] (pool-71-189-109-235.lsanca.fios.verizon.net [71.189.109.235]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id DCD9A39E80F8 for ; Mon, 4 Jul 2011 23:40:47 -0700 (PDT) Message-ID: <4E12B1EB.9060406@cs.ucla.edu> Date: Mon, 04 Jul 2011 23:40:43 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.17) Gecko/20110516 Thunderbird/3.1.10 MIME-Version: 1.0 To: bug-gnu-emacs@gnu.org Subject: patch for higher-resolution time stamps Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 3) X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.6 (newer, 3) X-Received-From: 140.186.70.17 X-Spam-Score: -4.7 (----) X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -4.7 (----) Currently, Emacs supports time stamps to at most microsecond resolution, and often to only 1-second resolution, even though most modern systems have nanosecond-resolution time stamps for clock and file time stamps. This leads to some problems, for example: * "C-u M-x copy-file RET A RET B" discards the fractional part of A's time stamp when copying A to B (except for Windows, which I've been told uses special code to preserve the time stamp correctly). * The file-attributes function truncates file time stamps to one-second resolution, making it impossible for a dired written in Emacs to emulate the behavior of "ls --full-time". * (format-time-string "%s.%N") is supposed to output nanosecond-resolution time stamps, but on the Emacs trunk it always outputs a multiple of one microsecond, even when the system clock supports nanosecond resolution. * If some other process modifies a file during the same second that Emacs gets the file's time stamp, Emacs won't notice the conflict, as the visited-file-modtime function supports only 1-second resolution. If Emacs used nanosecond-resolution time stamps, this race condition would be much less likely. None of these problems are fatal, but they are annoyances that could lead to real problems (e.g., when working with "make", which uses high-resolution file time stamps). I've proposed a patch for this: http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00015.html http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00016.html http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00017.html http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00018.html http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00019.html http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00020.html http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00021.html Stefan asked me in to make the patch more upward-compatible, by appending a new picosecond count to the end of the time stamp list, rather than changing the microsecond to a nanosecond count (which would likely break more code). I'll do that soon, but thought I'd first file a bug report to make this whole issue easier to track. In part I am also following up to Stefan's suggestion to have a bug report for this issue. From debbugs-submit-bounces@debbugs.gnu.org Tue Jul 05 02:57:32 2011 Received: (at 9000) by debbugs.gnu.org; 5 Jul 2011 06:57:32 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1QdzZX-0005Z1-An for submit@debbugs.gnu.org; Tue, 05 Jul 2011 02:57:32 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1QdzZN-0005Yi-Gr for 9000@debbugs.gnu.org; Tue, 05 Jul 2011 02:57:25 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 8213039E810F for <9000@debbugs.gnu.org>; Mon, 4 Jul 2011 23:57:11 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id MIxlzj3ml8zP for <9000@debbugs.gnu.org>; Mon, 4 Jul 2011 23:57:02 -0700 (PDT) Received: from [192.168.1.10] (pool-71-189-109-235.lsanca.fios.verizon.net [71.189.109.235]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id A964B39E80F8 for <9000@debbugs.gnu.org>; Mon, 4 Jul 2011 23:57:02 -0700 (PDT) Message-ID: <4E12B5BE.6070903@cs.ucla.edu> Date: Mon, 04 Jul 2011 23:57:02 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.17) Gecko/20110516 Thunderbird/3.1.10 MIME-Version: 1.0 To: 9000@debbugs.gnu.org Subject: More-compatible proposal, using (HIGH LOW USEC PSEC) time stamps Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Debbugs-Envelope-To: 9000 X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org Here's the improved version of the patch that I mentioned. It follows Stefan's suggestion in using more-compatible time stamps. With this patch, (current-time) returns time stamps in the format (HIGH LOW USEC PSEC), and existing Lisp code that looks at the 1st three elements will continue to work as before. Older-format time stamps such as (HIGH LOW USEC) are still accepted. To avoid repetition this patch assumes the already-submitted patches for the gnulib code, for configure-time support, and for lib-src support: http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00015.html http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00018.html http://lists.gnu.org/archive/html/emacs-devel/2011-07/msg00020.html as these don't need to be changed to accommodate Stefan's suggestion. Further suggestions for improvements are welcome. === modified file 'etc/ChangeLog' --- etc/ChangeLog 2011-07-03 21:39:49 +0000 +++ etc/ChangeLog 2011-07-04 08:24:10 +0000 @@ -1,3 +1,7 @@ +2011-07-04 Paul Eggert + + * NEWS: Mention addition of picoseconds to time stamp format. + 2011-03-29 Kevin Ryde * compilation.txt (perl-Test2): New samples. === modified file 'etc/NEWS' --- etc/NEWS 2011-07-02 04:27:41 +0000 +++ etc/NEWS 2011-07-04 08:24:10 +0000 @@ -238,6 +238,13 @@ *** Tramp offers handlers for file-selinux-context and set-file-selinux-context for remote machines which support SELinux. +** The function current-time now returns extended-format time stamps +(HIGH LOW USEC PSEC) that use picosecond resolution; the PSEC +component is new. PSEC is typically a multiple of 1000 on current +machines. Other functions that use this format, such as +file-attributes and format-time-string, have been changed accordingly. +Old-format time stamps are still accepted. + +++ ** The function format-time-string now supports the %N directive, for higher-resolution time stamps. === modified file 'doc/lispref/ChangeLog' --- doc/lispref/ChangeLog 2011-07-03 18:44:53 +0000 +++ doc/lispref/ChangeLog 2011-07-04 08:24:10 +0000 @@ -1,3 +1,10 @@ +2011-07-04 Paul Eggert + + Document the change to time stamp format and resolution. + * os.texi (Time of Day, Time Parsing, Processor Run Time, Idle Timers): + * processes.texi (System Processes): + Time stamp resolution is now picosecond, not microsecond. + 2011-07-03 Tobias C. Rittweiler (tiny change) * searching.texi (Match Data): Note that match data can be === modified file 'doc/lispref/os.texi' --- doc/lispref/os.texi 2011-06-03 18:49:33 +0000 +++ doc/lispref/os.texi 2011-07-04 06:42:19 +0000 @@ -1110,8 +1110,8 @@ instead of the current time. This argument should have the same form as the times obtained from @code{current-time} (see below) and from @code{file-attributes} (@pxref{Definition of file-attributes}). It -should be a list whose first two elements are integers; a third -(microsecond) element, if present, is ignored. @var{time-value} can +should be a list whose first two elements are integers; trailing +elements, if present, are ignored. @var{time-value} can also be a cons of two integers, but this usage is obsolete. @example @@ -1123,8 +1123,8 @@ @end defun @defun current-time -This function returns the system's time value as a list of three -integers: @code{(@var{high} @var{low} @var{microsec})}. The integers +This function returns the system's time value as a list of four integers: +@code{(@var{high} @var{low} @var{microsec} @var{picosec})}. The integers @var{high} and @var{low} combine to give the number of seconds since 0:00 January 1, 1970 UTC (Coordinated Universal Time), which is @ifnottex @@ -1135,10 +1135,14 @@ @end tex The third element, @var{microsec}, gives the microseconds since the -start of the current second (or 0 for systems that return time with -the resolution of only one second). +start of the current second. The fourth element, @var{picosec}, gives +the picoseconds since the start of the current microsecond. These +integers have trailing zeros on systems that return time with lower +resolutions. On all current machines @var{picosec} is a multiple of +1000, but this may change as higher-resolution clocks become +available. -The first two elements can be compared with file time values such as you +The list can be compared with file time values such as you get with the function @code{file-attributes}. @xref{Definition of file-attributes}. @end defun @@ -1340,8 +1344,6 @@ This stands for the nanoseconds (000000000-999999999). To ask for fewer digits, use @samp{%3N} for milliseconds, @samp{%6N} for microseconds, etc. Any excess digits are discarded, without rounding. -Currently Emacs time stamps are at best microsecond resolution so the -last three digits generated by plain @samp{%N} are always zero. @item %p This stands for @samp{AM} or @samp{PM}, as appropriate. @item %r @@ -1493,18 +1495,9 @@ @defun get-internal-run-time This function returns the processor run time used by Emacs as a list -of three integers: @code{(@var{high} @var{low} @var{microsec})}. The -integers @var{high} and @var{low} combine to give the number of -seconds, which is -@ifnottex -@var{high} * 2**16 + @var{low}. -@end ifnottex -@tex -$high*2^{16}+low$. -@end tex - -The third element, @var{microsec}, gives the microseconds (or 0 for -systems that return time with the resolution of only one second). +of four integers: @code{(@var{high} @var{low} @var{microsec} +@var{picosec})}, using the same format as @code{current-time} +(@pxref{Time of Day}). Note that the time returned by this function excludes the time Emacs was not using the processor, and if the Emacs process has several @@ -1748,19 +1741,9 @@ @c Emacs 19 feature @defun current-idle-time If Emacs is idle, this function returns the length of time Emacs has -been idle, as a list of three integers: @code{(@var{high} @var{low} -@var{microsec})}. The integers @var{high} and @var{low} combine to -give the number of seconds of idleness, which is -@ifnottex -@var{high} * 2**16 + @var{low}. -@end ifnottex -@tex -$high*2^{16}+low$. -@end tex - -The third element, @var{microsec}, gives the microseconds since the -start of the current second (or 0 for systems that return time with -the resolution of only one second). +been idle, as a list of four integers: @code{(@var{high} @var{low} +@var{microsec} @var{picosec})}, using the same format as +@code{current-time} (@pxref{Time of Day}). When Emacs is not idle, @code{current-idle-time} returns @code{nil}. This is a convenient way to test whether Emacs is idle. === modified file 'doc/lispref/processes.texi' --- doc/lispref/processes.texi 2011-06-15 17:30:41 +0000 +++ doc/lispref/processes.texi 2011-07-04 06:42:19 +0000 @@ -1770,7 +1770,7 @@ @item utime Time spent by the process in the user context, for running the application's code. The corresponding @var{value} is in the -@w{@code{(@var{high} @var{low} @var{microsec})}} format, the same +@w{@code{(@var{high} @var{low} @var{microsec} @var{picosec})}} format, the same format used by functions @code{current-time} (@pxref{Time of Day, current-time}) and @code{file-attributes} (@pxref{File Attributes}). @@ -1801,12 +1801,12 @@ @item start The time when the process was started, in the same -@w{@code{(@var{high} @var{low} @var{microsec})}} format used by +@w{@code{(@var{high} @var{low} @var{microsec} @var{picosec})}} format used by @code{current-time} and @code{file-attributes}. @item etime The time elapsed since the process started, in the @w{@code{(@var{high} -@var{low} @var{microsec})}} format. +@var{low} @var{microsec} @var{picosec})}} format. @item vsize The virtual memory size of the process, measured in kilobytes. === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2011-07-04 16:08:16 +0000 +++ lisp/ChangeLog 2011-07-04 17:40:43 +0000 @@ -1,3 +1,26 @@ +2011-07-04 Paul Eggert + + Support picosecond-resolution time stamps. + + * calendar/time-date.el (with-decoded-time-value): New arg + PICO-SYMBOL in VARLIST. It's optional, for backward compatibility. + (encode-time-value): New optional arg PICO. New type 3. + (time-to-seconds) [!float-time]: Support the new picoseconds + component if it's used. + (seconds-to-time, time-subtract, time-add): + Support ps-resolution time stamps as well. + + * emacs-lisp/timer.el (timer): New component psecs. All uses changed. + (timerp): Timer vectors now have length 9, not 8. + (timer--time): Support new-style (4-part) time stamps. + (timer-next-integral-multiple-of-time): Time stamps now have + picosecond resolution, so take a bit more care about rounding. + (timer-relative-time, timer-inc-time): New optional arg psecs. + (timer-set-time-with-usecs): Set psecs to 0. + (timer--activate): Check psecs component, too. + + * lisp/proced.el (proced-time-lessp): Support ps-resolution stamps. + 2011-07-04 Stefan Monnier * files.el (find-file): Use pop-to-buffer-same-window (bug#8911). === modified file 'lisp/calendar/time-date.el' --- lisp/calendar/time-date.el 2011-04-19 04:11:01 +0000 +++ lisp/calendar/time-date.el 2011-07-04 07:16:35 +0000 @@ -23,15 +23,15 @@ ;;; Commentary: -;; Time values come in three formats. The oldest format is a cons +;; Time values come in several formats. The oldest format is a cons ;; cell of the form (HIGH . LOW). This format is obsolete, but still -;; supported. The two other formats are the lists (HIGH LOW) and -;; (HIGH LOW MICRO). The first two formats specify HIGH * 2^16 + LOW -;; seconds; the third format specifies HIGH * 2^16 + LOW + MICRO / -;; 1000000 seconds. We should have 0 <= MICRO < 1000000 and 0 <= LOW -;; < 2^16. If the time value represents a point in time, then HIGH is -;; nonnegative. If the time value is a time difference, then HIGH can -;; be negative as well. The macro `with-decoded-time-value' and the +;; supported. The other formats are the lists (HIGH LOW), (HIGH LOW +;; USEC), and (HIGH LOW USEC PSEC). These formats specify the time +;; value equal to HIGH * 2^16 + LOW + USEC * 10^-6 + PSEC * 10^-12 +;; seconds, where missing components are treated as zero. HIGH can be +;; negative, either because the value is a time difference, or because +;; the machine supports negative time stamps that fall before the +;; epoch. The macro `with-decoded-time-value' and the ;; function `encode-time-value' make it easier to deal with these ;; three formats. See `time-subtract' for an example of how to use ;; them. @@ -44,13 +44,15 @@ The value of the last form in BODY is returned. Each element of the list VARLIST is a list of the form -\(HIGH-SYMBOL LOW-SYMBOL MICRO-SYMBOL [TYPE-SYMBOL] TIME-VALUE). +\(HIGH-SYMBOL LOW-SYMBOL MICRO-SYMBOL [PICO-SYMBOL [TYPE-SYMBOL]] TIME-VALUE). The time value TIME-VALUE is decoded and the result it bound to the symbols HIGH-SYMBOL, LOW-SYMBOL and MICRO-SYMBOL. +The optional PICO-SYMBOL is bound to the picoseconds part. The optional TYPE-SYMBOL is bound to the type of the time value. Type 0 is the cons cell (HIGH . LOW), type 1 is the list (HIGH -LOW), and type 2 is the list (HIGH LOW MICRO)." +LOW), type 2 is the list (HIGH LOW MICRO), and type 3 is the +list (HIGH LOW MICRO PICO)." (declare (indent 1) (debug ((&rest (symbolp symbolp symbolp &or [symbolp form] form)) body))) @@ -59,6 +61,8 @@ (high (pop elt)) (low (pop elt)) (micro (pop elt)) + (pico (unless (<= (length elt) 2) + (pop elt))) (type (unless (eq (length elt) 1) (pop elt))) (time-value (car elt)) @@ -66,28 +70,44 @@ `(let* ,(append `((,gensym ,time-value) (,high (pop ,gensym)) ,low ,micro) + (when pico `(,pico)) (when type `(,type))) (if (consp ,gensym) (progn (setq ,low (pop ,gensym)) (if ,gensym - ,(append `(setq ,micro (car ,gensym)) - (when type `(,type 2))) + (progn + (setq ,micro (car ,gensym)) + ,(cond (pico + `(if (cdr ,gensym) + ,(append `(setq ,pico (cadr ,gensym)) + (when type `(,type 3))) + ,(append `(setq ,pico 0) + (when type `(,type 2))))) + (type + `(setq type 2)))) ,(append `(setq ,micro 0) + (when pico `(,pico 0)) (when type `(,type 1))))) ,(append `(setq ,low ,gensym ,micro 0) + (when pico `(,pico 0)) (when type `(,type 0)))) (with-decoded-time-value ,varlist ,@body))) `(progn ,@body))) -(defun encode-time-value (high low micro type) - "Encode HIGH, LOW, and MICRO into a time value of type TYPE. +(defun encode-time-value (high low micro pico &optional type) + "Encode HIGH, LOW, MICRO, and PICO into a time value of type TYPE. Type 0 is the cons cell (HIGH . LOW), type 1 is the list (HIGH LOW), -and type 2 is the list (HIGH LOW MICRO)." +type 2 is (HIGH LOW MICRO), and type 3 is (HIGH LOW MICRO PICO). + +For backward compatibility, if only four arguments are given, +it is assumed that PICO was omitted and should be treated as zero." (cond ((eq type 0) (cons high low)) ((eq type 1) (list high low)) - ((eq type 2) (list high low micro)))) + ((eq type 2) (list high low micro)) + ((eq type 3) (list high low micro pico)) + ((null type) (encode-time-value high low micro 0 pico)))) (autoload 'parse-time-string "parse-time") (autoload 'timezone-make-date-arpa-standard "timezone") @@ -125,28 +145,45 @@ (subrp (symbol-function 'float-time))) (defun time-to-seconds (time) "Convert time value TIME to a floating point number." - (with-decoded-time-value ((high low micro time)) + (with-decoded-time-value ((high low micro pico type time)) (+ (* 1.0 high 65536) low - (/ micro 1000000.0)))))) + (/ (+ (* micro 1e6) pico) 1e12)))))) ;;;###autoload (defun seconds-to-time (seconds) "Convert SECONDS (a floating point number) to a time value." - (list (floor seconds 65536) - (floor (mod seconds 65536)) - (floor (* (- seconds (ffloor seconds)) 1000000)))) + (let* ((usec (* 1000000 (mod seconds 1))) + (ps (round (* 1000000 (mod usec 1)))) + (us (floor usec)) + (lo (floor (mod seconds 65536))) + (hi (floor seconds 65536))) + (if (eq ps 1000000) + (progn + (setq ps 0) + (setq us (1+ us)) + (if (eq us 1000000) + (progn + (setq us 0) + (setq lo (1+ lo)) + (if (eq lo 65536) + (progn + (setq lo 0) + (setq hi (1+ hi)))))))) + (list hi lo us ps))) ;;;###autoload (defun time-less-p (t1 t2) "Return non-nil if time value T1 is earlier than time value T2." - (with-decoded-time-value ((high1 low1 micro1 t1) - (high2 low2 micro2 t2)) + (with-decoded-time-value ((high1 low1 micro1 pico1 type1 t1) + (high2 low2 micro2 pico2 type2 t2)) (or (< high1 high2) (and (= high1 high2) (or (< low1 low2) (and (= low1 low2) - (< micro1 micro2))))))) + (or (< micro1 micro2) + (and (= micro1 micro2) + (< pico1 pico2))))))))) ;;;###autoload (defun days-to-time (days) @@ -173,36 +210,44 @@ (defun time-subtract (t1 t2) "Subtract two time values, T1 minus T2. Return the difference in the format of a time value." - (with-decoded-time-value ((high low micro type t1) - (high2 low2 micro2 type2 t2)) + (with-decoded-time-value ((high low micro pico type t1) + (high2 low2 micro2 pico2 type2 t2)) (setq high (- high high2) low (- low low2) micro (- micro micro2) + pico (- pico pico2) type (max type type2)) + (when (< pico 0) + (setq micro (1- micro) + pico (+ pico 1000000))) (when (< micro 0) (setq low (1- low) micro (+ micro 1000000))) (when (< low 0) (setq high (1- high) low (+ low 65536))) - (encode-time-value high low micro type))) + (encode-time-value high low micro pico type))) ;;;###autoload (defun time-add (t1 t2) "Add two time values T1 and T2. One should represent a time difference." - (with-decoded-time-value ((high low micro type t1) - (high2 low2 micro2 type2 t2)) + (with-decoded-time-value ((high low micro pico type t1) + (high2 low2 micro2 pico2 type2 t2)) (setq high (+ high high2) low (+ low low2) micro (+ micro micro2) + pico (+ pico pico2) type (max type type2)) + (when (>= pico 1000000) + (setq micro (1+ micro) + pico (- pico 1000000))) (when (>= micro 1000000) (setq low (1+ low) micro (- micro 1000000))) (when (>= low 65536) (setq high (1+ high) low (- low 65536))) - (encode-time-value high low micro type))) + (encode-time-value high low micro pico type))) ;;;###autoload (defun date-to-day (date) === modified file 'lisp/emacs-lisp/timer.el' --- lisp/emacs-lisp/timer.el 2011-07-04 06:25:23 +0000 +++ lisp/emacs-lisp/timer.el 2011-07-04 08:24:10 +0000 @@ -28,7 +28,7 @@ ;;; Code: ;; Layout of a timer vector: -;; [triggered-p high-seconds low-seconds usecs repeat-delay +;; [triggered-p high-seconds low-seconds usecs psecs repeat-delay ;; function args idle-delay] ;; triggered-p is nil if the timer is active (waiting to be triggered), ;; t if it is inactive ("already triggered", in theory) @@ -42,27 +42,35 @@ (:type vector) (:conc-name timer--)) (triggered t) - high-seconds low-seconds usecs repeat-delay function args idle-delay) + high-seconds low-seconds usecs psecs repeat-delay function args idle-delay) (defun timerp (object) "Return t if OBJECT is a timer." - (and (vectorp object) (= (length object) 8))) + (and (vectorp object) (= (length object) 9))) ;; Pseudo field `time'. (defun timer--time (timer) (list (timer--high-seconds timer) (timer--low-seconds timer) - (timer--usecs timer))) + (timer--usecs timer) + (timer--psecs timer))) (defsetf timer--time (lambda (timer time) (or (timerp timer) (error "Invalid timer")) (setf (timer--high-seconds timer) (pop time)) - (setf (timer--low-seconds timer) - (if (consp time) (car time) time)) - (setf (timer--usecs timer) (or (and (consp time) (consp (cdr time)) - (cadr time)) - 0)))) + (let ((low time) (usecs 0) (psecs 0)) + (if (consp time) + (progn + (setq low (pop time)) + (if time + (progn + (setq usecs (pop time)) + (if time + (setq psecs (car time))))))) + (setf (timer--low-seconds timer) low) + (setf (timer--usecs timer) usecs) + (setf (timer--psecs timer) psecs)))) (defun timer-set-time (timer time &optional delta) @@ -77,7 +85,7 @@ (defun timer-set-idle-time (timer secs &optional repeat) "Set the trigger idle time of TIMER to SECS. SECS may be an integer, floating point number, or the internal -time format (HIGH LOW USECS) returned by, e.g., `current-idle-time'. +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." (if (consp secs) @@ -91,41 +99,46 @@ "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." - (let ((time-base (ash 1 16))) - ;; Use floating point, taking care to not lose precision. - (let* ((float-time-base (float time-base)) - (million 1000000.0) - (time-usec (+ (* million - (+ (* float-time-base (nth 0 time)) - (nth 1 time))) - (nth 2 time))) - (secs-usec (* million secs)) - (mod-usec (mod time-usec secs-usec)) - (next-usec (+ (- time-usec mod-usec) secs-usec)) - (time-base-million (* float-time-base million))) - (list (floor next-usec time-base-million) - (floor (mod next-usec time-base-million) million) - (floor (mod next-usec million)))))) + (let* ((trillion 1e12) + (time-sec (+ (nth 1 time) + (* 65536.0 (nth 0 time)))) + (delta-sec (mod (- time-sec) secs)) + (next-sec (+ time-sec (ffloor delta-sec))) + (next-sec-psec (ffloor (* trillion (mod delta-sec 1)))) + (sub-time-psec (+ (or (nth 3 time) 0) + (* 1e6 (nth 2 time)))) + (psec-diff (- sub-time-psec next-sec-psec))) + (if (and (<= next-sec time-sec) (< 0 psec-diff)) + (setq next-sec-psec (+ sub-time-psec + (mod (- psec-diff) (* trillion secs))))) + (setq next-sec (+ next-sec (floor next-sec-psec trillion))) + (setq next-sec-psec (mod next-sec-psec trillion)) + (list (floor next-sec 65536) + (floor (mod next-sec 65536)) + (floor next-sec-psec 1000000) + (floor (mod next-sec-psec 1000000))))) -(defun timer-relative-time (time secs &optional usecs) - "Advance TIME by SECS seconds and optionally USECS microseconds. -SECS may be either an integer or a floating point number." +(defun timer-relative-time (time secs &optional usecs psecs) + "Advance TIME by SECS seconds and optionally USECS nanoseconds +and PSECS picoseconds. SECS may be either an integer or a +floating point number." (let ((delta (if (floatp secs) (seconds-to-time secs) (list (floor secs 65536) (mod secs 65536))))) - (if usecs - (setq delta (time-add delta (list 0 0 usecs)))) + (if (or usecs psecs) + (setq delta (time-add delta (list 0 0 (or usecs 0) (or psecs 0))))) (time-add time delta))) (defun timer--time-less-p (t1 t2) "Say whether time value T1 is less than time value T2." (time-less-p (timer--time t1) (timer--time t2))) -(defun timer-inc-time (timer secs &optional usecs) - "Increment the time set in TIMER by SECS seconds and USECS microseconds. -SECS may be a fraction. If USECS is omitted, that means it is zero." +(defun timer-inc-time (timer secs &optional usecs psecs) + "Increment the time set in TIMER by SECS seconds, USECS nanoseconds, +and PSECS picoseconds. SECS may be a fraction. If USECS or PSECS are +omitted, they are treated as zero." (setf (timer--time timer) - (timer-relative-time (timer--time timer) secs usecs))) + (timer-relative-time (timer--time timer) secs usecs psecs))) (defun timer-set-time-with-usecs (timer time usecs &optional delta) "Set the trigger time of TIMER to TIME plus USECS. @@ -135,6 +148,7 @@ fire repeatedly that many seconds apart." (setf (timer--time timer) time) (setf (timer--usecs timer) usecs) + (setf (timer--psecs timer) 0) (setf (timer--repeat-delay timer) (and (numberp delta) (> delta 0) delta)) timer) (make-obsolete 'timer-set-time-with-usecs @@ -154,6 +168,7 @@ (integerp (timer--high-seconds timer)) (integerp (timer--low-seconds timer)) (integerp (timer--usecs timer)) + (integerp (timer--psecs timer)) (timer--function timer)) (let ((timers (if idle timer-idle-list timer-list)) last) @@ -384,7 +399,7 @@ "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 (HIGH LOW USECS) returned by, e.g., `current-idle-time'. +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. === modified file 'lisp/proced.el' --- lisp/proced.el 2011-06-25 18:08:41 +0000 +++ lisp/proced.el 2011-07-04 07:16:35 +0000 @@ -1170,14 +1170,16 @@ (defun proced-time-lessp (t1 t2) "Return t if time value T1 is less than time value T2. Return `equal' if T1 equals T2. Return nil otherwise." - (with-decoded-time-value ((high1 low1 micro1 t1) - (high2 low2 micro2 t2)) + (with-decoded-time-value ((high1 low1 micro1 pico1 type1 t1) + (high2 low2 micro2 pico2 type2 t2)) (cond ((< high1 high2)) ((< high2 high1) nil) ((< low1 low2)) ((< low2 low1) nil) ((< micro1 micro2)) ((< micro2 micro1) nil) + ((< pico1 pico2)) + ((< pico2 pico1) nil) (t 'equal)))) ;;; Sorting === modified file 'src/ChangeLog' --- src/ChangeLog 2011-07-04 15:32:22 +0000 +++ src/ChangeLog 2011-07-04 17:40:43 +0000 @@ -1,3 +1,171 @@ +2011-07-04 Paul Eggert + + Add support for picosecond-resolution time stamps. + The time stamps are only nanosecond-resolution at the C level, + since that's the best that any real-world system supports now. + But they are picosecond-resolution at the Lisp level, as that's + easy, and leaves room for future OS improvements. + + * Makefile.in (LIB_CLOCK_GETTIME): New macro. + (LIBES): Use it. + + * alloc.c (Fgarbage_collect): Port to higher-res time stamps. + Don't get current time unless it's needed. + + * atimer.c: Include unconditionally, since gnulib + now provides it if it's absent. + (start_atimer): Port to higher-res time stamps. + Check for time stamp overflow. Don't get current time more + often than is needed. + + * buffer.c (reset_buffer): + * buffer.h (struct buffer): Buffer modtime now has high resolution. + Include systime.h, not time.h. + (NONEXISTENT_MODTIME_NSECS, UNKNOWN_MODTIME_NSECS): New macros. + + * dired.c: Include stat-time.h. + (Ffile-attributes): File times now have higher resolution. + + * dispextern.h [HAVE_WINDOW_SYSTEM]: Include systime.h. + (struct image): Timestamp now has higher resolution. + + * dispnew.c (PERIODIC_PREEMPTION_CHECKING): Remove, as Emacs always + has at least microseconds now. All uses removed. + (update_frame, update_single_window, update_window, update_frame_1) + (Fsleep_for, sit_for): Port to higher-resolution time stamps. + + * editfns.c (time_overflow): Now extern. + (Fcurrent_time, Fget_internal_run_time, make_time, lisp_time_argument) + (float-time, Fformat_time_string, Fcurrent_time_string) + (Fcurrent_time_zone): Accept and generate higher-resolution + time stamps. + (make_time_tail, make_lisp_time, dissassemble_lisp_time) + (decode_time_components, lisp_seconds_argument): New functions. + (make_time): Now static. + (lisp_time_argument): Now returns EMACS_TIME. New arg ppsec. + Report an error if the time is invalid, rather than having the caller + do that. + + * fileio.c: Include + (Fcopy_file): Copy higher-resolution time stamps. + Prefer to set the time stamp via a file descriptor if that works. + (Fset_file_times, Finsert_file_contents, Fwrite_region) + (Fverify_visited_file_modtime, Fclear_visited_file_modtime) + (Fvisited_file_modtime, Fset_visited_file_modtime): + Support higher-resolution time stamps. + + * gtkutil.c (xg_maybe_add_timer): Port to higher-res time stamps. + + * image.c (prepare_image_for_display, clear_image_cache) + (lookup_image): Port to higer-resolution time stamps. + + * keyboard.c (start_polling, bind_polling_period): + Check for time stamp overflow. + (read_char, kbd_buffer_get_event, timer_start_idle) + (timer_stop_idle, timer_resume_idle, timer_check_2, timer_check) + (Fcurrent_idle_time, init_keyboard, set_waiting_for_input): + Port to higher-resolution time stamps. Do not assume time_t is signed. + (decode_timer): New function. Timers are now vectors of length 9, + not 8, to accommodate the picosecond component. + (timer_check_2): Use it. + + * nsterm.m (select_timeout, timeval_subtract): Remove. + (ns_timeout): Use Emacs's facilities for time stamp arithmetic, + as they're a bit more accurate and handle overflow better. + (ns_select): Change prototype to be compatible with pselect. + (ns_select, ns_term_shutdown): Port to ns-resolution time stamps. + * nsterm.h (ns_select): Adjust prototype. + + * msdos.c (EMACS_TIME_ZERO_OR_NEG_P): Remove, as it assumes + us-resolution time stamps. + (sys_select): Use the new EMACS_TIME_SIGN macro instead. + + * lread.c (read_filtered_event): Port to ns-resolution time stamps. + + * lisp.h (time_overflow): New decl. + (wait_reading_process_output): First arg is now intmax_t, not int, + to accommodate larger waits. + + * process.h (struct Lisp_Process.read_output_delay): + Now counts nanoseconds, not microseconds. + * process.c (ADAPTIVE_READ_BUFFERING): Don't worry about + EMACS_HAS_USECS. + (READ_OUTPUT_DELAY_INCREMENT, Faccept_process_output) + (wait_reading_process_output): + Port to ns-resolution time stamps. + (Faccept_process_output, wait_reading_process_output): + Check for time stamp overflow. Do not assume time_t is signed. + (select_wrapper): Remove; we now use pselect. + (Fprocess_attributes): Now generates ns-resolution time stamps. + + * sysdep.c: Include utimens.h. Don't include utime.h + or worry about struct utimbuf; gnulib does that for us now. + (gettimeofday): Remove; gnulib provides a substitute. + (make_timeval): New function. + (set_file_times): Now sets ns-resolution time stamps. + New arg FD; all uses changed. + (time_from_jiffies, ltime_from_jiffies, get_up_time) + (system_process_attributes): + Now returns ns-resolution time stamp. All uses changed. + Check for time stamp overflow. + + * sysselect.h: Don't depend on HAVE_SYS_SELECT_H; gnulib + provides a substitute now. + + * systime.h: Include timespec.h rather than sys/time.h and time.h, + since it guarantees struct timespec. + (EMACS_TIME): Now struct timespec, so that we can support + ns-resolution time stamps. + (EMACS_TIME_RESOLUTION, LOG10_EMACS_TIME_RESOLUTION): New macros. + (EMACS_HAS_USECS): Remove; Emacs always has sub-second time stamps now. + (EMACS_USECS): Remove. + (EMACS_SET_USECS): The underlying time stamp now has ns resolution, + so multiply the arg by 1000 before storing it. + (EMACS_NSECS, EMACS_SECS_ADDR, EMACS_SET_NSECS, EMACS_SET_SECS_NSECS): + New macros. + (EMACS_GET_TIME, EMACS_ADD_TIME, EMACS_SUB_TIME): + Port to ns-resolution time stamps. + (EMACS_TIME_NEG_P): Remove; replaced by.... + (EMACS_TIME_SIGN): New macro. + (EMACS_SET_INVALID_TIME, EMACS_TIME_VALID_P) + (EMACS_TIME_FROM_DOUBLE, EMACS_TIME_TO_DOUBLE): New macros. + (set_file_times, make_time, lisp_time_argument): Adjust signature. + (make_timeval, make_lisp_time, decode_time_components): New decls. + (EMACS_TIME_CMP): Remove; no longer used. Plus, it was buggy, in + that it mishandled time_t overflow. You can't compare by subtracting! + (EMACS_TIME_EQ, EMACS_TIME_NE, EMACS_TIME_GT, EMACS_TIME_GE) + (EMACS_TIME_LT, EMACS_TIME_LE): Rewrite in terms of timespec_cmp. + + * term.c: Include . + (timeval_to_Time): New function, for proper overflow wraparound. + (term_mouse_position, term_mouse_click): Use it. + + * undo.c (record_first_change): Support higher-resolution time stamps + in the undo buffer. + (Fprimitive_undo): Use them when restoring time stamps. + + * w32.c (ltime, U64_TO_LISP_TIME, process_times, emacs_gnutls_pull) + (w32_get_internal_run_time): + Port to higher-resolution Emacs time stamps. + (ltime): Now accepts single 64-bit integer, as that's more convenient + for callers. + + * xdisp.c (start_hourglass): Port to ns-resolution time stamps. + + * xgselect.c, xgselect.h (xg_select): Add sigmask argument, + for compatibility with pselect. Support ns-resolution time stamps. + + * xmenu.c (x_menu_wait_for_event): Support ns-resolution time stamps. + + * xselect.c (wait_for_property_change, x_get_foreign_selection): + Check for time stamp overflow, and support ns-resolution time stamps. + + * xterm.c: Don't include sys/time.h; gnulib does that for us now. + Don't worry about whether HAVE_TIMEVAL and HAVE_SELECT are set. + (timeval_subtract): Remove; no longer needed. + (XTflash, XTring_bell, x_wait_for_event): + Port to ns-resolution time stamps. Don't assume time_t is signed. + 2011-07-04 Lars Magne Ingebrigtsen * buffer.c (Foverlay_put): Say what the return value is === modified file 'src/Makefile.in' --- src/Makefile.in 2011-07-01 17:53:59 +0000 +++ src/Makefile.in 2011-07-01 20:41:12 +0000 @@ -147,6 +147,8 @@ M17N_FLT_CFLAGS = @M17N_FLT_CFLAGS@ M17N_FLT_LIBS = @M17N_FLT_LIBS@ +LIB_CLOCK_GETTIME=@LIB_CLOCK_GETTIME@ + DBUS_CFLAGS = @DBUS_CFLAGS@ DBUS_LIBS = @DBUS_LIBS@ ## dbusbind.o if HAVE_DBUS, else empty. @@ -379,7 +381,7 @@ ## duplicated symbols. If the standard libraries were compiled ## with GCC, we might need LIB_GCC again after them. LIBES = $(LIBS) $(LIBX_BASE) $(LIBX_OTHER) $(LIBSOUND) \ - $(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(DBUS_LIBS) \ + $(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(LIB_CLOCK_GETTIME) $(DBUS_LIBS) \ $(LIBXML2_LIBS) $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \ $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(SETTINGS_LIBS) $(LIBSELINUX_LIBS) \ $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \ === modified file 'src/alloc.c' --- src/alloc.c 2011-06-24 21:25:22 +0000 +++ src/alloc.c 2011-07-01 07:37:04 +0000 @@ -5159,12 +5159,14 @@ } /* Accumulate statistics. */ - EMACS_GET_TIME (t2); - EMACS_SUB_TIME (t3, t2, t1); if (FLOATP (Vgc_elapsed)) - Vgc_elapsed = make_float (XFLOAT_DATA (Vgc_elapsed) + - EMACS_SECS (t3) + - EMACS_USECS (t3) * 1.0e-6); + { + EMACS_GET_TIME (t2); + EMACS_SUB_TIME (t3, t2, t1); + Vgc_elapsed = make_float (XFLOAT_DATA (Vgc_elapsed) + + EMACS_TIME_TO_DOUBLE (t3)); + } + gcs_done++; return Flist (sizeof total / sizeof *total, total); === modified file 'src/atimer.c' --- src/atimer.c 2011-04-11 06:04:34 +0000 +++ src/atimer.c 2011-07-01 07:37:04 +0000 @@ -26,10 +26,7 @@ #include "blockinput.h" #include "atimer.h" #include - -#ifdef HAVE_SYS_TIME_H #include -#endif /* Free-list of atimer structures. */ @@ -94,7 +91,8 @@ /* Round TIME up to the next full second if we don't have itimers. */ #ifndef HAVE_SETITIMER - if (EMACS_USECS (timestamp) != 0) + if (EMACS_NSECS (timestamp) != 0 + && EMACS_SECS (timestamp) < TYPE_MAXIMUM (time_t)) { EMACS_SET_USECS (timestamp, 0); EMACS_SET_SECS (timestamp, EMACS_SECS (timestamp) + 1); @@ -294,18 +292,21 @@ /* Determine s/us till the next timer is ripe. */ EMACS_GET_TIME (now); - EMACS_SUB_TIME (timestamp, atimers->expiration, now); -#ifdef HAVE_SETITIMER /* Don't set the interval to 0; this disables the timer. */ if (EMACS_TIME_LE (atimers->expiration, now)) { EMACS_SET_SECS (timestamp, 0); EMACS_SET_USECS (timestamp, 1000); } + else + EMACS_SUB_TIME (timestamp, atimers->expiration, now); + + +#ifdef HAVE_SETITIMER memset (&it, 0, sizeof it); - it.it_value = timestamp; + it.it_value = make_timeval (timestamp); setitimer (ITIMER_REAL, &it, 0); #else /* not HAVE_SETITIMER */ alarm (max (EMACS_SECS (timestamp), 1)); @@ -341,11 +342,10 @@ { EMACS_TIME now; - EMACS_GET_TIME (now); - while (atimers && (pending_atimers = interrupt_input_blocked) == 0 - && EMACS_TIME_LE (atimers->expiration, now)) + && (EMACS_GET_TIME (now), + EMACS_TIME_LE (atimers->expiration, now))) { struct atimer *t; @@ -363,8 +363,6 @@ t->next = free_atimers; free_atimers = t; } - - EMACS_GET_TIME (now); } if (! atimers) === modified file 'src/buffer.c' --- src/buffer.c 2011-07-04 15:32:22 +0000 +++ src/buffer.c 2011-07-04 17:40:43 +0000 @@ -714,7 +714,7 @@ BVAR (b, filename) = Qnil; BVAR (b, file_truename) = Qnil; BVAR (b, directory) = (current_buffer) ? BVAR (current_buffer, directory) : Qnil; - b->modtime = 0; + EMACS_SET_SECS_NSECS (b->modtime, 0, UNKNOWN_MODTIME_NSECS); b->modtime_size = -1; XSETFASTINT (BVAR (b, save_length), 0); b->last_window_start = 1; @@ -5850,9 +5850,9 @@ from (abs POSITION). If POSITION is positive, point was at the front of the text being deleted; if negative, point was at the end. -An entry (t HIGH . LOW) indicates that the buffer previously had -\"unmodified\" status. HIGH and LOW are the high and low 16-bit portions -of the visited file's modification time, as of that time. If the +An entry (t HIGH LOW USEC PSEC) indicates that the buffer was previously +unmodified; (HIGH LOW USEC PSEC) is in the same style as (current-time) +and is the visited file's modification time, as of that time. If the modification time of the most recent save is different, this entry is obsolete. === modified file 'src/buffer.h' --- src/buffer.h 2011-06-21 21:32:10 +0000 +++ src/buffer.h 2011-07-04 08:09:05 +0000 @@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License along with GNU Emacs. If not, see . */ -#include /* for time_t */ +#include "systime.h" /* for EMACS_TIME */ /* Accessing the parameters of the current buffer. */ @@ -550,10 +550,13 @@ char local_flags[MAX_PER_BUFFER_VARS]; /* Set to the modtime of the visited file when read or written. - -1 means visited file was nonexistent. - 0 means visited file modtime unknown; in no case complain - about any mismatch on next save attempt. */ - time_t modtime; + EMACS_NSECS (modtime) == NONEXISTENT_MODTIME_NSECS means + visited file was nonexistent. EMACS_NSECS (modtime) == + UNKNOWN_MODTIME_NSECS means visited file modtime unknown; + in no case complain about any mismatch on next save attempt. */ +#define NONEXISTENT_MODTIME_NSECS (-1) +#define UNKNOWN_MODTIME_NSECS (-2) + EMACS_TIME modtime; /* Size of the file when modtime was set. This is used to detect the case where the file grew while we were reading it, so the modtime is still the same (since it's rounded up to seconds) but we're actually === modified file 'src/dired.c' --- src/dired.c 2011-06-24 21:25:22 +0000 +++ src/dired.c 2011-07-04 08:09:05 +0000 @@ -62,6 +62,7 @@ #endif /* HAVE_DIRENT_H */ #include +#include #ifdef MSDOS #define DIRENTRY_NONEMPTY(p) ((p)->d_name[0] != 0) @@ -889,8 +890,8 @@ 2. File uid as a string or a number. If a string value cannot be looked up, a numeric value, either an integer or a float, is returned. 3. File gid, likewise. - 4. Last access time, as a list of two integers. - First integer has high-order 16 bits of time, second has low 16 bits. + 4. Last access time, as a list of integers (HIGH LOW USEC PSEC) in the + same style as (current-time). (See a note below about access time on FAT-based filesystems.) 5. Last modification time, likewise. This is the time of the last change to the file's contents. @@ -975,9 +976,9 @@ else values[3] = make_fixnum_or_float (s.st_gid); - values[4] = make_time (s.st_atime); - values[5] = make_time (s.st_mtime); - values[6] = make_time (s.st_ctime); + values[4] = make_lisp_time (get_stat_atime (&s)); + values[5] = make_lisp_time (get_stat_mtime (&s)); + values[6] = make_lisp_time (get_stat_ctime (&s)); /* If the file size is a 4-byte type, assume that files of sizes in the 2-4 GiB range wrap around to negative values, as this is a === modified file 'src/dispextern.h' --- src/dispextern.h 2011-06-22 18:15:23 +0000 +++ src/dispextern.h 2011-07-01 07:37:04 +0000 @@ -68,6 +68,10 @@ typedef XImagePtr XImagePtr_or_DC; #endif +#ifdef HAVE_WINDOW_SYSTEM +# include "systime.h" +#endif + #ifndef HAVE_WINDOW_SYSTEM typedef int Cursor; #define No_Cursor (0) @@ -2719,7 +2723,7 @@ { /* The time in seconds at which the image was last displayed. Set in prepare_image_for_display. */ - time_t timestamp; + EMACS_TIME timestamp; /* Pixmaps of the image. */ Pixmap pixmap, mask; === modified file 'src/dispnew.c' --- src/dispnew.c 2011-06-25 18:21:00 +0000 +++ src/dispnew.c 2011-07-01 07:37:04 +0000 @@ -169,24 +169,11 @@ static void adjust_frame_glyphs_for_frame_redisplay (struct frame *); -/* Define PERIODIC_PREEMPTION_CHECKING to 1, if micro-second timers - are supported, so we can check for input during redisplay at - regular intervals. */ -#ifdef EMACS_HAS_USECS -#define PERIODIC_PREEMPTION_CHECKING 1 -#else -#define PERIODIC_PREEMPTION_CHECKING 0 -#endif - -#if PERIODIC_PREEMPTION_CHECKING - /* Redisplay preemption timers. */ static EMACS_TIME preemption_period; static EMACS_TIME preemption_next_check; -#endif - /* Nonzero upon entry to redisplay means do not assume anything about current contents of actual terminal frame; clear and redraw it. */ @@ -3227,14 +3214,12 @@ if (redisplay_dont_pause) force_p = 1; -#if PERIODIC_PREEMPTION_CHECKING else if (NILP (Vredisplay_preemption_period)) force_p = 1; else if (!force_p && NUMBERP (Vredisplay_preemption_period)) { EMACS_TIME tm; double p = XFLOATINT (Vredisplay_preemption_period); - int sec, usec; if (detect_input_pending_ignore_squeezables ()) { @@ -3242,14 +3227,10 @@ goto do_pause; } - sec = (int) p; - usec = (p - sec) * 1000000; - EMACS_GET_TIME (tm); - EMACS_SET_SECS_USECS (preemption_period, sec, usec); + preemption_period = EMACS_TIME_FROM_DOUBLE (p); EMACS_ADD_TIME (preemption_next_check, tm, preemption_period); } -#endif if (FRAME_WINDOW_P (f)) { @@ -3333,9 +3314,7 @@ #endif } -#if PERIODIC_PREEMPTION_CHECKING do_pause: -#endif /* Reset flags indicating that a window should be updated. */ set_window_update_flags (root_window, 0); @@ -3388,23 +3367,17 @@ if (redisplay_dont_pause) force_p = 1; -#if PERIODIC_PREEMPTION_CHECKING else if (NILP (Vredisplay_preemption_period)) force_p = 1; else if (!force_p && NUMBERP (Vredisplay_preemption_period)) { EMACS_TIME tm; double p = XFLOATINT (Vredisplay_preemption_period); - int sec, usec; - - sec = (int) p; - usec = (p - sec) * 1000000; EMACS_GET_TIME (tm); - EMACS_SET_SECS_USECS (preemption_period, sec, usec); + preemption_period = EMACS_TIME_FROM_DOUBLE (p); EMACS_ADD_TIME (preemption_next_check, tm, preemption_period); } -#endif /* Update W. */ update_begin (f); @@ -3649,10 +3622,9 @@ #if PERIODIC_PREEMPTION_CHECKING if (!force_p) { - EMACS_TIME tm, dif; + EMACS_TIME tm; EMACS_GET_TIME (tm); - EMACS_SUB_TIME (dif, preemption_next_check, tm); - if (EMACS_TIME_NEG_P (dif)) + if (EMACS_TIME_LT (preemption_next_check, tm)) { EMACS_ADD_TIME (preemption_next_check, tm, preemption_period); if (detect_input_pending_ignore_squeezables ()) @@ -4680,10 +4652,9 @@ #if PERIODIC_PREEMPTION_CHECKING if (!force_p) { - EMACS_TIME tm, dif; + EMACS_TIME tm; EMACS_GET_TIME (tm); - EMACS_SUB_TIME (dif, preemption_next_check, tm); - if (EMACS_TIME_NEG_P (dif)) + if (EMACS_TIME_LT (preemption_next_check, tm)) { EMACS_ADD_TIME (preemption_next_check, tm, preemption_period); if (detect_input_pending_ignore_squeezables ()) @@ -5890,46 +5861,24 @@ doc: /* Pause, without updating display, for SECONDS seconds. SECONDS may be a floating-point value, meaning that you can wait for a fraction of a second. Optional second arg MILLISECONDS specifies an -additional wait period, in milliseconds; this may be useful if your -Emacs was built without floating point support. +additional wait period, in milliseconds; this is for backwards compatibility. \(Not all operating systems support waiting for a fraction of a second.) */) (Lisp_Object seconds, Lisp_Object milliseconds) { - int sec, usec; - - if (NILP (milliseconds)) - XSETINT (milliseconds, 0); - else - CHECK_NUMBER (milliseconds); - usec = XINT (milliseconds) * 1000; - - { - double duration = extract_float (seconds); - sec = (int) duration; - usec += (duration - sec) * 1000000; - } - -#ifndef EMACS_HAS_USECS - if (sec == 0 && usec != 0) - error ("Millisecond `sleep-for' not supported on %s", SYSTEM_TYPE); -#endif - - /* Assure that 0 <= usec < 1000000. */ - if (usec < 0) - { - /* We can't rely on the rounding being correct if usec is negative. */ - if (-1000000 < usec) - sec--, usec += 1000000; - else - sec -= -usec / 1000000, usec = 1000000 - (-usec % 1000000); - } - else - sec += usec / 1000000, usec %= 1000000; - - if (sec < 0 || (sec == 0 && usec == 0)) - return Qnil; - - wait_reading_process_output (sec, usec, 0, 0, Qnil, NULL, 0); + double duration = extract_float (seconds); + + if (!NILP (milliseconds)) + { + CHECK_NUMBER (milliseconds); + duration += XINT (milliseconds) / 1000.0; + } + + if (0 < duration) + { + EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (duration); + wait_reading_process_output (min (EMACS_SECS (t), INTMAX_MAX), + EMACS_NSECS (t), 0, 0, Qnil, NULL, 0); + } return Qnil; } @@ -5948,7 +5897,9 @@ Lisp_Object sit_for (Lisp_Object timeout, int reading, int do_display) { - int sec, usec; + EMACS_TIME t; + intmax_t sec; + int nsec; swallow_events (do_display); @@ -5962,30 +5913,36 @@ if (INTEGERP (timeout)) { sec = XINT (timeout); - usec = 0; + if (! (0 < sec)) + return Qt; + nsec = 0; } else if (FLOATP (timeout)) { double seconds = XFLOAT_DATA (timeout); - sec = (int) seconds; - usec = (int) ((seconds - sec) * 1000000); + if (! (0 < seconds)) + return Qt; + else + { + EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (seconds); + sec = min (EMACS_SECS (t), INTMAX_MAX); + nsec = EMACS_NSECS (t); + } } else if (EQ (timeout, Qt)) { sec = 0; - usec = 0; + nsec = 0; } else wrong_type_argument (Qnumberp, timeout); - if (sec == 0 && usec == 0 && !EQ (timeout, Qt)) - return Qt; #ifdef SIGIO gobble_input (0); #endif - wait_reading_process_output (sec, usec, reading ? -1 : 1, do_display, + wait_reading_process_output (sec, nsec, reading ? -1 : 1, do_display, Qnil, NULL, 0); return detect_input_pending () ? Qnil : Qt; === modified file 'src/editfns.c' --- src/editfns.c 2011-07-04 07:44:38 +0000 +++ src/editfns.c 2011-07-04 08:24:10 +0000 @@ -84,7 +84,6 @@ extern Lisp_Object w32_get_internal_run_time (void); #endif -static void time_overflow (void) NO_RETURN; static int tm_diff (struct tm *, struct tm *); static void update_buffer_properties (EMACS_INT, EMACS_INT); @@ -1402,14 +1401,13 @@ #endif /* Report that a time value is out of range for Emacs. */ -static void +void time_overflow (void) { error ("Specified time is not representable"); } -/* Return the upper part of the time T (everything but the bottom 16 bits), - making sure that it is representable. */ +/* Return the upper part of the time T (everything but the bottom 16 bits). */ static EMACS_INT hi_time (time_t t) { @@ -1437,40 +1435,33 @@ DEFUN ("current-time", Fcurrent_time, Scurrent_time, 0, 0, 0, doc: /* Return the current time, as the number of seconds since 1970-01-01 00:00:00. -The time is returned as a list of three integers. The first has the -most significant 16 bits of the seconds, while the second has the -least significant 16 bits. The third integer gives the microsecond -count. - -The microsecond count is zero on systems that do not provide -resolution finer than a second. */) +The time is returned as a list of integers (HIGH LOW USEC PSEC). +HIGH has the most significant bits of the seconds, while LOW has the +least significant 16 bits. USEC and PSEC are the microsecond and +picosecond counts. */) (void) { EMACS_TIME t; EMACS_GET_TIME (t); - return list3 (make_number (hi_time (EMACS_SECS (t))), - make_number (lo_time (EMACS_SECS (t))), - make_number (EMACS_USECS (t))); + return make_lisp_time (t); } DEFUN ("get-internal-run-time", Fget_internal_run_time, Sget_internal_run_time, 0, 0, 0, doc: /* Return the current run time used by Emacs. -The time is returned as a list of three integers. The first has the -most significant 16 bits of the seconds, while the second has the -least significant 16 bits. The third integer gives the microsecond -count. +The time is returned as a list (HIGH LOW USEC PSEC), using the same +style as (current-time). On systems that can't determine the run time, `get-internal-run-time' -does the same thing as `current-time'. The microsecond count is zero -on systems that do not provide resolution finer than a second. */) +does the same thing as `current-time'. */) (void) { #ifdef HAVE_GETRUSAGE struct rusage usage; time_t secs; int usecs; + EMACS_TIME t; if (getrusage (RUSAGE_SELF, &usage) < 0) /* This shouldn't happen. What action is appropriate? */ @@ -1484,10 +1475,8 @@ usecs -= 1000000; secs++; } - - return list3 (make_number (hi_time (secs)), - make_number (lo_time (secs)), - make_number (usecs)); + EMACS_SET_SECS_USECS (t, secs, usecs); + return make_lisp_time (t); #else /* ! HAVE_GETRUSAGE */ #ifdef WINDOWSNT return w32_get_internal_run_time (); @@ -1498,101 +1487,175 @@ } -/* Make a Lisp list that represents the time T. */ -Lisp_Object +/* Make a Lisp list that represents the time T with fraction TAIL. */ +static Lisp_Object +make_time_tail (time_t t, Lisp_Object tail) +{ + return Fcons (make_number (hi_time (t)), + Fcons (make_number (lo_time (t)), tail)); +} + +/* Make a Lisp list that represents the system time T. */ +static Lisp_Object make_time (time_t t) { - return list2 (make_number (hi_time (t)), - make_number (lo_time (t))); + return make_time_tail (t, Qnil); +} + +/* Make a Lisp list that represents the Emacs time T. T may be an + invalid time, with a slightly negative tv_nsec value such as + UNKNOWN_MODTIME_NSECS; in that case, the Lisp list contains a + correspondingly negative picosecond count. */ +Lisp_Object +make_lisp_time (EMACS_TIME t) +{ + int ns = EMACS_NSECS (t); + return make_time_tail (EMACS_SECS (t), + list2 (make_number (ns / 1000), + make_number (ns % 1000 * 1000))); } /* Decode a Lisp list SPECIFIED_TIME that represents a time. - If SPECIFIED_TIME is nil, use the current time. - Set *RESULT to seconds since the Epoch. - If USEC is not null, set *USEC to the microseconds component. + Set *PHIGH, *PLOW, *PUSEC, *PPSEC to its parts; do not check their values. Return nonzero if successful. */ -int -lisp_time_argument (Lisp_Object specified_time, time_t *result, int *usec) +static int +disassemble_lisp_time (Lisp_Object specified_time, Lisp_Object *phigh, + Lisp_Object *plow, Lisp_Object *pusec, + Lisp_Object *ppsec) { - if (NILP (specified_time)) - { - if (usec) - { - EMACS_TIME t; - - EMACS_GET_TIME (t); - *usec = EMACS_USECS (t); - *result = EMACS_SECS (t); - return 1; - } - else - return time (result) != -1; - } - else - { - Lisp_Object high, low; - EMACS_INT hi; - high = Fcar (specified_time); - CHECK_NUMBER (high); - low = Fcdr (specified_time); + if (CONSP (specified_time)) + { + Lisp_Object low = XCDR (specified_time); + Lisp_Object usec = make_number (0); + Lisp_Object psec = make_number (0); if (CONSP (low)) - { - if (usec) - { - Lisp_Object usec_l = Fcdr (low); - if (CONSP (usec_l)) - usec_l = Fcar (usec_l); - if (NILP (usec_l)) - *usec = 0; - else - { - CHECK_NUMBER (usec_l); - *usec = XINT (usec_l); - } - } - low = Fcar (low); - } - else if (usec) - *usec = 0; - CHECK_NUMBER (low); - hi = XINT (high); - - /* Check for overflow, helping the compiler for common cases - where no runtime check is needed, and taking care not to - convert negative numbers to unsigned before comparing them. */ - if (! ((TYPE_SIGNED (time_t) - ? (TIME_T_MIN >> 16 <= MOST_NEGATIVE_FIXNUM - || TIME_T_MIN >> 16 <= hi) - : 0 <= hi) - && (MOST_POSITIVE_FIXNUM <= TIME_T_MAX >> 16 - || hi <= TIME_T_MAX >> 16))) - return 0; - - *result = (hi << 16) + (XINT (low) & 0xffff); + { + Lisp_Object low_tail = XCDR (low); + low = XCAR (low); + if (CONSP (low_tail)) + { + usec = XCAR (low_tail); + low_tail = XCDR (low_tail); + if (CONSP (low_tail)) + psec = XCAR (low_tail); + } + else if (!NILP (low_tail)) + usec = low_tail; + } + + *phigh = XCAR (specified_time); + *plow = low; + *pusec = usec; + *ppsec = psec; return 1; } -} + + return 0; +} + +/* From the time components HIGH, LOW, USEC and PSEC taken from a Lisp + list, generate the corresponding EMACS_TIME value *RESULT, and + if RESULT_PSEC is not null store into *RESULT_PSEC the + (nonnegative) difference in picoseconds between the input time and + the returned time. Return nonzero if successful. */ +int +decode_time_components (Lisp_Object high, Lisp_Object low, Lisp_Object usec, + Lisp_Object psec, EMACS_TIME *result, int *result_psec) +{ + EMACS_INT hi, lo, us, ps; + time_t sec; + if (! (INTEGERP (high) && INTEGERP (low) + && INTEGERP (usec) && INTEGERP (psec))) + return 0; + hi = XINT (high); + lo = XINT (low); + us = XINT (usec); + ps = XINT (psec); + + /* Normalize out-of-range lower-order components by carrying + each overflow into the next higher-order component. */ + us += ps / 1000000 - (ps % 1000000 < 0); + lo += us / 1000000 - (us % 1000000 < 0); + hi += lo >> 16; + ps = ps % 1000000 + 1000000 * (ps % 1000000 < 0); + us = us % 1000000 + 1000000 * (us % 1000000 < 0); + lo &= (1 << 16) - 1; + + /* Check for overflow in the highest-order component. */ + if (! ((TYPE_SIGNED (time_t) ? TIME_T_MIN >> 16 <= hi : 0 <= hi) + && hi <= TIME_T_MAX >> 16)) + return 0; + + sec = hi; + EMACS_SET_SECS_NSECS (*result, (sec << 16) + lo, us * 1000 + ps / 1000); + if (result_psec) + *result_psec = ps % 1000; + return 1; +} + +/* Decode a Lisp list SPECIFIED_TIME that represents a time. + If SPECIFIED_TIME is nil, use the current time. + Round the time down to the nearest EMACS_TIME value, and + if PPSEC is not null store into *PPSEC the (nonnegative) difference in + picoseconds between the input time and the returned time. + Return seconds since the Epoch. + Signal an error if unsuccessful. */ +EMACS_TIME +lisp_time_argument (Lisp_Object specified_time, int *ppsec) +{ + EMACS_TIME t; + if (NILP (specified_time)) + EMACS_GET_TIME (t); + else + { + Lisp_Object high, low, usec, psec; + if (! (disassemble_lisp_time (specified_time, &high, &low, &usec, &psec) + && decode_time_components (high, low, usec, psec, &t, ppsec))) + error ("Invalid time specification"); + } + return t; +} + +/* Like lisp_time_argument, except decode only the seconds part, + and do not check the subseconds part, and always round down. */ +static time_t +lisp_seconds_argument (Lisp_Object specified_time) +{ + if (NILP (specified_time)) + return time (NULL); + else + { + Lisp_Object high, low, usec, psec; + EMACS_TIME t; + if (! (disassemble_lisp_time (specified_time, &high, &low, &usec, &psec) + && decode_time_components (high, low, make_number (0), + make_number (0), &t, 0))) + error ("Invalid time specification"); + return EMACS_SECS (t); + } +} + DEFUN ("float-time", Ffloat_time, Sfloat_time, 0, 1, 0, doc: /* Return the current time, as a float number of seconds since the epoch. If SPECIFIED-TIME is given, it is the time to convert to float instead of the current time. The argument should have the form -(HIGH LOW) or (HIGH LOW USEC). Thus, you can use times obtained from -`current-time' and from `file-attributes'. SPECIFIED-TIME can also -have the form (HIGH . LOW), but this is considered obsolete. +(HIGH LOW) or (HIGH LOW USEC) or (HIGH LOW USEC PSEC). Thus, +you can use times from `current-time' and from `file-attributes'. +SPECIFIED-TIME can also have the form (HIGH . LOW), but this is +considered obsolete. WARNING: Since the result is floating point, it may not be exact. If precise time stamps are required, use either `current-time', or (if you need time as a string) `format-time-string'. */) (Lisp_Object specified_time) { - time_t sec; - int usec; - - if (! lisp_time_argument (specified_time, &sec, &usec)) - error ("Invalid time specification"); - - return make_float ((sec * 1e6 + usec) / 1e6); + int psec; + EMACS_TIME t = lisp_time_argument (specified_time, &psec); + double ps = (1000 * 1000 * 1000 <= INTMAX_MAX / 1000 + ? EMACS_NSECS (t) * (intmax_t) 1000 + psec + : EMACS_NSECS (t) * 1e3 + psec); + return make_float (EMACS_SECS (t) + ps / 1e12); } /* Write information into buffer S of size MAXSIZE, according to the @@ -1647,7 +1710,7 @@ DEFUN ("format-time-string", Fformat_time_string, Sformat_time_string, 1, 3, 0, doc: /* Use FORMAT-STRING to format the time TIME, or now if omitted. -TIME is specified as (HIGH LOW . IGNORED), as returned by +TIME is specified as (HIGH LOW USEC PSEC), as returned by `current-time' or `file-attributes'. The obsolete form (HIGH . LOW) is also still accepted. The third, optional, argument UNIVERSAL, if non-nil, means describe TIME @@ -1699,19 +1762,15 @@ For example, to produce full ISO 8601 format, use "%Y-%m-%dT%T%z". */) (Lisp_Object format_string, Lisp_Object timeval, Lisp_Object universal) { - time_t value; + EMACS_TIME t; ptrdiff_t size; - int usec; int ns; struct tm *tm; int ut = ! NILP (universal); CHECK_STRING (format_string); - if (! (lisp_time_argument (timeval, &value, &usec) - && 0 <= usec && usec < 1000000)) - error ("Invalid time specification"); - ns = usec * 1000; + t = lisp_time_argument (timeval, 0); format_string = code_convert_string_norecord (format_string, Vlocale_coding_system, 1); @@ -1722,7 +1781,7 @@ size = size * 6 + 50; BLOCK_INPUT; - tm = ut ? gmtime (&value) : localtime (&value); + tm = ut ? gmtime (EMACS_SECS_ADDR (t)) : localtime (EMACS_SECS_ADDR (t)); UNBLOCK_INPUT; if (! tm) time_overflow (); @@ -1738,7 +1797,7 @@ BLOCK_INPUT; result = emacs_nmemftime (buf, size, SSDATA (format_string), SBYTES (format_string), - tm, ut, ns); + tm, ut, EMACS_NSECS (t)); UNBLOCK_INPUT; if ((result > 0 && result < size) || (result == 0 && buf[0] == '\0')) return code_convert_string_norecord (make_unibyte_string (buf, result), @@ -1749,7 +1808,7 @@ result = emacs_nmemftime (NULL, (size_t) -1, SSDATA (format_string), SBYTES (format_string), - tm, ut, ns); + tm, ut, EMACS_NSECS (t)); UNBLOCK_INPUT; if (STRING_BYTES_BOUND <= result) string_overflow (); @@ -1774,14 +1833,11 @@ DOW and ZONE.) */) (Lisp_Object specified_time) { - time_t time_spec; + time_t time_spec = lisp_seconds_argument (specified_time); struct tm save_tm; struct tm *decoded_time; Lisp_Object list_args[9]; - if (! lisp_time_argument (specified_time, &time_spec, NULL)) - error ("Invalid time specification"); - BLOCK_INPUT; decoded_time = localtime (&time_spec); UNBLOCK_INPUT; @@ -1929,13 +1985,10 @@ but this is considered obsolete. */) (Lisp_Object specified_time) { - time_t value; + time_t value = lisp_seconds_argument (specified_time); struct tm *tm; register char *tem; - if (! lisp_time_argument (specified_time, &value, NULL)) - error ("Invalid time specification"); - /* Convert to a string, checking for out-of-range time stamps. Don't use 'ctime', as that might dump core if VALUE is out of range. */ @@ -1991,23 +2044,18 @@ the data it can't find. */) (Lisp_Object specified_time) { - time_t value; + time_t value = lisp_seconds_argument (specified_time); struct tm *t; struct tm gmt; - if (!lisp_time_argument (specified_time, &value, NULL)) - t = NULL; - else + BLOCK_INPUT; + t = gmtime (&value); + if (t) { - BLOCK_INPUT; - t = gmtime (&value); - if (t) - { - gmt = *t; - t = localtime (&value); - } - UNBLOCK_INPUT; + gmt = *t; + t = localtime (&value); } + UNBLOCK_INPUT; if (t) { === modified file 'src/fileio.c' --- src/fileio.c 2011-07-04 14:34:31 +0000 +++ src/fileio.c 2011-07-04 17:40:43 +0000 @@ -76,6 +76,7 @@ #endif #include "systime.h" +#include #ifdef HPUX #include @@ -1877,7 +1878,7 @@ /* Ensure file is writable while its modified time is set. */ attributes = GetFileAttributes (filename); SetFileAttributes (filename, attributes & ~FILE_ATTRIBUTE_READONLY); - if (set_file_times (filename, now, now)) + if (set_file_times (-1, filename, now, now)) { /* Restore original attributes. */ SetFileAttributes (filename, attributes); @@ -1978,24 +1979,21 @@ } #endif - /* Closing the output clobbers the file times on some systems. */ - if (emacs_close (ofd) < 0) - report_file_error ("I/O error", Fcons (newname, Qnil)); - if (input_file_statable_p) { if (!NILP (keep_time)) { - EMACS_TIME atime, mtime; - EMACS_SET_SECS_USECS (atime, st.st_atime, 0); - EMACS_SET_SECS_USECS (mtime, st.st_mtime, 0); - if (set_file_times (SSDATA (encoded_newname), - atime, mtime)) + EMACS_TIME atime = get_stat_atime (&st); + EMACS_TIME mtime = get_stat_mtime (&st); + if (set_file_times (ofd, SSDATA (encoded_newname), atime, mtime)) xsignal2 (Qfile_date_error, build_string ("Cannot set file date"), newname); } } + if (emacs_close (ofd) < 0) + report_file_error ("I/O error", Fcons (newname, Qnil)); + emacs_close (ifd); #ifdef MSDOS @@ -2936,11 +2934,7 @@ { Lisp_Object absname, encoded_absname; Lisp_Object handler; - time_t sec; - int usec; - - if (! lisp_time_argument (timestamp, &sec, &usec)) - error ("Invalid time specification"); + EMACS_TIME t = lisp_time_argument (timestamp, 0); absname = Fexpand_file_name (filename, BVAR (current_buffer, directory)); @@ -2953,12 +2947,7 @@ encoded_absname = ENCODE_FILE (absname); { - EMACS_TIME t; - - EMACS_SET_SECS (t, sec); - EMACS_SET_USECS (t, usec); - - if (set_file_times (SSDATA (encoded_absname), t, t)) + if (set_file_times (-1, SSDATA (encoded_absname), t, t)) { #ifdef DOS_NT struct stat st; @@ -4059,7 +4048,7 @@ if (NILP (handler)) { - current_buffer->modtime = st.st_mtime; + current_buffer->modtime = get_stat_mtime (&st); current_buffer->modtime_size = st.st_size; BVAR (current_buffer, filename) = orig_filename; } @@ -4224,7 +4213,7 @@ } if (!NILP (visit) - && current_buffer->modtime == -1) + && EMACS_NSECS (current_buffer->modtime) == NONEXISTENT_MODTIME_NSECS) { /* If visiting nonexistent file, return nil. */ report_file_error ("Opening input file", Fcons (orig_filename, Qnil)); @@ -4659,7 +4648,7 @@ next attempt to save. */ if (visiting) { - current_buffer->modtime = st.st_mtime; + current_buffer->modtime = get_stat_mtime (&st); current_buffer->modtime_size = st.st_size; } @@ -4936,6 +4925,7 @@ struct stat st; Lisp_Object handler; Lisp_Object filename; + EMACS_TIME mtime, diff, one_second; if (NILP (buf)) b = current_buffer; @@ -4946,7 +4936,7 @@ } if (!STRINGP (BVAR (b, filename))) return Qt; - if (b->modtime == 0) return Qt; + if (EMACS_NSECS (b->modtime) == UNKNOWN_MODTIME_NSECS) return Qt; /* If the file name has special constructs in it, call the corresponding file handler. */ @@ -4957,20 +4947,25 @@ filename = ENCODE_FILE (BVAR (b, filename)); - if (stat (SSDATA (filename), &st) < 0) + if (stat (SSDATA (filename), &st) == 0) + mtime = get_stat_mtime (&st); + else { /* If the file doesn't exist now and didn't exist before, we say that it isn't modified, provided the error is a tame one. */ - if (errno == ENOENT || errno == EACCES || errno == ENOTDIR) - st.st_mtime = -1; - else - st.st_mtime = 0; + int ns = (errno == ENOENT || errno == EACCES || errno == ENOTDIR + ? NONEXISTENT_MODTIME_NSECS + : UNKNOWN_MODTIME_NSECS); + EMACS_SET_SECS_NSECS (mtime, 0, ns); } - if ((st.st_mtime == b->modtime - /* If both are positive, accept them if they are off by one second. */ - || (st.st_mtime > 0 && b->modtime > 0 - && (st.st_mtime - 1 == b->modtime - || st.st_mtime == b->modtime - 1))) + if ((EMACS_TIME_EQ (mtime, b->modtime) + /* If both exist, accept them if they are off by one second. */ + || (EMACS_TIME_VALID_P (mtime) && EMACS_TIME_VALID_P (b->modtime) + && ((EMACS_TIME_LT (mtime, b->modtime) + ? EMACS_SUB_TIME (diff, b->modtime, mtime) + : EMACS_SUB_TIME (diff, mtime, b->modtime)), + EMACS_SET_SECS_NSECS (one_second, 1, 0), + EMACS_TIME_LE (diff, one_second)))) && (st.st_size == b->modtime_size || b->modtime_size < 0)) return Qt; @@ -4983,7 +4978,7 @@ Next attempt to save will certainly not complain of a discrepancy. */) (void) { - current_buffer->modtime = 0; + EMACS_SET_SECS_NSECS (current_buffer->modtime, 0, UNKNOWN_MODTIME_NSECS); current_buffer->modtime_size = -1; return Qnil; } @@ -4991,15 +4986,15 @@ DEFUN ("visited-file-modtime", Fvisited_file_modtime, Svisited_file_modtime, 0, 0, 0, doc: /* Return the current buffer's recorded visited file modification time. -The value is a list of the form (HIGH LOW), like the time values +The value is a list of the form (HIGH LOW USEC PSEC), like the time values that `file-attributes' returns. If the current buffer has no recorded file modification time, this function returns 0. See Info node `(elisp)Modification Time' for more details. */) (void) { - if (! current_buffer->modtime) + if (EMACS_NSECS (current_buffer->modtime) < 0) return make_number (0); - return make_time (current_buffer->modtime); + return make_lisp_time (current_buffer->modtime); } DEFUN ("set-visited-file-modtime", Fset_visited_file_modtime, @@ -5009,12 +5004,12 @@ or if the file itself has been changed for some known benign reason. An argument specifies the modification time value to use \(instead of that of the visited file), in the form of a list -\(HIGH . LOW) or (HIGH LOW). */) +\(HIGH LOW USEC PSEC) as returned by `current-time'. */) (Lisp_Object time_list) { if (!NILP (time_list)) { - CONS_TO_INTEGER (time_list, time_t, current_buffer->modtime); + current_buffer->modtime = lisp_time_argument (time_list, 0); current_buffer->modtime_size = -1; } else @@ -5036,7 +5031,7 @@ if (stat (SSDATA (filename), &st) >= 0) { - current_buffer->modtime = st.st_mtime; + current_buffer->modtime = get_stat_mtime (&st); current_buffer->modtime_size = st.st_size; } } === modified file 'src/gtkutil.c' --- src/gtkutil.c 2011-06-26 18:47:07 +0000 +++ src/gtkutil.c 2011-07-01 07:37:04 +0000 @@ -1579,16 +1579,16 @@ { struct xg_dialog_data *dd = (struct xg_dialog_data *) data; EMACS_TIME next_time = timer_check (); - long secs = EMACS_SECS (next_time); - long usecs = EMACS_USECS (next_time); dd->timerid = 0; - if (secs >= 0 && usecs >= 0 && secs < ((guint)-1)/1000) + if (EMACS_TIME_VALID_P (next_time)) { - dd->timerid = g_timeout_add (secs * 1000 + usecs/1000, - xg_maybe_add_timer, - dd); + time_t s = EMACS_SECS (next_time); + int per_ms = EMACS_TIME_RESOLUTION / 1000; + int ms = (EMACS_NSECS (next_time) + per_ms - 1) / per_ms; + if (s <= ((guint) -1 - ms) / 1000) + dd->timerid = g_timeout_add (s * 1000 + ms, xg_maybe_add_timer, dd); } return FALSE; } === modified file 'src/image.c' --- src/image.c 2011-06-23 00:46:41 +0000 +++ src/image.c 2011-07-01 07:37:04 +0000 @@ -1076,11 +1076,8 @@ void prepare_image_for_display (struct frame *f, struct image *img) { - EMACS_TIME t; - /* We're about to display IMG, so set its timestamp to `now'. */ - EMACS_GET_TIME (t); - img->timestamp = EMACS_SECS (t); + EMACS_GET_TIME (img->timestamp); /* If IMG doesn't have a pixmap yet, load it now, using the image type dependent loader function. */ @@ -1524,9 +1521,9 @@ else if (INTEGERP (Vimage_cache_eviction_delay)) { /* Free cache based on timestamp. */ - EMACS_TIME t; - time_t old; - int delay, nimages = 0; + EMACS_TIME old, t; + double delay; + unsigned nimages = 0; for (i = 0; i < c->used; ++i) if (c->images[i]) @@ -1534,17 +1531,18 @@ /* If the number of cached images has grown unusually large, decrease the cache eviction delay (Bug#6230). */ - delay = XFASTINT (Vimage_cache_eviction_delay); + delay = XINT (Vimage_cache_eviction_delay); if (nimages > 40) - delay = max (1, 1600 * delay / (nimages*nimages)); + delay = 1600 * delay / nimages / nimages; + delay = max (1, delay); EMACS_GET_TIME (t); - old = EMACS_SECS (t) - delay; + EMACS_SUB_TIME (old, t, EMACS_TIME_FROM_DOUBLE (delay)); for (i = 0; i < c->used; ++i) { struct image *img = c->images[i]; - if (img && img->timestamp < old) + if (img && EMACS_TIME_LT (img->timestamp, old)) { free_image (f, img); ++nfreed; @@ -1717,7 +1715,6 @@ { struct image *img; EMACS_UINT hash; - EMACS_TIME now; /* F must be a window-system frame, and SPEC must be a valid image specification. */ @@ -1812,8 +1809,7 @@ } /* We're using IMG, so set its timestamp to `now'. */ - EMACS_GET_TIME (now); - img->timestamp = EMACS_SECS (now); + EMACS_GET_TIME (img->timestamp); /* Value is the image id. */ return img->id; === modified file 'src/keyboard.c' --- src/keyboard.c 2011-07-02 23:40:04 +0000 +++ src/keyboard.c 2011-07-04 08:24:10 +0000 @@ -2014,12 +2014,13 @@ if (poll_timer == NULL || EMACS_SECS (poll_timer->interval) != polling_period) { + time_t period = max (1, min (polling_period, TYPE_MAXIMUM (time_t))); EMACS_TIME interval; if (poll_timer) cancel_atimer (poll_timer); - EMACS_SET_SECS_USECS (interval, polling_period, 0); + EMACS_SET_SECS_USECS (interval, period, 0); poll_timer = start_atimer (ATIMER_CONTINUOUS, interval, poll_for_input, NULL); } @@ -2087,7 +2088,7 @@ bind_polling_period (int n) { #ifdef POLL_FOR_INPUT - int new = polling_period; + EMACS_INT new = polling_period; if (n > new) new = n; @@ -2217,7 +2218,7 @@ /* Input of single characters from keyboard */ static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, int *used_mouse_menu, - struct timeval *end_time); + EMACS_TIME *end_time); static void record_char (Lisp_Object c); static Lisp_Object help_form_saved_window_configs; @@ -2268,7 +2269,7 @@ Lisp_Object read_char (int commandflag, int nmaps, Lisp_Object *maps, Lisp_Object prev_event, - int *used_mouse_menu, struct timeval *end_time) + int *used_mouse_menu, EMACS_TIME *end_time) { volatile Lisp_Object c; int jmpcount; @@ -3769,7 +3770,7 @@ static Lisp_Object kbd_buffer_get_event (KBOARD **kbp, int *used_mouse_menu, - struct timeval *end_time) + EMACS_TIME *end_time) { register int c; Lisp_Object obj; @@ -3842,8 +3843,9 @@ else { EMACS_SUB_TIME (duration, *end_time, duration); - wait_reading_process_output (EMACS_SECS (duration), - EMACS_USECS (duration), + wait_reading_process_output (min (EMACS_SECS (duration), + INTMAX_MAX), + EMACS_NSECS (duration), -1, 1, Qnil, NULL, 0); } } @@ -4205,7 +4207,7 @@ Lisp_Object timers; /* If we are already in the idle state, do nothing. */ - if (! EMACS_TIME_NEG_P (timer_idleness_start_time)) + if (EMACS_TIME_VALID_P (timer_idleness_start_time)) return; EMACS_GET_TIME (timer_idleness_start_time); @@ -4219,7 +4221,7 @@ timer = XCAR (timers); - if (!VECTORP (timer) || ASIZE (timer) != 8) + if (!VECTORP (timer) || ASIZE (timer) != 9) continue; XVECTOR (timer)->contents[0] = Qnil; } @@ -4230,7 +4232,7 @@ static void timer_stop_idle (void) { - EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1); + EMACS_SET_INVALID_TIME (timer_idleness_start_time); } /* Resume idle timer from last idle start time. */ @@ -4238,7 +4240,7 @@ static void timer_resume_idle (void) { - if (! EMACS_TIME_NEG_P (timer_idleness_start_time)) + if (EMACS_TIME_VALID_P (timer_idleness_start_time)) return; timer_idleness_start_time = timer_last_idleness_start_time; @@ -4252,6 +4254,24 @@ ...). Each element has the form (FUN . ARGS). */ Lisp_Object pending_funcalls; +/* If TIMER is a valid timer, return nonzero and place its value into + *RESULT. Otherwise return zero. */ +static int +decode_timer (Lisp_Object timer, EMACS_TIME *result) +{ + Lisp_Object *vector; + + if (! (VECTORP (timer) && ASIZE (timer) == 9)) + return 0; + vector = XVECTOR (timer)->contents; + if (! NILP (vector[0])) + return 0; + + return decode_time_components (vector[1], vector[2], vector[3], vector[4], + result, 0); +} + + /* Check whether a timer has fired. To prevent larger problems we simply disregard elements that are not proper timers. Do not make a circular timer list for the time being. @@ -4269,17 +4289,16 @@ { EMACS_TIME nexttime; EMACS_TIME now; - EMACS_TIME idleness_now IF_LINT (= {0}); + EMACS_TIME idleness_now; Lisp_Object timers, idle_timers, chosen_timer; struct gcpro gcpro1, gcpro2, gcpro3; - EMACS_SET_SECS (nexttime, -1); - EMACS_SET_USECS (nexttime, -1); + EMACS_SET_INVALID_TIME (nexttime); /* Always consider the ordinary timers. */ timers = Vtimer_list; /* Consider the idle timers only if Emacs is idle. */ - if (! EMACS_TIME_NEG_P (timer_idleness_start_time)) + if (EMACS_TIME_VALID_P (timer_idleness_start_time)) idle_timers = Vtimer_idle_list; else idle_timers = Qnil; @@ -4297,8 +4316,10 @@ if (CONSP (timers) || CONSP (idle_timers)) { EMACS_GET_TIME (now); - if (! EMACS_TIME_NEG_P (timer_idleness_start_time)) + if (EMACS_TIME_VALID_P (timer_idleness_start_time)) EMACS_SUB_TIME (idleness_now, now, timer_idleness_start_time); + else + EMACS_SET_SECS_NSECS (idleness_now, 0, 0); } while (CONSP (timers) || CONSP (idle_timers)) @@ -4307,113 +4328,84 @@ Lisp_Object timer = Qnil, idle_timer = Qnil; EMACS_TIME timer_time, idle_timer_time; EMACS_TIME difference; - EMACS_TIME timer_difference IF_LINT (= {0}); - EMACS_TIME idle_timer_difference IF_LINT (= {0}); - - /* Skip past invalid timers and timers already handled. */ - if (CONSP (timers)) - { - timer = XCAR (timers); - if (!VECTORP (timer) || ASIZE (timer) != 8) - { - timers = XCDR (timers); - continue; - } - vector = XVECTOR (timer)->contents; - - if (!INTEGERP (vector[1]) || !INTEGERP (vector[2]) - || !INTEGERP (vector[3]) - || ! NILP (vector[0])) - { - timers = XCDR (timers); - continue; - } - } - if (CONSP (idle_timers)) - { - timer = XCAR (idle_timers); - if (!VECTORP (timer) || ASIZE (timer) != 8) - { - idle_timers = XCDR (idle_timers); - continue; - } - vector = XVECTOR (timer)->contents; - - if (!INTEGERP (vector[1]) || !INTEGERP (vector[2]) - || !INTEGERP (vector[3]) - || ! NILP (vector[0])) - { - idle_timers = XCDR (idle_timers); - continue; - } - } - - /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE + EMACS_TIME timer_difference, idle_timer_difference; + int ripe, timer_ripe = 0, idle_timer_ripe = 0; + + EMACS_SET_INVALID_TIME (timer_difference); + EMACS_SET_INVALID_TIME (idle_timer_difference); + + /* Set TIMER and TIMER_DIFFERENCE based on the next ordinary timer. TIMER_DIFFERENCE is the distance in time from NOW to when - this timer becomes ripe (negative if it's already ripe). */ + this timer becomes ripe (negative if it's already ripe). + Skip past invalid timers and timers already handled. */ if (CONSP (timers)) { timer = XCAR (timers); - vector = XVECTOR (timer)->contents; - EMACS_SET_SECS (timer_time, - (XINT (vector[1]) << 16) | (XINT (vector[2]))); - EMACS_SET_USECS (timer_time, XINT (vector[3])); - EMACS_SUB_TIME (timer_difference, timer_time, now); + if (! decode_timer (timer, &timer_time)) + { + timers = XCDR (timers); + continue; + } + + timer_ripe = EMACS_TIME_LE (timer_time, now); + if (timer_ripe) + EMACS_SUB_TIME (timer_difference, now, timer_time); + else + EMACS_SUB_TIME (timer_difference, timer_time, now); } - /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE + /* Likewise for IDLE_TIMER and IDLE_TIMER_DIFFERENCE based on the next idle timer. */ if (CONSP (idle_timers)) { idle_timer = XCAR (idle_timers); - vector = XVECTOR (idle_timer)->contents; - EMACS_SET_SECS (idle_timer_time, - (XINT (vector[1]) << 16) | (XINT (vector[2]))); - EMACS_SET_USECS (idle_timer_time, XINT (vector[3])); - EMACS_SUB_TIME (idle_timer_difference, idle_timer_time, idleness_now); + if (! decode_timer (idle_timer, &idle_timer_time)) + { + idle_timers = XCDR (idle_timers); + continue; + } + + idle_timer_ripe = EMACS_TIME_LE (idle_timer_time, idleness_now); + if (idle_timer_ripe) + EMACS_SUB_TIME (idle_timer_difference, + idleness_now, idle_timer_time); + else + EMACS_SUB_TIME (idle_timer_difference, + idle_timer_time, idleness_now); } /* Decide which timer is the next timer, - and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly. + and set CHOSEN_TIMER, DIFFERENCE, and RIPE accordingly. Also step down the list where we found that timer. */ - if (CONSP (timers) && CONSP (idle_timers)) - { - EMACS_TIME temp; - EMACS_SUB_TIME (temp, timer_difference, idle_timer_difference); - if (EMACS_TIME_NEG_P (temp)) - { - chosen_timer = timer; - timers = XCDR (timers); - difference = timer_difference; - } - else - { - chosen_timer = idle_timer; - idle_timers = XCDR (idle_timers); - difference = idle_timer_difference; - } - } - else if (CONSP (timers)) + if (EMACS_TIME_VALID_P (timer_difference) + && (! EMACS_TIME_VALID_P (idle_timer_difference) + || idle_timer_ripe < timer_ripe + || (idle_timer_ripe == timer_ripe + && (timer_ripe + ? EMACS_TIME_LT (idle_timer_difference, + timer_difference) + : EMACS_TIME_LT (timer_difference, + idle_timer_difference))))) { chosen_timer = timer; timers = XCDR (timers); difference = timer_difference; + ripe = timer_ripe; } else { chosen_timer = idle_timer; idle_timers = XCDR (idle_timers); difference = idle_timer_difference; + ripe = idle_timer_ripe; } - vector = XVECTOR (chosen_timer)->contents; /* If timer is ripe, run it if it hasn't been run. */ - if (EMACS_TIME_NEG_P (difference) - || (EMACS_SECS (difference) == 0 - && EMACS_USECS (difference) == 0)) + if (ripe) { + vector = XVECTOR (chosen_timer)->contents; if (NILP (vector[0])) { int count = SPECPDL_INDEX (); @@ -4460,7 +4452,7 @@ timer list for the time being. Returns the time to wait until the next timer fires. - If no timer is active, return -1. + If no timer is active, return an invalid value. As long as any timer is ripe, we run it. */ @@ -4473,33 +4465,29 @@ { nexttime = timer_check_2 (); } - while (EMACS_SECS (nexttime) == 0 && EMACS_USECS (nexttime) == 0); + while (EMACS_SECS (nexttime) == 0 && EMACS_NSECS (nexttime) == 0); return nexttime; } DEFUN ("current-idle-time", Fcurrent_idle_time, Scurrent_idle_time, 0, 0, 0, doc: /* Return the current length of Emacs idleness, or nil. -The value when Emacs is idle is a list of three integers. The first has -the most significant 16 bits of the seconds, while the second has the least -significant 16 bits. The third integer gives the microsecond count. +The value when Emacs is idle is a list of four integers (HIGH LOW USEC PSEC) +in the same style as (current-time). The value when Emacs is not idle is nil. -The microsecond count is zero on systems that do not provide -resolution finer than a second. */) +NSEC is a multiple of the system clock resolution. */) (void) { - if (! EMACS_TIME_NEG_P (timer_idleness_start_time)) + if (EMACS_TIME_VALID_P (timer_idleness_start_time)) { EMACS_TIME now, idleness_now; EMACS_GET_TIME (now); EMACS_SUB_TIME (idleness_now, now, timer_idleness_start_time); - return list3 (make_number ((EMACS_SECS (idleness_now) >> 16) & 0xffff), - make_number ((EMACS_SECS (idleness_now) >> 0) & 0xffff), - make_number (EMACS_USECS (idleness_now))); + return make_lisp_time (idleness_now); } return Qnil; @@ -10790,7 +10778,7 @@ } void -set_waiting_for_input (struct timeval *time_to_clear) +set_waiting_for_input (EMACS_TIME *time_to_clear) { input_available_clear_time = time_to_clear; @@ -11393,7 +11381,7 @@ quit_char = Ctl ('g'); Vunread_command_events = Qnil; unread_command_char = -1; - EMACS_SET_SECS_USECS (timer_idleness_start_time, -1, -1); + EMACS_SET_INVALID_TIME (timer_idleness_start_time); total_keys = 0; recent_keys_index = 0; kbd_fetch_ptr = kbd_buffer; === modified file 'src/lisp.h' --- src/lisp.h 2011-06-24 21:25:22 +0000 +++ src/lisp.h 2011-07-01 07:37:04 +0000 @@ -3011,6 +3011,7 @@ EXFUN (Fwiden, 0); EXFUN (Fuser_login_name, 1); EXFUN (Fsystem_name, 0); +extern void time_overflow (void) NO_RETURN; EXFUN (Fcurrent_time, 0); EXFUN (Fget_internal_run_time, 0); extern EMACS_INT clip_to_bounds (EMACS_INT, EMACS_INT, EMACS_INT); @@ -3307,7 +3308,7 @@ EXFUN (Fwaiting_for_user_input_p, 0); extern Lisp_Object Qprocessp; extern void kill_buffer_processes (Lisp_Object); -extern int wait_reading_process_output (int, int, int, int, +extern int wait_reading_process_output (intmax_t, int, int, int, Lisp_Object, struct Lisp_Process *, int); === modified file 'src/lread.c' --- src/lread.c 2011-07-02 16:18:24 +0000 +++ src/lread.c 2011-07-04 08:24:10 +0000 @@ -604,14 +604,10 @@ /* Compute timeout. */ if (NUMBERP (seconds)) { - EMACS_TIME wait_time; - int sec, usec; double duration = extract_float (seconds); + EMACS_TIME wait_time = EMACS_TIME_FROM_DOUBLE (duration); - sec = (int) duration; - usec = (duration - sec) * 1000000; EMACS_GET_TIME (end_time); - EMACS_SET_SECS_USECS (wait_time, sec, usec); EMACS_ADD_TIME (end_time, end_time, wait_time); } === modified file 'src/msdos.c' --- src/msdos.c 2011-06-24 21:25:22 +0000 +++ src/msdos.c 2011-07-01 07:37:04 +0000 @@ -4072,13 +4072,6 @@ #ifndef HAVE_SELECT #include "sysselect.h" -#ifndef EMACS_TIME_ZERO_OR_NEG_P -#define EMACS_TIME_ZERO_OR_NEG_P(time) \ - ((long)(time).tv_sec < 0 \ - || ((time).tv_sec == 0 \ - && (long)(time).tv_usec <= 0)) -#endif - /* This yields the rest of the current time slice to the task manager. It should be called by any code which knows that it has nothing useful to do except idle. @@ -4147,12 +4140,12 @@ /* When seconds wrap around, we assume that no more than 1 minute passed since last `gettime'. */ - if (EMACS_TIME_NEG_P (cldiff)) + if (EMACS_TIME_SIGN (cldiff) < 0) EMACS_SET_SECS (cldiff, EMACS_SECS (cldiff) + 60); EMACS_SUB_TIME (*timeout, *timeout, cldiff); /* Stop when timeout value crosses zero. */ - if (EMACS_TIME_ZERO_OR_NEG_P (*timeout)) + if (EMACS_TIME_SIGN (*timeout) <= 0) return 0; cllast = clnow; dos_yield_time_slice (); === modified file 'src/nsterm.h' --- src/nsterm.h 2011-06-22 06:16:16 +0000 +++ src/nsterm.h 2011-07-01 07:37:04 +0000 @@ -787,7 +787,8 @@ /* This in nsterm.m */ extern int ns_select (int nfds, fd_set *readfds, fd_set *writefds, - fd_set *exceptfds, struct timeval *timeout); + fd_set *exceptfds, EMACS_TIME *timeout, + sigset_t *sigmask); extern unsigned long ns_get_rgb_color (struct frame *f, float r, float g, float b, float a); extern NSPoint last_mouse_motion_position; === modified file 'src/nsterm.m' --- src/nsterm.m 2011-05-28 16:56:53 +0000 +++ src/nsterm.m 2011-07-01 07:37:04 +0000 @@ -180,7 +180,6 @@ static NSTimer *fd_entry = nil; static NSTimer *scroll_repeat_entry = nil; static fd_set select_readfds, t_readfds; -static struct timeval select_timeout; static int select_nfds; static NSAutoreleasePool *outerpool; static struct input_event *emacs_event = NULL; @@ -383,67 +382,30 @@ } } - -static int -timeval_subtract (struct timeval *result, struct timeval x, struct timeval y) -/* -------------------------------------------------------------------------- - Subtract the `struct timeval' values X and Y, storing the result in RESULT. - Return 1 if the difference is negative, otherwise 0. - -------------------------------------------------------------------------- */ -{ - /* Perform the carry for the later subtraction by updating y. - This is safer because on some systems - the tv_sec member is unsigned. */ - if (x.tv_usec < y.tv_usec) - { - int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1; - y.tv_usec -= 1000000 * nsec; - y.tv_sec += nsec; - } - if (x.tv_usec - y.tv_usec > 1000000) - { - int nsec = (y.tv_usec - x.tv_usec) / 1000000; - y.tv_usec += 1000000 * nsec; - y.tv_sec -= nsec; - } - - /* Compute the time remaining to wait. tv_usec is certainly positive. */ - result->tv_sec = x.tv_sec - y.tv_sec; - result->tv_usec = x.tv_usec - y.tv_usec; - - /* Return indication of whether the result should be considered negative. */ - return x.tv_sec < y.tv_sec; -} - static void ns_timeout (int usecs) /* -------------------------------------------------------------------------- Blocking timer utility used by ns_ring_bell -------------------------------------------------------------------------- */ { - struct timeval wakeup; + EMACS_TIME wakeup, delay; EMACS_GET_TIME (wakeup); - - /* Compute time to wait until, propagating carry from usecs. */ - wakeup.tv_usec += usecs; - wakeup.tv_sec += (wakeup.tv_usec / 1000000); - wakeup.tv_usec %= 1000000; + EMACS_SET_SECS_USECS (delay, 0, usecs); + EMACS_ADD_TIME (wakeup, wakeup, delay); /* Keep waiting until past the time wakeup. */ while (1) { - struct timeval timeout; + EMACS_TIME timeout; EMACS_GET_TIME (timeout); - - /* In effect, timeout = wakeup - timeout. - Break if result would be negative. */ - if (timeval_subtract (&timeout, wakeup, timeout)) + if (EMACS_TIME_LE (wakeup, timeout)) break; + EMACS_SUB_TIME (timeout, wakeup, timeout); /* Try to wait that long--but we might wake up sooner. */ - select (0, NULL, NULL, NULL, &timeout); + pselect (0, NULL, NULL, NULL, &timeout, NULL); } } @@ -3318,7 +3280,7 @@ int ns_select (int nfds, fd_set *readfds, fd_set *writefds, - fd_set *exceptfds, struct timeval *timeout) + fd_set *exceptfds, EMACS_TIME *timeout, sigset_t *sigmask) /* -------------------------------------------------------------------------- Replacement for select, checking for events -------------------------------------------------------------------------- */ @@ -3326,12 +3288,14 @@ int result; double time; NSEvent *ev; + struct timespec select_timeout; + /* NSTRACE (ns_select); */ if (NSApp == nil || inNsSelect == 1 /* || ([NSApp isActive] == NO && [NSApp nextEventMatchingMask:NSAnyEventMask untilDate:nil inMode:NSDefaultRunLoopMode dequeue:NO] == nil) */) - return select (nfds, readfds, writefds, exceptfds, timeout); + return pselect (nfds, readfds, writefds, exceptfds, timeout, sigmask); /* Save file descriptor set, which gets overwritten in calls to select () Note, this is called from process.c, and only readfds is ever set */ @@ -3344,8 +3308,9 @@ select_nfds = 0; /* Try an initial select for pending data on input files */ - select_timeout.tv_sec = select_timeout.tv_usec = 0; - result = select (nfds, readfds, writefds, exceptfds, &select_timeout); + select_timeout.tv_sec = select_timeout.tv_nsec = 0; + result = pselect (nfds, readfds, writefds, exceptfds, + &select_timeout, sigmask); if (result) return result; @@ -3354,7 +3319,7 @@ /* set a timeout and run the main AppKit event loop while continuing to monitor the files */ - time = ((double) timeout->tv_sec) + ((double) timeout->tv_usec)/1000000.0; + time = EMACS_TIME_TO_DOUBLE (*timeout); timed_entry = [[NSTimer scheduledTimerWithTimeInterval: time target: NSApp selector: @selector (timeout_handler:) @@ -3362,7 +3327,7 @@ repeats: YES] /* for safe removal */ retain]; - /* set a periodic task to try the select () again */ + /* set a periodic task to try the pselect () again */ fd_entry = [[NSTimer scheduledTimerWithTimeInterval: 0.1 target: NSApp selector: @selector (fd_handler:) @@ -3404,7 +3369,7 @@ } else { - /* Received back from select () in fd_handler; copy the results */ + /* Received back from pselect () in fd_handler; copy the results */ if (readfds) memcpy (readfds, &select_readfds, sizeof (fd_set)); return t; @@ -4367,6 +4332,7 @@ -------------------------------------------------------------------------- */ { int result; + struct timespec select_timeout; /* NSTRACE (fd_handler); */ if (select_nfds == 0) @@ -4374,9 +4340,8 @@ memcpy (&t_readfds, &select_readfds, sizeof (fd_set)); - select_timeout.tv_sec = select_timeout.tv_usec = 0; - result = select (select_nfds, &t_readfds, (SELECT_TYPE *)0, (SELECT_TYPE *)0, - &select_timeout); + select_timeout.tv_sec = select_timeout.tv_nsec = 0; + result = pselect (select_nfds, &t_readfds, NULL, NULL, &select_timeout, NULL); if (result) { memcpy (&select_readfds, &t_readfds, sizeof (fd_set)); === modified file 'src/process.c' --- src/process.c 2011-07-01 09:18:46 +0000 +++ src/process.c 2011-07-04 08:09:05 +0000 @@ -210,13 +210,11 @@ #endif #if !defined (ADAPTIVE_READ_BUFFERING) && !defined (NO_ADAPTIVE_READ_BUFFERING) -#ifdef EMACS_HAS_USECS #define ADAPTIVE_READ_BUFFERING #endif -#endif #ifdef ADAPTIVE_READ_BUFFERING -#define READ_OUTPUT_DELAY_INCREMENT 10000 +#define READ_OUTPUT_DELAY_INCREMENT (EMACS_TIME_RESOLUTION / 100) #define READ_OUTPUT_DELAY_MAX (READ_OUTPUT_DELAY_INCREMENT * 5) #define READ_OUTPUT_DELAY_MAX_MAX (READ_OUTPUT_DELAY_INCREMENT * 7) @@ -3264,7 +3262,7 @@ { /* Unlike most other syscalls connect() cannot be called again. (That would return EALREADY.) The proper way to - wait for completion is select(). */ + wait for completion is pselect(). */ int sc; socklen_t len; SELECT_TYPE fdset; @@ -3272,8 +3270,7 @@ FD_ZERO (&fdset); FD_SET (s, &fdset); QUIT; - sc = select (s + 1, (SELECT_TYPE *)0, &fdset, (SELECT_TYPE *)0, - (EMACS_TIME *)0); + sc = pselect (s + 1, NULL, &fdset, NULL, NULL, NULL); if (sc == -1) { if (errno == EINTR) @@ -3875,7 +3872,8 @@ Return non-nil if we received any output before the timeout expired. */) (register Lisp_Object process, Lisp_Object seconds, Lisp_Object millisec, Lisp_Object just_this_one) { - int secs, usecs = 0; + intmax_t secs; + int nsecs; if (! NILP (process)) CHECK_PROCESS (process); @@ -3894,27 +3892,36 @@ } } + secs = 0; + nsecs = -1; + if (!NILP (seconds)) { if (INTEGERP (seconds)) - secs = XINT (seconds); + { + if (0 < XINT (seconds)) + { + secs = XINT (seconds); + nsecs = 0; + } + } else if (FLOATP (seconds)) { - double timeout = XFLOAT_DATA (seconds); - secs = (int) timeout; - usecs = (int) ((timeout - (double) secs) * 1000000); + if (0 < XFLOAT_DATA (seconds)) + { + EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds)); + secs = min (EMACS_SECS (t), INTMAX_MAX); + nsecs = EMACS_NSECS (t); + } } else wrong_type_argument (Qnumberp, seconds); - - if (secs < 0 || (secs == 0 && usecs == 0)) - secs = -1, usecs = 0; } - else - secs = NILP (process) ? -1 : 0; + else if (! NILP (process)) + nsecs = 0; return - (wait_reading_process_output (secs, usecs, 0, 0, + (wait_reading_process_output (secs, nsecs, 0, 0, Qnil, !NILP (process) ? XPROCESS (process) : NULL, NILP (just_this_one) ? 0 : @@ -4155,34 +4162,19 @@ { } -/* Use a wrapper around select to work around a bug in gdb 5.3. - Normally, the wrapper is optimized away by inlining. - - If emacs is stopped inside select, the gdb backtrace doesn't - show the function which called select, so it is practically - impossible to step through wait_reading_process_output. */ - -#ifndef select -static inline int -select_wrapper (int n, fd_set *rfd, fd_set *wfd, fd_set *xfd, struct timeval *tmo) -{ - return select (n, rfd, wfd, xfd, tmo); -} -#define select select_wrapper -#endif - /* Read and dispose of subprocess output while waiting for timeout to elapse and/or keyboard input to be available. TIME_LIMIT is: - timeout in seconds, or - zero for no limit, or - -1 means gobble data immediately available but don't wait for any. + timeout in seconds + If negative, gobble data immediately available but don't wait for any. - MICROSECS is: - an additional duration to wait, measured in microseconds. - If this is nonzero and time_limit is 0, then the timeout - consists of MICROSECS only. + NSECS is: + an additional duration to wait, measured in nanoseconds + If TIME_LIMIT is zero, then: + If NSECS == 0, there is no limit. + If NSECS > 0, the timeout consists of NSEC only. + If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative. READ_KBD is a lisp value: 0 to ignore keyboard input, or @@ -4209,7 +4201,7 @@ Otherwise, return true if we received input from any process. */ int -wait_reading_process_output (int time_limit, int microsecs, int read_kbd, +wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd, int do_display, Lisp_Object wait_for_cell, struct Lisp_Process *wait_proc, int just_wait_proc) @@ -4229,7 +4221,7 @@ FD_ZERO (&Available); FD_ZERO (&Writeok); - if (time_limit == 0 && microsecs == 0 && wait_proc && !NILP (Vinhibit_quit) + if (time_limit == 0 && nsecs == 0 && wait_proc && !NILP (Vinhibit_quit) && !(CONSP (wait_proc->status) && EQ (XCAR (wait_proc->status), Qexit))) message ("Blocking call to accept-process-output with quit inhibited!!"); @@ -4241,12 +4233,20 @@ make_number (waiting_for_user_input_p)); waiting_for_user_input_p = read_kbd; + if (time_limit < 0) + { + time_limit = 0; + nsecs = -1; + } + else if (TYPE_MAXIMUM (time_t) < time_limit) + time_limit = TYPE_MAXIMUM (time_t); + /* Since we may need to wait several times, compute the absolute time to return at. */ - if (time_limit || microsecs) + if (time_limit || nsecs) /* FIXME neither should be negative, no? */ { EMACS_GET_TIME (end_time); - EMACS_SET_SECS_USECS (timeout, time_limit, microsecs); + EMACS_SET_SECS_NSECS (timeout, time_limit, nsecs); EMACS_ADD_TIME (end_time, end_time, timeout); } @@ -4270,7 +4270,7 @@ /* Compute time from now till when time limit is up */ /* Exit if already run out */ - if (time_limit == -1) + if (nsecs < 0) { /* -1 specified for timeout means gobble output available now @@ -4278,12 +4278,12 @@ EMACS_SET_SECS_USECS (timeout, 0, 0); } - else if (time_limit || microsecs) + else if (time_limit || nsecs) { EMACS_GET_TIME (timeout); + if (EMACS_TIME_LE (end_time, timeout)) + break; EMACS_SUB_TIME (timeout, end_time, timeout); - if (EMACS_TIME_NEG_P (timeout)) - break; } else { @@ -4329,21 +4329,22 @@ && requeued_events_pending_p ()) break; - if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1) - { - EMACS_TIME difference; - EMACS_SUB_TIME (difference, timer_delay, timeout); - if (EMACS_TIME_NEG_P (difference)) - { - timeout = timer_delay; - timeout_reduced_for_timers = 1; - } - } - /* If time_limit is -1, we are not going to wait at all. */ - else if (time_limit != -1) - { - /* This is so a breakpoint can be put here. */ - wait_reading_process_output_1 (); + /* If time_limit is negative, we are not going to wait at all. */ + if (0 <= nsecs) + { + if (EMACS_TIME_VALID_P (timer_delay)) + { + if (EMACS_TIME_LT (timer_delay, timeout)) + { + timeout = timer_delay; + timeout_reduced_for_timers = 1; + } + } + else + { + /* This is so a breakpoint can be put here. */ + wait_reading_process_output_1 (); + } } } @@ -4372,14 +4373,14 @@ Ctemp = write_mask; EMACS_SET_SECS_USECS (timeout, 0, 0); - if ((select (max (max_process_desc, max_input_desc) + 1, - &Atemp, + if ((pselect (max (max_process_desc, max_input_desc) + 1, + &Atemp, #ifdef NON_BLOCKING_CONNECT - (num_pending_connects > 0 ? &Ctemp : (SELECT_TYPE *)0), + (num_pending_connects > 0 ? &Ctemp : NULL), #else - (SELECT_TYPE *)0, + NULL, #endif - (SELECT_TYPE *)0, &timeout) + NULL, &timeout, NULL) <= 0)) { /* It's okay for us to do this and then continue with @@ -4502,9 +4503,9 @@ Vprocess_adaptive_read_buffering is nil. */ if (process_output_skip && check_delay > 0) { - int usecs = EMACS_USECS (timeout); - if (EMACS_SECS (timeout) > 0 || usecs > READ_OUTPUT_DELAY_MAX) - usecs = READ_OUTPUT_DELAY_MAX; + int nsecs = EMACS_NSECS (timeout); + if (EMACS_SECS (timeout) > 0 || nsecs > READ_OUTPUT_DELAY_MAX) + nsecs = READ_OUTPUT_DELAY_MAX; for (channel = 0; check_delay > 0 && channel <= max_process_desc; channel++) { proc = chan_process[channel]; @@ -4519,11 +4520,11 @@ continue; FD_CLR (channel, &Available); XPROCESS (proc)->read_output_skip = 0; - if (XPROCESS (proc)->read_output_delay < usecs) - usecs = XPROCESS (proc)->read_output_delay; + if (XPROCESS (proc)->read_output_delay < nsecs) + nsecs = XPROCESS (proc)->read_output_delay; } } - EMACS_SET_SECS_USECS (timeout, 0, usecs); + EMACS_SET_SECS_NSECS (timeout, 0, nsecs); process_output_skip = 0; } #endif @@ -4532,12 +4533,12 @@ #elif defined (HAVE_NS) nfds = ns_select #else - nfds = select + nfds = pselect #endif (max (max_process_desc, max_input_desc) + 1, &Available, (check_write ? &Writeok : (SELECT_TYPE *)0), - (SELECT_TYPE *)0, &timeout); + NULL, &timeout, NULL); #ifdef HAVE_GNUTLS /* GnuTLS buffers data internally. In lowat mode it leaves @@ -4564,7 +4565,7 @@ /* If we woke up due to SIGWINCH, actually change size now. */ do_pending_window_change (0); - if (time_limit && nfds == 0 && ! timeout_reduced_for_timers) + if ((time_limit || nsecs) && nfds == 0 && ! timeout_reduced_for_timers) /* We wanted the full specified time, so return now. */ break; if (nfds < 0) @@ -4716,7 +4717,7 @@ if (wait_channel == channel) { wait_channel = -1; - time_limit = -1; + nsecs = -1; got_some_input = 1; } proc = chan_process[channel]; @@ -5488,12 +5489,8 @@ else if (STRINGP (object)) offset = buf - SSDATA (object); -#ifdef EMACS_HAS_USECS - wait_reading_process_output (0, 20000, 0, 0, Qnil, NULL, 0); -#else - wait_reading_process_output (1, 0, 0, 0, Qnil, NULL, 0); -#endif - + wait_reading_process_output (0, 20 * 1000 * 1000, + 0, 0, Qnil, NULL, 0); if (BUFFERP (object)) buf = (char *) BUF_BYTE_ADDRESS (XBUFFER (object), offset); @@ -6647,9 +6644,15 @@ Wait for timeout to elapse and/or keyboard input to be available. time_limit is: - timeout in seconds, or - zero for no limit, or - -1 means gobble data immediately available but don't wait for any. + timeout in seconds + If negative, gobble data immediately available but don't wait for any. + + nsec is: + an additional duration to wait, measured in nanoseconds + If TIME_LIMIT is zero, then: + If NSEC == 0, there is no limit. + If NSEC > 0, the timeout consists of NSEC only. + If NSECS < 0, gobble data immediately, as if TIME_LIMIT were negative. read_kbd is a Lisp_Object: 0 to ignore keyboard input, or @@ -6666,7 +6669,7 @@ Return true if we received input from any process. */ int -wait_reading_process_output (int time_limit, int microsecs, int read_kbd, +wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd, int do_display, Lisp_Object wait_for_cell, struct Lisp_Process *wait_proc, int just_wait_proc) @@ -6676,11 +6679,19 @@ SELECT_TYPE waitchannels; int xerrno; + if (time_limit < 0) + { + time_limit = 0; + nsecs = -1; + } + else if (TYPE_MAXIMUM (time_t) < time_limit) + time_limit = TYPE_MAXIMUM (time_t); + /* What does time_limit really mean? */ - if (time_limit || microsecs) + if (time_limit || nsecs) /* FIXME: what if negative? */ { EMACS_GET_TIME (end_time); - EMACS_SET_SECS_USECS (timeout, time_limit, microsecs); + EMACS_SET_SECS_NSECS (timeout, time_limit, nsecs); EMACS_ADD_TIME (end_time, end_time, timeout); } @@ -6706,7 +6717,7 @@ /* Compute time from now till when time limit is up */ /* Exit if already run out */ - if (time_limit == -1) + if (nsecs < 0) { /* -1 specified for timeout means gobble output available now @@ -6714,12 +6725,12 @@ EMACS_SET_SECS_USECS (timeout, 0, 0); } - else if (time_limit || microsecs) + else if (time_limit || nsecs) { EMACS_GET_TIME (timeout); + if (EMACS_TIME_LE (end_time, timeout)) + break; EMACS_SUB_TIME (timeout, end_time, timeout); - if (EMACS_TIME_NEG_P (timeout)) - break; } else { @@ -6752,11 +6763,9 @@ && requeued_events_pending_p ()) break; - if (! EMACS_TIME_NEG_P (timer_delay) && time_limit != -1) + if (EMACS_TIME_VALID_P (timer_delay) && 0 <= nsecs) { - EMACS_TIME difference; - EMACS_SUB_TIME (difference, timer_delay, timeout); - if (EMACS_TIME_NEG_P (difference)) + if (EMACS_TIME_LT (timer_delay, timeout)) { timeout = timer_delay; timeout_reduced_for_timers = 1; @@ -6792,8 +6801,7 @@ FD_ZERO (&waitchannels); } else - nfds = select (1, &waitchannels, (SELECT_TYPE *)0, (SELECT_TYPE *)0, - &timeout); + nfds = pselect (1, &waitchannels, NULL, NULL, &timeout, NULL); xerrno = errno; @@ -6803,7 +6811,7 @@ /* If we woke up due to SIGWINCH, actually change size now. */ do_pending_window_change (0); - if (time_limit && nfds == 0 && ! timeout_reduced_for_timers) + if ((time_limit || nsecs) && nfds == 0 && ! timeout_reduced_for_timers) /* We waited the full specified time, so return now. */ break; @@ -7106,19 +7114,20 @@ majflt -- number of major page faults (number) cminflt -- cumulative number of minor page faults (number) cmajflt -- cumulative number of major page faults (number) - utime -- user time used by the process, in the (HIGH LOW USEC) format - stime -- system time used by the process, in the (HIGH LOW USEC) format - time -- sum of utime and stime, in the (HIGH LOW USEC) format - cutime -- user time used by the process and its children, (HIGH LOW USEC) - cstime -- system time used by the process and its children, (HIGH LOW USEC) - ctime -- sum of cutime and cstime, in the (HIGH LOW USEC) format + utime -- user time used by the process, in (current-time) format, + which is a list of integers (HIGH LOW USEC PSEC) + stime -- system time used by the process (current-time) + time -- sum of utime and stime (current-time) + cutime -- user time used by the process and its children (current-time) + cstime -- system time used by the process and its children (current-time) + ctime -- sum of cutime and cstime (current-time) pri -- priority of the process (number) nice -- nice value of the process (number) thcount -- process thread count (number) - start -- time the process started, in the (HIGH LOW USEC) format + start -- time the process started (current-time) vsize -- virtual memory size of the process in KB's (number) rss -- resident set size of the process in KB's (number) - etime -- elapsed time the process is running, in (HIGH LOW USEC) format + etime -- elapsed time the process is running, in (HIGH LOW USEC PSEC) format pcpu -- percents of CPU time used by the process (floating-point number) pmem -- percents of total physical memory used by process's resident set (floating-point number) === modified file 'src/process.h' --- src/process.h 2011-05-12 07:07:06 +0000 +++ src/process.h 2011-07-01 07:37:04 +0000 @@ -104,8 +104,8 @@ On some systems, e.g. GNU/Linux, Emacs is seen as an interactive app also when reading process output, meaning that process output can be read in as little as 1 byte at a - time. Value is micro-seconds to delay reading output from - this process. Range is 0 .. 50000. */ + time. Value is nanoseconds to delay reading output from + this process. Range is 0 .. 50 * 1000 * 1000. */ int read_output_delay; /* Should we delay reading output from this process. Initialized from `Vprocess_adaptive_read_buffering'. === modified file 'src/sysdep.c' --- src/sysdep.c 2011-06-25 08:40:38 +0000 +++ src/sysdep.c 2011-07-01 07:37:04 +0000 @@ -34,6 +34,7 @@ #include #include #include +#include #include "lisp.h" #include "sysselect.h" @@ -103,20 +104,6 @@ #include "syssignal.h" #include "systime.h" -#ifdef HAVE_UTIME_H -#include -#endif - -#ifndef HAVE_UTIMES -#ifndef HAVE_STRUCT_UTIMBUF -/* We want to use utime rather than utimes, but we couldn't find the - structure declaration. We'll use the traditional one. */ -struct utimbuf { - long actime; - long modtime; -}; -#endif -#endif static int emacs_get_tty (int, struct emacs_tty *); static int emacs_set_tty (int, struct emacs_tty *, int); @@ -2013,30 +2000,6 @@ #endif /* HPUX and not HAVE_PERROR */ /* - * Gettimeofday. Simulate as much as possible. Only accurate - * to nearest second. Emacs doesn't use tzp so ignore it for now. - * Only needed when subprocesses are defined. - */ - -#ifndef HAVE_GETTIMEOFDAY -#ifdef HAVE_TIMEVAL - -int -gettimeofday (struct timeval *tp, struct timezone *tzp) -{ - extern long time (long); - - tp->tv_sec = time ((long *)0); - tp->tv_usec = 0; - if (tzp != 0) - tzp->tz_minuteswest = -1; - return 0; -} - -#endif -#endif /* !HAVE_GETTIMEOFDAY && HAVE_TIMEVAL */ - -/* * This function will go away as soon as all the stubs fixed. (fnf) */ @@ -2072,20 +2035,43 @@ #endif /* HAVE_DIRENT_H */ +/* Return a struct timeval that is roughly equivalent to T. + Use the least timeval not less than T. + Return an extremal value if the result would overflow. */ +struct timeval +make_timeval (EMACS_TIME t) +{ + struct timeval tv; + tv.tv_sec = t.tv_sec; + tv.tv_usec = t.tv_nsec / 1000; + + if (t.tv_nsec % 1000 != 0) + { + if (tv.tv_usec < 999999) + tv.tv_usec++; + else if (tv.tv_sec < TYPE_MAXIMUM (time_t)) + { + tv.tv_sec++; + tv.tv_usec = 0; + } + } + + return tv; +} + +/* Set the access and modification time stamps of FD (a.k.a. FILE) to be + ATIME and MTIME, respectively. + FD must be either negative -- in which case it is ignored -- + or a file descriptor that is open on FILE. + If FD is nonnegative, then FILE can be NULL. */ int -set_file_times (const char *filename, EMACS_TIME atime, EMACS_TIME mtime) +set_file_times (int fd, const char *filename, + EMACS_TIME atime, EMACS_TIME mtime) { -#ifdef HAVE_UTIMES - struct timeval tv[2]; - tv[0] = atime; - tv[1] = mtime; - return utimes (filename, tv); -#else /* not HAVE_UTIMES */ - struct utimbuf utb; - utb.actime = EMACS_SECS (atime); - utb.modtime = EMACS_SECS (mtime); - return utime (filename, &utb); -#endif /* not HAVE_UTIMES */ + struct timespec timespec[2]; + timespec[0] = atime; + timespec[1] = mtime; + return fdutimens (fd, filename, timespec); } /* mkdir and rmdir functions, for systems which don't have them. */ @@ -2549,60 +2535,82 @@ #endif /* !defined (WINDOWSNT) */ #ifdef GNU_LINUX -static void -time_from_jiffies (unsigned long long tval, long hz, - time_t *sec, unsigned *usec) +static EMACS_TIME +time_from_jiffies (unsigned long long tval, long hz) { - unsigned long long ullsec; + unsigned long long s = tval / hz; + unsigned long long frac = tval % hz; + int ns; + EMACS_TIME t; - *sec = tval / hz; - ullsec = *sec; - tval -= ullsec * hz; - /* Careful: if HZ > 1 million, then integer division by it yields zero. */ - if (hz <= 1000000) - *usec = tval * 1000000 / hz; + if (TYPE_MAXIMUM (time_t) < s) + time_overflow (); + if (LONG_MAX - 1 <= ULLONG_MAX / EMACS_TIME_RESOLUTION + || frac <= ULLONG_MAX / EMACS_TIME_RESOLUTION) + ns = frac * EMACS_TIME_RESOLUTION / hz; else - *usec = tval / (hz / 1000000); + { + /* This is reachable only in the unlikely case that HZ * HZ + exceeds ULLONG_MAX. It calculates an approximation that is + guaranteed to be in range. */ + long hz_per_ns = (hz / EMACS_TIME_RESOLUTION + + (hz % EMACS_TIME_RESOLUTION != 0)); + ns = frac / hz_per_ns; + } + + EMACS_SET_SECS_NSECS (t, s, ns); + return t; } static Lisp_Object ltime_from_jiffies (unsigned long long tval, long hz) { - time_t sec; - unsigned usec; - - time_from_jiffies (tval, hz, &sec, &usec); - - return list3 (make_number ((sec >> 16) & 0xffff), - make_number (sec & 0xffff), - make_number (usec)); + EMACS_TIME t = time_from_jiffies (tval, hz); + return make_lisp_time (t); } -static void -get_up_time (time_t *sec, unsigned *usec) +static EMACS_TIME +get_up_time (void) { FILE *fup; + EMACS_TIME up; - *sec = *usec = 0; + EMACS_SET_SECS_NSECS (up, 0, 0); BLOCK_INPUT; fup = fopen ("/proc/uptime", "r"); if (fup) { - double uptime, idletime; + unsigned long long upsec, upfrac, idlesec, idlefrac; + int upfrac_start, upfrac_end, idlefrac_start, idlefrac_end; - /* The numbers in /proc/uptime use C-locale decimal point, but - we already set ourselves to the C locale (see `fixup_locale' - in emacs.c). */ - if (2 <= fscanf (fup, "%lf %lf", &uptime, &idletime)) + if (fscanf (fup, "%llu.%n%llu%n %llu.%n%llu%n", + &upsec, &upfrac_start, &upfrac, &upfrac_end, + &idlesec, &idlefrac_start, &idlefrac, &idlefrac_end) + == 4) { - *sec = uptime; - *usec = (uptime - *sec) * 1000000; + if (TYPE_MAXIMUM (time_t) < upsec) + { + upsec = TYPE_MAXIMUM (time_t); + upfrac = EMACS_TIME_RESOLUTION - 1; + } + else + { + int upfraclen = upfrac_end - upfrac_start; + for (; upfraclen < LOG10_EMACS_TIME_RESOLUTION; upfraclen++) + upfrac *= 10; + for (; LOG10_EMACS_TIME_RESOLUTION < upfraclen; upfraclen--) + upfrac /= 10; + upfrac = min (upfrac, EMACS_TIME_RESOLUTION - 1); + } + EMACS_SET_SECS_NSECS (up, upsec, upfrac); } fclose (fup); } UNBLOCK_INPUT; + + return up; } #define MAJOR(d) (((unsigned)(d) >> 8) & 0xfff) @@ -2701,7 +2709,7 @@ unsigned long minflt, majflt, cminflt, cmajflt, vsize; time_t sec; unsigned usec; - EMACS_TIME tnow, tstart, tboot, telapsed; + EMACS_TIME tnow, tstart, tboot, telapsed, us_time; double pcpu, pmem; Lisp_Object attrs = Qnil; Lisp_Object cmd_str, decoded_cmd, tem; @@ -2828,35 +2836,18 @@ attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs); attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount_eint)), attrs); EMACS_GET_TIME (tnow); - get_up_time (&sec, &usec); - EMACS_SET_SECS (telapsed, sec); - EMACS_SET_USECS (telapsed, usec); + telapsed = get_up_time (); EMACS_SUB_TIME (tboot, tnow, telapsed); - time_from_jiffies (start, clocks_per_sec, &sec, &usec); - EMACS_SET_SECS (tstart, sec); - EMACS_SET_USECS (tstart, usec); + tstart = time_from_jiffies (start, clocks_per_sec); EMACS_ADD_TIME (tstart, tboot, tstart); - attrs = Fcons (Fcons (Qstart, - list3 (make_number - ((EMACS_SECS (tstart) >> 16) & 0xffff), - make_number - (EMACS_SECS (tstart) & 0xffff), - make_number - (EMACS_USECS (tstart)))), - attrs); + attrs = Fcons (Fcons (Qstart, make_lisp_time (tstart)), attrs); attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize/1024)), attrs); attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4*rss)), attrs); EMACS_SUB_TIME (telapsed, tnow, tstart); - attrs = Fcons (Fcons (Qetime, - list3 (make_number - ((EMACS_SECS (telapsed) >> 16) & 0xffff), - make_number - (EMACS_SECS (telapsed) & 0xffff), - make_number - (EMACS_USECS (telapsed)))), - attrs); - time_from_jiffies (u_time + s_time, clocks_per_sec, &sec, &usec); - pcpu = (sec + usec / 1000000.0) / (EMACS_SECS (telapsed) + EMACS_USECS (telapsed) / 1000000.0); + attrs = Fcons (Fcons (Qetime, make_lisp_time (telapsed)), attrs); + us_time = time_from_jiffies (u_time + s_time, clocks_per_sec); + pcpu = (EMACS_TIME_TO_DOUBLE (us_time) + / EMACS_TIME_TO_DOUBLE (telapsed)); if (pcpu > 1.0) pcpu = 1.0; attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs); @@ -3037,27 +3028,13 @@ Qcstime Are they available? */ - attrs = Fcons (Fcons (Qtime, - list3 (make_number (pinfo.pr_time.tv_sec >> 16), - make_number (pinfo.pr_time.tv_sec & 0xffff), - make_number (pinfo.pr_time.tv_nsec))), - attrs); - - attrs = Fcons (Fcons (Qctime, - list3 (make_number (pinfo.pr_ctime.tv_sec >> 16), - make_number (pinfo.pr_ctime.tv_sec & 0xffff), - make_number (pinfo.pr_ctime.tv_nsec))), - attrs); - + attrs = Fcons (Fcons (Qtime, make_lisp_time (pinfo.pr_time)), attrs); + attrs = Fcons (Fcons (Qctime, make_lisp_time (pinfo.pr_ctime)), attrs); attrs = Fcons (Fcons (Qpri, make_number (pinfo.pr_lwp.pr_pri)), attrs); attrs = Fcons (Fcons (Qnice, make_number (pinfo.pr_lwp.pr_nice)), attrs); attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (pinfo.pr_nlwp)), attrs); - attrs = Fcons (Fcons (Qstart, - list3 (make_number (pinfo.pr_start.tv_sec >> 16), - make_number (pinfo.pr_start.tv_sec & 0xffff), - make_number (pinfo.pr_start.tv_nsec))), - attrs); + attrs = Fcons (Fcons (Qstart, make_lisp_time (pinfo.pr_start.tv_sec)), attrs); attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (pinfo.pr_size)), attrs); attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (pinfo.pr_rssize)), attrs); === modified file 'src/sysselect.h' --- src/sysselect.h 2011-01-25 04:08:28 +0000 +++ src/sysselect.h 2011-07-01 07:37:04 +0000 @@ -16,7 +16,6 @@ You should have received a copy of the GNU General Public License along with GNU Emacs. If not, see . */ -#ifdef HAVE_SYS_SELECT_H #if defined (DARWIN_OS) #undef init_process #endif @@ -24,7 +23,6 @@ #if defined (DARWIN_OS) #define init_process emacs_init_process #endif -#endif /* The w32 build defines select stuff in w32.h, which is included where w32 needs it, but not where sysselect.h is included. The w32 @@ -52,4 +50,3 @@ #if !defined (HAVE_SELECT) #define select sys_select #endif - === modified file 'src/systime.h' --- src/systime.h 2011-05-20 06:37:13 +0000 +++ src/systime.h 2011-07-04 08:09:05 +0000 @@ -19,16 +19,7 @@ #ifndef EMACS_SYSTIME_H #define EMACS_SYSTIME_H -#ifdef TIME_WITH_SYS_TIME -#include -#include -#else -#ifdef HAVE_SYS_TIME_H -#include -#else -#include -#endif -#endif +#include #ifdef emacs # ifdef HAVE_X_WINDOWS @@ -59,91 +50,64 @@ #endif #endif -/* EMACS_TIME is the type to use to represent temporal intervals - - struct timeval on some systems, int on others. It can be passed as - the timeout argument to the select system call. - - EMACS_SECS (TIME) is an rvalue for the seconds component of TIME. +/* The type to use to represent temporal intervals. It can be passed + as the timeout argument to the pselect system call. */ +#define EMACS_TIME struct timespec + +/* Resolution of EMACS_TIME time stamps (in units per second), and log + base 10 of the resolution. The log must be a positive integer. */ +#define EMACS_TIME_RESOLUTION 1000000000 +#define LOG10_EMACS_TIME_RESOLUTION 9 + +/* EMACS_SECS (TIME) is an rvalue for the seconds component of TIME. + EMACS_ADDR_SECS (time) is the address of the seconds component. EMACS_SET_SECS (TIME, SECONDS) sets that to SECONDS. - EMACS_HAS_USECS is defined if EMACS_TIME has a usecs component. - EMACS_USECS (TIME) is an rvalue for the microseconds component of TIME. - This returns zero if EMACS_TIME doesn't have a microseconds component. - EMACS_SET_USECS (TIME, MICROSECONDS) sets that to MICROSECONDS. - This does nothing if EMACS_TIME doesn't have a microseconds component. - - EMACS_SET_SECS_USECS (TIME, SECS, USECS) sets both components of TIME. - - EMACS_GET_TIME (TIME) stores the current system time in TIME, which - should be an lvalue. - - EMACS_ADD_TIME (DEST, SRC1, SRC2) adds SRC1 to SRC2 and stores the - result in DEST. SRC should not be negative. - - EMACS_SUB_TIME (DEST, SRC1, SRC2) subtracts SRC2 from SRC1 and - stores the result in DEST. SRC should not be negative. - EMACS_TIME_NEG_P (TIME) is true if TIME is negative. - -*/ - -#ifdef HAVE_TIMEVAL - -#define EMACS_HAS_USECS - -#define EMACS_TIME struct timeval + EMACS_NSECS (TIME) is an rvalue for the nanoseconds component of TIME. + EMACS_SET_NSECS (TIME, NANOSECONDS) sets that to NANOSECONDS. + + EMACS_SET_SECS_NSECS (TIME, SECS, NSECS) sets both components of TIME. */ #define EMACS_SECS(time) ((time).tv_sec + 0) -#define EMACS_USECS(time) ((time).tv_usec + 0) +#define EMACS_NSECS(time) ((time).tv_nsec + 0) +#define EMACS_SECS_ADDR(time) (&(time).tv_sec) #define EMACS_SET_SECS(time, seconds) ((time).tv_sec = (seconds)) -#define EMACS_SET_USECS(time, microseconds) ((time).tv_usec = (microseconds)) - -/* On SVR4, the compiler may complain if given this extra BSD arg. */ -#ifdef GETTIMEOFDAY_ONE_ARGUMENT -#define EMACS_GET_TIME(time) gettimeofday (&(time)) -#else /* not GETTIMEOFDAY_ONE_ARGUMENT */ -/* Presumably the second arg is ignored. */ -#define EMACS_GET_TIME(time) gettimeofday (&(time), NULL) -#endif /* not GETTIMEOFDAY_ONE_ARGUMENT */ - -#define EMACS_ADD_TIME(dest, src1, src2) \ - do { \ - (dest).tv_sec = (src1).tv_sec + (src2).tv_sec; \ - (dest).tv_usec = (src1).tv_usec + (src2).tv_usec; \ - if ((dest).tv_usec > 1000000) \ - (dest).tv_usec -= 1000000, (dest).tv_sec++; \ - } while (0) - -#define EMACS_SUB_TIME(dest, src1, src2) \ - do { \ - (dest).tv_sec = (src1).tv_sec - (src2).tv_sec; \ - (dest).tv_usec = (src1).tv_usec - (src2).tv_usec; \ - if ((dest).tv_usec < 0) \ - (dest).tv_usec += 1000000, (dest).tv_sec--; \ - } while (0) - -#define EMACS_TIME_NEG_P(time) \ - ((long)(time).tv_sec < 0 \ - || ((time).tv_sec == 0 \ - && (long)(time).tv_usec < 0)) - -#else /* ! defined (HAVE_TIMEVAL) */ - -#define EMACS_TIME int -#define EMACS_SECS(time) (time) -#define EMACS_USECS(time) 0 -#define EMACS_SET_SECS(time, seconds) ((time) = (seconds)) -#define EMACS_SET_USECS(time, usecs) 0 - -#define EMACS_GET_TIME(t) ((t) = time ((long *) 0)) -#define EMACS_ADD_TIME(dest, src1, src2) ((dest) = (src1) + (src2)) -#define EMACS_SUB_TIME(dest, src1, src2) ((dest) = (src1) - (src2)) -#define EMACS_TIME_NEG_P(t) ((t) < 0) - -#endif /* ! defined (HAVE_TIMEVAL) */ - +#define EMACS_SET_NSECS(time, ns) ((time).tv_nsec = (ns)) +#define EMACS_SET_SECS_NSECS(time, s, ns) \ + ((void) (EMACS_SET_SECS (time, s), EMACS_SET_NSECS (time, ns))) + +/* Convenience macros for older code that counts microseconds. */ +#define EMACS_SET_USECS(time, us) ((void) EMACS_SET_NSECS (time, (us) * 1000)) #define EMACS_SET_SECS_USECS(time, secs, usecs) \ (EMACS_SET_SECS (time, secs), EMACS_SET_USECS (time, usecs)) -extern int set_file_times (const char *, EMACS_TIME, EMACS_TIME); +/* Set TIME to an invalid time stamp. */ +#define EMACS_SET_INVALID_TIME(time) EMACS_SET_SECS_NSECS(time, 0, -1) + +/* Set TIME to the current system time. */ +#define EMACS_GET_TIME(time) gettime (&(time)) + +/* Put into DEST the result of adding SRC1 to SRC2, or of subtracting + SRC2 from SRC1. On overflow, store an extremal value. */ +#define EMACS_ADD_TIME(dest, src1, src2) ((dest) = timespec_add (src1, src2)) +#define EMACS_SUB_TIME(dest, src1, src2) ((dest) = timespec_sub (src1, src2)) + +/* Return the sign of the valid time stamp TIME, either -1, 0, or 1. */ +#define EMACS_TIME_SIGN(time) timespec_sign (time) + +/* Return 1 if TIME is a valid time stamp. */ +#define EMACS_TIME_VALID_P(time) (0 <= (time).tv_nsec) + +/* Convert the double D to the greatest EMACS_TIME not greater than D. + On overflow, return an extremal value. Return the minimum + EMACS_TIME if D is not a number. */ +#define EMACS_TIME_FROM_DOUBLE(d) dtotimespec (d) + +/* Convert the Emacs time T to an approximate double value D. */ +#define EMACS_TIME_TO_DOUBLE(t) timespectod (t) + +/* defined in sysdep.c */ +extern int set_file_times (int, const char *, EMACS_TIME, EMACS_TIME); +extern struct timeval make_timeval (EMACS_TIME); /* defined in keyboard.c */ extern void set_waiting_for_input (EMACS_TIME *); @@ -152,29 +116,20 @@ happen when this files is used outside the src directory). Use GCPRO1 to determine if lisp.h was included. */ #ifdef GCPRO1 -/* defined in editfns.c*/ -extern Lisp_Object make_time (time_t); -extern int lisp_time_argument (Lisp_Object, time_t *, int *); +/* defined in editfns.c */ +extern Lisp_Object make_lisp_time (EMACS_TIME); +extern int decode_time_components (Lisp_Object, Lisp_Object, Lisp_Object, + Lisp_Object, EMACS_TIME *, int *); +extern EMACS_TIME lisp_time_argument (Lisp_Object, int *); #endif -/* Compare times T1 and T2. Value is 0 if T1 and T2 are the same. - Value is < 0 if T1 is less than T2. Value is > 0 otherwise. (Cast - to long is for those platforms where time_t is an unsigned - type, and where otherwise T1 will always be grater than T2.) */ - -#define EMACS_TIME_CMP(T1, T2) \ - ((long)EMACS_SECS (T1) - (long)EMACS_SECS (T2) \ - + (EMACS_SECS (T1) == EMACS_SECS (T2) \ - ? EMACS_USECS (T1) - EMACS_USECS (T2) \ - : 0)) - /* Compare times T1 and T2 for equality, inequality etc. */ -#define EMACS_TIME_EQ(T1, T2) (EMACS_TIME_CMP (T1, T2) == 0) -#define EMACS_TIME_NE(T1, T2) (EMACS_TIME_CMP (T1, T2) != 0) -#define EMACS_TIME_GT(T1, T2) (EMACS_TIME_CMP (T1, T2) > 0) -#define EMACS_TIME_GE(T1, T2) (EMACS_TIME_CMP (T1, T2) >= 0) -#define EMACS_TIME_LT(T1, T2) (EMACS_TIME_CMP (T1, T2) < 0) -#define EMACS_TIME_LE(T1, T2) (EMACS_TIME_CMP (T1, T2) <= 0) +#define EMACS_TIME_EQ(T1, T2) (timespec_cmp (T1, T2) == 0) +#define EMACS_TIME_NE(T1, T2) (timespec_cmp (T1, T2) != 0) +#define EMACS_TIME_GT(T1, T2) (timespec_cmp (T1, T2) > 0) +#define EMACS_TIME_GE(T1, T2) (timespec_cmp (T1, T2) >= 0) +#define EMACS_TIME_LT(T1, T2) (timespec_cmp (T1, T2) < 0) +#define EMACS_TIME_LE(T1, T2) (timespec_cmp (T1, T2) <= 0) #endif /* EMACS_SYSTIME_H */ === modified file 'src/term.c' --- src/term.c 2011-05-18 00:39:40 +0000 +++ src/term.c 2011-07-01 07:37:04 +0000 @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -2683,6 +2684,18 @@ return 0; } +/* Return the Time that corresponds to T. Wrap around on overflow. */ +static Time +timeval_to_Time (struct timeval const *t) +{ + Time s_1000, ms; + + s_1000 = t->tv_sec; + s_1000 *= 1000; + ms = t->tv_usec / 1000; + return s_1000 + ms; +} + /* Return the current position of the mouse. Set *f to the frame the mouse is in, or zero if the mouse is in no @@ -2702,7 +2715,6 @@ Lisp_Object *y, Time *timeptr) { struct timeval now; - Time sec, usec; *fp = SELECTED_FRAME (); (*fp)->mouse_moved = 0; @@ -2713,9 +2725,7 @@ XSETINT (*x, last_mouse_x); XSETINT (*y, last_mouse_y); gettimeofday(&now, 0); - sec = now.tv_sec; - usec = now.tv_usec; - *timeptr = (sec * 1000) + (usec / 1000); + *timeptr = timeval_to_Time (&now); } /* Prepare a mouse-event in *RESULT for placement in the input queue. @@ -2739,7 +2749,7 @@ } } gettimeofday(&now, 0); - result->timestamp = (now.tv_sec * 1000) + (now.tv_usec / 1000); + result->timestamp = timeval_to_Time (&now); if (event->type & GPM_UP) result->modifiers = up_modifier; === modified file 'src/undo.c' --- src/undo.c 2011-06-24 21:25:22 +0000 +++ src/undo.c 2011-07-04 08:09:05 +0000 @@ -225,7 +225,7 @@ base_buffer = base_buffer->base_buffer; BVAR (current_buffer, undo_list) = - Fcons (Fcons (Qt, INTEGER_TO_CONS (base_buffer->modtime)), + Fcons (Fcons (Qt, make_lisp_time (base_buffer->modtime)), BVAR (current_buffer, undo_list)); } @@ -497,10 +497,23 @@ cdr = XCDR (next); if (EQ (car, Qt)) { - /* Element (t high . low) records previous modtime. */ + /* Element (t . TIME) records previous modtime. + Preserve any flag of NONEXISTENT_MODTIME_NSECS or + UNKNOWN_MODTIME_NSECS. */ struct buffer *base_buffer = current_buffer; - time_t mod_time; - CONS_TO_INTEGER (cdr, time_t, mod_time); + EMACS_TIME mod_time; + + if (CONSP (cdr) + && CONSP (XCDR (cdr)) + && CONSP (XCDR (XCDR (cdr))) + && CONSP (XCDR (XCDR (XCDR (cdr)))) + && INTEGERP (XCAR (XCDR (XCDR (XCDR (cdr))))) + && XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) < 0) + EMACS_SET_SECS_NSECS + (mod_time, 0, + XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) / 1000); + else + mod_time = lisp_time_argument (cdr, 0); if (current_buffer->base_buffer) base_buffer = current_buffer->base_buffer; @@ -508,7 +521,7 @@ /* If this records an obsolete save (not matching the actual disk file) then don't mark unmodified. */ - if (mod_time != base_buffer->modtime) + if (EMACS_TIME_NE (mod_time, base_buffer->modtime)) continue; #ifdef CLASH_DETECTION Funlock_buffer (); === modified file 'src/w32.c' --- src/w32.c 2011-06-24 21:25:22 +0000 +++ src/w32.c 2011-07-04 08:09:05 +0000 @@ -316,8 +316,10 @@ return s_b_ret; } +static Lisp_Object ltime (ULONGLONG); + /* Get total user and system times for get-internal-run-time. - Returns a list of three integers if the times are provided by the OS + Returns a list of integers if the times are provided by the OS (NT derivatives), otherwise it returns the result of current-time. */ Lisp_Object w32_get_internal_run_time (void) @@ -329,27 +331,13 @@ if ((*get_process_times_fn) (proc, &create, &exit, &kernel, &user)) { LARGE_INTEGER user_int, kernel_int, total; - int microseconds; + int time_100ns; user_int.LowPart = user.dwLowDateTime; user_int.HighPart = user.dwHighDateTime; kernel_int.LowPart = kernel.dwLowDateTime; kernel_int.HighPart = kernel.dwHighDateTime; total.QuadPart = user_int.QuadPart + kernel_int.QuadPart; - /* FILETIME is 100 nanosecond increments, Emacs only wants - microsecond resolution. */ - total.QuadPart /= 10; - microseconds = total.QuadPart % 1000000; - total.QuadPart /= 1000000; - - /* Sanity check to make sure we can represent the result. */ - if (total.HighPart == 0) - { - int secs = total.LowPart; - - return list3 (make_number ((secs >> 16) & 0xffff), - make_number (secs & 0xffff), - make_number (microseconds)); - } + return ltime (total.QuadPart); } } @@ -4004,15 +3992,17 @@ return ret_val; } -static Lisp_Object -ltime (long time_sec, long time_usec) +ltime (ULONGLONG time_100ns) { - return list3 (make_number ((time_sec >> 16) & 0xffff), + ULONGLONG time_sec = time_100ns / 10000000; + int subsec = time_100ns % 10000000; + return list4 (make_number (time_sec >> 16), make_number (time_sec & 0xffff), - make_number (time_usec)); + make_number (subsec / 10), + make_number (subsec % 10 * 100000)); } -#define U64_TO_LISP_TIME(time) ltime ((time) / 1000000L, (time) % 1000000L) +#define U64_TO_LISP_TIME(time) ltime (time) static int process_times (HANDLE h_proc, Lisp_Object *ctime, Lisp_Object *etime, @@ -4031,11 +4021,9 @@ GetSystemTimeAsFileTime (&ft_current); FILETIME_TO_U64 (tem1, ft_kernel); - tem1 /= 10L; *stime = U64_TO_LISP_TIME (tem1); FILETIME_TO_U64 (tem2, ft_user); - tem2 /= 10L; *utime = U64_TO_LISP_TIME (tem2); tem3 = tem1 + tem2; @@ -4044,13 +4032,13 @@ FILETIME_TO_U64 (tem, ft_creation); /* Process no 4 (System) returns zero creation time. */ if (tem) - tem = (tem - utc_base) / 10L; + tem -= utc_base; *ctime = U64_TO_LISP_TIME (tem); if (tem) { FILETIME_TO_U64 (tem3, ft_current); - tem = (tem3 - utc_base) / 10L - tem; + tem = (tem3 - utc_base) - tem; } *etime = U64_TO_LISP_TIME (tem); @@ -6198,7 +6186,7 @@ { int n, sc, err; SELECT_TYPE fdset; - EMACS_TIME timeout; + struct timeval timeout; struct Lisp_Process *process = (struct Lisp_Process *)p; int fd = process->infd; @@ -6214,7 +6202,8 @@ if (err == EWOULDBLOCK) { /* Set a small timeout. */ - EMACS_SET_SECS_USECS(timeout, 1, 0); + timeout.tv_sec = 1; + timeout.tv_usec = 0; FD_ZERO (&fdset); FD_SET ((int)fd, &fdset); === modified file 'src/xdisp.c' --- src/xdisp.c 2011-06-24 21:25:22 +0000 +++ src/xdisp.c 2011-07-01 07:37:04 +0000 @@ -27098,25 +27098,20 @@ { #if defined (HAVE_WINDOW_SYSTEM) EMACS_TIME delay; - int secs, usecs = 0; cancel_hourglass (); if (INTEGERP (Vhourglass_delay) && XINT (Vhourglass_delay) > 0) - secs = XFASTINT (Vhourglass_delay); + EMACS_SET_SECS_NSECS (delay, + min (XINT (Vhourglass_delay), TYPE_MAXIMUM (time_t)), + 0); else if (FLOATP (Vhourglass_delay) && XFLOAT_DATA (Vhourglass_delay) > 0) - { - Lisp_Object tem; - tem = Ftruncate (Vhourglass_delay, Qnil); - secs = XFASTINT (tem); - usecs = (XFLOAT_DATA (Vhourglass_delay) - secs) * 1000000; - } + delay = EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (Vhourglass_delay)); else - secs = DEFAULT_HOURGLASS_DELAY; + EMACS_SET_SECS_NSECS (delay, DEFAULT_HOURGLASS_DELAY, 0); - EMACS_SET_SECS_USECS (delay, secs, usecs); hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay, show_hourglass, NULL); #endif === modified file 'src/xgselect.c' --- src/xgselect.c 2011-07-01 09:18:46 +0000 +++ src/xgselect.c 2011-07-01 20:41:12 +0000 @@ -33,14 +33,14 @@ int xg_select (int max_fds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds, - EMACS_TIME *timeout) + EMACS_TIME *timeout, sigset_t *sigmask) { SELECT_TYPE all_rfds, all_wfds; EMACS_TIME tmo, *tmop = timeout; GMainContext *context = g_main_context_default (); int have_wfds = wfds != NULL; - int n_gfds = 0, our_tmo = 0, retval = 0, our_fds = 0; + int n_gfds = 0, retval = 0, our_fds = 0; int i, nfds, tmo_in_millisec; if (rfds) memcpy (&all_rfds, rfds, sizeof (all_rfds)); @@ -86,20 +86,12 @@ { EMACS_SET_SECS_USECS (tmo, tmo_in_millisec/1000, 1000 * (tmo_in_millisec % 1000)); - if (!timeout) our_tmo = 1; - else - { - EMACS_TIME difference; - - EMACS_SUB_TIME (difference, tmo, *timeout); - if (EMACS_TIME_NEG_P (difference)) our_tmo = 1; - } - - if (our_tmo) tmop = &tmo; + if (!timeout || EMACS_TIME_LT (tmo, *timeout)) + tmop = &tmo; } - nfds = select (max_fds+1, &all_rfds, have_wfds ? &all_wfds : NULL, - efds, tmop); + nfds = pselect (max_fds+1, &all_rfds, have_wfds ? &all_wfds : NULL, + efds, tmop, sigmask); if (nfds < 0) retval = nfds; @@ -128,7 +120,7 @@ } } - if (our_fds > 0 || (nfds == 0 && our_tmo)) + if (our_fds > 0 || (nfds == 0 && tmop == &tmo)) { /* If Gtk+ is in use eventually gtk_main_iteration will be called, === modified file 'src/xgselect.h' --- src/xgselect.h 2011-01-26 08:36:39 +0000 +++ src/xgselect.h 2011-07-01 07:37:04 +0000 @@ -28,9 +28,9 @@ SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds, - EMACS_TIME *timeout); + EMACS_TIME *timeout, + sigset_t *sigmask); extern void xgselect_initialize (void); #endif /* XGSELECT_H */ - === modified file 'src/xmenu.c' --- src/xmenu.c 2011-06-24 21:25:22 +0000 +++ src/xmenu.c 2011-07-01 07:37:04 +0000 @@ -388,8 +388,6 @@ ) { EMACS_TIME next_time = timer_check (), *ntp; - long secs = EMACS_SECS (next_time); - long usecs = EMACS_USECS (next_time); SELECT_TYPE read_fds; struct x_display_info *dpyinfo; int n = 0; @@ -403,12 +401,12 @@ XFlush (dpyinfo->display); } - if (secs < 0 && usecs < 0) + if (! EMACS_TIME_VALID_P (next_time)) ntp = 0; else ntp = &next_time; - select (n + 1, &read_fds, (SELECT_TYPE *)0, (SELECT_TYPE *)0, ntp); + pselect (n + 1, &read_fds, NULL, NULL, ntp, NULL); } } #endif /* ! MSDOS */ === modified file 'src/xselect.c' --- src/xselect.c 2011-06-21 02:16:54 +0000 +++ src/xselect.c 2011-07-01 07:37:04 +0000 @@ -1118,7 +1118,6 @@ static void wait_for_property_change (struct prop_location *location) { - int secs, usecs; int count = SPECPDL_INDEX (); if (property_change_reply_object) @@ -1135,10 +1134,11 @@ property_change_reply, because property_change_reply_object says so. */ if (! location->arrived) { - secs = x_selection_timeout / 1000; - usecs = (x_selection_timeout % 1000) * 1000; - TRACE2 (" Waiting %d secs, %d usecs", secs, usecs); - wait_reading_process_output (secs, usecs, 0, 0, + EMACS_INT timeout = max (0, x_selection_timeout); + EMACS_INT secs = timeout / 1000; + int nsecs = (timeout % 1000) * 1000000; + TRACE2 (" Waiting %"pI"d secs, %d nsecs", secs, nsecs); + wait_reading_process_output (secs, nsecs, 0, 0, property_change_reply, NULL, 0); if (NILP (XCAR (property_change_reply))) @@ -1207,7 +1207,8 @@ Atom type_atom = (CONSP (target_type) ? symbol_to_x_atom (dpyinfo, XCAR (target_type)) : symbol_to_x_atom (dpyinfo, target_type)); - int secs, usecs; + EMACS_INT timeout, secs; + int nsecs; if (!FRAME_LIVE_P (f)) return Qnil; @@ -1243,10 +1244,11 @@ UNBLOCK_INPUT; /* This allows quits. Also, don't wait forever. */ - secs = x_selection_timeout / 1000; - usecs = (x_selection_timeout % 1000) * 1000; - TRACE1 (" Start waiting %d secs for SelectionNotify", secs); - wait_reading_process_output (secs, usecs, 0, 0, + timeout = max (0, x_selection_timeout); + secs = timeout / 1000; + nsecs = (timeout % 1000) * 1000000; + TRACE1 (" Start waiting %"pI"d secs for SelectionNotify", secs); + wait_reading_process_output (secs, nsecs, 0, 0, reading_selection_reply, NULL, 0); TRACE1 (" Got event = %d", !NILP (XCAR (reading_selection_reply))); === modified file 'src/xterm.c' --- src/xterm.c 2011-06-24 21:25:22 +0000 +++ src/xterm.c 2011-07-01 07:37:04 +0000 @@ -85,10 +85,6 @@ #include #endif -#ifdef HAVE_SYS_TIME_H -#include -#endif - #include #ifdef USE_GTK @@ -2949,44 +2945,6 @@ /* Invert the middle quarter of the frame for .15 sec. */ -/* We use the select system call to do the waiting, so we have to make - sure it's available. If it isn't, we just won't do visual bells. */ - -#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) - - -/* Subtract the `struct timeval' values X and Y, storing the result in - *RESULT. Return 1 if the difference is negative, otherwise 0. */ - -static int -timeval_subtract (struct timeval *result, struct timeval x, struct timeval y) -{ - /* Perform the carry for the later subtraction by updating y. This - is safer because on some systems the tv_sec member is unsigned. */ - if (x.tv_usec < y.tv_usec) - { - int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1; - y.tv_usec -= 1000000 * nsec; - y.tv_sec += nsec; - } - - if (x.tv_usec - y.tv_usec > 1000000) - { - int nsec = (y.tv_usec - x.tv_usec) / 1000000; - y.tv_usec += 1000000 * nsec; - y.tv_sec -= nsec; - } - - /* Compute the time remaining to wait. tv_usec is certainly - positive. */ - result->tv_sec = x.tv_sec - y.tv_sec; - result->tv_usec = x.tv_usec - y.tv_usec; - - /* Return indication of whether the result should be considered - negative. */ - return x.tv_sec < y.tv_sec; -} - static void XTflash (struct frame *f) { @@ -3087,34 +3045,29 @@ x_flush (f); { - struct timeval wakeup; + EMACS_TIME wakeup, delay; EMACS_GET_TIME (wakeup); - - /* Compute time to wait until, propagating carry from usecs. */ - wakeup.tv_usec += 150000; - wakeup.tv_sec += (wakeup.tv_usec / 1000000); - wakeup.tv_usec %= 1000000; + EMACS_SET_SECS_NSECS (delay, 0, 150 * 1000 * 1000); + EMACS_ADD_TIME (wakeup, wakeup, delay); /* Keep waiting until past the time wakeup or any input gets available. */ while (! detect_input_pending ()) { - struct timeval current; - struct timeval timeout; + EMACS_TIME current, timeout; EMACS_GET_TIME (current); - /* Break if result would be negative. */ - if (timeval_subtract (¤t, wakeup, current)) + /* Break if result would not be positive. */ + if (EMACS_TIME_LE (wakeup, current)) break; /* How long `select' should wait. */ - timeout.tv_sec = 0; - timeout.tv_usec = 10000; + EMACS_SET_SECS_NSECS (timeout, 0, 10 * 1000 * 1000); /* Try to wait that long--but we might wake up sooner. */ - select (0, NULL, NULL, NULL, &timeout); + pselect (0, NULL, NULL, NULL, &timeout, NULL); } } @@ -3155,8 +3108,6 @@ UNBLOCK_INPUT; } -#endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */ - static void XTtoggle_invisible_pointer (FRAME_PTR f, int invisible) @@ -3183,11 +3134,9 @@ { if (FRAME_X_DISPLAY (f)) { -#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) if (visible_bell) XTflash (f); else -#endif { BLOCK_INPUT; XBell (FRAME_X_DISPLAY (f), 0); @@ -8713,9 +8662,11 @@ FD_SET (fd, &fds); EMACS_GET_TIME (time_now); + if (EMACS_TIME_LT (tmo_at, time_now)) + break; + EMACS_SUB_TIME (tmo, tmo_at, time_now); - - if (EMACS_TIME_NEG_P (tmo) || select (fd+1, &fds, NULL, NULL, &tmo) == 0) + if (pselect (fd + 1, &fds, NULL, NULL, &tmo, NULL) == 0) break; /* Timeout */ } pending_event_wait.f = 0; From debbugs-submit-bounces@debbugs.gnu.org Wed Jul 06 13:00:27 2011 Received: (at 9000) by debbugs.gnu.org; 6 Jul 2011 17:00:28 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1QeVSc-00058t-4o for submit@debbugs.gnu.org; Wed, 06 Jul 2011 13:00:27 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1QeVSX-0004wC-Em for 9000@debbugs.gnu.org; Wed, 06 Jul 2011 13:00:24 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 0AC7039E8118; Wed, 6 Jul 2011 10:00:16 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id evyXuFviZlpu; Wed, 6 Jul 2011 10:00:13 -0700 (PDT) Received: from [131.179.64.200] (Penguin.CS.UCLA.EDU [131.179.64.200]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 4FEE639E80F8; Wed, 6 Jul 2011 10:00:13 -0700 (PDT) Message-ID: <4E14949D.6030200@cs.ucla.edu> Date: Wed, 06 Jul 2011 10:00:13 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.17) Gecko/20110428 Fedora/3.1.10-1.fc14 Thunderbird/3.1.10 MIME-Version: 1.0 To: 9000@debbugs.gnu.org Subject: Update time patch for Frandom, pthread_sigmask, etc. References: <4E12B5BE.6070903@cs.ucla.edu> In-Reply-To: <4E12B5BE.6070903@cs.ucla.edu> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -3.1 (---) X-Debbugs-Envelope-To: 9000 Cc: Eli Zaretskii X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -3.1 (---) Here are three minor updates to the previous patch for high-resolution time stamps, to accommodate recent changes to Emacs and to gnulib. Almost all of this is automatically generated. I don't think this affects the Windows build (although the last patch builds a wrapper for signal.h, to support pthread_sigmask, this is irrelevant for Windows), but I'm sending this as a heads-up, just in case. * fns.c (Frandom): Use nanoseconds, not microseconds, for seed. =3D=3D=3D modified file 'src/fns.c' --- src/fns.c 2011-07-05 02:51:15 +0000 +++ src/fns.c 2011-07-06 16:32:00 +0000 @@ -84,7 +84,7 @@ { EMACS_TIME t; EMACS_GET_TIME (t); - seed_random (getpid () ^ EMACS_SECS (t) ^ EMACS_USECS (t)); + seed_random (getpid () ^ EMACS_SECS (t) ^ EMACS_NSECS (t)); } if (NATNUMP (limit) && XFASTINT (limit) !=3D 0) =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D * Makefile.in (GNULIB_TOOL_FLAGS): Add --avoid=3Dselect --avoid=3Dsigproc= mask. This trims down the gnulib import, from the very latest gnulib. Emacs does its own implementation of 'select' and 'sigprocmask' on Windows, and it assumes 'select' and 'sigprocmask' on non-Windows hosts, so it doesn't need these modules. =3D=3D=3D modified file 'Makefile.in' --- Makefile.in 2011-07-01 06:21:22 +0000 +++ Makefile.in 2011-07-06 16:24:49 +0000 @@ -340,6 +340,7 @@ symlink sys_stat sys_time \ time timespec-add timespec-sub utimens GNULIB_TOOL_FLAGS =3D \ + --avoid=3Dselect --avoid=3Dsigprocmask \ --conditional-dependencies --import --no-changelog --no-vc-files \ --makefile-name=3Dgnulib.mk sync-from-gnulib: $(gnulib_srcdir) =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D =3D=3D=3D modified file '.bzrignore' --- .bzrignore 2011-06-27 04:31:43 +0000 +++ .bzrignore 2011-07-06 16:49:44 +0000 @@ -52,6 +52,7 @@ lib/c++defs.h lib/getopt.h lib/inttypes.h +lib/signal.h lib/stdbool.h lib/stdio.h lib/stdint.h =3D=3D=3D modified file 'ChangeLog' --- ChangeLog 2011-07-06 16:42:05 +0000 +++ ChangeLog 2011-07-06 16:49:44 +0000 @@ -20,15 +20,18 @@ This contains just the automatically-generated stuff from gnulib; a later patch will contain the more-interesting stuff. * lib/dtotimespec.c, lib/errno.in.h, lib/gettime.c: - * lib/gettimeofday.c, lib/pselect.c, lib/stat-time.h, lib/strtoll.c: + * lib/gettimeofday.c, lib/pselect.c, lib/signal.in.h: + * lib/stat-time.h, lib/strtoll.c: * lib/sys_select.in.h, lib/sys_time.in.h, lib/timespec-add.c: * lib/timespec-sub.c, lib/timespec.h, lib/utimens.c, lib/utimens.h: * m4/clock_time.m4, m4/errno_h.m4, m4/gettime.m4, m4/gettimeofday.m4: - * m4/pselect.m4, m4/stat-time.m4, m4/strtoimax.m4, m4/strtoll.m4: + * m4/pselect.m4, m4/pthread_sigmask.m4, m4/signal_h.m4: + * m4/stat-time.m4, m4/strtoimax.m4, m4/strtoll.m4: * m4/sys_select_h.m4, m4/sys_socket_h.m4, m4/sys_time_h.m4: * m4/timespec.m4, m4/utimbuf.m4, m4/utimens.m4, m4/utimes.m4: New files, copied automatically from gnulib. * lib/gnulib.mk, m4/gl-comp.m4: Merge from gnulib. + * .bzrignore: Add lib/signal.h. =20 2011-07-05 Jan Dj=C3=A4rv =20 =3D=3D=3D modified file 'lib/gnulib.mk' --- lib/gnulib.mk 2011-07-01 06:13:09 +0000 +++ lib/gnulib.mk 2011-07-06 16:49:44 +0000 @@ -9,7 +9,7 @@ # the same distribution terms as the rest of that program. # # Generated by gnulib-tool. -# Reproduce by: gnulib-tool --import --dir=3D. --lib=3Dlibgnu --source-b= ase=3Dlib --m4-base=3Dm4 --doc-base=3Ddoc --tests-base=3Dtests --aux-dir=3D= . --makefile-name=3Dgnulib.mk --conditional-dependencies --no-libtool --m= acro-prefix=3Dgl --no-vc-files alloca-opt careadlinkat crypto/md5 crypto/= sha1 crypto/sha256 crypto/sha512 dtoastr dtotimespec dup2 filemode getloa= davg getopt-gnu gettime gettimeofday ignore-value intprops lstat mktime p= select readlink socklen stat-time stdarg stdio strftime strtoimax strtoum= ax symlink sys_stat sys_time time timespec-add timespec-sub utimens +# Reproduce by: gnulib-tool --import --dir=3D. --lib=3Dlibgnu --source-b= ase=3Dlib --m4-base=3Dm4 --doc-base=3Ddoc --tests-base=3Dtests --aux-dir=3D= . --avoid=3Dselect --avoid=3Dsigprocmask --makefile-name=3Dgnulib.mk --co= nditional-dependencies --no-libtool --macro-prefix=3Dgl --no-vc-files all= oca-opt careadlinkat crypto/md5 crypto/sha1 crypto/sha256 crypto/sha512 d= toastr dtotimespec dup2 filemode getloadavg getopt-gnu gettime gettimeofd= ay ignore-value intprops lstat mktime pselect readlink socklen stat-time = stdarg stdio strftime strtoimax strtoumax symlink sys_stat sys_time time = timespec-add timespec-sub utimens =20 =20 MOSTLYCLEANFILES +=3D core *.stackdump @@ -367,6 +367,44 @@ =20 ## end gnulib module readlink =20 +## begin gnulib module signal + +BUILT_SOURCES +=3D signal.h + +# We need the following in order to create when the system +# doesn't have a complete one. +signal.h: signal.in.h $(top_builddir)/config.status $(CXXDEFS_H) $(ARG_N= ONNULL_H) $(WARN_ON_USE_H) + $(AM_V_GEN)rm -f $@-t $@ && \ + { echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */' && \ + sed -e 's|@''GUARD_PREFIX''@|GL|g' \ + -e 's|@''INCLUDE_NEXT''@|$(INCLUDE_NEXT)|g' \ + -e 's|@''PRAGMA_SYSTEM_HEADER''@|@PRAGMA_SYSTEM_HEADER@|g' \ + -e 's|@''PRAGMA_COLUMNS''@|@PRAGMA_COLUMNS@|g' \ + -e 's|@''NEXT_SIGNAL_H''@|$(NEXT_SIGNAL_H)|g' \ + -e 's|@''GNULIB_PTHREAD_SIGMASK''@|$(GNULIB_PTHREAD_SIGMASK)|g' \ + -e 's/@''GNULIB_SIGNAL_H_SIGPIPE''@/$(GNULIB_SIGNAL_H_SIGPIPE)/g'= \ + -e 's/@''GNULIB_SIGPROCMASK''@/$(GNULIB_SIGPROCMASK)/g' \ + -e 's/@''GNULIB_SIGACTION''@/$(GNULIB_SIGACTION)/g' \ + -e 's|@''HAVE_POSIX_SIGNALBLOCKING''@|$(HAVE_POSIX_SIGNALBLOCKING= )|g' \ + -e 's|@''HAVE_SIGSET_T''@|$(HAVE_SIGSET_T)|g' \ + -e 's|@''HAVE_SIGINFO_T''@|$(HAVE_SIGINFO_T)|g' \ + -e 's|@''HAVE_SIGACTION''@|$(HAVE_SIGACTION)|g' \ + -e 's|@''HAVE_STRUCT_SIGACTION_SA_SIGACTION''@|$(HAVE_STRUCT_SIGA= CTION_SA_SIGACTION)|g' \ + -e 's|@''HAVE_TYPE_VOLATILE_SIG_ATOMIC_T''@|$(HAVE_TYPE_VOLATILE_= SIG_ATOMIC_T)|g' \ + -e 's|@''HAVE_SIGHANDLER_T''@|$(HAVE_SIGHANDLER_T)|g' \ + -e 's|@''REPLACE_PTHREAD_SIGMASK''@|$(REPLACE_PTHREAD_SIGMASK)|g'= \ + -e '/definitions of _GL_FUNCDECL_RPL/r $(CXXDEFS_H)' \ + -e '/definition of _GL_ARG_NONNULL/r $(ARG_NONNULL_H)' \ + -e '/definition of _GL_WARN_ON_USE/r $(WARN_ON_USE_H)' \ + < $(srcdir)/signal.in.h; \ + } > $@-t && \ + mv $@-t $@ +MOSTLYCLEANFILES +=3D signal.h signal.h-t + +EXTRA_DIST +=3D signal.in.h + +## end gnulib module signal + ## begin gnulib module stat =20 if gl_GNULIB_ENABLED_stat =3D=3D=3D modified file 'lib/pselect.c' --- lib/pselect.c 2011-07-01 06:13:09 +0000 +++ lib/pselect.c 2011-07-06 16:49:44 +0000 @@ -27,8 +27,6 @@ #include #include =20 -#undef pselect - /* Examine the size-NFDS file descriptor sets in RFDS, WFDS, and XFDS to see whether some of their descriptors are ready for reading, ready for writing, or have exceptions pending. Wait for at most @@ -37,10 +35,10 @@ or an unaffected signal mask. */ =20 int -rpl_pselect (int nfds, fd_set *restrict rfds, - fd_set *restrict wfds, fd_set *restrict xfds, - struct timespec const *restrict timeout, - sigset_t const *restrict sigmask) +pselect (int nfds, fd_set *restrict rfds, + fd_set *restrict wfds, fd_set *restrict xfds, + struct timespec const *restrict timeout, + sigset_t const *restrict sigmask) { int select_result; sigset_t origmask; @@ -64,14 +62,14 @@ /* Signal mask munging should be atomic, but this is the best we can do in this emulation. */ if (sigmask) - sigprocmask (SIG_SETMASK, sigmask, &origmask); + pthread_sigmask (SIG_SETMASK, sigmask, &origmask); =20 select_result =3D select (nfds, rfds, wfds, xfds, tvp); =20 if (sigmask) { int select_errno =3D errno; - sigprocmask (SIG_SETMASK, &origmask, NULL); + pthread_sigmask (SIG_SETMASK, &origmask, NULL); errno =3D select_errno; } =20 =3D=3D=3D added file 'lib/signal.in.h' --- lib/signal.in.h 1970-01-01 00:00:00 +0000 +++ lib/signal.in.h 2011-07-06 16:49:44 +0000 @@ -0,0 +1,392 @@ +/* A GNU-like . + + Copyright (C) 2006-2011 Free Software Foundation, Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see .= */ + +#if __GNUC__ >=3D 3 +@PRAGMA_SYSTEM_HEADER@ +#endif +@PRAGMA_COLUMNS@ + +#if defined __need_sig_atomic_t || defined __need_sigset_t +/* Special invocation convention inside glibc header files. */ + +# @INCLUDE_NEXT@ @NEXT_SIGNAL_H@ + +#else +/* Normal invocation convention. */ + +#ifndef _@GUARD_PREFIX@_SIGNAL_H + +/* Define pid_t, uid_t. + Also, mingw defines sigset_t not in , but in . + On Solaris 10, includes , which eventually in= cludes + us; so include now, before the second inclusion guard. = */ +#include + +/* The include_next requires a split double-inclusion guard. */ +#@INCLUDE_NEXT@ @NEXT_SIGNAL_H@ + +#ifndef _@GUARD_PREFIX@_SIGNAL_H +#define _@GUARD_PREFIX@_SIGNAL_H + +/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ + +/* The definition of _GL_ARG_NONNULL is copied here. */ + +/* The definition of _GL_WARN_ON_USE is copied here. */ + +/* On AIX, sig_atomic_t already includes volatile. C99 requires that + 'volatile sig_atomic_t' ignore the extra modifier, but C89 did not. + Hence, redefine this to a non-volatile type as needed. */ +#if ! @HAVE_TYPE_VOLATILE_SIG_ATOMIC_T@ +# if !GNULIB_defined_sig_atomic_t +typedef int rpl_sig_atomic_t; +# undef sig_atomic_t +# define sig_atomic_t rpl_sig_atomic_t +# define GNULIB_defined_sig_atomic_t 1 +# endif +#endif + +/* A set or mask of signals. */ +#if !@HAVE_SIGSET_T@ +# if !GNULIB_defined_sigset_t +typedef unsigned int sigset_t; +# define GNULIB_defined_sigset_t 1 +# endif +#endif + +/* Define sighandler_t, the type of signal handlers. A GNU extension. = */ +#if !@HAVE_SIGHANDLER_T@ +# ifdef __cplusplus +extern "C" { +# endif +# if !GNULIB_defined_sighandler_t +typedef void (*sighandler_t) (int); +# define GNULIB_defined_sighandler_t 1 +# endif +# ifdef __cplusplus +} +# endif +#endif + + +#if @GNULIB_SIGNAL_H_SIGPIPE@ +# ifndef SIGPIPE +/* Define SIGPIPE to a value that does not overlap with other signals. = */ +# define SIGPIPE 13 +# define GNULIB_defined_SIGPIPE 1 +/* To actually use SIGPIPE, you also need the gnulib modules 'sigprocmas= k', + 'write', 'stdio'. */ +# endif +#endif + + +/* Maximum signal number + 1. */ +#ifndef NSIG +# if defined __TANDEM +# define NSIG 32 +# endif +#endif + + +#if @GNULIB_PTHREAD_SIGMASK@ +# if @REPLACE_PTHREAD_SIGMASK@ +# undef pthread_sigmask +# define pthread_sigmask sigprocmask +# endif +#elif defined GNULIB_POSIXCHECK +# undef pthread_sigmask +# if HAVE_RAW_DECL_PTHREAD_SIGMASK +_GL_WARN_ON_USE (pthread_sigmask, "pthread_sigmask is not portable - " + "use gnulib module pthread_sigmask for portability"); +# endif +#endif + + +#if @GNULIB_SIGPROCMASK@ +# if !@HAVE_POSIX_SIGNALBLOCKING@ + +/* Maximum signal number + 1. */ +# ifndef NSIG +# define NSIG 32 +# endif + +/* This code supports only 32 signals. */ +# if !GNULIB_defined_verify_NSIG_constraint +typedef int verify_NSIG_constraint[NSIG <=3D 32 ? 1 : -1]; +# define GNULIB_defined_verify_NSIG_constraint 1 +# endif + +# endif + +/* Test whether a given signal is contained in a signal set. */ +# if @HAVE_POSIX_SIGNALBLOCKING@ +/* This function is defined as a macro on MacOS X. */ +# if defined __cplusplus && defined GNULIB_NAMESPACE +# undef sigismember +# endif +# else +_GL_FUNCDECL_SYS (sigismember, int, (const sigset_t *set, int sig) + _GL_ARG_NONNULL ((1))); +# endif +_GL_CXXALIAS_SYS (sigismember, int, (const sigset_t *set, int sig)); +_GL_CXXALIASWARN (sigismember); + +/* Initialize a signal set to the empty set. */ +# if @HAVE_POSIX_SIGNALBLOCKING@ +/* This function is defined as a macro on MacOS X. */ +# if defined __cplusplus && defined GNULIB_NAMESPACE +# undef sigemptyset +# endif +# else +_GL_FUNCDECL_SYS (sigemptyset, int, (sigset_t *set) _GL_ARG_NONNULL ((1)= )); +# endif +_GL_CXXALIAS_SYS (sigemptyset, int, (sigset_t *set)); +_GL_CXXALIASWARN (sigemptyset); + +/* Add a signal to a signal set. */ +# if @HAVE_POSIX_SIGNALBLOCKING@ +/* This function is defined as a macro on MacOS X. */ +# if defined __cplusplus && defined GNULIB_NAMESPACE +# undef sigaddset +# endif +# else +_GL_FUNCDECL_SYS (sigaddset, int, (sigset_t *set, int sig) + _GL_ARG_NONNULL ((1))); +# endif +_GL_CXXALIAS_SYS (sigaddset, int, (sigset_t *set, int sig)); +_GL_CXXALIASWARN (sigaddset); + +/* Remove a signal from a signal set. */ +# if @HAVE_POSIX_SIGNALBLOCKING@ +/* This function is defined as a macro on MacOS X. */ +# if defined __cplusplus && defined GNULIB_NAMESPACE +# undef sigdelset +# endif +# else +_GL_FUNCDECL_SYS (sigdelset, int, (sigset_t *set, int sig) + _GL_ARG_NONNULL ((1))); +# endif +_GL_CXXALIAS_SYS (sigdelset, int, (sigset_t *set, int sig)); +_GL_CXXALIASWARN (sigdelset); + +/* Fill a signal set with all possible signals. */ +# if @HAVE_POSIX_SIGNALBLOCKING@ +/* This function is defined as a macro on MacOS X. */ +# if defined __cplusplus && defined GNULIB_NAMESPACE +# undef sigfillset +# endif +# else +_GL_FUNCDECL_SYS (sigfillset, int, (sigset_t *set) _GL_ARG_NONNULL ((1))= ); +# endif +_GL_CXXALIAS_SYS (sigfillset, int, (sigset_t *set)); +_GL_CXXALIASWARN (sigfillset); + +/* Return the set of those blocked signals that are pending. */ +# if !@HAVE_POSIX_SIGNALBLOCKING@ +_GL_FUNCDECL_SYS (sigpending, int, (sigset_t *set) _GL_ARG_NONNULL ((1))= ); +# endif +_GL_CXXALIAS_SYS (sigpending, int, (sigset_t *set)); +_GL_CXXALIASWARN (sigpending); + +/* If OLD_SET is not NULL, put the current set of blocked signals in *OL= D_SET. + Then, if SET is not NULL, affect the current set of blocked signals b= y + combining it with *SET as indicated in OPERATION. + In this implementation, you are not allowed to change a signal handle= r + while the signal is blocked. */ +# if !@HAVE_POSIX_SIGNALBLOCKING@ +# define SIG_BLOCK 0 /* blocked_set =3D blocked_set | *set; */ +# define SIG_SETMASK 1 /* blocked_set =3D *set; */ +# define SIG_UNBLOCK 2 /* blocked_set =3D blocked_set & ~*set; */ +_GL_FUNCDECL_SYS (sigprocmask, int, + (int operation, const sigset_t *set, sigset_t *old_set= )); +# endif +_GL_CXXALIAS_SYS (sigprocmask, int, + (int operation, const sigset_t *set, sigset_t *old_set= )); +_GL_CXXALIASWARN (sigprocmask); + +/* Install the handler FUNC for signal SIG, and return the previous + handler. */ +# ifdef __cplusplus +extern "C" { +# endif +# if !GNULIB_defined_function_taking_int_returning_void_t +typedef void (*_gl_function_taking_int_returning_void_t) (int); +# define GNULIB_defined_function_taking_int_returning_void_t 1 +# endif +# ifdef __cplusplus +} +# endif +# if !@HAVE_POSIX_SIGNALBLOCKING@ +# if !(defined __cplusplus && defined GNULIB_NAMESPACE) +# define signal rpl_signal +# endif +_GL_FUNCDECL_RPL (signal, _gl_function_taking_int_returning_void_t, + (int sig, _gl_function_taking_int_returning_void_t fun= c)); +_GL_CXXALIAS_RPL (signal, _gl_function_taking_int_returning_void_t, + (int sig, _gl_function_taking_int_returning_void_t fun= c)); +# else +_GL_CXXALIAS_SYS (signal, _gl_function_taking_int_returning_void_t, + (int sig, _gl_function_taking_int_returning_void_t fun= c)); +# endif +_GL_CXXALIASWARN (signal); + +/* Raise signal SIG. */ +# if !@HAVE_POSIX_SIGNALBLOCKING@ && GNULIB_defined_SIGPIPE +# if !(defined __cplusplus && defined GNULIB_NAMESPACE) +# undef raise +# define raise rpl_raise +# endif +_GL_FUNCDECL_RPL (raise, int, (int sig)); +_GL_CXXALIAS_RPL (raise, int, (int sig)); +# else +_GL_CXXALIAS_SYS (raise, int, (int sig)); +# endif +_GL_CXXALIASWARN (raise); + +#elif defined GNULIB_POSIXCHECK +# undef sigaddset +# if HAVE_RAW_DECL_SIGADDSET +_GL_WARN_ON_USE (sigaddset, "sigaddset is unportable - " + "use the gnulib module sigprocmask for portability"); +# endif +# undef sigdelset +# if HAVE_RAW_DECL_SIGDELSET +_GL_WARN_ON_USE (sigdelset, "sigdelset is unportable - " + "use the gnulib module sigprocmask for portability"); +# endif +# undef sigemptyset +# if HAVE_RAW_DECL_SIGEMPTYSET +_GL_WARN_ON_USE (sigemptyset, "sigemptyset is unportable - " + "use the gnulib module sigprocmask for portability"); +# endif +# undef sigfillset +# if HAVE_RAW_DECL_SIGFILLSET +_GL_WARN_ON_USE (sigfillset, "sigfillset is unportable - " + "use the gnulib module sigprocmask for portability"); +# endif +# undef sigismember +# if HAVE_RAW_DECL_SIGISMEMBER +_GL_WARN_ON_USE (sigismember, "sigismember is unportable - " + "use the gnulib module sigprocmask for portability"); +# endif +# undef sigpending +# if HAVE_RAW_DECL_SIGPENDING +_GL_WARN_ON_USE (sigpending, "sigpending is unportable - " + "use the gnulib module sigprocmask for portability"); +# endif +# undef sigprocmask +# if HAVE_RAW_DECL_SIGPROCMASK +_GL_WARN_ON_USE (sigprocmask, "sigprocmask is unportable - " + "use the gnulib module sigprocmask for portability"); +# endif +#endif /* @GNULIB_SIGPROCMASK@ */ + + +#if @GNULIB_SIGACTION@ +# if !@HAVE_SIGACTION@ + +# if !@HAVE_SIGINFO_T@ + +# if !GNULIB_defined_siginfo_types + +/* Present to allow compilation, but unsupported by gnulib. */ +union sigval +{ + int sival_int; + void *sival_ptr; +}; + +/* Present to allow compilation, but unsupported by gnulib. */ +struct siginfo_t +{ + int si_signo; + int si_code; + int si_errno; + pid_t si_pid; + uid_t si_uid; + void *si_addr; + int si_status; + long si_band; + union sigval si_value; +}; +typedef struct siginfo_t siginfo_t; + +# define GNULIB_defined_siginfo_types 1 +# endif + +# endif /* !@HAVE_SIGINFO_T@ */ + +/* We assume that platforms which lack the sigaction() function also lac= k + the 'struct sigaction' type, and vice versa. */ + +# if !GNULIB_defined_struct_sigaction + +struct sigaction +{ + union + { + void (*_sa_handler) (int); + /* Present to allow compilation, but unsupported by gnulib. POSIX + says that implementations may, but not must, make sa_sigaction + overlap with sa_handler, but we know of no implementation where + they do not overlap. */ + void (*_sa_sigaction) (int, siginfo_t *, void *); + } _sa_func; + sigset_t sa_mask; + /* Not all POSIX flags are supported. */ + int sa_flags; +}; +# define sa_handler _sa_func._sa_handler +# define sa_sigaction _sa_func._sa_sigaction +/* Unsupported flags are not present. */ +# define SA_RESETHAND 1 +# define SA_NODEFER 2 +# define SA_RESTART 4 + +# define GNULIB_defined_struct_sigaction 1 +# endif + +_GL_FUNCDECL_SYS (sigaction, int, (int, const struct sigaction *restrict= , + struct sigaction *restrict)); + +# elif !@HAVE_STRUCT_SIGACTION_SA_SIGACTION@ + +# define sa_sigaction sa_handler + +# endif /* !@HAVE_SIGACTION@, !@HAVE_STRUCT_SIGACTION_SA_SIGACTION@ */ + +_GL_CXXALIAS_SYS (sigaction, int, (int, const struct sigaction *restrict= , + struct sigaction *restrict)); +_GL_CXXALIASWARN (sigaction); + +#elif defined GNULIB_POSIXCHECK +# undef sigaction +# if HAVE_RAW_DECL_SIGACTION +_GL_WARN_ON_USE (sigaction, "sigaction is unportable - " + "use the gnulib module sigaction for portability"); +# endif +#endif + +/* Some systems don't have SA_NODEFER. */ +#ifndef SA_NODEFER +# define SA_NODEFER 0 +#endif + + +#endif /* _@GUARD_PREFIX@_SIGNAL_H */ +#endif /* _@GUARD_PREFIX@_SIGNAL_H */ +#endif =3D=3D=3D modified file 'lib/sys_select.in.h' --- lib/sys_select.in.h 2011-07-01 06:13:09 +0000 +++ lib/sys_select.in.h 2011-07-06 16:49:44 +0000 @@ -36,12 +36,19 @@ =20 #ifndef _@GUARD_PREFIX@_SYS_SELECT_H =20 +/* On many platforms, assumes prior inclusion of + . Also, mingw defines sigset_t there, instead of + in where it belongs. */ +#include + +/* Get definition of 'sigset_t'. + But avoid namespace pollution on glibc systems. */ +#if !(defined __GLIBC__ && !defined __UCLIBC__) +# include +#endif + #if @HAVE_SYS_SELECT_H@ =20 -/* On many platforms, assumes prior inclusion of - . */ -# include - /* On OSF/1 4.0, provides only a forward declaration of 'struct timeval', and no definition of this type. Also, MacOS X, AIX, HP-UX, IRIX, Solaris, Interix declare select() @@ -77,20 +84,12 @@ # if defined __hpux # include # endif -/* On native Windows platforms: - Get the 'fd_set' type. Also, gnulib's redefines selec= t - so as to hide the declaration from . */ -# if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__ -# include +/* On native Windows platforms, get the 'fd_set' type and related macros= . */ +# if @HAVE_WINSOCK2_H@ +# include # endif #endif =20 -/* Get definition of 'sigset_t'. - But avoid namespace pollution on glibc systems. */ -#if !(defined __GLIBC__ && !defined __UCLIBC__) -# include -#endif - /* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ =20 /* The definition of _GL_WARN_ON_USE is copied here. */ =3D=3D=3D modified file 'm4/gl-comp.m4' --- m4/gl-comp.m4 2011-07-01 06:13:09 +0000 +++ m4/gl-comp.m4 2011-07-06 16:49:44 +0000 @@ -58,7 +58,9 @@ # Code from module mktime: # Code from module multiarch: # Code from module pselect: + # Code from module pthread_sigmask: # Code from module readlink: + # Code from module signal: # Code from module socklen: # Code from module ssize_t: # Code from module stat: @@ -165,7 +167,7 @@ gl_TIME_MODULE_INDICATOR([mktime]) gl_MULTIARCH gl_FUNC_PSELECT -if test $REPLACE_PSELECT =3D 1; then +if test $HAVE_PSELECT =3D 0 || test $REPLACE_PSELECT =3D 1; then AC_LIBOBJ([pselect]) fi gl_SYS_SELECT_MODULE_INDICATOR([pselect]) @@ -175,6 +177,7 @@ gl_PREREQ_READLINK fi gl_UNISTD_MODULE_INDICATOR([readlink]) +gl_SIGNAL_H gl_TYPE_SOCKLEN_T gt_TYPE_SSIZE_T gl_STAT_TIME @@ -222,6 +225,7 @@ gl_UTIMENS gl_gnulib_enabled_dosname=3Dfalse gl_gnulib_enabled_be453cec5eecf5731a274f2de7f2db36=3Dfalse + gl_gnulib_enabled_pthread_sigmask=3Dfalse gl_gnulib_enabled_stat=3Dfalse gl_gnulib_enabled_strtoll=3Dfalse gl_gnulib_enabled_strtoull=3Dfalse @@ -240,6 +244,17 @@ gl_gnulib_enabled_be453cec5eecf5731a274f2de7f2db36=3Dtrue fi } + func_gl_gnulib_m4code_pthread_sigmask () + { + if ! $gl_gnulib_enabled_pthread_sigmask; then +gl_PTHREAD_SIGMASK +gl_SYS_SELECT_MODULE_INDICATOR([pthread_sigmask]) + gl_gnulib_enabled_pthread_sigmask=3Dtrue + if $condition; then + func_gl_gnulib_m4code_sigprocmask + fi + fi + } func_gl_gnulib_m4code_stat () { if ! $gl_gnulib_enabled_stat; then @@ -297,6 +312,12 @@ if test $REPLACE_LSTAT =3D 1; then func_gl_gnulib_m4code_stat fi + if test $HAVE_PSELECT =3D 0 || test $REPLACE_PSELECT =3D 1; then + func_gl_gnulib_m4code_pthread_sigmask + fi + if test $HAVE_PSELECT =3D 0 || test $REPLACE_PSELECT =3D 1; then + func_gl_gnulib_m4code_select + fi if test $HAVE_READLINK =3D 0 || test $REPLACE_READLINK =3D 1; then func_gl_gnulib_m4code_stat fi @@ -315,6 +336,7 @@ m4_pattern_allow([^gl_GNULIB_ENABLED_]) AM_CONDITIONAL([gl_GNULIB_ENABLED_dosname], [$gl_gnulib_enabled_dosnam= e]) AM_CONDITIONAL([gl_GNULIB_ENABLED_be453cec5eecf5731a274f2de7f2db36], [= $gl_gnulib_enabled_be453cec5eecf5731a274f2de7f2db36]) + AM_CONDITIONAL([gl_GNULIB_ENABLED_pthread_sigmask], [$gl_gnulib_enable= d_pthread_sigmask]) AM_CONDITIONAL([gl_GNULIB_ENABLED_stat], [$gl_gnulib_enabled_stat]) AM_CONDITIONAL([gl_GNULIB_ENABLED_strtoll], [$gl_gnulib_enabled_strtol= l]) AM_CONDITIONAL([gl_GNULIB_ENABLED_strtoull], [$gl_gnulib_enabled_strto= ull]) @@ -501,6 +523,7 @@ lib/sha256.h lib/sha512.c lib/sha512.h + lib/signal.in.h lib/stat-time.h lib/stat.c lib/stdarg.in.h @@ -552,10 +575,12 @@ m4/mktime.m4 m4/multiarch.m4 m4/pselect.m4 + m4/pthread_sigmask.m4 m4/readlink.m4 m4/sha1.m4 m4/sha256.m4 m4/sha512.m4 + m4/signal_h.m4 m4/socklen.m4 m4/ssize_t.m4 m4/st_dm_mode.m4 =3D=3D=3D modified file 'm4/pselect.m4' --- m4/pselect.m4 2011-07-01 06:13:09 +0000 +++ m4/pselect.m4 2011-07-06 16:49:44 +0000 @@ -14,15 +14,15 @@ AC_CACHE_CHECK([whether signature of pselect conforms to POSIX], gl_cv_sig_pselect, [AC_LINK_IFELSE( - [AC_LANG_PROGRAM( - [[#include - ]], - [[int (*p) (int, fd_set *, fd_set *, fd_set *restrict, - struct timespec const *restrict, - sigset_t const *restrict) =3D pselect; - return !p;]])], - [gl_cv_sig_pselect=3Dyes], - [gl_cv_sig_pselect=3Dno])]) + [AC_LANG_PROGRAM( + [[#include + ]], + [[int (*p) (int, fd_set *, fd_set *, fd_set *restrict, + struct timespec const *restrict, + sigset_t const *restrict) =3D pselect; + return !p;]])], + [gl_cv_sig_pselect=3Dyes], + [gl_cv_sig_pselect=3Dno])]) fi =20 if test $ac_cv_func_pselect =3D no || test $gl_cv_sig_pselect =3D no; = then =3D=3D=3D added file 'm4/pthread_sigmask.m4' --- m4/pthread_sigmask.m4 1970-01-01 00:00:00 +0000 +++ m4/pthread_sigmask.m4 2011-07-06 16:49:44 +0000 @@ -0,0 +1,24 @@ +# pthread_sigmask.m4 serial 1 +dnl Copyright (C) 2011 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +AC_DEFUN([gl_PTHREAD_SIGMASK], +[ + m4_ifdef([gl_THREADLIB], [ + AC_REQUIRE([gl_THREADLIB]) + if test "$gl_threads_api" =3D posix; then + gl_save_LIBS=3D"$LIBS" + LIBS=3D"$LIBS $LIBMULTITHREAD" + AC_CHECK_FUNCS([pthread_sigmask]) + LIBS=3D"$gl_save_LIBS" + fi + ], [ + AC_CHECK_FUNCS_ONCE([pthread_sigmask]) + ]) + + if test $ac_cv_func_pthread_sigmask =3D no; then + REPLACE_PTHREAD_SIGMASK=3D0 + fi +]) =3D=3D=3D added file 'm4/signal_h.m4' --- m4/signal_h.m4 1970-01-01 00:00:00 +0000 +++ m4/signal_h.m4 2011-07-06 16:49:44 +0000 @@ -0,0 +1,76 @@ +# signal_h.m4 serial 14 +dnl Copyright (C) 2007-2011 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +AC_DEFUN([gl_SIGNAL_H], +[ + AC_REQUIRE([gl_SIGNAL_H_DEFAULTS]) + AC_REQUIRE([gl_CHECK_TYPE_SIGSET_T]) + gl_NEXT_HEADERS([signal.h]) + +# AIX declares sig_atomic_t to already include volatile, and C89 compile= rs +# then choke on 'volatile sig_atomic_t'. C99 requires that it compile. + AC_CHECK_TYPE([volatile sig_atomic_t], [], + [HAVE_TYPE_VOLATILE_SIG_ATOMIC_T=3D0], [[ +#include + ]]) + + AC_REQUIRE([AC_TYPE_UID_T]) + + dnl Persuade glibc to define sighandler_t. + AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) + AC_CHECK_TYPE([sighandler_t], [], [HAVE_SIGHANDLER_T=3D0], [[ +#include + ]]) + + dnl Check for declarations of anything we want to poison if the + dnl corresponding gnulib module is not in use. + gl_WARN_ON_USE_PREPARE([[#include + ]], [pthread_sigmask sigaction + sigaddset sigdelset sigemptyset sigfillset sigismember + sigpending sigprocmask]) +]) + +AC_DEFUN([gl_CHECK_TYPE_SIGSET_T], +[ + AC_CHECK_TYPES([sigset_t], + [gl_cv_type_sigset_t=3Dyes], [gl_cv_type_sigset_t=3Dno], + [[ + #include + /* Mingw defines sigset_t not in , but in .= */ + #include + ]]) + if test $gl_cv_type_sigset_t !=3D yes; then + HAVE_SIGSET_T=3D0 + fi +]) + +AC_DEFUN([gl_SIGNAL_MODULE_INDICATOR], +[ + dnl Use AC_REQUIRE here, so that the default settings are expanded onc= e only. + AC_REQUIRE([gl_SIGNAL_H_DEFAULTS]) + gl_MODULE_INDICATOR_SET_VARIABLE([$1]) + dnl Define it also as a C macro, for the benefit of the unit tests. + gl_MODULE_INDICATOR_FOR_TESTS([$1]) +]) + +AC_DEFUN([gl_SIGNAL_H_DEFAULTS], +[ + GNULIB_PTHREAD_SIGMASK=3D0; AC_SUBST([GNULIB_PTHREAD_SIGMASK]) + GNULIB_SIGNAL_H_SIGPIPE=3D0; AC_SUBST([GNULIB_SIGNAL_H_SIGPIPE]) + GNULIB_SIGPROCMASK=3D0; AC_SUBST([GNULIB_SIGPROCMASK]) + GNULIB_SIGACTION=3D0; AC_SUBST([GNULIB_SIGACTION]) + dnl Assume proper GNU behavior unless another module says otherwise. + HAVE_POSIX_SIGNALBLOCKING=3D1; AC_SUBST([HAVE_POSIX_SIGNALBLOCKING]) + HAVE_SIGSET_T=3D1; AC_SUBST([HAVE_SIGSET_T]) + HAVE_SIGINFO_T=3D1; AC_SUBST([HAVE_SIGINFO_T]) + HAVE_SIGACTION=3D1; AC_SUBST([HAVE_SIGACTION]) + HAVE_STRUCT_SIGACTION_SA_SIGACTION=3D1; + AC_SUBST([HAVE_STRUCT_SIGACTION_SA_SIGACT= ION]) + HAVE_TYPE_VOLATILE_SIG_ATOMIC_T=3D1; + AC_SUBST([HAVE_TYPE_VOLATILE_SIG_ATOMIC_T= ]) + HAVE_SIGHANDLER_T=3D1; AC_SUBST([HAVE_SIGHANDLER_T]) + REPLACE_PTHREAD_SIGMASK=3D0; AC_SUBST([REPLACE_PTHREAD_SIGMASK]) +]) =3D=3D=3D modified file 'm4/sys_select_h.m4' --- m4/sys_select_h.m4 2011-07-01 06:13:09 +0000 +++ m4/sys_select_h.m4 2011-07-06 16:49:44 +0000 @@ -1,4 +1,4 @@ -# sys_select_h.m4 serial 18 +# sys_select_h.m4 serial 19 dnl Copyright (C) 2006-2011 Free Software Foundation, Inc. dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, @@ -64,7 +64,7 @@ # include #endif #include - ]], [select]) + ]], [pselect select]) ]) =20 AC_DEFUN([gl_SYS_SELECT_MODULE_INDICATOR], From debbugs-submit-bounces@debbugs.gnu.org Sat Dec 31 03:45:49 2011 Received: (at control) by debbugs.gnu.org; 31 Dec 2011 08:45:49 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1RguZY-0008Rh-LY for submit@debbugs.gnu.org; Sat, 31 Dec 2011 03:45:49 -0500 Received: from smtp.cs.ucla.edu ([131.179.128.62]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1RguZX-0008Ra-3i for control@debbugs.gnu.org; Sat, 31 Dec 2011 03:45:47 -0500 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id C3A5C39E8007 for ; Sat, 31 Dec 2011 00:42:45 -0800 (PST) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id ZpUhcKiX2pF8 for ; Sat, 31 Dec 2011 00:42:45 -0800 (PST) Received: from [192.168.1.10] (pool-71-189-109-235.lsanca.fios.verizon.net [71.189.109.235]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 7CA63A60001 for ; Sat, 31 Dec 2011 00:42:45 -0800 (PST) Message-ID: <4EFECB0A.3000809@cs.ucla.edu> Date: Sat, 31 Dec 2011 00:42:50 -0800 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:8.0) Gecko/20111124 Thunderbird/8.0 MIME-Version: 1.0 To: control@debbugs.gnu.org Subject: bug 9000 has a patch Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -2.9 (--) X-Debbugs-Envelope-To: control X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.11 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -2.9 (--) tags 9000 patch From debbugs-submit-bounces@debbugs.gnu.org Fri May 04 16:55:11 2012 Received: (at 9000) by debbugs.gnu.org; 4 May 2012 20:55:11 +0000 Received: from localhost ([127.0.0.1]:36387 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SQPWm-0003Te-Bx for submit@debbugs.gnu.org; Fri, 04 May 2012 16:55:11 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:49812) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SQPWW-0003TC-Rw for 9000@debbugs.gnu.org; Fri, 04 May 2012 16:54:55 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 4F490A60001 for <9000@debbugs.gnu.org>; Fri, 4 May 2012 13:52:53 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id CBLSRRfG1o98 for <9000@debbugs.gnu.org>; Fri, 4 May 2012 13:52:47 -0700 (PDT) Received: from [192.168.1.10] (pool-71-189-109-235.lsanca.fios.verizon.net [71.189.109.235]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 5C85439E8006 for <9000@debbugs.gnu.org>; Fri, 4 May 2012 13:52:47 -0700 (PDT) Message-ID: <4FA441A0.2030501@cs.ucla.edu> Date: Fri, 04 May 2012 13:52:48 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:12.0) Gecko/20120430 Thunderbird/12.0.1 MIME-Version: 1.0 To: 9000@debbugs.gnu.org Subject: 2012-05-04 version of patch Content-Type: multipart/mixed; boundary="------------000801010703000000030508" X-Debbugs-Envelope-To: 9000 X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org This is a multi-part message in MIME format. --------------000801010703000000030508 Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit Attached is an updated version of the patch, relative to the current trunk version (bzr 108124). It's in two parts. The first part is to Emacs proper: this actually shrinks the Emacs source code a bit, by deleting 1047 lines and adding 934 lines, for a savings of 113 lines. The second part is the changes automatically brought in from gnulib, which either bring in new time-related modules or update old modules, partly to update copyright notices. The second part is long and boring and I've taken the liberty of compressing it. --------------000801010703000000030508 Content-Type: text/plain; charset=UTF-8; name="emacs-ns-diff.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="emacs-ns-diff.txt" PT09IG1vZGlmaWVkIGZpbGUgJy5ienJpZ25vcmUnCi0tLSAuYnpyaWdub3JlCTIwMTItMDQt MTAgMTk6MDc6NDYgKzAwMDAKKysrIC5ienJpZ25vcmUJMjAxMi0wNS0wNCAwNjo0MjowMyAr MDAwMApAQCAtNzYsNiArNzYsNyBAQAogbGliL2MrK2RlZnMuaAogbGliL2dldG9wdC5oCiBs aWIvaW50dHlwZXMuaAorbGliL3NpZ25hbC5oCiBsaWIvc3RkYm9vbC5oCiBsaWIvc3RkaW8u aAogbGliL3N0ZGludC5oCgo9PT0gbW9kaWZpZWQgZmlsZSAnQ2hhbmdlTG9nJwotLS0gQ2hh bmdlTG9nCTIwMTItMDUtMDQgMDY6NDU6MDMgKzAwMDAKKysrIENoYW5nZUxvZwkyMDEyLTA1 LTA0IDIwOjI5OjU4ICswMDAwCkBAIC0xLDMgKzEsNzcgQEAKKzIwMTItMDUtMDQgIFBhdWwg RWdnZXJ0ICA8ZWdnZXJ0QGNzLnVjbGEuZWR1PgorCisJU3VwcG9ydCBoaWdoZXItcmVzb2x1 dGlvbiB0aW1lIHN0YW1wcyAoQnVnIzkwMDApLgorCSogTWFrZWZpbGUuaW4gKEdOVUxJQl9N T0RVTEVTKTogQWRkIGR0b3RpbWVzcGVjLCBnZXR0aW1lLCBnZXR0aW1lb2ZkYXksCisJcHNl bGVjdCwgc3RhdC10aW1lLCBzdHJ0b2ltYXgsIHN5c190aW1lLCB0aW1lLCB0aW1lc3BlYy1h ZGQsCisJdGltZXNwZWMtc3ViLCB1dGltZW5zLgorCShHTlVMSUJfVE9PTF9GTEFHUyk6IEFk ZCAtLWF2b2lkPXNlbGVjdCAtLWF2b2lkPXNpZ3Byb2NtYXNrLgorCVRoaXMgdHJpbXMgZG93 biB0aGUgZ251bGliIGltcG9ydCwgZnJvbSB0aGUgdmVyeSBsYXRlc3QgZ251bGliLgorCUVt YWNzIGRvZXMgaXRzIG93biBpbXBsZW1lbnRhdGlvbiBvZiAnc2VsZWN0JyBhbmQgJ3NpZ3By b2NtYXNrJworCW9uIFdpbmRvd3MsIGFuZCBpdCBhc3N1bWVzICdzZWxlY3QnIGFuZCAnc2ln cHJvY21hc2snIG9uIG5vbi1XaW5kb3dzCisJaG9zdHMsIHNvIGl0IGRvZXNuJ3QgbmVlZCB0 aGVzZSBtb2R1bGVzLgorCVNpbWlsYXJseSwgYXZvaWQgZXJybm8sIGZjbnRsLCBmY250bF9o LCBhbmQgc3lzX3R5cGVzLCBhcyB0aGVzZQorCWdudWxpYiBtb2R1bGVzIGFyZSBvbmx5IGZv ciBXaW5kb3dzIHBvcnRpbmcgYW5kIEVtYWNzIHBvcnRzIHRvCisJV2luZG93cyBpbiBhIGRp ZmZlcmVudCB3YXkuCisJKiBjb25maWd1cmUuaW4gKGdsX0FTU0VSVF9OT19HTlVMSUJfUE9T SVhDSEVDSykKKwkoZ2xfQVNTRVJUX05PX0dOVUxJQl9URVNUUywgZ2xfSU5JVCk6IE1vdmUg dGhlc2UgdXAgZWFybGllciwgc28KKwl0aGF0IHRoZSBuZXcgY2xvY2sgc3R1ZmYgZG9lc24n dCBjbGFzaCB3aXRoIFJTVkdfTElCUy4KKwkoQUNfQ0hFQ0tfSEVBREVSUyk6IERvbid0IGNo ZWNrIGZvciBzeXMvc2VsZWN0LmgsIHN5cy90aW1lLmgsIHV0aW1lLmgsCisJYXMgZ251bGli IGRvZXMgdGhhdCBmb3IgdXMgbm93LgorCShlbWFjc19jdl9zdHJ1Y3RfdXRpbWJ1Zik6IFJl bW92ZTsgZ251bGliIGRvZXMgdGhpcy4KKworCVByZXBhcmUgdG8gYWRkIHN1cHBvcnQgZm9y IG5hbm9zZWNvbmQtcmVzb2x1dGlvbiB0aW1lIHN0YW1wcy4KKwlUaGlzIGNvbnRhaW5zIGp1 c3QgdGhlIGF1dG9tYXRpY2FsbHktZ2VuZXJhdGVkIHN0dWZmIGZyb20gZ251bGliOworCWEg bGF0ZXIgcGF0Y2ggd2lsbCBjb250YWluIHRoZSBtb3JlLWludGVyZXN0aW5nIHN0dWZmLgor CSogbGliL2R0b3RpbWVzcGVjLmMsIGxpYi9nZXR0aW1lLmM6CisJKiBsaWIvZ2V0dGltZW9m ZGF5LmMsIGxpYi9wc2VsZWN0LmMsIGxpYi9zaWduYWwuaW4uaDoKKwkqIGxpYi9zdGF0LXRp bWUuaCwgbGliL3N0ZGFsaWduLmluLmgsIGxpYi9zdHJ0b2xsLmM6CisJKiBsaWIvc3lzX3Nl bGVjdC5pbi5oLCBsaWIvc3lzX3RpbWUuaW4uaCwgbGliL3RpbWVzcGVjLWFkZC5jOgorCSog bGliL3RpbWVzcGVjLXN1Yi5jLCBsaWIvdGltZXNwZWMuaCwgbGliL3V0aW1lbnMuYywgbGli L3V0aW1lbnMuaDoKKwkqIG00L2Nsb2NrX3RpbWUubTQsIG00L2dldHRpbWUubTQsIG00L2dl dHRpbWVvZmRheS5tNCwgbTQvb2ZmX3QubTQ6CisJKiBtNC9wc2VsZWN0Lm00LCBtNC9wdGhy ZWFkX3NpZ21hc2subTQsIG00L3NpZ25hbF9oLm00OgorCSogbTQvc3RhdC10aW1lLm00LCBt NC9zdGRhbGlnbi5tNCwgbTQvc3RydG9pbWF4Lm00LCBtNC9zdHJ0b2xsLm00OgorCSogbTQv c3lzX3NlbGVjdF9oLm00LCBtNC9zeXNfc29ja2V0X2gubTQsIG00L3N5c190aW1lX2gubTQ6 CisJKiBtNC90aW1lc3BlYy5tNCwgbTQvdXRpbWJ1Zi5tNCwgbTQvdXRpbWVucy5tNCwgbTQv dXRpbWVzLm00OgorCU5ldyBmaWxlcywgY29waWVkIGF1dG9tYXRpY2FsbHkgZnJvbSBnbnVs aWIuCisJKiBsaWIvZ251bGliLm1rLCBtNC9nbC1jb21wLm00OiBNZXJnZSBmcm9tIGdudWxp Yi4KKwkqIGJ1aWxkLWF1eC9tb3ZlLWlmLWNoYW5nZSwgYnVpbGQtYXV4L3NuaXBwZXQvX05v cmV0dXJuLmg6CisJKiBidWlsZC1hdXgvc25pcHBldC9hcmctbm9ubnVsbC5oLCBidWlsZC1h dXgvc25pcHBldC9jKytkZWZzLmg6CisJKiBidWlsZC1hdXgvc25pcHBldC93YXJuLW9uLXVz ZS5oLCBkb2MvbWlzYy90ZXhpbmZvLnRleDoKKwkqIGxpYi9hbGxvY2EuaW4uaCwgbGliL2Fs bG9jYXRvci5oLCBsaWIvY2FyZWFkbGlua2F0LmM6CisJKiBsaWIvY2FyZWFkbGlua2F0Lmgs IGxpYi9kb3NuYW1lLmgsIGxpYi9kdG90aW1lc3BlYy5jLCBsaWIvZHVwMi5jOgorCSogbGli L2ZpbGVtb2RlLmMsIGxpYi9maWxlbW9kZS5oLCBsaWIvZnRvYXN0ci5jLCBsaWIvZnRvYXN0 ci5oOgorCSogbGliL2dldGxvYWRhdmcuYywgbGliL2dldG9wdC5jLCBsaWIvZ2V0b3B0Lmlu LmgsIGxpYi9nZXRvcHQxLmM6CisJKiBsaWIvZ2V0b3B0X2ludC5oLCBsaWIvZ2V0dGV4dC5o LCBsaWIvZ2V0dGltZS5jLCBsaWIvZ2V0dGltZW9mZGF5LmM6CisJKiBsaWIvZ251bGliLm1r LCBsaWIvaWdub3JlLXZhbHVlLmgsIGxpYi9pbnRwcm9wcy5oLCBsaWIvaW50dHlwZXMuaW4u aDoKKwkqIGxpYi9sc3RhdC5jLCBsaWIvbWQ1LmMsIGxpYi9tZDUuaCwgbGliL21rdGltZS5j LCBsaWIvcGF0aG1heC5oOgorCSogbGliL3BzZWxlY3QuYywgbGliL3B0aHJlYWRfc2lnbWFz ay5jLCBsaWIvcmVhZGxpbmsuYywgbGliL3NoYTEuYzoKKwkqIGxpYi9zaGExLmgsIGxpYi9z aGEyNTYuYywgbGliL3NoYTI1Ni5oLCBsaWIvc2hhNTEyLmMsIGxpYi9zaGE1MTIuaDoKKwkq IGxpYi9zaWduYWwuaW4uaCwgbGliL3N0YXQtdGltZS5oLCBsaWIvc3RhdC5jLCBsaWIvc3Rk YXJnLmluLmg6CisJKiBsaWIvc3RkYm9vbC5pbi5oLCBsaWIvc3RkZGVmLmluLmgsIGxpYi9z dGRpbnQuaW4uaCwgbGliL3N0ZGlvLmluLmg6CisJKiBsaWIvc3RkbGliLmluLmgsIGxpYi9z dHJmdGltZS5jLCBsaWIvc3RyZnRpbWUuaCwgbGliL3N0cnRvaW1heC5jOgorCSogbGliL3N0 cnRvbC5jLCBsaWIvc3RydG9sbC5jLCBsaWIvc3RydG91bC5jLCBsaWIvc3RydG91bGwuYzoK KwkqIGxpYi9zeW1saW5rLmMsIGxpYi9zeXNfc2VsZWN0LmluLmgsIGxpYi9zeXNfc3RhdC5p bi5oOgorCSogbGliL3N5c190aW1lLmluLmgsIGxpYi90aW1lLmluLmgsIGxpYi90aW1lX3Iu YywgbGliL3RpbWVzcGVjLWFkZC5jOgorCSogbGliL3RpbWVzcGVjLXN1Yi5jLCBsaWIvdGlt ZXNwZWMuaCwgbGliL3U2NC5oLCBsaWIvdW5pc3RkLmluLmg6CisJKiBsaWIvdXRpbWVucy5j LCBsaWIvdmVyaWZ5LmgsIG00LzAwZ251bGliLm00LCBtNC9hbGxvY2EubTQ6CisJKiBtNC9j LXN0cnRvZC5tNCwgbTQvY2xvY2tfdGltZS5tNCwgbTQvZHVwMi5tNCwgbTQvZXh0ZW5zaW9u cy5tNDoKKwkqIG00L2ZpbGVtb2RlLm00LCBtNC9nZXRsb2FkYXZnLm00LCBtNC9nZXRvcHQu bTQsIG00L2dldHRpbWUubTQ6CisJKiBtNC9nZXR0aW1lb2ZkYXkubTQsIG00L2dsLWNvbXAu bTQsIG00L2dudWxpYi1jb21tb24ubTQ6CisJKiBtNC9nbnVsaWItdG9vbC5tNCwgbTQvaW5j bHVkZV9uZXh0Lm00LCBtNC9pbnR0eXBlcy5tNDoKKwkqIG00L2xhcmdlZmlsZS5tNCwgbTQv bG9uZ2xvbmcubTQsIG00L2xzdGF0Lm00LCBtNC9tZDUubTQ6CisJKiBtNC9ta3RpbWUubTQs IG00L211bHRpYXJjaC5tNCwgbTQvbm9jcmFzaC5tNCwgbTQvcGF0aG1heC5tNDoKKwkqIG00 L3BzZWxlY3QubTQsIG00L3B0aHJlYWRfc2lnbWFzay5tNCwgbTQvcmVhZGxpbmsubTQsIG00 L3NoYTEubTQ6CisJKiBtNC9zaGEyNTYubTQsIG00L3NoYTUxMi5tNCwgbTQvc2lnbmFsX2gu bTQsIG00L3NvY2tsZW4ubTQ6CisJKiBtNC9zc2l6ZV90Lm00LCBtNC9zdF9kbV9tb2RlLm00 LCBtNC9zdGF0LXRpbWUubTQsIG00L3N0YXQubTQ6CisJKiBtNC9zdGRhcmcubTQsIG00L3N0 ZGJvb2wubTQsIG00L3N0ZGRlZl9oLm00LCBtNC9zdGRpbnQubTQ6CisJKiBtNC9zdGRpb19o Lm00LCBtNC9zdGRsaWJfaC5tNCwgbTQvc3RyZnRpbWUubTQsIG00L3N0cnRvaW1heC5tNDoK KwkqIG00L3N0cnRvbGwubTQsIG00L3N0cnRvdWxsLm00LCBtNC9zdHJ0b3VtYXgubTQsIG00 L3N5bWxpbmsubTQ6CisJKiBtNC9zeXNfc2VsZWN0X2gubTQsIG00L3N5c19zb2NrZXRfaC5t NCwgbTQvc3lzX3N0YXRfaC5tNDoKKwkqIG00L3N5c190aW1lX2gubTQsIG00L3RpbWVfaC5t NCwgbTQvdGltZV9yLm00LCBtNC90aW1lc3BlYy5tNDoKKwkqIG00L3RtX2dtdG9mZi5tNCwg bTQvdW5pc3RkX2gubTQsIG00L3V0aW1idWYubTQsIG00L3V0aW1lbnMubTQ6CisJKiBtNC91 dGltZXMubTQsIG00L3djaGFyX3QubTQ6CisJU3luYyBmcm9tIGdudWxpYi4KKwogMjAxMi0w NS0wNCAgR2xlbm4gTW9ycmlzICA8cmdtQGdudS5vcmc+CiAKIAkqIGNvbmZpZ3VyZS5pbiAo SU5GT19FWFQsIElORk9fT1BUUyk6IE5ldyBvdXRwdXQgdmFyaWFibGVzLgoKPT09IG1vZGlm aWVkIGZpbGUgJ01ha2VmaWxlLmluJwotLS0gTWFrZWZpbGUuaW4JMjAxMi0wNS0wNCAwNjo0 NTowMyArMDAwMAorKysgTWFrZWZpbGUuaW4JMjAxMi0wNS0wNCAyMDoxNDo0OSArMDAwMApA QCAtMzI5LDE0ICszMjksMTcgQEAKIEdOVUxJQl9NT0RVTEVTID0gXAogICBhbGxvY2Etb3B0 IFwKICAgY2FyZWFkbGlua2F0IGNyeXB0by9tZDUgY3J5cHRvL3NoYTEgY3J5cHRvL3NoYTI1 NiBjcnlwdG8vc2hhNTEyIGR0b2FzdHIgXAotICBkdXAyIFwKLSAgZmlsZW1vZGUgZ2V0bG9h ZGF2ZyBnZXRvcHQtZ251IGlnbm9yZS12YWx1ZSBpbnRwcm9wcyBsc3RhdCBcCi0gIG1hbnl3 YXJuaW5ncyBta3RpbWUgcHRocmVhZF9zaWdtYXNrIHJlYWRsaW5rIFwKLSAgc29ja2xlbiBz dGRhcmcgc3RkaW8gc3RyZnRpbWUgc3RydG9pbWF4IHN0cnRvdW1heCBzeW1saW5rIHN5c19z dGF0IFwKKyAgZHRvdGltZXNwZWMgZHVwMiBmaWxlbW9kZSBnZXRsb2FkYXZnIGdldG9wdC1n bnUgZ2V0dGltZSBnZXR0aW1lb2ZkYXkgXAorICBpZ25vcmUtdmFsdWUgaW50cHJvcHMgbHN0 YXQgXAorICBtYW55d2FybmluZ3MgbWt0aW1lIHBzZWxlY3QgcHRocmVhZF9zaWdtYXNrIHJl YWRsaW5rIFwKKyAgc29ja2xlbiBzdGF0LXRpbWUgc3RkYXJnIHN0ZGlvIHN0cmZ0aW1lIHN0 cnRvaW1heCBzdHJ0b3VtYXggc3ltbGluayBzeXNfc3RhdCBcCisgIHN5c190aW1lIHRpbWUg dGltZXNwZWMtYWRkIHRpbWVzcGVjLXN1YiB1dGltZW5zIFwKICAgd2FybmluZ3MKIEdOVUxJ Ql9UT09MX0ZMQUdTID0gXAorIC0tYXZvaWQ9ZXJybm8gLS1hdm9pZD1mY250bCAtLWF2b2lk PWZjbnRsLWggLS1hdm9pZD1mc3RhdCBcCiAgLS1hdm9pZD1tc3ZjLWludmFsIC0tYXZvaWQ9 bXN2Yy1ub3Rocm93IFwKLSAtLWF2b2lkPXJhaXNlIC0tYXZvaWQ9dGhyZWFkbGliIFwKKyAt LWF2b2lkPXJhaXNlIC0tYXZvaWQ9c2VsZWN0IC0tYXZvaWQ9c2lncHJvY21hc2sgLS1hdm9p ZD1zeXNfdHlwZXMgXAorIC0tYXZvaWQ9dGhyZWFkbGliIFwKICAtLWNvbmRpdGlvbmFsLWRl cGVuZGVuY2llcyAtLWltcG9ydCAtLW5vLWNoYW5nZWxvZyAtLW5vLXZjLWZpbGVzIFwKICAt LW1ha2VmaWxlLW5hbWU9Z251bGliLm1rCiBzeW5jLWZyb20tZ251bGliOiAkKGdudWxpYl9z cmNkaXIpCgo9PT0gbW9kaWZpZWQgZmlsZSAnY29uZmlndXJlLmluJwotLS0gY29uZmlndXJl LmluCTIwMTItMDUtMDQgMDY6NDU6MDMgKzAwMDAKKysrIGNvbmZpZ3VyZS5pbgkyMDEyLTA1 LTA0IDIwOjE0OjQ5ICswMDAwCkBAIC0xMTkwLDYgKzExOTAsMTMgQEAKIGVzYWMKIAogCisj IENvbmZpZ3VyZSBnbnVsaWIgYmVmb3JlIGludm9raW5nIFBLR19DSEVDS19NT0RVTEVTLCBh cyB0aGUgbGF0dGVyIG1pZ2h0CisjIGZvciBleGFtcGxlIGFkZCAtbHJ0IHRvIFJTVkdfTElC Uywgd2hpY2ggd291bGQgdGhlbiBjYXVzZSBnbnVsaWIgdG8gaW5jb3JyZWN0bHkKKyMgY29u Y2x1ZGUgdGhhdCAtbHJ0IGlzIG5vdCBuZWVkZWQgdG8gbGluayBjbG9ja19nZXR0aW1lLgor Z2xfQVNTRVJUX05PX0dOVUxJQl9QT1NJWENIRUNLCitnbF9BU1NFUlRfTk9fR05VTElCX1RF U1RTCitnbF9JTklUCisKIGRubCBUaGlzIGZ1bmN0aW9uIGRlZmluaXRpb24gdGFrZW4gZnJv bSBHbm9tZSAyLjAKIGRubCBQS0dfQ0hFQ0tfTU9EVUxFUyhHU1RVRkYsIGd0aystMi4wID49 IDEuMyBnbGliID0gMS4zLjQsIGFjdGlvbi1pZiwgYWN0aW9uLW5vdCkKIGRubCBkZWZpbmVz IEdTVFVGRl9MSUJTLCBHU1RVRkZfQ0ZMQUdTLCBzZWUgcGtnLWNvbmZpZyBtYW4gcGFnZQpA QCAtMTI5OSw3ICsxMzA2LDggQEAKIGZpCiAKIGRubCBjaGVja3MgZm9yIGhlYWRlciBmaWxl cwotQUNfQ0hFQ0tfSEVBREVSUyhzeXMvc2VsZWN0Lmggc3lzL3RpbWUuaCB1bmlzdGQuaCB1 dGltZS5oIFwKKworQUNfQ0hFQ0tfSEVBREVSUyh1bmlzdGQuaCBcCiAgIGxpbnV4L3ZlcnNp b24uaCBzeXMvc3lzdGVtaW5mby5oIFwKICAgc3RkaW9fZXh0LmggZmNudGwuaCBjb2ZmLmgg cHR5Lmggc3lzL21tYW4uaCBcCiAgIHN5cy92bGltaXQuaCBzeXMvcmVzb3VyY2UuaCBsb2Nh bGUuaCBzeXMvX21ic3RhdGVfdC5oIFwKQEAgLTEzMzEsMjYgKzEzMzksNiBAQAogZmkKIEFD X0hFQURFUl9TWVNfV0FJVAogCi1kbmwgU29tZSBzeXN0ZW1zIGhhdmUgdXRpbWUuaCBidXQg ZG9uJ3QgZGVjbGFyZSB0aGUgc3RydWN0IGFueXBsYWNlLgotQUNfQ0FDSEVfQ0hFQ0soZm9y IHN0cnVjdCB1dGltYnVmLCBlbWFjc19jdl9zdHJ1Y3RfdXRpbWJ1ZiwKLUFDX0NPTVBJTEVf SUZFTFNFKFtBQ19MQU5HX1BST0dSQU0oW1sjaWZkZWYgVElNRV9XSVRIX1NZU19USU1FCi0j aW5jbHVkZSA8c3lzL3RpbWUuaD4KLSNpbmNsdWRlIDx0aW1lLmg+Ci0jZWxzZQotI2lmZGVm IEhBVkVfU1lTX1RJTUVfSAotI2luY2x1ZGUgPHN5cy90aW1lLmg+Ci0jZWxzZQotI2luY2x1 ZGUgPHRpbWUuaD4KLSNlbmRpZgotI2VuZGlmCi0jaWZkZWYgSEFWRV9VVElNRV9ICi0jaW5j bHVkZSA8dXRpbWUuaD4KLSNlbmRpZl1dLCBbW3N0YXRpYyBzdHJ1Y3QgdXRpbWJ1ZiB4OyB4 LmFjdGltZSA9IHgubW9kdGltZTtdXSldLAotICBlbWFjc19jdl9zdHJ1Y3RfdXRpbWJ1Zj15 ZXMsIGVtYWNzX2N2X3N0cnVjdF91dGltYnVmPW5vKSkKLWlmIHRlc3QgJGVtYWNzX2N2X3N0 cnVjdF91dGltYnVmID0geWVzOyB0aGVuCi0gIEFDX0RFRklORShIQVZFX1NUUlVDVF9VVElN QlVGLCAxLCBbRGVmaW5lIHRvIDEgaWYgYHN0cnVjdCB1dGltYnVmJyBpcyBkZWNsYXJlZCBi eSA8dXRpbWUuaD4uXSkKLWZpCi0KIGRubCBDaGVjayBmb3Igc3BlZWRfdCB0eXBlZGVmLgog QUNfQ0FDSEVfQ0hFQ0soZm9yIHNwZWVkX3QsIGVtYWNzX2N2X3NwZWVkX3QsCiAgIFtBQ19D T01QSUxFX0lGRUxTRShbQUNfTEFOR19QUk9HUkFNKFtbI2luY2x1ZGUgPHRlcm1pb3MuaD5d XSwgW1tzcGVlZF90IHggPSAxO11dKV0sCkBAIC0xMzYwLDIzICsxMzQ4LDYgQEAKICAgCSAg IFtEZWZpbmUgdG8gMSBpZiBgc3BlZWRfdCcgaXMgZGVjbGFyZWQgYnkgPHRlcm1pb3MuaD4u XSkKIGZpCiAKLUFDX0NBQ0hFX0NIRUNLKGZvciBzdHJ1Y3QgdGltZXZhbCwgZW1hY3NfY3Zf c3RydWN0X3RpbWV2YWwsCi1BQ19DT01QSUxFX0lGRUxTRShbQUNfTEFOR19QUk9HUkFNKFtb I2lmZGVmIFRJTUVfV0lUSF9TWVNfVElNRQotI2luY2x1ZGUgPHN5cy90aW1lLmg+Ci0jaW5j bHVkZSA8dGltZS5oPgotI2Vsc2UKLSNpZmRlZiBIQVZFX1NZU19USU1FX0gKLSNpbmNsdWRl IDxzeXMvdGltZS5oPgotI2Vsc2UKLSNpbmNsdWRlIDx0aW1lLmg+Ci0jZW5kaWYKLSNlbmRp Zl1dLCBbW3N0YXRpYyBzdHJ1Y3QgdGltZXZhbCB4OyB4LnR2X3NlYyA9IHgudHZfdXNlYztd XSldLAotICBlbWFjc19jdl9zdHJ1Y3RfdGltZXZhbD15ZXMsIGVtYWNzX2N2X3N0cnVjdF90 aW1ldmFsPW5vKSkKLUhBVkVfVElNRVZBTD0kZW1hY3NfY3Zfc3RydWN0X3RpbWV2YWwKLWlm IHRlc3QgJGVtYWNzX2N2X3N0cnVjdF90aW1ldmFsID0geWVzOyB0aGVuCi0gIEFDX0RFRklO RShIQVZFX1RJTUVWQUwsIDEsIFtEZWZpbmUgdG8gMSBpZiBgc3RydWN0IHRpbWV2YWwnIGlz IGRlY2xhcmVkIGJ5IDxzeXMvdGltZS5oPi5dKQotZmkKLQogQUNfQ0FDSEVfQ0hFQ0soZm9y IHN0cnVjdCBleGNlcHRpb24sIGVtYWNzX2N2X3N0cnVjdF9leGNlcHRpb24sCiBBQ19DT01Q SUxFX0lGRUxTRShbQUNfTEFOR19QUk9HUkFNKFtbI2luY2x1ZGUgPG1hdGguaD5dXSwKIFtb c3RhdGljIHN0cnVjdCBleGNlcHRpb24geDsgeC5hcmcxID0geC5hcmcyID0geC5yZXR2YWw7 IHgubmFtZSA9ICIiOyB4LnR5cGUgPSAxO11dKV0sCkBAIC0yODI0LDcgKzI3OTUsNyBAQAog cmVuYW1lIGNsb3NlZGlyIG1rZGlyIHJtZGlyIHN5c2luZm8gZ2V0cnVzYWdlIGdldF9jdXJy ZW50X2Rpcl9uYW1lIFwKIHJhbmRvbSBscmFuZDQ4IGxvZ2IgZnJleHAgZm1vZCByaW50IGNi cnQgZnRpbWUgc2V0c2lkIFwKIHN0cmVycm9yIGZwYXRoY29uZiBzZWxlY3QgZXVpZGFjY2Vz cyBnZXRwYWdlc2l6ZSB0enNldCBzZXRsb2NhbGUgXAotdXRpbWVzIGdldHJsaW1pdCBzZXRy bGltaXQgc2V0cGdpZCBnZXRjd2QgZ2V0d2Qgc2h1dGRvd24gZ2V0YWRkcmluZm8gXAorZ2V0 cmxpbWl0IHNldHJsaW1pdCBzZXRwZ2lkIGdldGN3ZCBnZXR3ZCBzaHV0ZG93biBnZXRhZGRy aW5mbyBcCiBfX2ZwZW5kaW5nIG1ibGVuIG1icmxlbiBtYnNpbml0IHN0cnNpZ25hbCBzZXRp dGltZXIgdWFsYXJtIFwKIHNlbmR0byByZWN2ZnJvbSBnZXRzb2Nrb3B0IHNldHNvY2tvcHQg Z2V0c29ja25hbWUgZ2V0cGVlcm5hbWUgXAogZ2FpX3N0cmVycm9yIG1rc3RlbXAgZ2V0bGlu ZSBnZXRkZWxpbSBtcmVtYXAgZnN5bmMgc3luYyBcCkBAIC0zMTQ3LDMzICszMTE4LDYgQEAK IAkgICAgW0RlZmluZSB0byAxIGlmIGxvY2FsdGltZSBjYWNoZXMgVFouXSkKIGZpCiAKLWlm IHRlc3QgIngkSEFWRV9USU1FVkFMIiA9IHh5ZXM7IHRoZW4KLSAgQUNfQ0hFQ0tfRlVOQ1Mo Z2V0dGltZW9mZGF5KQotICBpZiB0ZXN0ICRhY19jdl9mdW5jX2dldHRpbWVvZmRheSA9IHll czsgdGhlbgotICAgIEFDX0NBQ0hFX0NIRUNLKHdoZXRoZXIgZ2V0dGltZW9mZGF5IGNhbiBh Y2NlcHQgdHdvIGFyZ3VtZW50cywKLQkJICAgZW1hY3NfY3ZfZ2V0dGltZW9mZGF5X3R3b19h cmd1bWVudHMsCi0gICAgW0FDX0NPTVBJTEVfSUZFTFNFKFtBQ19MQU5HX1BST0dSQU0oW1sK LSNpZmRlZiBUSU1FX1dJVEhfU1lTX1RJTUUKLSNpbmNsdWRlIDxzeXMvdGltZS5oPgotI2lu Y2x1ZGUgPHRpbWUuaD4KLSNlbHNlCi0jaWZkZWYgSEFWRV9TWVNfVElNRV9ICi0jaW5jbHVk ZSA8c3lzL3RpbWUuaD4KLSNlbHNlCi0jaW5jbHVkZSA8dGltZS5oPgotI2VuZGlmCi0jZW5k aWZdXSwKLSAgICAgIFtbc3RydWN0IHRpbWV2YWwgdGltZTsKLSAgICAgICBnZXR0aW1lb2Zk YXkgKCZ0aW1lLCAwKTtdXSldLAotICAgICAgZW1hY3NfY3ZfZ2V0dGltZW9mZGF5X3R3b19h cmd1bWVudHM9eWVzLAotICAgICAgZW1hY3NfY3ZfZ2V0dGltZW9mZGF5X3R3b19hcmd1bWVu dHM9bm8pXSkKLSAgICBpZiB0ZXN0ICRlbWFjc19jdl9nZXR0aW1lb2ZkYXlfdHdvX2FyZ3Vt ZW50cyA9IG5vOyB0aGVuCi0gICAgICBBQ19ERUZJTkUoR0VUVElNRU9GREFZX09ORV9BUkdV TUVOVCwgMSwKLQkJW0RlZmluZSB0byAxIGlmIGdldHRpbWVvZmRheSBhY2NlcHRzIG9ubHkg b25lIGFyZ3VtZW50Ll0pCi0gICAgZmkKLSAgZmkKLWZpCi0KIG9rX3NvX2Zhcj15ZXMKIEFD X0NIRUNLX0ZVTkMoc29ja2V0LCAsIG9rX3NvX2Zhcj1ubykKIGlmIHRlc3QgJG9rX3NvX2Zh ciA9IHllczsgdGhlbgoKPT09IG1vZGlmaWVkIGZpbGUgJ2RvYy9saXNwcmVmL0NoYW5nZUxv ZycKLS0tIGRvYy9saXNwcmVmL0NoYW5nZUxvZwkyMDEyLTA1LTA0IDA2OjQ1OjAzICswMDAw CisrKyBkb2MvbGlzcHJlZi9DaGFuZ2VMb2cJMjAxMi0wNS0wNCAyMDoyOTo1OCArMDAwMApA QCAtMSwzICsxLDEwIEBACisyMDEyLTA1LTA0ICBQYXVsIEVnZ2VydCAgPGVnZ2VydEBjcy51 Y2xhLmVkdT4KKworCVN1cHBvcnQgaGlnaGVyLXJlc29sdXRpb24gdGltZSBzdGFtcHMgKEJ1 ZyM5MDAwKS4KKwkqIG9zLnRleGkgKFRpbWUgb2YgRGF5LCBUaW1lIFBhcnNpbmcsIFByb2Nl c3NvciBSdW4gVGltZSwgSWRsZSBUaW1lcnMpOgorCSogcHJvY2Vzc2VzLnRleGkgKFN5c3Rl bSBQcm9jZXNzZXMpOgorCVRpbWUgc3RhbXAgcmVzb2x1dGlvbiBpcyBub3cgcGljb3NlY29u ZCwgbm90IG1pY3Jvc2Vjb25kLgorCiAyMDEyLTA1LTA0ICBHbGVubiBNb3JyaXMgIDxyZ21A Z251Lm9yZz4KIAogCSogTWFrZWZpbGUuaW4gKElORk9fRVhULCBJTkZPX09QVFMpOiBOZXcs IHNldCBieSBjb25maWd1cmUuCgo9PT0gbW9kaWZpZWQgZmlsZSAnZG9jL2xpc3ByZWYvb3Mu dGV4aScKLS0tIGRvYy9saXNwcmVmL29zLnRleGkJMjAxMi0wNS0wNCAwNToxNDoxNCArMDAw MAorKysgZG9jL2xpc3ByZWYvb3MudGV4aQkyMDEyLTA1LTA0IDA3OjEyOjU5ICswMDAwCkBA IC0xMTY3LDcgKzExNjcsOSBAQAogem9uZS4KIAogQGNpbmRleCBlcG9jaAotICBNb3N0IG9m IHRoZXNlIGZ1bmN0aW9ucyByZXByZXNlbnQgdGltZSBhcyBhIGxpc3Qgb2YgZWl0aGVyIHRo cmVlCisgIE1vc3Qgb2YgdGhlc2UgZnVuY3Rpb25zIHJlcHJlc2VudCB0aW1lIGFzIGEgbGlz dCBvZiBlaXRoZXIgZm91cgoraW50ZWdlcnMsIEBjb2RleyhAdmFye3NlYy1oaWdofSBAdmFy e3NlYy1sb3d9IEB2YXJ7bWljcm9zZWN9CitAdmFye3BpY29zZWN9KX0sIG9yIG9mIHRocmVl CiBpbnRlZ2VycywgQGNvZGV7KEB2YXJ7c2VjLWhpZ2h9IEB2YXJ7c2VjLWxvd30gQHZhcntt aWNyb3NlY30pfSwgb3Igb2YKIHR3byBpbnRlZ2VycywgQGNvZGV7KEB2YXJ7c2VjLWhpZ2h9 IEB2YXJ7c2VjLWxvd30pfS4gIFRoZSBpbnRlZ2VycwogQHZhcntzZWMtaGlnaH0gYW5kIEB2 YXJ7c2VjLWxvd30gZ2l2ZSB0aGUgaGlnaCBhbmQgbG93IGJpdHMgb2YgYW4KQEAgLTExODIs MTIgKzExODQsMTUgQEAKIFVUQykgdG8gdGhlIHNwZWNpZmllZCB0aW1lLiAgVGhlIHRoaXJk IGxpc3QgZWxlbWVudCBAdmFye21pY3Jvc2VjfSwgaWYKIHByZXNlbnQsIGdpdmVzIHRoZSBu dW1iZXIgb2YgbWljcm9zZWNvbmRzIGZyb20gdGhlIHN0YXJ0IG9mIHRoYXQKIHNlY29uZCB0 byB0aGUgc3BlY2lmaWVkIHRpbWUuCitTaW1pbGFybHksIHRoZSBmb3VydGggbGlzdCBlbGVt ZW50IEB2YXJ7cGljb3NlY30sIGlmIHByZXNlbnQsIGdpdmVzCit0aGUgbnVtYmVyIG9mIHBp Y29zZWNvbmRzIGZyb20gdGhlIHN0YXJ0IG9mIHRoYXQgbWljcm9zZWNvbmQgdG8gdGhlCitz cGVjaWZpZWQgdGltZS4KIAogICBUaGUgcmV0dXJuIHZhbHVlIG9mIEBjb2Rle2N1cnJlbnQt dGltZX0gcmVwcmVzZW50cyB0aW1lIHVzaW5nIHRocmVlCi1pbnRlZ2Vycywgd2hpbGUgdGhl IHRpbWVzdGFtcHMgaW4gdGhlIHJldHVybiB2YWx1ZSBvZgotQGNvZGV7ZmlsZS1hdHRyaWJ1 dGVzfSB1c2UgdHdvIGludGVnZXJzIChAcHhyZWZ7RGVmaW5pdGlvbiBvZgoraW50ZWdlcnMs IGFzIGRvIHRoZSB0aW1lc3RhbXBzIGluIHRoZSByZXR1cm4gdmFsdWUgb2YKK0Bjb2Rle2Zp bGUtYXR0cmlidXRlc30gKEBweHJlZntEZWZpbml0aW9uIG9mCiBmaWxlLWF0dHJpYnV0ZXN9 KS4gIEluIGZ1bmN0aW9uIGFyZ3VtZW50cywgZS5nLkA6IHRoZSBAdmFye3RpbWUtdmFsdWV9 Ci1hcmd1bWVudCB0byBAY29kZXtjdXJyZW50LXRpbWUtc3RyaW5nfSwgYm90aCB0d28tIGFu ZCB0aHJlZS1pbnRlZ2VyCithcmd1bWVudCB0byBAY29kZXtjdXJyZW50LXRpbWUtc3RyaW5n fSwgdHdvLSwgdGhyZWUtLCBhbmQgZm91ci1pbnRlZ2VyCiBsaXN0cyBhcmUgYWNjZXB0ZWQu ICBZb3UgY2FuIGNvbnZlcnQgdGltZXMgZnJvbSB0aGUgbGlzdAogcmVwcmVzZW50YXRpb24g aW50byBzdGFuZGFyZCBodW1hbi1yZWFkYWJsZSBzdHJpbmdzIHVzaW5nCiBAY29kZXtjdXJy ZW50LXRpbWV9LCBvciB0byBvdGhlciBmb3JtcyB1c2luZyB0aGUgQGNvZGV7ZGVjb2RlLXRp bWV9CkBAIC0xMjE3LDkgKzEyMjIsMTIgQEAKIEBlbmQgZGVmdW4KIAogQGRlZnVuIGN1cnJl bnQtdGltZQotVGhpcyBmdW5jdGlvbiByZXR1cm5zIHRoZSBjdXJyZW50IHRpbWUsIHJlcHJl c2VudGVkIGFzIGEgbGlzdCBvZiB0aHJlZQotaW50ZWdlcnMgQGNvZGV7KEB2YXJ7c2VjLWhp Z2h9IEB2YXJ7c2VjLWxvd30gQHZhcnttaWNyb3NlY30pfS4gIE9uCi1zeXN0ZW1zIHdpdGgg b25seSBvbmUtc2Vjb25kIHRpbWUgcmVzb2x1dGlvbnMsIEB2YXJ7bWljcm9zZWN9IGlzIDAu CitUaGlzIGZ1bmN0aW9uIHJldHVybnMgdGhlIGN1cnJlbnQgdGltZSwgcmVwcmVzZW50ZWQg YXMgYSBsaXN0IG9mIGZvdXIKK2ludGVnZXJzIEBjb2RleyhAdmFye3NlYy1oaWdofSBAdmFy e3NlYy1sb3d9IEB2YXJ7bWljcm9zZWN9IEB2YXJ7cGljb3NlY30pfS4KK1RoZXNlIGludGVn ZXJzIGhhdmUgdHJhaWxpbmcgemVyb3Mgb24gc3lzdGVtcyB0aGF0IHJldHVybiB0aW1lIHdp dGgKK2xvd2VyIHJlc29sdXRpb25zLiAgT24gYWxsIGN1cnJlbnQgbWFjaGluZXMgQHZhcntw aWNvc2VjfSBpcyBhCittdWx0aXBsZSBvZiAxMDAwLCBidXQgdGhpcyBtYXkgY2hhbmdlIGFz IGhpZ2hlci1yZXNvbHV0aW9uIGNsb2NrcworYmVjb21lIGF2YWlsYWJsZS4KIEBlbmQgZGVm dW4KIAogQGRlZnVuIGZsb2F0LXRpbWUgJm9wdGlvbmFsIHRpbWUtdmFsdWUKQEAgLTEyNjAs NyArMTI2OCw3IEBACiBAbm9kZSBUaW1lIENvbnZlcnNpb24KIEBzZWN0aW9uIFRpbWUgQ29u dmVyc2lvbgogCi0gIFRoZXNlIGZ1bmN0aW9ucyBjb252ZXJ0IHRpbWUgdmFsdWVzIChsaXN0 cyBvZiB0d28gb3IgdGhyZWUgaW50ZWdlcnMsCisgIFRoZXNlIGZ1bmN0aW9ucyBjb252ZXJ0 IHRpbWUgdmFsdWVzIChsaXN0cyBvZiB0d28gdG8gZm91ciBpbnRlZ2VycywKIGFzIGV4cGxh aW5lZCBpbiB0aGUgcHJldmlvdXMgc2VjdGlvbikgaW50byBjYWxlbmRyaWNhbCBpbmZvcm1h dGlvbiBhbmQKIHZpY2UgdmVyc2EuCiAKQEAgLTE0MTEsOCArMTQxOSw2IEBACiBUaGlzIHN0 YW5kcyBmb3IgdGhlIG5hbm9zZWNvbmRzICgwMDAwMDAwMDAtOTk5OTk5OTk5KS4gIFRvIGFz ayBmb3IKIGZld2VyIGRpZ2l0cywgdXNlIEBzYW1weyUzTn0gZm9yIG1pbGxpc2Vjb25kcywg QHNhbXB7JTZOfSBmb3IKIG1pY3Jvc2Vjb25kcywgZXRjLiAgQW55IGV4Y2VzcyBkaWdpdHMg YXJlIGRpc2NhcmRlZCwgd2l0aG91dCByb3VuZGluZy4KLUN1cnJlbnRseSBFbWFjcyB0aW1l IHN0YW1wcyBhcmUgYXQgYmVzdCBtaWNyb3NlY29uZCByZXNvbHV0aW9uIHNvIHRoZQotbGFz dCB0aHJlZSBkaWdpdHMgZ2VuZXJhdGVkIGJ5IHBsYWluIEBzYW1weyVOfSBhcmUgYWx3YXlz IHplcm8uCiBAaXRlbSAlcAogVGhpcyBzdGFuZHMgZm9yIEBzYW1we0FNfSBvciBAc2FtcHtQ TX0sIGFzIGFwcHJvcHJpYXRlLgogQGl0ZW0gJXIKQEAgLTE1NjQsMTggKzE1NzAsOSBAQAog CiBAZGVmdW4gZ2V0LWludGVybmFsLXJ1bi10aW1lCiBUaGlzIGZ1bmN0aW9uIHJldHVybnMg dGhlIHByb2Nlc3NvciBydW4gdGltZSB1c2VkIGJ5IEVtYWNzIGFzIGEgbGlzdAotb2YgdGhy ZWUgaW50ZWdlcnM6IEBjb2RleyhAdmFye2hpZ2h9IEB2YXJ7bG93fSBAdmFye21pY3Jvc2Vj fSl9LiAgVGhlCi1pbnRlZ2VycyBAdmFye2hpZ2h9IGFuZCBAdmFye2xvd30gY29tYmluZSB0 byBnaXZlIHRoZSBudW1iZXIgb2YKLXNlY29uZHMsIHdoaWNoIGlzCi1AaWZub3R0ZXgKLUB2 YXJ7aGlnaH0gKiAyKioxNiArIEB2YXJ7bG93fS4KLUBlbmQgaWZub3R0ZXgKLUB0ZXgKLSRo aWdoKjJeezE2fStsb3ckLgotQGVuZCB0ZXgKLQotVGhlIHRoaXJkIGVsZW1lbnQsIEB2YXJ7 bWljcm9zZWN9LCBnaXZlcyB0aGUgbWljcm9zZWNvbmRzIChvciAwIGZvcgotc3lzdGVtcyB0 aGF0IHJldHVybiB0aW1lIHdpdGggdGhlIHJlc29sdXRpb24gb2Ygb25seSBvbmUgc2Vjb25k KS4KK29mIGZvdXIgaW50ZWdlcnM6IEBjb2RleyhAdmFye2hpZ2h9IEB2YXJ7bG93fSBAdmFy e21pY3Jvc2VjfQorQHZhcntwaWNvc2VjfSl9LCB1c2luZyB0aGUgc2FtZSBmb3JtYXQgYXMg QGNvZGV7Y3VycmVudC10aW1lfQorKEBweHJlZntUaW1lIG9mIERheX0pLgogCiBOb3RlIHRo YXQgdGhlIHRpbWUgcmV0dXJuZWQgYnkgdGhpcyBmdW5jdGlvbiBleGNsdWRlcyB0aGUgdGlt ZSBFbWFjcwogd2FzIG5vdCB1c2luZyB0aGUgcHJvY2Vzc29yLCBhbmQgaWYgdGhlIEVtYWNz IHByb2Nlc3MgaGFzIHNldmVyYWwKQEAgLTE4MTgsMTAgKzE4MTUsOSBAQAogCiBAZGVmdW4g Y3VycmVudC1pZGxlLXRpbWUKIElmIEVtYWNzIGlzIGlkbGUsIHRoaXMgZnVuY3Rpb24gcmV0 dXJucyB0aGUgbGVuZ3RoIG9mIHRpbWUgRW1hY3MgaGFzCi1iZWVuIGlkbGUsIGFzIGEgbGlz dCBvZiB0aHJlZSBpbnRlZ2VyczogQGNvZGV7KEB2YXJ7c2VjLWhpZ2h9Ci1AdmFye3NlYy1s b3d9IEB2YXJ7bWljcm9zZWN9KX0sIHdoZXJlIEB2YXJ7aGlnaH0gYW5kIEB2YXJ7bG93fSBh cmUgdGhlCi1oaWdoIGFuZCBsb3cgYml0cyBmb3IgdGhlIG51bWJlciBvZiBzZWNvbmRzIGFu ZCBAdmFye21pY3Jvc2VjfSBpcyB0aGUKLWFkZGl0aW9uYWwgbnVtYmVyIG9mIG1pY3Jvc2Vj b25kcyAoQHB4cmVme1RpbWUgb2YgRGF5fSkuCitiZWVuIGlkbGUsIGFzIGEgbGlzdCBvZiBm b3VyIGludGVnZXJzOiBAY29kZXsoQHZhcntzZWMtaGlnaH0KK0B2YXJ7c2VjLWxvd30gQHZh cnttaWNyb3NlY30gQHZhcntwaWNvc2VjfSl9LCB1c2luZyB0aGUgc2FtZSBmb3JtYXQgYXMK K0Bjb2Rle2N1cnJlbnQtdGltZX0gKEBweHJlZntUaW1lIG9mIERheX0pLgogCiBXaGVuIEVt YWNzIGlzIG5vdCBpZGxlLCBAY29kZXtjdXJyZW50LWlkbGUtdGltZX0gcmV0dXJucyBAY29k ZXtuaWx9LgogVGhpcyBpcyBhIGNvbnZlbmllbnQgd2F5IHRvIHRlc3Qgd2hldGhlciBFbWFj cyBpcyBpZGxlLgoKPT09IG1vZGlmaWVkIGZpbGUgJ2RvYy9saXNwcmVmL3Byb2Nlc3Nlcy50 ZXhpJwotLS0gZG9jL2xpc3ByZWYvcHJvY2Vzc2VzLnRleGkJMjAxMi0wNS0wMiAxMzowMDoy OSArMDAwMAorKysgZG9jL2xpc3ByZWYvcHJvY2Vzc2VzLnRleGkJMjAxMi0wNS0wNCAwNzox Mjo1OSArMDAwMApAQCAtMTc3MCw3ICsxNzcwLDcgQEAKIEBpdGVtIHV0aW1lCiBUaW1lIHNw ZW50IGJ5IHRoZSBwcm9jZXNzIGluIHRoZSB1c2VyIGNvbnRleHQsIGZvciBydW5uaW5nIHRo ZQogYXBwbGljYXRpb24ncyBjb2RlLiAgVGhlIGNvcnJlc3BvbmRpbmcgQHZhcnt2YWx1ZX0g aXMgaW4gdGhlCi1Ad3tAY29kZXsoQHZhcntoaWdofSBAdmFye2xvd30gQHZhcnttaWNyb3Nl Y30pfX0gZm9ybWF0LCB0aGUgc2FtZQorQHd7QGNvZGV7KEB2YXJ7aGlnaH0gQHZhcntsb3d9 IEB2YXJ7bWljcm9zZWN9IEB2YXJ7cGljb3NlY30pfX0gZm9ybWF0LCB0aGUgc2FtZQogZm9y bWF0IHVzZWQgYnkgZnVuY3Rpb25zIEBjb2Rle2N1cnJlbnQtdGltZX0gKEBweHJlZntUaW1l IG9mIERheSwKIGN1cnJlbnQtdGltZX0pIGFuZCBAY29kZXtmaWxlLWF0dHJpYnV0ZXN9IChA cHhyZWZ7RmlsZSBBdHRyaWJ1dGVzfSkuCiAKQEAgLTE4MDEsMTIgKzE4MDEsMTIgQEAKIAog QGl0ZW0gc3RhcnQKIFRoZSB0aW1lIHdoZW4gdGhlIHByb2Nlc3Mgd2FzIHN0YXJ0ZWQsIGlu IHRoZSBzYW1lCi1Ad3tAY29kZXsoQHZhcntoaWdofSBAdmFye2xvd30gQHZhcnttaWNyb3Nl Y30pfX0gZm9ybWF0IHVzZWQgYnkKK0B3e0Bjb2RleyhAdmFye2hpZ2h9IEB2YXJ7bG93fSBA dmFye21pY3Jvc2VjfSBAdmFye3BpY29zZWN9KX19IGZvcm1hdCB1c2VkIGJ5CiBAY29kZXtj dXJyZW50LXRpbWV9IGFuZCBAY29kZXtmaWxlLWF0dHJpYnV0ZXN9LgogCiBAaXRlbSBldGlt ZQogVGhlIHRpbWUgZWxhcHNlZCBzaW5jZSB0aGUgcHJvY2VzcyBzdGFydGVkLCBpbiB0aGUg QHd7QGNvZGV7KEB2YXJ7aGlnaH0KLUB2YXJ7bG93fSBAdmFye21pY3Jvc2VjfSl9fSBmb3Jt YXQuCitAdmFye2xvd30gQHZhcnttaWNyb3NlY30gQHZhcntwaWNvc2VjfSl9fSBmb3JtYXQu CiAKIEBpdGVtIHZzaXplCiBUaGUgdmlydHVhbCBtZW1vcnkgc2l6ZSBvZiB0aGUgcHJvY2Vz cywgbWVhc3VyZWQgaW4ga2lsb2J5dGVzLgoKPT09IG1vZGlmaWVkIGZpbGUgJ2V0Yy9DaGFu Z2VMb2cnCi0tLSBldGMvQ2hhbmdlTG9nCTIwMTItMDUtMDMgMjA6MDQ6MjkgKzAwMDAKKysr IGV0Yy9DaGFuZ2VMb2cJMjAxMi0wNS0wNCAyMDoyOTo1OCArMDAwMApAQCAtMSwzICsxLDgg QEAKKzIwMTItMDUtMDQgIFBhdWwgRWdnZXJ0ICA8ZWdnZXJ0QGNzLnVjbGEuZWR1PgorCisJ U3VwcG9ydCBoaWdoZXItcmVzb2x1dGlvbiB0aW1lIHN0YW1wcyAoQnVnIzkwMDApLgorCSog TkVXUzogTWVudGlvbiBhZGRpdGlvbiBvZiBwaWNvc2Vjb25kcyB0byB0aW1lIHN0YW1wIGZv cm1hdC4KKwogMjAxMi0wNS0wMyAgUGF1bCBFZ2dlcnQgIDxlZ2dlcnRAY3MudWNsYS5lZHU+ CiAKIAkqIE5FV1M6IERvIG5vdCBsaW1pdCBjdXJyZW50LXRpbWUtc3RyaW5nIHRvIHllYXJz IDEwMDAuLjk5OTkuCgo9PT0gbW9kaWZpZWQgZmlsZSAnZXRjL05FV1MnCi0tLSBldGMvTkVX UwkyMDEyLTA1LTA0IDE5OjE0OjQyICswMDAwCisrKyBldGMvTkVXUwkyMDEyLTA1LTA0IDIw OjE0OjQ5ICswMDAwCkBAIC00Nyw2ICs0NywxMyBAQAogDAogKiBDaGFuZ2VzIGluIEVtYWNz IDI0LjIKIAorKiogVGhlIGZ1bmN0aW9uIGBjdXJyZW50LXRpbWUnIG5vdyByZXR1cm5zIGV4 dGVuZGVkLWZvcm1hdCB0aW1lIHN0YW1wcworKEhJR0ggTE9XIFVTRUMgUFNFQykgdGhhdCB1 c2UgcGljb3NlY29uZCByZXNvbHV0aW9uOyB0aGUgUFNFQworY29tcG9uZW50IGlzIG5ldy4g IFBTRUMgaXMgdHlwaWNhbGx5IGEgbXVsdGlwbGUgb2YgMTAwMCBvbiBjdXJyZW50CittYWNo aW5lcy4gIE90aGVyIGZ1bmN0aW9ucyB0aGF0IHVzZSB0aGlzIGZvcm1hdCwgc3VjaCBhcwor ZmlsZS1hdHRyaWJ1dGVzIGFuZCBmb3JtYXQtdGltZS1zdHJpbmcsIGhhdmUgYmVlbiBjaGFu Z2VkIGFjY29yZGluZ2x5LgorT2xkLWZvcm1hdCB0aW1lIHN0YW1wcyBhcmUgc3RpbGwgYWNj ZXB0ZWQuCisKICoqIE5ldyBmdW5jdGlvbnMgYHN5c3RlbS11c2VycycsIGBzeXN0ZW0tZ3Jv dXBzJyByZXR1cm4gbGlzdHMgb2YgdGhlIHVzZXIKIG5hbWUsIGdyb3VwIG5hbWVzIGtub3du IHRvIHRoZSBzeXN0ZW0gKHdoZXJlIHBvc3NpYmxlKS4KIAoKPT09IG1vZGlmaWVkIGZpbGUg J2xpYi1zcmMvQ2hhbmdlTG9nJwotLS0gbGliLXNyYy9DaGFuZ2VMb2cJMjAxMi0wNS0wMiAx MTo0MzoxNCArMDAwMAorKysgbGliLXNyYy9DaGFuZ2VMb2cJMjAxMi0wNS0wNCAyMDoyOTo1 OCArMDAwMApAQCAtMSwzICsxLDEzIEBACisyMDEyLTA1LTA0ICBQYXVsIEVnZ2VydCAgPGVn Z2VydEBjcy51Y2xhLmVkdT4KKworCVN1cHBvcnQgaGlnaGVyLXJlc29sdXRpb24gdGltZSBz dGFtcHMgKEJ1ZyM5MDAwKS4KKwkqIE1ha2VmaWxlLmluIChMSUJfQ0xPQ0tfR0VUVElNRSk6 IE5ldyBtYWNyby4KKwkocHJvZmlsZSR7RVhFRVhUfSk6IFVzZSBpdC4KKwkqIHByb2ZpbGUu YzogSW5jbHVkZSBpbnR0eWVwcy5oLCBpbnRwcm9wcy5oLgorCSh0aW1lX3N0cmluZyk6IFNp emUgY29uc2VydmF0aXZlbHk7IGRvIG5vdCBndWVzcyBzaXplLgorCShnZXRfdGltZSk6IE5v dyBwcmludHMgbmFub3NlY29uZHMuCisJKGdldHRpbWVvZmRheSk6IFJlbW92ZSByZXBsYWNl bWVudCBmdW5jdGlvbjsgZ251bGliIG5vdyBkb2VzIHRoaXMuCisKIDIwMTItMDUtMDIgIEp1 YW5tYSBCYXJyYW5xdWVybyAgPGxla2t0dUBnbWFpbC5jb20+CiAKIAkqIGVtYWNzY2xpZW50 LmMgKG1pbik6IFVuZGVmIGJlZm9yZSByZWRlZmluaW5nIGl0LgoKPT09IG1vZGlmaWVkIGZp bGUgJ2xpYi1zcmMvTWFrZWZpbGUuaW4nCi0tLSBsaWItc3JjL01ha2VmaWxlLmluCTIwMTIt MDQtMDkgMDc6NDU6NTkgKzAwMDAKKysrIGxpYi1zcmMvTWFrZWZpbGUuaW4JMjAxMi0wNS0w NCAwNjo0MjowMyArMDAwMApAQCAtMTU3LDYgKzE1Nyw4IEBACiBMSUJSRVNPTFY9QExJQlJF U09MVkAKICMjIC1sbG9ja2ZpbGUgaWYgSEFWRV9MSUJMT0NLRklMRSBvciAtbG1haWwgaWYg SEFWRV9MSUJNQUlMCiBMSUJTX01BSUw9QExJQlNfTUFJTEAKKyMjIGVtcHR5IG9yIC1scnQg b3IgLWxwb3NpeDQgaWYgSEFWRV9DTE9DS19HRVRUSU1FCitMSUJfQ0xPQ0tfR0VUVElNRSA9 IEBMSUJfQ0xPQ0tfR0VUVElNRUAKIAogIyMgRXh0cmEgbGlicmFyaWVzIHRvIHVzZSB3aGVu IGxpbmtpbmcgbW92ZW1haWwuCiBMSUJTX01PVkUgPSAkKExJQlNfTUFJTCkgJChLUkI0TElC KSAkKERFU0xJQikgJChLUkI1TElCKSAkKENSWVBUT0xJQikgXApAQCAtMzMwLDcgKzMzMiw4 IEBACiAJICByZWdleC5vICQoTE9BRExJQkVTKSAtbyBjdGFncwogCiBwcm9maWxlJHtFWEVF WFR9OiAke3NyY2Rpcn0vcHJvZmlsZS5jIC4uL3NyYy9jb25maWcuaAotCSQoQ0MpICR7QUxM X0NGTEFHU30gJHtzcmNkaXJ9L3Byb2ZpbGUuYyAkKExPQURMSUJFUykgLW8gcHJvZmlsZQor CSQoQ0MpICR7QUxMX0NGTEFHU30gJHtzcmNkaXJ9L3Byb2ZpbGUuYyBcCisJICAkKExPQURM SUJFUykgJChMSUJfQ0xPQ0tfR0VUVElNRSkgLW8gcHJvZmlsZQogCiBtYWtlLWRvY2ZpbGUk e0VYRUVYVH06ICR7c3JjZGlyfS9tYWtlLWRvY2ZpbGUuYyAuLi9zcmMvY29uZmlnLmgKIAkk KENDKSAke0FMTF9DRkxBR1N9ICR7c3JjZGlyfS9tYWtlLWRvY2ZpbGUuYyAkKExPQURMSUJF UykgXAoKPT09IG1vZGlmaWVkIGZpbGUgJ2xpYi1zcmMvcHJvZmlsZS5jJwotLS0gbGliLXNy Yy9wcm9maWxlLmMJMjAxMi0wMS0xOSAwNzoyMToyNSArMDAwMAorKysgbGliLXNyYy9wcm9m aWxlLmMJMjAxMi0wNS0wNCAwNjo0MjowMyArMDAwMApAQCAtMjksMTIgKzI5LDE3IEBACiAg KiogIG9wZXJhdGlvbnM6IHJlc2V0X3dhdGNoLCBnZXRfdGltZQogICovCiAjaW5jbHVkZSA8 Y29uZmlnLmg+CisKKyNpbmNsdWRlIDxpbnR0eXBlcy5oPgogI2luY2x1ZGUgPHN0ZGlvLmg+ CisKKyNpbmNsdWRlIDxpbnRwcm9wcy5oPgogI2luY2x1ZGUgPHN5c3RpbWUuaD4KIAogc3Rh dGljIEVNQUNTX1RJTUUgVFYxLCBUVjI7CiBzdGF0aWMgaW50IHdhdGNoX25vdF9zdGFydGVk ID0gMTsgLyogZmxhZyAqLwotc3RhdGljIGNoYXIgdGltZV9zdHJpbmdbMzBdOworc3RhdGlj IGNoYXIgdGltZV9zdHJpbmdbSU5UX1NUUkxFTl9CT1VORCAodWludG1heF90KSArIHNpemVv ZiAiLiIKKwkJCSsgTE9HMTBfRU1BQ1NfVElNRV9SRVNPTFVUSU9OXTsKIAogLyogUmVzZXQg dGhlIHN0b3B3YXRjaCB0byB6ZXJvLiAgKi8KIApAQCAtNDYsMzYgKzUxLDIzIEBACiB9CiAK IC8qIFRoaXMgY2FsbCByZXR1cm5zIHRoZSB0aW1lIHNpbmNlIHRoZSBsYXN0IHJlc2V0X3dh dGNoIGNhbGwuICBUaGUgdGltZQotICAgaXMgcmV0dXJuZWQgYXMgYSBzdHJpbmcgd2l0aCB0 aGUgZm9ybWF0ICA8c2Vjb25kcz4uPG1pY3JvLXNlY29uZHM+CisgICBpcyByZXR1cm5lZCBh cyBhIHN0cmluZyB3aXRoIHRoZSBmb3JtYXQgIDxzZWNvbmRzPi48bmFub3NlY29uZHM+CiAg ICBJZiByZXNldF93YXRjaCB3YXMgbm90IGNhbGxlZCB5ZXQsIGV4aXQuICAqLwogCiBzdGF0 aWMgY2hhciAqCiBnZXRfdGltZSAodm9pZCkKIHsKKyAgdWludG1heF90IHM7CisgIGludCBu czsKICAgaWYgKHdhdGNoX25vdF9zdGFydGVkKQogICAgIGV4aXQgKEVYSVRfRkFJTFVSRSk7 ICAvKiBjYWxsIHJlc2V0X3dhdGNoIGZpcnN0ICEgKi8KICAgRU1BQ1NfR0VUX1RJTUUgKFRW Mik7CiAgIEVNQUNTX1NVQl9USU1FIChUVjIsIFRWMiwgVFYxKTsKLSAgc3ByaW50ZiAodGlt ZV9zdHJpbmcsICIlbHUuJTA2bHUiLCAodW5zaWduZWQgbG9uZylFTUFDU19TRUNTIChUVjIp LCAodW5zaWduZWQgbG9uZylFTUFDU19VU0VDUyAoVFYyKSk7CisgIHMgPSBFTUFDU19TRUNT IChUVjIpOworICBucyA9IEVNQUNTX05TRUNTIChUVjIpOworICBzcHJpbnRmICh0aW1lX3N0 cmluZywgIiUiUFJJdU1BWCIuJTAqZCIsIHMsIExPRzEwX0VNQUNTX1RJTUVfUkVTT0xVVElP TiwgbnMpOwogICByZXR1cm4gdGltZV9zdHJpbmc7CiB9Ci0KLSNpZiAhIGRlZmluZWQgKEhB VkVfR0VUVElNRU9GREFZKSAmJiBkZWZpbmVkIChIQVZFX1RJTUVWQUwpCi0KLS8qIEFSR1NV U0VEICovCi1nZXR0aW1lb2ZkYXkgKHRwLCB0enApCi0gICAgIHN0cnVjdCB0aW1ldmFsICp0 cDsKLSAgICAgc3RydWN0IHRpbWV6b25lICp0enA7Ci17Ci0gIGV4dGVybiBsb25nIHRpbWUg KCk7Ci0KLSAgdHAtPnR2X3NlYyA9IHRpbWUgKChsb25nICopMCk7Ci0gIHRwLT50dl91c2Vj ID0gMDsKLSAgaWYgKHR6cCAhPSAwKQotICAgIHR6cC0+dHpfbWludXRlc3dlc3QgPSAtMTsK LX0KLQotI2VuZGlmCiAMCiBpbnQKIG1haW4gKHZvaWQpCgo9PT0gbW9kaWZpZWQgZmlsZSAn bGlzcC9DaGFuZ2VMb2cnCi0tLSBsaXNwL0NoYW5nZUxvZwkyMDEyLTA1LTA0IDE5OjE3OjAx ICswMDAwCisrKyBsaXNwL0NoYW5nZUxvZwkyMDEyLTA1LTA0IDIwOjI5OjU4ICswMDAwCkBA IC0xLDMgKzEsMjYgQEAKKzIwMTItMDUtMDQgIFBhdWwgRWdnZXJ0ICA8ZWdnZXJ0QGNzLnVj bGEuZWR1PgorCisJU3VwcG9ydCBoaWdoZXItcmVzb2x1dGlvbiB0aW1lIHN0YW1wcyAoQnVn IzkwMDApLgorCisJKiBjYWxlbmRhci90aW1lLWRhdGUuZWwgKHdpdGgtZGVjb2RlZC10aW1l LXZhbHVlKTogTmV3IGFyZworCVBJQ08tU1lNQk9MIGluIFZBUkxJU1QuICBJdCdzIG9wdGlv bmFsLCBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eS4KKwkoZW5jb2RlLXRpbWUtdmFsdWUp OiBOZXcgb3B0aW9uYWwgYXJnIFBJQ08uICBOZXcgdHlwZSAzLgorCSh0aW1lLXRvLXNlY29u ZHMpIFshZmxvYXQtdGltZV06IFN1cHBvcnQgdGhlIG5ldyBwaWNvc2Vjb25kcworCWNvbXBv bmVudCBpZiBpdCdzIHVzZWQuCisJKHNlY29uZHMtdG8tdGltZSwgdGltZS1zdWJ0cmFjdCwg dGltZS1hZGQpOgorCVN1cHBvcnQgcHMtcmVzb2x1dGlvbiB0aW1lIHN0YW1wcyBhcyB3ZWxs LgorCisJKiBlbWFjcy1saXNwL3RpbWVyLmVsICh0aW1lcik6IE5ldyBjb21wb25lbnQgcHNl Y3MuICBBbGwgdXNlcyBjaGFuZ2VkLgorCSh0aW1lcnApOiBUaW1lciB2ZWN0b3JzIG5vdyBo YXZlIGxlbmd0aCA5LCBub3QgOC4KKwkodGltZXItLXRpbWUpOiBTdXBwb3J0IG5ldy1zdHls ZSAoNC1wYXJ0KSB0aW1lIHN0YW1wcy4KKwkodGltZXItbmV4dC1pbnRlZ3JhbC1tdWx0aXBs ZS1vZi10aW1lKTogVGltZSBzdGFtcHMgbm93IGhhdmUKKwlwaWNvc2Vjb25kIHJlc29sdXRp b24sIHNvIHRha2UgYSBiaXQgbW9yZSBjYXJlIGFib3V0IHJvdW5kaW5nLgorCSh0aW1lci1y ZWxhdGl2ZS10aW1lLCB0aW1lci1pbmMtdGltZSk6IE5ldyBvcHRpb25hbCBhcmcgcHNlY3Mu CisJKHRpbWVyLXNldC10aW1lLXdpdGgtdXNlY3MpOiBTZXQgcHNlY3MgdG8gMC4KKwkodGlt ZXItLWFjdGl2YXRlKTogQ2hlY2sgcHNlY3MgY29tcG9uZW50LCB0b28uCisKKwkqIGxpc3Av cHJvY2VkLmVsIChwcm9jZWQtdGltZS1sZXNzcCk6IFN1cHBvcnQgcHMtcmVzb2x1dGlvbiBz dGFtcHMuCisKIDIwMTItMDUtMDQgIFN0ZWZhbiBNb25uaWVyICA8bW9ubmllckBpcm8udW1v bnRyZWFsLmNhPgogCiAJKiBkYWJicmV2LmVsIChkYWJicmV2LS1pZ25vcmUtY2FzZS1wKTog TmV3IGZ1bmN0aW9uLgoKPT09IG1vZGlmaWVkIGZpbGUgJ2xpc3AvY2FsZW5kYXIvdGltZS1k YXRlLmVsJwotLS0gbGlzcC9jYWxlbmRhci90aW1lLWRhdGUuZWwJMjAxMi0wMS0xOSAwNzoy MToyNSArMDAwMAorKysgbGlzcC9jYWxlbmRhci90aW1lLWRhdGUuZWwJMjAxMi0wNS0wNCAw Njo0MjowMyArMDAwMApAQCAtMjMsMTUgKzIzLDE1IEBACiAKIDs7OyBDb21tZW50YXJ5Ogog Ci07OyBUaW1lIHZhbHVlcyBjb21lIGluIHRocmVlIGZvcm1hdHMuICBUaGUgb2xkZXN0IGZv cm1hdCBpcyBhIGNvbnMKKzs7IFRpbWUgdmFsdWVzIGNvbWUgaW4gc2V2ZXJhbCBmb3JtYXRz LiAgVGhlIG9sZGVzdCBmb3JtYXQgaXMgYSBjb25zCiA7OyBjZWxsIG9mIHRoZSBmb3JtIChI SUdIIC4gTE9XKS4gIFRoaXMgZm9ybWF0IGlzIG9ic29sZXRlLCBidXQgc3RpbGwKLTs7IHN1 cHBvcnRlZC4gIFRoZSB0d28gb3RoZXIgZm9ybWF0cyBhcmUgdGhlIGxpc3RzIChISUdIIExP VykgYW5kCi07OyAoSElHSCBMT1cgTUlDUk8pLiAgVGhlIGZpcnN0IHR3byBmb3JtYXRzIHNw ZWNpZnkgSElHSCAqIDJeMTYgKyBMT1cKLTs7IHNlY29uZHM7IHRoZSB0aGlyZCBmb3JtYXQg c3BlY2lmaWVzIEhJR0ggKiAyXjE2ICsgTE9XICsgTUlDUk8gLwotOzsgMTAwMDAwMCBzZWNv bmRzLiAgV2Ugc2hvdWxkIGhhdmUgMCA8PSBNSUNSTyA8IDEwMDAwMDAgYW5kIDAgPD0gTE9X Ci07OyA8IDJeMTYuICBJZiB0aGUgdGltZSB2YWx1ZSByZXByZXNlbnRzIGEgcG9pbnQgaW4g dGltZSwgdGhlbiBISUdIIGlzCi07OyBub25uZWdhdGl2ZS4gIElmIHRoZSB0aW1lIHZhbHVl IGlzIGEgdGltZSBkaWZmZXJlbmNlLCB0aGVuIEhJR0ggY2FuCi07OyBiZSBuZWdhdGl2ZSBh cyB3ZWxsLiAgVGhlIG1hY3JvIGB3aXRoLWRlY29kZWQtdGltZS12YWx1ZScgYW5kIHRoZQor Ozsgc3VwcG9ydGVkLiAgVGhlIG90aGVyIGZvcm1hdHMgYXJlIHRoZSBsaXN0cyAoSElHSCBM T1cpLCAoSElHSCBMT1cKKzs7IFVTRUMpLCBhbmQgKEhJR0ggTE9XIFVTRUMgUFNFQykuICBU aGVzZSBmb3JtYXRzIHNwZWNpZnkgdGhlIHRpbWUKKzs7IHZhbHVlIGVxdWFsIHRvIEhJR0gg KiAyXjE2ICsgTE9XICsgVVNFQyAqIDEwXi02ICsgUFNFQyAqIDEwXi0xMgorOzsgc2Vjb25k cywgd2hlcmUgbWlzc2luZyBjb21wb25lbnRzIGFyZSB0cmVhdGVkIGFzIHplcm8uICBISUdI IGNhbiBiZQorOzsgbmVnYXRpdmUsIGVpdGhlciBiZWNhdXNlIHRoZSB2YWx1ZSBpcyBhIHRp bWUgZGlmZmVyZW5jZSwgb3IgYmVjYXVzZQorOzsgdGhlIG1hY2hpbmUgc3VwcG9ydHMgbmVn YXRpdmUgdGltZSBzdGFtcHMgdGhhdCBmYWxsIGJlZm9yZSB0aGUKKzs7IGVwb2NoLiAgVGhl IG1hY3JvIGB3aXRoLWRlY29kZWQtdGltZS12YWx1ZScgYW5kIHRoZQogOzsgZnVuY3Rpb24g YGVuY29kZS10aW1lLXZhbHVlJyBtYWtlIGl0IGVhc2llciB0byBkZWFsIHdpdGggdGhlc2UK IDs7IHRocmVlIGZvcm1hdHMuICBTZWUgYHRpbWUtc3VidHJhY3QnIGZvciBhbiBleGFtcGxl IG9mIGhvdyB0byB1c2UKIDs7IHRoZW0uCkBAIC00NCwxMyArNDQsMTUgQEAKIFRoZSB2YWx1 ZSBvZiB0aGUgbGFzdCBmb3JtIGluIEJPRFkgaXMgcmV0dXJuZWQuCiAKIEVhY2ggZWxlbWVu dCBvZiB0aGUgbGlzdCBWQVJMSVNUIGlzIGEgbGlzdCBvZiB0aGUgZm9ybQotXChISUdILVNZ TUJPTCBMT1ctU1lNQk9MIE1JQ1JPLVNZTUJPTCBbVFlQRS1TWU1CT0xdIFRJTUUtVkFMVUUp LgorXChISUdILVNZTUJPTCBMT1ctU1lNQk9MIE1JQ1JPLVNZTUJPTCBbUElDTy1TWU1CT0wg W1RZUEUtU1lNQk9MXV0gVElNRS1WQUxVRSkuCiBUaGUgdGltZSB2YWx1ZSBUSU1FLVZBTFVF IGlzIGRlY29kZWQgYW5kIHRoZSByZXN1bHQgaXQgYm91bmQgdG8KIHRoZSBzeW1ib2xzIEhJ R0gtU1lNQk9MLCBMT1ctU1lNQk9MIGFuZCBNSUNSTy1TWU1CT0wuCitUaGUgb3B0aW9uYWwg UElDTy1TWU1CT0wgaXMgYm91bmQgdG8gdGhlIHBpY29zZWNvbmRzIHBhcnQuCiAKIFRoZSBv cHRpb25hbCBUWVBFLVNZTUJPTCBpcyBib3VuZCB0byB0aGUgdHlwZSBvZiB0aGUgdGltZSB2 YWx1ZS4KIFR5cGUgMCBpcyB0aGUgY29ucyBjZWxsIChISUdIIC4gTE9XKSwgdHlwZSAxIGlz IHRoZSBsaXN0IChISUdICi1MT1cpLCBhbmQgdHlwZSAyIGlzIHRoZSBsaXN0IChISUdIIExP VyBNSUNSTykuIgorTE9XKSwgdHlwZSAyIGlzIHRoZSBsaXN0IChISUdIIExPVyBNSUNSTyks IGFuZCB0eXBlIDMgaXMgdGhlCitsaXN0IChISUdIIExPVyBNSUNSTyBQSUNPKS4iCiAgIChk ZWNsYXJlIChpbmRlbnQgMSkKIAkgICAoZGVidWcgKCgmcmVzdCAoc3ltYm9scCBzeW1ib2xw IHN5bWJvbHAgJm9yIFtzeW1ib2xwIGZvcm1dIGZvcm0pKQogCQkgICBib2R5KSkpCkBAIC01 OSw2ICs2MSw4IEBACiAJICAgICAoaGlnaCAocG9wIGVsdCkpCiAJICAgICAobG93IChwb3Ag ZWx0KSkKIAkgICAgIChtaWNybyAocG9wIGVsdCkpCisJICAgICAocGljbyAodW5sZXNzICg8 PSAobGVuZ3RoIGVsdCkgMikKKwkJICAgICAocG9wIGVsdCkpKQogCSAgICAgKHR5cGUgKHVu bGVzcyAoZXEgKGxlbmd0aCBlbHQpIDEpCiAJCSAgICAgKHBvcCBlbHQpKSkKIAkgICAgICh0 aW1lLXZhbHVlIChjYXIgZWx0KSkKQEAgLTY2LDI4ICs3MCw0NCBAQAogCWAobGV0KiAsKGFw cGVuZCBgKCgsZ2Vuc3ltICx0aW1lLXZhbHVlKQogCQkJICAoLGhpZ2ggKHBvcCAsZ2Vuc3lt KSkKIAkJCSAgLGxvdyAsbWljcm8pCisJCQkod2hlbiBwaWNvIGAoLHBpY28pKQogCQkJKHdo ZW4gdHlwZSBgKCx0eXBlKSkpCiAJICAgKGlmIChjb25zcCAsZ2Vuc3ltKQogCSAgICAgICAo cHJvZ24KIAkJIChzZXRxICxsb3cgKHBvcCAsZ2Vuc3ltKSkKIAkJIChpZiAsZ2Vuc3ltCi0J CSAgICAgLChhcHBlbmQgYChzZXRxICxtaWNybyAoY2FyICxnZW5zeW0pKQotCQkJICAgICAg KHdoZW4gdHlwZSBgKCx0eXBlIDIpKSkKKwkJICAgICAocHJvZ24KKwkJICAgICAgIChzZXRx ICxtaWNybyAoY2FyICxnZW5zeW0pKQorCQkgICAgICAgLChjb25kIChwaWNvCisJCQkgICAg ICAgYChpZiAoY2RyICxnZW5zeW0pCisJCQkJICAgICwoYXBwZW5kIGAoc2V0cSAscGljbyAo Y2FkciAsZ2Vuc3ltKSkKKwkJCQkJICAgICAod2hlbiB0eXBlIGAoLHR5cGUgMykpKQorCQkJ CSAgLChhcHBlbmQgYChzZXRxICxwaWNvIDApCisJCQkJCSAgICh3aGVuIHR5cGUgYCgsdHlw ZSAyKSkpKSkKKwkJCSAgICAgICh0eXBlCisJCQkgICAgICAgYChzZXRxIHR5cGUgMikpKSkK IAkJICAgLChhcHBlbmQgYChzZXRxICxtaWNybyAwKQorCQkJICAgICh3aGVuIHBpY28gYCgs cGljbyAwKSkKIAkJCSAgICAod2hlbiB0eXBlIGAoLHR5cGUgMSkpKSkpCiAJICAgICAsKGFw cGVuZCBgKHNldHEgLGxvdyAsZ2Vuc3ltICxtaWNybyAwKQorCQkgICAgICAod2hlbiBwaWNv IGAoLHBpY28gMCkpCiAJCSAgICAgICh3aGVuIHR5cGUgYCgsdHlwZSAwKSkpKQogCSAgICh3 aXRoLWRlY29kZWQtdGltZS12YWx1ZSAsdmFybGlzdCAsQGJvZHkpKSkKICAgICBgKHByb2du ICxAYm9keSkpKQogCi0oZGVmdW4gZW5jb2RlLXRpbWUtdmFsdWUgKGhpZ2ggbG93IG1pY3Jv IHR5cGUpCi0gICJFbmNvZGUgSElHSCwgTE9XLCBhbmQgTUlDUk8gaW50byBhIHRpbWUgdmFs dWUgb2YgdHlwZSBUWVBFLgorKGRlZnVuIGVuY29kZS10aW1lLXZhbHVlIChoaWdoIGxvdyBt aWNybyBwaWNvICZvcHRpb25hbCB0eXBlKQorICAiRW5jb2RlIEhJR0gsIExPVywgTUlDUk8s IGFuZCBQSUNPIGludG8gYSB0aW1lIHZhbHVlIG9mIHR5cGUgVFlQRS4KIFR5cGUgMCBpcyB0 aGUgY29ucyBjZWxsIChISUdIIC4gTE9XKSwgdHlwZSAxIGlzIHRoZSBsaXN0IChISUdIIExP VyksCi1hbmQgdHlwZSAyIGlzIHRoZSBsaXN0IChISUdIIExPVyBNSUNSTykuIgordHlwZSAy IGlzIChISUdIIExPVyBNSUNSTyksIGFuZCB0eXBlIDMgaXMgKEhJR0ggTE9XIE1JQ1JPIFBJ Q08pLgorCitGb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSwgaWYgb25seSBmb3VyIGFyZ3Vt ZW50cyBhcmUgZ2l2ZW4sCitpdCBpcyBhc3N1bWVkIHRoYXQgUElDTyB3YXMgb21pdHRlZCBh bmQgc2hvdWxkIGJlIHRyZWF0ZWQgYXMgemVyby4iCiAgIChjb25kCiAgICAoKGVxIHR5cGUg MCkgKGNvbnMgaGlnaCBsb3cpKQogICAgKChlcSB0eXBlIDEpIChsaXN0IGhpZ2ggbG93KSkK LSAgICgoZXEgdHlwZSAyKSAobGlzdCBoaWdoIGxvdyBtaWNybykpKSkKKyAgICgoZXEgdHlw ZSAyKSAobGlzdCBoaWdoIGxvdyBtaWNybykpCisgICAoKGVxIHR5cGUgMykgKGxpc3QgaGln aCBsb3cgbWljcm8gcGljbykpCisgICAoKG51bGwgdHlwZSkgKGVuY29kZS10aW1lLXZhbHVl IGhpZ2ggbG93IG1pY3JvIDAgcGljbykpKSkKIAogKGF1dG9sb2FkICdwYXJzZS10aW1lLXN0 cmluZyAicGFyc2UtdGltZSIpCiAoYXV0b2xvYWQgJ3RpbWV6b25lLW1ha2UtZGF0ZS1hcnBh LXN0YW5kYXJkICJ0aW1lem9uZSIpCkBAIC0xMjUsMjggKzE0NSw0NSBAQAogICAgICAgICAg ICAoc3VicnAgKHN5bWJvbC1mdW5jdGlvbiAnZmxvYXQtdGltZSkpKQogICAgICAgKGRlZnVu IHRpbWUtdG8tc2Vjb25kcyAodGltZSkKICAgICAgICAgIkNvbnZlcnQgdGltZSB2YWx1ZSBU SU1FIHRvIGEgZmxvYXRpbmcgcG9pbnQgbnVtYmVyLiIKLSAgICAgICAgKHdpdGgtZGVjb2Rl ZC10aW1lLXZhbHVlICgoaGlnaCBsb3cgbWljcm8gdGltZSkpCisgICAgICAgICh3aXRoLWRl Y29kZWQtdGltZS12YWx1ZSAoKGhpZ2ggbG93IG1pY3JvIHBpY28gdHlwZSB0aW1lKSkKICAg ICAgICAgICAoKyAoKiAxLjAgaGlnaCA2NTUzNikKICAgICAgICAgICAgICBsb3cKLSAgICAg ICAgICAgICAoLyBtaWNybyAxMDAwMDAwLjApKSkpKSkKKwkgICAgICgvICgrICgqIG1pY3Jv IDFlNikgcGljbykgMWUxMikpKSkpKQogCiA7OzsjIyNhdXRvbG9hZAogKGRlZnVuIHNlY29u ZHMtdG8tdGltZSAoc2Vjb25kcykKICAgIkNvbnZlcnQgU0VDT05EUyAoYSBmbG9hdGluZyBw b2ludCBudW1iZXIpIHRvIGEgdGltZSB2YWx1ZS4iCi0gIChsaXN0IChmbG9vciBzZWNvbmRz IDY1NTM2KQotCShmbG9vciAobW9kIHNlY29uZHMgNjU1MzYpKQotCShmbG9vciAoKiAoLSBz ZWNvbmRzIChmZmxvb3Igc2Vjb25kcykpIDEwMDAwMDApKSkpCisgIChsZXQqICgodXNlYyAo KiAxMDAwMDAwIChtb2Qgc2Vjb25kcyAxKSkpCisJIChwcyAocm91bmQgKCogMTAwMDAwMCAo bW9kIHVzZWMgMSkpKSkKKwkgKHVzIChmbG9vciB1c2VjKSkKKwkgKGxvIChmbG9vciAobW9k IHNlY29uZHMgNjU1MzYpKSkKKwkgKGhpIChmbG9vciBzZWNvbmRzIDY1NTM2KSkpCisgICAg KGlmIChlcSBwcyAxMDAwMDAwKQorCShwcm9nbgorCSAgKHNldHEgcHMgMCkKKwkgIChzZXRx IHVzICgxKyB1cykpCisJICAoaWYgKGVxIHVzIDEwMDAwMDApCisJICAgICAgKHByb2duCisJ CShzZXRxIHVzIDApCisJCShzZXRxIGxvICgxKyBsbykpCisJCShpZiAoZXEgbG8gNjU1MzYp CisJCSAgICAocHJvZ24KKwkJICAgICAgKHNldHEgbG8gMCkKKwkJICAgICAgKHNldHEgaGkg KDErIGhpKSkpKSkpKSkKKyAgICAobGlzdCBoaSBsbyB1cyBwcykpKQogCiA7OzsjIyNhdXRv bG9hZAogKGRlZnVuIHRpbWUtbGVzcy1wICh0MSB0MikKICAgIlJldHVybiBub24tbmlsIGlm IHRpbWUgdmFsdWUgVDEgaXMgZWFybGllciB0aGFuIHRpbWUgdmFsdWUgVDIuIgotICAod2l0 aC1kZWNvZGVkLXRpbWUtdmFsdWUgKChoaWdoMSBsb3cxIG1pY3JvMSB0MSkKLQkJCSAgICAo aGlnaDIgbG93MiBtaWNybzIgdDIpKQorICAod2l0aC1kZWNvZGVkLXRpbWUtdmFsdWUgKCho aWdoMSBsb3cxIG1pY3JvMSBwaWNvMSB0eXBlMSB0MSkKKwkJCSAgICAoaGlnaDIgbG93MiBt aWNybzIgcGljbzIgdHlwZTIgdDIpKQogICAgIChvciAoPCBoaWdoMSBoaWdoMikKIAkoYW5k ICg9IGhpZ2gxIGhpZ2gyKQogCSAgICAgKG9yICg8IGxvdzEgbG93MikKIAkJIChhbmQgKD0g bG93MSBsb3cyKQotCQkgICAgICAoPCBtaWNybzEgbWljcm8yKSkpKSkpKQorCQkgICAgICAo b3IgKDwgbWljcm8xIG1pY3JvMikKKwkJCSAgKGFuZCAoPSBtaWNybzEgbWljcm8yKQorCQkJ ICAgICAgICg8IHBpY28xIHBpY28yKSkpKSkpKSkpCiAKIDs7OyMjI2F1dG9sb2FkCiAoZGVm dW4gZGF5cy10by10aW1lIChkYXlzKQpAQCAtMTczLDM2ICsyMTAsNDQgQEAKIChkZWZ1biB0 aW1lLXN1YnRyYWN0ICh0MSB0MikKICAgIlN1YnRyYWN0IHR3byB0aW1lIHZhbHVlcywgVDEg bWludXMgVDIuCiBSZXR1cm4gdGhlIGRpZmZlcmVuY2UgaW4gdGhlIGZvcm1hdCBvZiBhIHRp bWUgdmFsdWUuIgotICAod2l0aC1kZWNvZGVkLXRpbWUtdmFsdWUgKChoaWdoIGxvdyBtaWNy byB0eXBlIHQxKQotCQkJICAgIChoaWdoMiBsb3cyIG1pY3JvMiB0eXBlMiB0MikpCisgICh3 aXRoLWRlY29kZWQtdGltZS12YWx1ZSAoKGhpZ2ggbG93IG1pY3JvIHBpY28gdHlwZSB0MSkK KwkJCSAgICAoaGlnaDIgbG93MiBtaWNybzIgcGljbzIgdHlwZTIgdDIpKQogICAgIChzZXRx IGhpZ2ggKC0gaGlnaCBoaWdoMikKIAkgIGxvdyAoLSBsb3cgbG93MikKIAkgIG1pY3JvICgt IG1pY3JvIG1pY3JvMikKKwkgIHBpY28gKC0gcGljbyBwaWNvMikKIAkgIHR5cGUgKG1heCB0 eXBlIHR5cGUyKSkKKyAgICAod2hlbiAoPCBwaWNvIDApCisgICAgICAoc2V0cSBtaWNybyAo MS0gbWljcm8pCisJICAgIHBpY28gKCsgcGljbyAxMDAwMDAwKSkpCiAgICAgKHdoZW4gKDwg bWljcm8gMCkKICAgICAgIChzZXRxIGxvdyAoMS0gbG93KQogCSAgICBtaWNybyAoKyBtaWNy byAxMDAwMDAwKSkpCiAgICAgKHdoZW4gKDwgbG93IDApCiAgICAgICAoc2V0cSBoaWdoICgx LSBoaWdoKQogCSAgICBsb3cgKCsgbG93IDY1NTM2KSkpCi0gICAgKGVuY29kZS10aW1lLXZh bHVlIGhpZ2ggbG93IG1pY3JvIHR5cGUpKSkKKyAgICAoZW5jb2RlLXRpbWUtdmFsdWUgaGln aCBsb3cgbWljcm8gcGljbyB0eXBlKSkpCiAKIDs7OyMjI2F1dG9sb2FkCiAoZGVmdW4gdGlt ZS1hZGQgKHQxIHQyKQogICAiQWRkIHR3byB0aW1lIHZhbHVlcyBUMSBhbmQgVDIuICBPbmUg c2hvdWxkIHJlcHJlc2VudCBhIHRpbWUgZGlmZmVyZW5jZS4iCi0gICh3aXRoLWRlY29kZWQt dGltZS12YWx1ZSAoKGhpZ2ggbG93IG1pY3JvIHR5cGUgdDEpCi0JCQkgICAgKGhpZ2gyIGxv dzIgbWljcm8yIHR5cGUyIHQyKSkKKyAgKHdpdGgtZGVjb2RlZC10aW1lLXZhbHVlICgoaGln aCBsb3cgbWljcm8gcGljbyB0eXBlIHQxKQorCQkJICAgIChoaWdoMiBsb3cyIG1pY3JvMiBw aWNvMiB0eXBlMiB0MikpCiAgICAgKHNldHEgaGlnaCAoKyBoaWdoIGhpZ2gyKQogCSAgbG93 ICgrIGxvdyBsb3cyKQogCSAgbWljcm8gKCsgbWljcm8gbWljcm8yKQorCSAgcGljbyAoKyBw aWNvIHBpY28yKQogCSAgdHlwZSAobWF4IHR5cGUgdHlwZTIpKQorICAgICh3aGVuICg+PSBw aWNvIDEwMDAwMDApCisgICAgICAoc2V0cSBtaWNybyAoMSsgbWljcm8pCisJICAgIHBpY28g KC0gcGljbyAxMDAwMDAwKSkpCiAgICAgKHdoZW4gKD49IG1pY3JvIDEwMDAwMDApCiAgICAg ICAoc2V0cSBsb3cgKDErIGxvdykKIAkgICAgbWljcm8gKC0gbWljcm8gMTAwMDAwMCkpKQog ICAgICh3aGVuICg+PSBsb3cgNjU1MzYpCiAgICAgICAoc2V0cSBoaWdoICgxKyBoaWdoKQog CSAgICBsb3cgKC0gbG93IDY1NTM2KSkpCi0gICAgKGVuY29kZS10aW1lLXZhbHVlIGhpZ2gg bG93IG1pY3JvIHR5cGUpKSkKKyAgICAoZW5jb2RlLXRpbWUtdmFsdWUgaGlnaCBsb3cgbWlj cm8gcGljbyB0eXBlKSkpCiAKIDs7OyMjI2F1dG9sb2FkCiAoZGVmdW4gZGF0ZS10by1kYXkg KGRhdGUpCgo9PT0gbW9kaWZpZWQgZmlsZSAnbGlzcC9lbWFjcy1saXNwL3RpbWVyLmVsJwot LS0gbGlzcC9lbWFjcy1saXNwL3RpbWVyLmVsCTIwMTItMDUtMDQgMDU6MTQ6MTQgKzAwMDAK KysrIGxpc3AvZW1hY3MtbGlzcC90aW1lci5lbAkyMDEyLTA1LTA0IDA3OjEyOjU5ICswMDAw CkBAIC0yOCw3ICsyOCw3IEBACiA7OzsgQ29kZToKIAogOzsgTGF5b3V0IG9mIGEgdGltZXIg dmVjdG9yOgotOzsgW3RyaWdnZXJlZC1wIGhpZ2gtc2Vjb25kcyBsb3ctc2Vjb25kcyB1c2Vj cyByZXBlYXQtZGVsYXkKKzs7IFt0cmlnZ2VyZWQtcCBoaWdoLXNlY29uZHMgbG93LXNlY29u ZHMgdXNlY3MgcHNlY3MgcmVwZWF0LWRlbGF5CiA7OyAgZnVuY3Rpb24gYXJncyBpZGxlLWRl bGF5XQogOzsgdHJpZ2dlcmVkLXAgaXMgbmlsIGlmIHRoZSB0aW1lciBpcyBhY3RpdmUgKHdh aXRpbmcgdG8gYmUgdHJpZ2dlcmVkKSwKIDs7ICB0IGlmIGl0IGlzIGluYWN0aXZlICgiYWxy ZWFkeSB0cmlnZ2VyZWQiLCBpbiB0aGVvcnkpCkBAIC00MiwyNyArNDIsMzUgQEAKICAgICAg ICAgICAgICg6dHlwZSB2ZWN0b3IpCiAgICAgICAgICAgICAoOmNvbmMtbmFtZSB0aW1lci0t KSkKICAgKHRyaWdnZXJlZCB0KQotICBoaWdoLXNlY29uZHMgbG93LXNlY29uZHMgdXNlY3Mg cmVwZWF0LWRlbGF5IGZ1bmN0aW9uIGFyZ3MgaWRsZS1kZWxheSkKKyAgaGlnaC1zZWNvbmRz IGxvdy1zZWNvbmRzIHVzZWNzIHBzZWNzIHJlcGVhdC1kZWxheSBmdW5jdGlvbiBhcmdzIGlk bGUtZGVsYXkpCiAKIChkZWZ1biB0aW1lcnAgKG9iamVjdCkKICAgIlJldHVybiB0IGlmIE9C SkVDVCBpcyBhIHRpbWVyLiIKLSAgKGFuZCAodmVjdG9ycCBvYmplY3QpICg9IChsZW5ndGgg b2JqZWN0KSA4KSkpCisgIChhbmQgKHZlY3RvcnAgb2JqZWN0KSAoPSAobGVuZ3RoIG9iamVj dCkgOSkpKQogCiA7OyBQc2V1ZG8gZmllbGQgYHRpbWUnLgogKGRlZnVuIHRpbWVyLS10aW1l ICh0aW1lcikKICAgKGxpc3QgKHRpbWVyLS1oaWdoLXNlY29uZHMgdGltZXIpCiAgICAgICAg ICh0aW1lci0tbG93LXNlY29uZHMgdGltZXIpCi0gICAgICAgICh0aW1lci0tdXNlY3MgdGlt ZXIpKSkKKwkodGltZXItLXVzZWNzIHRpbWVyKQorCSh0aW1lci0tcHNlY3MgdGltZXIpKSkK IAogKGRlZnNldGYgdGltZXItLXRpbWUKICAgKGxhbWJkYSAodGltZXIgdGltZSkKICAgICAo b3IgKHRpbWVycCB0aW1lcikgKGVycm9yICJJbnZhbGlkIHRpbWVyIikpCiAgICAgKHNldGYg KHRpbWVyLS1oaWdoLXNlY29uZHMgdGltZXIpIChwb3AgdGltZSkpCi0gICAgKHNldGYgKHRp bWVyLS1sb3ctc2Vjb25kcyB0aW1lcikKLQkgIChpZiAoY29uc3AgdGltZSkgKGNhciB0aW1l KSB0aW1lKSkKLSAgICAoc2V0ZiAodGltZXItLXVzZWNzIHRpbWVyKSAob3IgKGFuZCAoY29u c3AgdGltZSkgKGNvbnNwIChjZHIgdGltZSkpCi0JCQkJCShjYWRyIHRpbWUpKQotCQkJCSAg IDApKSkpCisgICAgKGxldCAoKGxvdyB0aW1lKSAodXNlY3MgMCkgKHBzZWNzIDApKQorICAg ICAgKGlmIChjb25zcCB0aW1lKQorCSAgKHByb2duCisJICAgIChzZXRxIGxvdyAocG9wIHRp bWUpKQorCSAgICAoaWYgdGltZQorCQkocHJvZ24KKwkJICAoc2V0cSB1c2VjcyAocG9wIHRp bWUpKQorCQkgIChpZiB0aW1lCisJCSAgICAgIChzZXRxIHBzZWNzIChjYXIgdGltZSkpKSkp KSkKKyAgICAgIChzZXRmICh0aW1lci0tbG93LXNlY29uZHMgdGltZXIpIGxvdykKKyAgICAg IChzZXRmICh0aW1lci0tdXNlY3MgdGltZXIpIHVzZWNzKQorICAgICAgKHNldGYgKHRpbWVy LS1wc2VjcyB0aW1lcikgcHNlY3MpKSkpCiAKIAogKGRlZnVuIHRpbWVyLXNldC10aW1lICh0 aW1lciB0aW1lICZvcHRpb25hbCBkZWx0YSkKQEAgLTc3LDcgKzg1LDcgQEAKIChkZWZ1biB0 aW1lci1zZXQtaWRsZS10aW1lICh0aW1lciBzZWNzICZvcHRpb25hbCByZXBlYXQpCiAgICJT ZXQgdGhlIHRyaWdnZXIgaWRsZSB0aW1lIG9mIFRJTUVSIHRvIFNFQ1MuCiBTRUNTIG1heSBi ZSBhbiBpbnRlZ2VyLCBmbG9hdGluZyBwb2ludCBudW1iZXIsIG9yIHRoZSBpbnRlcm5hbAot dGltZSBmb3JtYXQgKEhJR0ggTE9XIFVTRUNTKSByZXR1cm5lZCBieSwgZS5nLiwgYGN1cnJl bnQtaWRsZS10aW1lJy4KK3RpbWUgZm9ybWF0IHJldHVybmVkIGJ5LCBlLmcuLCBgY3VycmVu dC1pZGxlLXRpbWUnLgogSWYgb3B0aW9uYWwgdGhpcmQgYXJndW1lbnQgUkVQRUFUIGlzIG5v bi1uaWwsIG1ha2UgdGhlIHRpbWVyCiBmaXJlIGVhY2ggdGltZSBFbWFjcyBpcyBpZGxlIGZv ciB0aGF0IG1hbnkgc2Vjb25kcy4iCiAgIChpZiAoY29uc3Agc2VjcykKQEAgLTkxLDQxICs5 OSw0NiBAQAogICAiWWllbGQgdGhlIG5leHQgdmFsdWUgYWZ0ZXIgVElNRSB0aGF0IGlzIGFu IGludGVncmFsIG11bHRpcGxlIG9mIFNFQ1MuCiBNb3JlIHByZWNpc2VseSwgdGhlIG5leHQg dmFsdWUsIGFmdGVyIFRJTUUsIHRoYXQgaXMgYW4gaW50ZWdyYWwgbXVsdGlwbGUKIG9mIFNF Q1Mgc2Vjb25kcyBzaW5jZSB0aGUgZXBvY2guICBTRUNTIG1heSBiZSBhIGZyYWN0aW9uLiIK LSAgKGxldCAoKHRpbWUtYmFzZSAoYXNoIDEgMTYpKSkKLSAgICA7OyBVc2UgZmxvYXRpbmcg cG9pbnQsIHRha2luZyBjYXJlIHRvIG5vdCBsb3NlIHByZWNpc2lvbi4KLSAgICAobGV0KiAo KGZsb2F0LXRpbWUtYmFzZSAoZmxvYXQgdGltZS1iYXNlKSkKLQkgICAobWlsbGlvbiAxMDAw MDAwLjApCi0JICAgKHRpbWUtdXNlYyAoKyAoKiBtaWxsaW9uCi0JCQkgICAgKCsgKCogZmxv YXQtdGltZS1iYXNlIChudGggMCB0aW1lKSkKLQkJCSAgICAgICAobnRoIDEgdGltZSkpKQot CQkJIChudGggMiB0aW1lKSkpCi0JICAgKHNlY3MtdXNlYyAoKiBtaWxsaW9uIHNlY3MpKQot CSAgIChtb2QtdXNlYyAobW9kIHRpbWUtdXNlYyBzZWNzLXVzZWMpKQotCSAgIChuZXh0LXVz ZWMgKCsgKC0gdGltZS11c2VjIG1vZC11c2VjKSBzZWNzLXVzZWMpKQotCSAgICh0aW1lLWJh c2UtbWlsbGlvbiAoKiBmbG9hdC10aW1lLWJhc2UgbWlsbGlvbikpKQotICAgICAgKGxpc3Qg KGZsb29yIG5leHQtdXNlYyB0aW1lLWJhc2UtbWlsbGlvbikKLQkgICAgKGZsb29yIChtb2Qg bmV4dC11c2VjIHRpbWUtYmFzZS1taWxsaW9uKSBtaWxsaW9uKQotCSAgICAoZmxvb3IgKG1v ZCBuZXh0LXVzZWMgbWlsbGlvbikpKSkpKQorICAobGV0KiAoKHRyaWxsaW9uIDFlMTIpCisJ ICh0aW1lLXNlYyAoKyAobnRoIDEgdGltZSkKKwkJICAgICAgKCogNjU1MzYuMCAobnRoIDAg dGltZSkpKSkKKwkgKGRlbHRhLXNlYyAobW9kICgtIHRpbWUtc2VjKSBzZWNzKSkKKwkgKG5l eHQtc2VjICgrIHRpbWUtc2VjIChmZmxvb3IgZGVsdGEtc2VjKSkpCisJIChuZXh0LXNlYy1w c2VjIChmZmxvb3IgKCogdHJpbGxpb24gKG1vZCBkZWx0YS1zZWMgMSkpKSkKKwkgKHN1Yi10 aW1lLXBzZWMgKCsgKG9yIChudGggMyB0aW1lKSAwKQorCQkJICAgKCogMWU2IChudGggMiB0 aW1lKSkpKQorCSAocHNlYy1kaWZmICgtIHN1Yi10aW1lLXBzZWMgbmV4dC1zZWMtcHNlYykp KQorICAgIChpZiAoYW5kICg8PSBuZXh0LXNlYyB0aW1lLXNlYykgKDwgMCBwc2VjLWRpZmYp KQorCShzZXRxIG5leHQtc2VjLXBzZWMgKCsgc3ViLXRpbWUtcHNlYworCQkJICAgICAgICht b2QgKC0gcHNlYy1kaWZmKSAoKiB0cmlsbGlvbiBzZWNzKSkpKSkKKyAgICAoc2V0cSBuZXh0 LXNlYyAoKyBuZXh0LXNlYyAoZmxvb3IgbmV4dC1zZWMtcHNlYyB0cmlsbGlvbikpKQorICAg IChzZXRxIG5leHQtc2VjLXBzZWMgKG1vZCBuZXh0LXNlYy1wc2VjIHRyaWxsaW9uKSkKKyAg ICAobGlzdCAoZmxvb3IgbmV4dC1zZWMgNjU1MzYpCisJICAoZmxvb3IgKG1vZCBuZXh0LXNl YyA2NTUzNikpCisJICAoZmxvb3IgbmV4dC1zZWMtcHNlYyAxMDAwMDAwKQorCSAgKGZsb29y IChtb2QgbmV4dC1zZWMtcHNlYyAxMDAwMDAwKSkpKSkKIAotKGRlZnVuIHRpbWVyLXJlbGF0 aXZlLXRpbWUgKHRpbWUgc2VjcyAmb3B0aW9uYWwgdXNlY3MpCi0gICJBZHZhbmNlIFRJTUUg YnkgU0VDUyBzZWNvbmRzIGFuZCBvcHRpb25hbGx5IFVTRUNTIG1pY3Jvc2Vjb25kcy4KLVNF Q1MgbWF5IGJlIGVpdGhlciBhbiBpbnRlZ2VyIG9yIGEgZmxvYXRpbmcgcG9pbnQgbnVtYmVy LiIKKyhkZWZ1biB0aW1lci1yZWxhdGl2ZS10aW1lICh0aW1lIHNlY3MgJm9wdGlvbmFsIHVz ZWNzIHBzZWNzKQorICAiQWR2YW5jZSBUSU1FIGJ5IFNFQ1Mgc2Vjb25kcyBhbmQgb3B0aW9u YWxseSBVU0VDUyBuYW5vc2Vjb25kcworYW5kIFBTRUNTIHBpY29zZWNvbmRzLiAgU0VDUyBt YXkgYmUgZWl0aGVyIGFuIGludGVnZXIgb3IgYQorZmxvYXRpbmcgcG9pbnQgbnVtYmVyLiIK ICAgKGxldCAoKGRlbHRhIChpZiAoZmxvYXRwIHNlY3MpCiAJCSAgIChzZWNvbmRzLXRvLXRp bWUgc2VjcykKIAkJIChsaXN0IChmbG9vciBzZWNzIDY1NTM2KSAobW9kIHNlY3MgNjU1MzYp KSkpKQotICAgIChpZiB1c2VjcwotCShzZXRxIGRlbHRhICh0aW1lLWFkZCBkZWx0YSAobGlz dCAwIDAgdXNlY3MpKSkpCisgICAgKGlmIChvciB1c2VjcyBwc2VjcykKKwkoc2V0cSBkZWx0 YSAodGltZS1hZGQgZGVsdGEgKGxpc3QgMCAwIChvciB1c2VjcyAwKSAob3IgcHNlY3MgMCkp KSkpCiAgICAgKHRpbWUtYWRkIHRpbWUgZGVsdGEpKSkKIAogKGRlZnVuIHRpbWVyLS10aW1l LWxlc3MtcCAodDEgdDIpCiAgICJTYXkgd2hldGhlciB0aW1lIHZhbHVlIFQxIGlzIGxlc3Mg dGhhbiB0aW1lIHZhbHVlIFQyLiIKICAgKHRpbWUtbGVzcy1wICh0aW1lci0tdGltZSB0MSkg KHRpbWVyLS10aW1lIHQyKSkpCiAKLShkZWZ1biB0aW1lci1pbmMtdGltZSAodGltZXIgc2Vj cyAmb3B0aW9uYWwgdXNlY3MpCi0gICJJbmNyZW1lbnQgdGhlIHRpbWUgc2V0IGluIFRJTUVS IGJ5IFNFQ1Mgc2Vjb25kcyBhbmQgVVNFQ1MgbWljcm9zZWNvbmRzLgotU0VDUyBtYXkgYmUg YSBmcmFjdGlvbi4gIElmIFVTRUNTIGlzIG9taXR0ZWQsIHRoYXQgbWVhbnMgaXQgaXMgemVy by4iCisoZGVmdW4gdGltZXItaW5jLXRpbWUgKHRpbWVyIHNlY3MgJm9wdGlvbmFsIHVzZWNz IHBzZWNzKQorICAiSW5jcmVtZW50IHRoZSB0aW1lIHNldCBpbiBUSU1FUiBieSBTRUNTIHNl Y29uZHMsIFVTRUNTIG5hbm9zZWNvbmRzLAorYW5kIFBTRUNTIHBpY29zZWNvbmRzLiAgU0VD UyBtYXkgYmUgYSBmcmFjdGlvbi4gIElmIFVTRUNTIG9yIFBTRUNTIGFyZQorb21pdHRlZCwg dGhleSBhcmUgdHJlYXRlZCBhcyB6ZXJvLiIKICAgKHNldGYgKHRpbWVyLS10aW1lIHRpbWVy KQotICAgICAgICAodGltZXItcmVsYXRpdmUtdGltZSAodGltZXItLXRpbWUgdGltZXIpIHNl Y3MgdXNlY3MpKSkKKyAgICAgICAgKHRpbWVyLXJlbGF0aXZlLXRpbWUgKHRpbWVyLS10aW1l IHRpbWVyKSBzZWNzIHVzZWNzIHBzZWNzKSkpCiAKIChkZWZ1biB0aW1lci1zZXQtdGltZS13 aXRoLXVzZWNzICh0aW1lciB0aW1lIHVzZWNzICZvcHRpb25hbCBkZWx0YSkKICAgIlNldCB0 aGUgdHJpZ2dlciB0aW1lIG9mIFRJTUVSIHRvIFRJTUUgcGx1cyBVU0VDUy4KQEAgLTEzNSw2 ICsxNDgsNyBAQAogZmlyZSByZXBlYXRlZGx5IHRoYXQgbWFueSBzZWNvbmRzIGFwYXJ0LiIK ICAgKHNldGYgKHRpbWVyLS10aW1lIHRpbWVyKSB0aW1lKQogICAoc2V0ZiAodGltZXItLXVz ZWNzIHRpbWVyKSB1c2VjcykKKyAgKHNldGYgKHRpbWVyLS1wc2VjcyB0aW1lcikgMCkKICAg KHNldGYgKHRpbWVyLS1yZXBlYXQtZGVsYXkgdGltZXIpIChhbmQgKG51bWJlcnAgZGVsdGEp ICg+IGRlbHRhIDApIGRlbHRhKSkKICAgdGltZXIpCiAobWFrZS1vYnNvbGV0ZSAndGltZXIt c2V0LXRpbWUtd2l0aC11c2VjcwpAQCAtMTU0LDYgKzE2OCw3IEBACiAJICAgKGludGVnZXJw ICh0aW1lci0taGlnaC1zZWNvbmRzIHRpbWVyKSkKIAkgICAoaW50ZWdlcnAgKHRpbWVyLS1s b3ctc2Vjb25kcyB0aW1lcikpCiAJICAgKGludGVnZXJwICh0aW1lci0tdXNlY3MgdGltZXIp KQorCSAgIChpbnRlZ2VycCAodGltZXItLXBzZWNzIHRpbWVyKSkKIAkgICAodGltZXItLWZ1 bmN0aW9uIHRpbWVyKSkKICAgICAgIChsZXQgKCh0aW1lcnMgKGlmIGlkbGUgdGltZXItaWRs ZS1saXN0IHRpbWVyLWxpc3QpKQogCSAgICBsYXN0KQpAQCAtMzg2LDcgKzQwMSw3IEBACiAg ICJQZXJmb3JtIGFuIGFjdGlvbiB0aGUgbmV4dCB0aW1lIEVtYWNzIGlzIGlkbGUgZm9yIFNF Q1Mgc2Vjb25kcy4KIFRoZSBhY3Rpb24gaXMgdG8gY2FsbCBGVU5DVElPTiB3aXRoIGFyZ3Vt ZW50cyBBUkdTLgogU0VDUyBtYXkgYmUgYW4gaW50ZWdlciwgYSBmbG9hdGluZyBwb2ludCBu dW1iZXIsIG9yIHRoZSBpbnRlcm5hbAotdGltZSBmb3JtYXQgKEhJR0ggTE9XIFVTRUNTKSBy ZXR1cm5lZCBieSwgZS5nLiwgYGN1cnJlbnQtaWRsZS10aW1lJy4KK3RpbWUgZm9ybWF0IHJl dHVybmVkIGJ5LCBlLmcuLCBgY3VycmVudC1pZGxlLXRpbWUnLgogSWYgRW1hY3MgaXMgY3Vy cmVudGx5IGlkbGUsIGFuZCBoYXMgYmVlbiBpZGxlIGZvciBOIHNlY29uZHMgKE4gPCBTRUNT KSwKIHRoZW4gaXQgd2lsbCBjYWxsIEZVTkNUSU9OIGluIFNFQ1MgLSBOIHNlY29uZHMgZnJv bSBub3cuCiAKCj09PSBtb2RpZmllZCBmaWxlICdsaXNwL3Byb2NlZC5lbCcKLS0tIGxpc3Av cHJvY2VkLmVsCTIwMTItMDEtMTkgMDc6MjE6MjUgKzAwMDAKKysrIGxpc3AvcHJvY2VkLmVs CTIwMTItMDUtMDQgMDY6NDI6MDMgKzAwMDAKQEAgLTExNzAsMTQgKzExNzAsMTYgQEAKIChk ZWZ1biBwcm9jZWQtdGltZS1sZXNzcCAodDEgdDIpCiAgICJSZXR1cm4gdCBpZiB0aW1lIHZh bHVlIFQxIGlzIGxlc3MgdGhhbiB0aW1lIHZhbHVlIFQyLgogUmV0dXJuIGBlcXVhbCcgaWYg VDEgZXF1YWxzIFQyLiAgUmV0dXJuIG5pbCBvdGhlcndpc2UuIgotICAod2l0aC1kZWNvZGVk LXRpbWUtdmFsdWUgKChoaWdoMSBsb3cxIG1pY3JvMSB0MSkKLQkJCSAgICAoaGlnaDIgbG93 MiBtaWNybzIgdDIpKQorICAod2l0aC1kZWNvZGVkLXRpbWUtdmFsdWUgKChoaWdoMSBsb3cx IG1pY3JvMSBwaWNvMSB0eXBlMSB0MSkKKwkJCSAgICAoaGlnaDIgbG93MiBtaWNybzIgcGlj bzIgdHlwZTIgdDIpKQogICAgIChjb25kICgoPCBoaWdoMSBoaWdoMikpCiAgICAgICAgICAg KCg8IGhpZ2gyIGhpZ2gxKSBuaWwpCiAgICAgICAgICAgKCg8IGxvdzEgbG93MikpCiAgICAg ICAgICAgKCg8IGxvdzIgbG93MSkgbmlsKQogICAgICAgICAgICgoPCBtaWNybzEgbWljcm8y KSkKICAgICAgICAgICAoKDwgbWljcm8yIG1pY3JvMSkgbmlsKQorCSAgKCg8IHBpY28xIHBp Y28yKSkKKwkgICgoPCBwaWNvMiBwaWNvMSkgbmlsKQogICAgICAgICAgICh0ICdlcXVhbCkp KSkKIAogOzs7IFNvcnRpbmcKCj09PSBtb2RpZmllZCBmaWxlICdzcmMvQ2hhbmdlTG9nJwot LS0gc3JjL0NoYW5nZUxvZwkyMDEyLTA1LTAzIDIwOjA0OjI5ICswMDAwCisrKyBzcmMvQ2hh bmdlTG9nCTIwMTItMDUtMDQgMjA6Mjk6NTggKzAwMDAKQEAgLTEsMyArMSwxNzIgQEAKKzIw MTItMDUtMDQgIFBhdWwgRWdnZXJ0ICA8ZWdnZXJ0QGNzLnVjbGEuZWR1PgorCisJU3VwcG9y dCBoaWdoZXItcmVzb2x1dGlvbiB0aW1lIHN0YW1wcyAoQnVnIzkwMDApLgorCVRoZSB0aW1l IHN0YW1wcyBhcmUgb25seSBuYW5vc2Vjb25kLXJlc29sdXRpb24gYXQgdGhlIEMgbGV2ZWws CisJc2luY2UgdGhhdCdzIHRoZSBiZXN0IHRoYXQgYW55IHJlYWwtd29ybGQgc3lzdGVtIHN1 cHBvcnRzIG5vdy4KKwlCdXQgdGhleSBhcmUgcGljb3NlY29uZC1yZXNvbHV0aW9uIGF0IHRo ZSBMaXNwIGxldmVsLCBhcyB0aGF0J3MKKwllYXN5LCBhbmQgbGVhdmVzIHJvb20gZm9yIGZ1 dHVyZSBPUyBpbXByb3ZlbWVudHMuCisKKwkqIE1ha2VmaWxlLmluIChMSUJfQ0xPQ0tfR0VU VElNRSk6IE5ldyBtYWNyby4KKwkoTElCRVMpOiBVc2UgaXQuCisKKwkqIGFsbG9jLmMgKEZn YXJiYWdlX2NvbGxlY3QpOiBQb3J0IHRvIGhpZ2hlci1yZXMgdGltZSBzdGFtcHMuCisJRG9u J3QgZ2V0IGN1cnJlbnQgdGltZSB1bmxlc3MgaXQncyBuZWVkZWQuCisKKwkqIGF0aW1lci5j OiBJbmNsdWRlIDxzeXMvdGltZS5oPiB1bmNvbmRpdGlvbmFsbHksIHNpbmNlIGdudWxpYgor CW5vdyBwcm92aWRlcyBpdCBpZiBpdCdzIGFic2VudC4KKwkoc3RhcnRfYXRpbWVyKTogUG9y dCB0byBoaWdoZXItcmVzIHRpbWUgc3RhbXBzLgorCUNoZWNrIGZvciB0aW1lIHN0YW1wIG92 ZXJmbG93LiAgRG9uJ3QgZ2V0IGN1cnJlbnQgdGltZSBtb3JlCisJb2Z0ZW4gdGhhbiBpcyBu ZWVkZWQuCisKKwkqIGJ1ZmZlci5oIChzdHJ1Y3QgYnVmZmVyKTogQnVmZmVyIG1vZHRpbWUg bm93IGhhcyBoaWdoIHJlc29sdXRpb24uCisJSW5jbHVkZSBzeXN0aW1lLmgsIG5vdCB0aW1l LmguCisJKE5PTkVYSVNURU5UX01PRFRJTUVfTlNFQ1MsIFVOS05PV05fTU9EVElNRV9OU0VD Uyk6IE5ldyBtYWNyb3MuCisKKwkqIGRpcmVkLmM6IEluY2x1ZGUgc3RhdC10aW1lLmguCisJ KEZmaWxlLWF0dHJpYnV0ZXMpOiBGaWxlIHRpbWVzIG5vdyBoYXZlIGhpZ2hlciByZXNvbHV0 aW9uLgorCisJKiBkaXNwZXh0ZXJuLmggW0hBVkVfV0lORE9XX1NZU1RFTV06IEluY2x1ZGUg c3lzdGltZS5oLgorCShzdHJ1Y3QgaW1hZ2UpOiBUaW1lc3RhbXAgbm93IGhhcyBoaWdoZXIg cmVzb2x1dGlvbi4KKworCSogZGlzcG5ldy5jIChQRVJJT0RJQ19QUkVFTVBUSU9OX0NIRUNL SU5HKTogUmVtb3ZlLCBhcyBFbWFjcyBhbHdheXMKKwloYXMgYXQgbGVhc3QgbWljcm9zZWNv bmRzIG5vdy4gIEFsbCB1c2VzIHJlbW92ZWQuCisJKHVwZGF0ZV9mcmFtZSwgdXBkYXRlX3Np bmdsZV93aW5kb3csIHVwZGF0ZV93aW5kb3csIHVwZGF0ZV9mcmFtZV8xKQorCShGc2xlZXBf Zm9yLCBzaXRfZm9yKTogUG9ydCB0byBoaWdoZXItcmVzb2x1dGlvbiB0aW1lIHN0YW1wcy4K KworCSogZWRpdGZucy5jICh0aW1lX292ZXJmbG93KTogTm93IGV4dGVybi4KKwkoRmN1cnJl bnRfdGltZSwgRmdldF9pbnRlcm5hbF9ydW5fdGltZSwgbWFrZV90aW1lLCBsaXNwX3RpbWVf YXJndW1lbnQpCisJKGZsb2F0LXRpbWUsIEZmb3JtYXRfdGltZV9zdHJpbmcsIEZjdXJyZW50 X3RpbWVfc3RyaW5nKQorCShGY3VycmVudF90aW1lX3pvbmUpOiBBY2NlcHQgYW5kIGdlbmVy YXRlIGhpZ2hlci1yZXNvbHV0aW9uCisJdGltZSBzdGFtcHMuCisJKG1ha2VfdGltZV90YWls LCBtYWtlX2xpc3BfdGltZSwgZGlzc2Fzc2VtYmxlX2xpc3BfdGltZSkKKwkoZGVjb2RlX3Rp bWVfY29tcG9uZW50cywgbGlzcF9zZWNvbmRzX2FyZ3VtZW50KTogTmV3IGZ1bmN0aW9ucy4K KwkobWFrZV90aW1lKTogTm93IHN0YXRpYy4KKwkobGlzcF90aW1lX2FyZ3VtZW50KTogTm93 IHJldHVybnMgRU1BQ1NfVElNRS4gIE5ldyBhcmcgcHBzZWMuCisJUmVwb3J0IGFuIGVycm9y IGlmIHRoZSB0aW1lIGlzIGludmFsaWQsIHJhdGhlciB0aGFuIGhhdmluZyB0aGUgY2FsbGVy CisJZG8gdGhhdC4KKworCSogZmlsZWlvLmM6IEluY2x1ZGUgPHN0YXQtdGltZS5oPgorCShG Y29weV9maWxlKTogQ29weSBoaWdoZXItcmVzb2x1dGlvbiB0aW1lIHN0YW1wcy4KKwlQcmVm ZXIgdG8gc2V0IHRoZSB0aW1lIHN0YW1wIHZpYSBhIGZpbGUgZGVzY3JpcHRvciBpZiB0aGF0 IHdvcmtzLgorCShGc2V0X2ZpbGVfdGltZXMsIEZpbnNlcnRfZmlsZV9jb250ZW50cywgRndy aXRlX3JlZ2lvbikKKwkoRnZlcmlmeV92aXNpdGVkX2ZpbGVfbW9kdGltZSwgRmNsZWFyX3Zp c2l0ZWRfZmlsZV9tb2R0aW1lKQorCShGdmlzaXRlZF9maWxlX21vZHRpbWUsIEZzZXRfdmlz aXRlZF9maWxlX21vZHRpbWUpOgorCVN1cHBvcnQgaGlnaGVyLXJlc29sdXRpb24gdGltZSBz dGFtcHMuCisKKwkqIGZucy5jIChGcmFuZG9tKTogVXNlIG5hbm9zZWNvbmRzLCBub3QgbWlj cm9zZWNvbmRzLCBmb3Igc2VlZC4KKworCSogZ3RrdXRpbC5jICh4Z19tYXliZV9hZGRfdGlt ZXIpOiBQb3J0IHRvIGhpZ2hlci1yZXMgdGltZSBzdGFtcHMuCisKKwkqIGltYWdlLmMgKHBy ZXBhcmVfaW1hZ2VfZm9yX2Rpc3BsYXksIGNsZWFyX2ltYWdlX2NhY2hlKQorCShsb29rdXBf aW1hZ2UpOiBQb3J0IHRvIGhpZ2VyLXJlc29sdXRpb24gdGltZSBzdGFtcHMuCisKKwkqIGtl eWJvYXJkLmMgKHN0YXJ0X3BvbGxpbmcsIGJpbmRfcG9sbGluZ19wZXJpb2QpOgorCUNoZWNr IGZvciB0aW1lIHN0YW1wIG92ZXJmbG93LgorCShyZWFkX2NoYXIsIGtiZF9idWZmZXJfZ2V0 X2V2ZW50LCB0aW1lcl9zdGFydF9pZGxlKQorCSh0aW1lcl9zdG9wX2lkbGUsIHRpbWVyX3Jl c3VtZV9pZGxlLCB0aW1lcl9jaGVja18yLCB0aW1lcl9jaGVjaykKKwkoRmN1cnJlbnRfaWRs ZV90aW1lLCBpbml0X2tleWJvYXJkLCBzZXRfd2FpdGluZ19mb3JfaW5wdXQpOgorCVBvcnQg dG8gaGlnaGVyLXJlc29sdXRpb24gdGltZSBzdGFtcHMuICBEbyBub3QgYXNzdW1lIHRpbWVf dCBpcyBzaWduZWQuCisJKGRlY29kZV90aW1lcik6IE5ldyBmdW5jdGlvbi4gIFRpbWVycyBh cmUgbm93IHZlY3RvcnMgb2YgbGVuZ3RoIDksCisJbm90IDgsIHRvIGFjY29tbW9kYXRlIHRo ZSBwaWNvc2Vjb25kIGNvbXBvbmVudC4KKwkodGltZXJfY2hlY2tfMik6IFVzZSBpdC4KKwor CSogbnN0ZXJtLm0gKHNlbGVjdF90aW1lb3V0LCB0aW1ldmFsX3N1YnRyYWN0KTogUmVtb3Zl LgorCShuc190aW1lb3V0KTogVXNlIEVtYWNzJ3MgZmFjaWxpdGllcyBmb3IgdGltZSBzdGFt cCBhcml0aG1ldGljLAorCWFzIHRoZXkncmUgYSBiaXQgbW9yZSBhY2N1cmF0ZSBhbmQgaGFu ZGxlIG92ZXJmbG93IGJldHRlci4KKwkobnNfc2VsZWN0KTogQ2hhbmdlIHByb3RvdHlwZSB0 byBiZSBjb21wYXRpYmxlIHdpdGggcHNlbGVjdC4KKwkobnNfc2VsZWN0LCBuc190ZXJtX3No dXRkb3duKTogUG9ydCB0byBucy1yZXNvbHV0aW9uIHRpbWUgc3RhbXBzLgorCSogbnN0ZXJt LmggKG5zX3NlbGVjdCk6IEFkanVzdCBwcm90b3R5cGUuCisKKwkqIG1zZG9zLmMgKEVNQUNT X1RJTUVfWkVST19PUl9ORUdfUCk6IFJlbW92ZSwgYXMgaXQgYXNzdW1lcworCXVzLXJlc29s dXRpb24gdGltZSBzdGFtcHMuCisJKHN5c19zZWxlY3QpOiBVc2UgdGhlIG5ldyBFTUFDU19U SU1FX1NJR04gbWFjcm8gaW5zdGVhZC4KKworCSogbHJlYWQuYyAocmVhZF9maWx0ZXJlZF9l dmVudCk6IFBvcnQgdG8gbnMtcmVzb2x1dGlvbiB0aW1lIHN0YW1wcy4KKworCSogbGlzcC5o ICh0aW1lX292ZXJmbG93KTogTmV3IGRlY2wuCisJKHdhaXRfcmVhZGluZ19wcm9jZXNzX291 dHB1dCk6IEZpcnN0IGFyZyBpcyBub3cgaW50bWF4X3QsIG5vdCBpbnQsCisJdG8gYWNjb21t b2RhdGUgbGFyZ2VyIHdhaXRzLgorCisJKiBwcm9jZXNzLmggKHN0cnVjdCBMaXNwX1Byb2Nl c3MucmVhZF9vdXRwdXRfZGVsYXkpOgorCU5vdyBjb3VudHMgbmFub3NlY29uZHMsIG5vdCBt aWNyb3NlY29uZHMuCisJKiBwcm9jZXNzLmMgKEFEQVBUSVZFX1JFQURfQlVGRkVSSU5HKTog RG9uJ3Qgd29ycnkgYWJvdXQKKwlFTUFDU19IQVNfVVNFQ1MuCisJKFJFQURfT1VUUFVUX0RF TEFZX0lOQ1JFTUVOVCwgRmFjY2VwdF9wcm9jZXNzX291dHB1dCkKKwkod2FpdF9yZWFkaW5n X3Byb2Nlc3Nfb3V0cHV0KToKKwlQb3J0IHRvIG5zLXJlc29sdXRpb24gdGltZSBzdGFtcHMu CisJKEZhY2NlcHRfcHJvY2Vzc19vdXRwdXQsIHdhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1 dCk6CisJQ2hlY2sgZm9yIHRpbWUgc3RhbXAgb3ZlcmZsb3cuICBEbyBub3QgYXNzdW1lIHRp bWVfdCBpcyBzaWduZWQuCisJKHNlbGVjdF93cmFwcGVyKTogUmVtb3ZlOyB3ZSBub3cgdXNl IHBzZWxlY3QuCisJKEZwcm9jZXNzX2F0dHJpYnV0ZXMpOiBOb3cgZ2VuZXJhdGVzIG5zLXJl c29sdXRpb24gdGltZSBzdGFtcHMuCisKKwkqIHN5c2RlcC5jOiBJbmNsdWRlIHV0aW1lbnMu aC4gIERvbid0IGluY2x1ZGUgdXRpbWUuaAorCW9yIHdvcnJ5IGFib3V0IHN0cnVjdCB1dGlt YnVmOyBnbnVsaWIgZG9lcyB0aGF0IGZvciB1cyBub3cuCisJKGdldHRpbWVvZmRheSk6IFJl bW92ZTsgZ251bGliIHByb3ZpZGVzIGEgc3Vic3RpdHV0ZS4KKwkobWFrZV90aW1ldmFsKTog TmV3IGZ1bmN0aW9uLgorCShzZXRfZmlsZV90aW1lcyk6IE5vdyBzZXRzIG5zLXJlc29sdXRp b24gdGltZSBzdGFtcHMuCisJTmV3IGFyZyBGRDsgYWxsIHVzZXMgY2hhbmdlZC4KKwkodGlt ZV9mcm9tX2ppZmZpZXMsIGx0aW1lX2Zyb21famlmZmllcywgZ2V0X3VwX3RpbWUpCisJKHN5 c3RlbV9wcm9jZXNzX2F0dHJpYnV0ZXMpOgorCU5vdyByZXR1cm5zIG5zLXJlc29sdXRpb24g dGltZSBzdGFtcC4gIEFsbCB1c2VzIGNoYW5nZWQuCisJQ2hlY2sgZm9yIHRpbWUgc3RhbXAg b3ZlcmZsb3cuCisKKwkqIHN5c3NlbGVjdC5oOiBEb24ndCBkZXBlbmQgb24gSEFWRV9TWVNf U0VMRUNUX0g7IGdudWxpYgorCXByb3ZpZGVzIGEgc3Vic3RpdHV0ZSBub3cuCisKKwkqIHN5 c3RpbWUuaDogSW5jbHVkZSB0aW1lc3BlYy5oIHJhdGhlciB0aGFuIHN5cy90aW1lLmggYW5k IHRpbWUuaCwKKwlzaW5jZSBpdCBndWFyYW50ZWVzIHN0cnVjdCB0aW1lc3BlYy4KKwkoRU1B Q1NfVElNRSk6IE5vdyBzdHJ1Y3QgdGltZXNwZWMsIHNvIHRoYXQgd2UgY2FuIHN1cHBvcnQK Kwlucy1yZXNvbHV0aW9uIHRpbWUgc3RhbXBzLgorCShFTUFDU19USU1FX1JFU09MVVRJT04s IExPRzEwX0VNQUNTX1RJTUVfUkVTT0xVVElPTik6IE5ldyBtYWNyb3MuCisJKEVNQUNTX0hB U19VU0VDUyk6IFJlbW92ZTsgRW1hY3MgYWx3YXlzIGhhcyBzdWItc2Vjb25kIHRpbWUgc3Rh bXBzIG5vdy4KKwkoRU1BQ1NfVVNFQ1MpOiBSZW1vdmUuCisJKEVNQUNTX1NFVF9VU0VDUyk6 IFRoZSB1bmRlcmx5aW5nIHRpbWUgc3RhbXAgbm93IGhhcyBucyByZXNvbHV0aW9uLAorCXNv IG11bHRpcGx5IHRoZSBhcmcgYnkgMTAwMCBiZWZvcmUgc3RvcmluZyBpdC4KKwkoRU1BQ1Nf TlNFQ1MsIEVNQUNTX1NFQ1NfQUREUiwgRU1BQ1NfU0VUX05TRUNTLCBFTUFDU19TRVRfU0VD U19OU0VDUyk6CisJTmV3IG1hY3Jvcy4KKwkoRU1BQ1NfR0VUX1RJTUUsIEVNQUNTX0FERF9U SU1FLCBFTUFDU19TVUJfVElNRSk6CisJUG9ydCB0byBucy1yZXNvbHV0aW9uIHRpbWUgc3Rh bXBzLgorCShFTUFDU19USU1FX05FR19QKTogUmVtb3ZlOyByZXBsYWNlZCBieS4uLi4KKwko RU1BQ1NfVElNRV9TSUdOKTogTmV3IG1hY3JvLgorCShFTUFDU19TRVRfSU5WQUxJRF9USU1F LCBFTUFDU19USU1FX1ZBTElEX1ApCisJKEVNQUNTX1RJTUVfRlJPTV9ET1VCTEUsIEVNQUNT X1RJTUVfVE9fRE9VQkxFKTogTmV3IG1hY3Jvcy4KKwkoc2V0X2ZpbGVfdGltZXMsIG1ha2Vf dGltZSwgbGlzcF90aW1lX2FyZ3VtZW50KTogQWRqdXN0IHNpZ25hdHVyZS4KKwkobWFrZV90 aW1ldmFsLCBtYWtlX2xpc3BfdGltZSwgZGVjb2RlX3RpbWVfY29tcG9uZW50cyk6IE5ldyBk ZWNscy4KKwkoRU1BQ1NfVElNRV9DTVApOiBSZW1vdmU7IG5vIGxvbmdlciB1c2VkLiAgUGx1 cywgaXQgd2FzIGJ1Z2d5LCBpbgorCXRoYXQgaXQgbWlzaGFuZGxlZCB0aW1lX3Qgb3ZlcmZs b3cuICBZb3UgY2FuJ3QgY29tcGFyZSBieSBzdWJ0cmFjdGluZyEKKwkoRU1BQ1NfVElNRV9F USwgRU1BQ1NfVElNRV9ORSwgRU1BQ1NfVElNRV9HVCwgRU1BQ1NfVElNRV9HRSkKKwkoRU1B Q1NfVElNRV9MVCwgRU1BQ1NfVElNRV9MRSk6IFJld3JpdGUgaW4gdGVybXMgb2YgdGltZXNw ZWNfY21wLgorCisJKiB0ZXJtLmM6IEluY2x1ZGUgPHN5cy90aW1lLmg+LgorCSh0aW1ldmFs X3RvX1RpbWUpOiBOZXcgZnVuY3Rpb24sIGZvciBwcm9wZXIgb3ZlcmZsb3cgd3JhcGFyb3Vu ZC4KKwkodGVybV9tb3VzZV9wb3NpdGlvbiwgdGVybV9tb3VzZV9jbGljayk6IFVzZSBpdC4K KworCSogdW5kby5jIChyZWNvcmRfZmlyc3RfY2hhbmdlKTogU3VwcG9ydCBoaWdoZXItcmVz b2x1dGlvbiB0aW1lIHN0YW1wcworCWluIHRoZSB1bmRvIGJ1ZmZlci4KKwkoRnByaW1pdGl2 ZV91bmRvKTogVXNlIHRoZW0gd2hlbiByZXN0b3JpbmcgdGltZSBzdGFtcHMuCisKKwkqIHcz Mi5jIChsdGltZSwgVTY0X1RPX0xJU1BfVElNRSwgcHJvY2Vzc190aW1lcywgZW1hY3NfZ251 dGxzX3B1bGwpCisJKHczMl9nZXRfaW50ZXJuYWxfcnVuX3RpbWUpOgorCVBvcnQgdG8gaGln aGVyLXJlc29sdXRpb24gRW1hY3MgdGltZSBzdGFtcHMuCisJKGx0aW1lKTogTm93IGFjY2Vw dHMgc2luZ2xlIDY0LWJpdCBpbnRlZ2VyLCBhcyB0aGF0J3MgbW9yZSBjb252ZW5pZW50CisJ Zm9yIGNhbGxlcnMuCisKKwkqIHhkaXNwLmMgKHN0YXJ0X2hvdXJnbGFzcyk6IFBvcnQgdG8g bnMtcmVzb2x1dGlvbiB0aW1lIHN0YW1wcy4KKworCSogeGdzZWxlY3QuYywgeGdzZWxlY3Qu aCAoeGdfc2VsZWN0KTogQWRkIHNpZ21hc2sgYXJndW1lbnQsCisJZm9yIGNvbXBhdGliaWxp dHkgd2l0aCBwc2VsZWN0LiAgU3VwcG9ydCBucy1yZXNvbHV0aW9uIHRpbWUgc3RhbXBzLgor CisJKiB4bWVudS5jICh4X21lbnVfd2FpdF9mb3JfZXZlbnQpOiBTdXBwb3J0IG5zLXJlc29s dXRpb24gdGltZSBzdGFtcHMuCisKKwkqIHhzZWxlY3QuYyAod2FpdF9mb3JfcHJvcGVydHlf Y2hhbmdlLCB4X2dldF9mb3JlaWduX3NlbGVjdGlvbik6CisJQ2hlY2sgZm9yIHRpbWUgc3Rh bXAgb3ZlcmZsb3csIGFuZCBzdXBwb3J0IG5zLXJlc29sdXRpb24gdGltZSBzdGFtcHMuCisK KwkqIHh0ZXJtLmM6IERvbid0IGluY2x1ZGUgc3lzL3RpbWUuaDsgZ251bGliIGRvZXMgdGhh dCBmb3IgdXMgbm93LgorCURvbid0IHdvcnJ5IGFib3V0IHdoZXRoZXIgSEFWRV9USU1FVkFM IGFuZCBIQVZFX1NFTEVDVCBhcmUgc2V0LgorCSh0aW1ldmFsX3N1YnRyYWN0KTogUmVtb3Zl OyBubyBsb25nZXIgbmVlZGVkLgorCShYVGZsYXNoLCBYVHJpbmdfYmVsbCwgeF93YWl0X2Zv cl9ldmVudCk6CisJUG9ydCB0byBucy1yZXNvbHV0aW9uIHRpbWUgc3RhbXBzLiAgRG9uJ3Qg YXNzdW1lIHRpbWVfdCBpcyBzaWduZWQuCisKIDIwMTItMDUtMDMgIFBhdWwgRWdnZXJ0ICA8 ZWdnZXJ0QGNzLnVjbGEuZWR1PgogCiAJRG8gbm90IGxpbWl0IGN1cnJlbnQtdGltZS1zdHJp bmcgdG8geWVhcnMgMTAwMC4uOTk5OS4KCj09PSBtb2RpZmllZCBmaWxlICdzcmMvTWFrZWZp bGUuaW4nCi0tLSBzcmMvTWFrZWZpbGUuaW4JMjAxMi0wNS0wMSAwMDoxNjowMiArMDAwMAor Kysgc3JjL01ha2VmaWxlLmluCTIwMTItMDUtMDQgMDc6MTI6NTkgKzAwMDAKQEAgLTE0Nyw2 ICsxNDcsOCBAQAogTTE3Tl9GTFRfQ0ZMQUdTID0gQE0xN05fRkxUX0NGTEFHU0AKIE0xN05f RkxUX0xJQlMgPSBATTE3Tl9GTFRfTElCU0AKIAorTElCX0NMT0NLX0dFVFRJTUU9QExJQl9D TE9DS19HRVRUSU1FQAorCiBEQlVTX0NGTEFHUyA9IEBEQlVTX0NGTEFHU0AKIERCVVNfTElC UyA9IEBEQlVTX0xJQlNACiAjIyBkYnVzYmluZC5vIGlmIEhBVkVfREJVUywgZWxzZSBlbXB0 eS4KQEAgLTM3OCw3ICszODAsNyBAQAogIyMgZHVwbGljYXRlZCBzeW1ib2xzLiAgSWYgdGhl IHN0YW5kYXJkIGxpYnJhcmllcyB3ZXJlIGNvbXBpbGVkCiAjIyB3aXRoIEdDQywgd2UgbWln aHQgbmVlZCBMSUJfR0NDIGFnYWluIGFmdGVyIHRoZW0uCiBMSUJFUyA9ICQoTElCUykgJChM SUJYX0JBU0UpICQoTElCWF9PVEhFUikgJChMSUJTT1VORCkgXAotICAgJChSU1ZHX0xJQlMp ICQoSU1BR0VNQUdJQ0tfTElCUykgJChEQlVTX0xJQlMpIFwKKyAgICQoUlNWR19MSUJTKSAk KElNQUdFTUFHSUNLX0xJQlMpICQoTElCX0NMT0NLX0dFVFRJTUUpICQoREJVU19MSUJTKSBc CiAgICAkKExJQlhNTDJfTElCUykgJChMSUJHUE0pICQoTElCUkVTT0xWKSAkKExJQlNfU1lT VEVNKSBcCiAgICAkKExJQlNfVEVSTUNBUCkgJChHRVRMT0FEQVZHX0xJQlMpICQoU0VUVElO R1NfTElCUykgJChMSUJTRUxJTlVYX0xJQlMpIFwKICAgICQoRlJFRVRZUEVfTElCUykgJChG T05UQ09ORklHX0xJQlMpICQoTElCT1RGX0xJQlMpICQoTTE3Tl9GTFRfTElCUykgXAoKPT09 IG1vZGlmaWVkIGZpbGUgJ3NyYy9hbGxvYy5jJwotLS0gc3JjL2FsbG9jLmMJMjAxMi0wNC0y MyAwNTo0NDo0OSArMDAwMAorKysgc3JjL2FsbG9jLmMJMjAxMi0wNS0wNCAwNjo0MjowMyAr MDAwMApAQCAtNTM2NCwxMiArNTM2NCwxNCBAQAogICAgIH0KIAogICAvKiBBY2N1bXVsYXRl IHN0YXRpc3RpY3MuICAqLwotICBFTUFDU19HRVRfVElNRSAodDIpOwotICBFTUFDU19TVUJf VElNRSAodDMsIHQyLCB0MSk7CiAgIGlmIChGTE9BVFAgKFZnY19lbGFwc2VkKSkKLSAgICBW Z2NfZWxhcHNlZCA9IG1ha2VfZmxvYXQgKFhGTE9BVF9EQVRBIChWZ2NfZWxhcHNlZCkgKwot CQkJICAgICAgRU1BQ1NfU0VDUyAodDMpICsKLQkJCSAgICAgIEVNQUNTX1VTRUNTICh0Mykg KiAxLjBlLTYpOworICAgIHsKKyAgICAgIEVNQUNTX0dFVF9USU1FICh0Mik7CisgICAgICBF TUFDU19TVUJfVElNRSAodDMsIHQyLCB0MSk7CisgICAgICBWZ2NfZWxhcHNlZCA9IG1ha2Vf ZmxvYXQgKFhGTE9BVF9EQVRBIChWZ2NfZWxhcHNlZCkKKwkJCQkrIEVNQUNTX1RJTUVfVE9f RE9VQkxFICh0MykpOworICAgIH0KKwogICBnY3NfZG9uZSsrOwogCiAgIHJldHVybiBGbGlz dCAoc2l6ZW9mIHRvdGFsIC8gc2l6ZW9mICp0b3RhbCwgdG90YWwpOwoKPT09IG1vZGlmaWVk IGZpbGUgJ3NyYy9hdGltZXIuYycKLS0tIHNyYy9hdGltZXIuYwkyMDEyLTAxLTE5IDA3OjIx OjI1ICswMDAwCisrKyBzcmMvYXRpbWVyLmMJMjAxMi0wNS0wNCAwNjo0MjowMyArMDAwMApA QCAtMjYsMTAgKzI2LDcgQEAKICNpbmNsdWRlICJibG9ja2lucHV0LmgiCiAjaW5jbHVkZSAi YXRpbWVyLmgiCiAjaW5jbHVkZSA8dW5pc3RkLmg+Ci0KLSNpZmRlZiBIQVZFX1NZU19USU1F X0gKICNpbmNsdWRlIDxzeXMvdGltZS5oPgotI2VuZGlmCiAKIC8qIEZyZWUtbGlzdCBvZiBh dGltZXIgc3RydWN0dXJlcy4gICovCiAKQEAgLTk0LDcgKzkxLDggQEAKICAgLyogUm91bmQg VElNRSB1cCB0byB0aGUgbmV4dCBmdWxsIHNlY29uZCBpZiB3ZSBkb24ndCBoYXZlCiAgICAg IGl0aW1lcnMuICAqLwogI2lmbmRlZiBIQVZFX1NFVElUSU1FUgotICBpZiAoRU1BQ1NfVVNF Q1MgKHRpbWVzdGFtcCkgIT0gMCkKKyAgaWYgKEVNQUNTX05TRUNTICh0aW1lc3RhbXApICE9 IDAKKyAgICAgICYmIEVNQUNTX1NFQ1MgKHRpbWVzdGFtcCkgPCBUWVBFX01BWElNVU0gKHRp bWVfdCkpCiAgICAgewogICAgICAgRU1BQ1NfU0VUX1VTRUNTICh0aW1lc3RhbXAsIDApOwog ICAgICAgRU1BQ1NfU0VUX1NFQ1MgKHRpbWVzdGFtcCwgRU1BQ1NfU0VDUyAodGltZXN0YW1w KSArIDEpOwpAQCAtMjk0LDE4ICsyOTIsMjEgQEAKIAogICAgICAgLyogRGV0ZXJtaW5lIHMv dXMgdGlsbCB0aGUgbmV4dCB0aW1lciBpcyByaXBlLiAgKi8KICAgICAgIEVNQUNTX0dFVF9U SU1FIChub3cpOwotICAgICAgRU1BQ1NfU1VCX1RJTUUgKHRpbWVzdGFtcCwgYXRpbWVycy0+ ZXhwaXJhdGlvbiwgbm93KTsKIAotI2lmZGVmIEhBVkVfU0VUSVRJTUVSCiAgICAgICAvKiBE b24ndCBzZXQgdGhlIGludGVydmFsIHRvIDA7IHRoaXMgZGlzYWJsZXMgdGhlIHRpbWVyLiAg Ki8KICAgICAgIGlmIChFTUFDU19USU1FX0xFIChhdGltZXJzLT5leHBpcmF0aW9uLCBub3cp KQogCXsKIAkgIEVNQUNTX1NFVF9TRUNTICh0aW1lc3RhbXAsIDApOwogCSAgRU1BQ1NfU0VU X1VTRUNTICh0aW1lc3RhbXAsIDEwMDApOwogCX0KKyAgICAgIGVsc2UKKwlFTUFDU19TVUJf VElNRSAodGltZXN0YW1wLCBhdGltZXJzLT5leHBpcmF0aW9uLCBub3cpOworCisKKyNpZmRl ZiBIQVZFX1NFVElUSU1FUgogCiAgICAgICBtZW1zZXQgKCZpdCwgMCwgc2l6ZW9mIGl0KTsK LSAgICAgIGl0Lml0X3ZhbHVlID0gdGltZXN0YW1wOworICAgICAgaXQuaXRfdmFsdWUgPSBt YWtlX3RpbWV2YWwgKHRpbWVzdGFtcCk7CiAgICAgICBzZXRpdGltZXIgKElUSU1FUl9SRUFM LCAmaXQsIDApOwogI2Vsc2UgLyogbm90IEhBVkVfU0VUSVRJTUVSICovCiAgICAgICBhbGFy bSAobWF4IChFTUFDU19TRUNTICh0aW1lc3RhbXApLCAxKSk7CkBAIC0zNDEsMTEgKzM0Miwx MCBAQAogewogICBFTUFDU19USU1FIG5vdzsKIAotICBFTUFDU19HRVRfVElNRSAobm93KTsK LQogICB3aGlsZSAoYXRpbWVycwogCSAmJiAocGVuZGluZ19hdGltZXJzID0gaW50ZXJydXB0 X2lucHV0X2Jsb2NrZWQpID09IDAKLQkgJiYgRU1BQ1NfVElNRV9MRSAoYXRpbWVycy0+ZXhw aXJhdGlvbiwgbm93KSkKKwkgJiYgKEVNQUNTX0dFVF9USU1FIChub3cpLAorCSAgICAgRU1B Q1NfVElNRV9MRSAoYXRpbWVycy0+ZXhwaXJhdGlvbiwgbm93KSkpCiAgICAgewogICAgICAg c3RydWN0IGF0aW1lciAqdDsKIApAQCAtMzYzLDggKzM2Myw2IEBACiAJICB0LT5uZXh0ID0g ZnJlZV9hdGltZXJzOwogCSAgZnJlZV9hdGltZXJzID0gdDsKIAl9Ci0KLSAgICAgIEVNQUNT X0dFVF9USU1FIChub3cpOwogICAgIH0KIAogICBpZiAoISBhdGltZXJzKQoKPT09IG1vZGlm aWVkIGZpbGUgJ3NyYy9idWZmZXIuYycKLS0tIHNyYy9idWZmZXIuYwkyMDEyLTA1LTAyIDE3 OjIxOjU0ICswMDAwCisrKyBzcmMvYnVmZmVyLmMJMjAxMi0wNS0wNCAwNzoxMjo1OSArMDAw MApAQCAtNzA5LDcgKzcwOSw3IEBACiAgIEJWQVIgKGIsIGZpbGVuYW1lKSA9IFFuaWw7CiAg IEJWQVIgKGIsIGZpbGVfdHJ1ZW5hbWUpID0gUW5pbDsKICAgQlZBUiAoYiwgZGlyZWN0b3J5 KSA9IChjdXJyZW50X2J1ZmZlcikgPyBCVkFSIChjdXJyZW50X2J1ZmZlciwgZGlyZWN0b3J5 KSA6IFFuaWw7Ci0gIGItPm1vZHRpbWUgPSAwOworICBFTUFDU19TRVRfU0VDU19OU0VDUyAo Yi0+bW9kdGltZSwgMCwgVU5LTk9XTl9NT0RUSU1FX05TRUNTKTsKICAgYi0+bW9kdGltZV9z aXplID0gLTE7CiAgIFhTRVRGQVNUSU5UIChCVkFSIChiLCBzYXZlX2xlbmd0aCksIDApOwog ICBiLT5sYXN0X3dpbmRvd19zdGFydCA9IDE7CkBAIC01Nzk3LDkgKzU3OTcsOSBAQAogZnJv bSAoYWJzIFBPU0lUSU9OKS4gIElmIFBPU0lUSU9OIGlzIHBvc2l0aXZlLCBwb2ludCB3YXMg YXQgdGhlIGZyb250CiBvZiB0aGUgdGV4dCBiZWluZyBkZWxldGVkOyBpZiBuZWdhdGl2ZSwg cG9pbnQgd2FzIGF0IHRoZSBlbmQuCiAKLUFuIGVudHJ5ICh0IEhJR0ggLiBMT1cpIGluZGlj YXRlcyB0aGF0IHRoZSBidWZmZXIgcHJldmlvdXNseSBoYWQKLVwidW5tb2RpZmllZFwiIHN0 YXR1cy4gIEhJR0ggYW5kIExPVyBhcmUgdGhlIGhpZ2ggYW5kIGxvdyAxNi1iaXQgcG9ydGlv bnMKLW9mIHRoZSB2aXNpdGVkIGZpbGUncyBtb2RpZmljYXRpb24gdGltZSwgYXMgb2YgdGhh dCB0aW1lLiAgSWYgdGhlCitBbiBlbnRyeSAodCBISUdIIExPVyBVU0VDIFBTRUMpIGluZGlj YXRlcyB0aGF0IHRoZSBidWZmZXIgd2FzIHByZXZpb3VzbHkKK3VubW9kaWZpZWQ7IChISUdI IExPVyBVU0VDIFBTRUMpIGlzIGluIHRoZSBzYW1lIHN0eWxlIGFzIChjdXJyZW50LXRpbWUp CithbmQgaXMgdGhlIHZpc2l0ZWQgZmlsZSdzIG1vZGlmaWNhdGlvbiB0aW1lLCBhcyBvZiB0 aGF0IHRpbWUuICBJZiB0aGUKIG1vZGlmaWNhdGlvbiB0aW1lIG9mIHRoZSBtb3N0IHJlY2Vu dCBzYXZlIGlzIGRpZmZlcmVudCwgdGhpcyBlbnRyeSBpcwogb2Jzb2xldGUuCiAKCj09PSBt b2RpZmllZCBmaWxlICdzcmMvYnVmZmVyLmgnCi0tLSBzcmMvYnVmZmVyLmgJMjAxMi0wNC0w NiAxMzoxMDozMCArMDAwMAorKysgc3JjL2J1ZmZlci5oCTIwMTItMDUtMDQgMDY6NDI6MDMg KzAwMDAKQEAgLTE4LDcgKzE4LDkgQEAKIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCiBhbG9uZyB3aXRoIEdOVSBF bWFjcy4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4gICov CiAKKwogI2luY2x1ZGUgPHN5cy90eXBlcy5oPiAvKiBmb3Igb2ZmX3QsIHRpbWVfdCAqLwor I2luY2x1ZGUgInN5c3RpbWUuaCIgLyogZm9yIEVNQUNTX1RJTUUgKi8KIAogLyogQWNjZXNz aW5nIHRoZSBwYXJhbWV0ZXJzIG9mIHRoZSBjdXJyZW50IGJ1ZmZlci4gICovCiAKQEAgLTU2 MSwxMCArNTYzLDEzIEBACiAgIGNoYXIgbG9jYWxfZmxhZ3NbTUFYX1BFUl9CVUZGRVJfVkFS U107CiAKICAgLyogU2V0IHRvIHRoZSBtb2R0aW1lIG9mIHRoZSB2aXNpdGVkIGZpbGUgd2hl biByZWFkIG9yIHdyaXR0ZW4uCi0gICAgIC0xIG1lYW5zIHZpc2l0ZWQgZmlsZSB3YXMgbm9u ZXhpc3RlbnQuCi0gICAgIDAgbWVhbnMgdmlzaXRlZCBmaWxlIG1vZHRpbWUgdW5rbm93bjsg aW4gbm8gY2FzZSBjb21wbGFpbgotICAgICBhYm91dCBhbnkgbWlzbWF0Y2ggb24gbmV4dCBz YXZlIGF0dGVtcHQuICAqLwotICB0aW1lX3QgbW9kdGltZTsKKyAgICAgRU1BQ1NfTlNFQ1Mg KG1vZHRpbWUpID09IE5PTkVYSVNURU5UX01PRFRJTUVfTlNFQ1MgbWVhbnMKKyAgICAgdmlz aXRlZCBmaWxlIHdhcyBub25leGlzdGVudC4gIEVNQUNTX05TRUNTIChtb2R0aW1lKSA9PQor ICAgICBVTktOT1dOX01PRFRJTUVfTlNFQ1MgbWVhbnMgdmlzaXRlZCBmaWxlIG1vZHRpbWUg dW5rbm93bjsKKyAgICAgaW4gbm8gY2FzZSBjb21wbGFpbiBhYm91dCBhbnkgbWlzbWF0Y2gg b24gbmV4dCBzYXZlIGF0dGVtcHQuICAqLworI2RlZmluZSBOT05FWElTVEVOVF9NT0RUSU1F X05TRUNTICgtMSkKKyNkZWZpbmUgVU5LTk9XTl9NT0RUSU1FX05TRUNTICgtMikKKyAgRU1B Q1NfVElNRSBtb2R0aW1lOwogICAvKiBTaXplIG9mIHRoZSBmaWxlIHdoZW4gbW9kdGltZSB3 YXMgc2V0LiAgVGhpcyBpcyB1c2VkIHRvIGRldGVjdCB0aGUKICAgICAgY2FzZSB3aGVyZSB0 aGUgZmlsZSBncmV3IHdoaWxlIHdlIHdlcmUgcmVhZGluZyBpdCwgc28gdGhlIG1vZHRpbWUK ICAgICAgaXMgc3RpbGwgdGhlIHNhbWUgKHNpbmNlIGl0J3Mgcm91bmRlZCB1cCB0byBzZWNv bmRzKSBidXQgd2UncmUgYWN0dWFsbHkKCj09PSBtb2RpZmllZCBmaWxlICdzcmMvZGlyZWQu YycKLS0tIHNyYy9kaXJlZC5jCTIwMTItMDQtMTcgMjI6NTY6MDYgKzAwMDAKKysrIHNyYy9k aXJlZC5jCTIwMTItMDUtMDQgMDY6NDI6MDMgKzAwMDAKQEAgLTYyLDYgKzYyLDcgQEAKICNl bmRpZiAvKiBIQVZFX0RJUkVOVF9IICovCiAKICNpbmNsdWRlIDxmaWxlbW9kZS5oPgorI2lu Y2x1ZGUgPHN0YXQtdGltZS5oPgogCiAjaWZkZWYgTVNET1MKICNkZWZpbmUgRElSRU5UUllf Tk9ORU1QVFkocCkgKChwKS0+ZF9uYW1lWzBdICE9IDApCkBAIC04OTAsOCArODkxLDggQEAK ICAyLiBGaWxlIHVpZCBhcyBhIHN0cmluZyBvciBhIG51bWJlci4gIElmIGEgc3RyaW5nIHZh bHVlIGNhbm5vdCBiZQogICBsb29rZWQgdXAsIGEgbnVtZXJpYyB2YWx1ZSwgZWl0aGVyIGFu IGludGVnZXIgb3IgYSBmbG9hdCwgaXMgcmV0dXJuZWQuCiAgMy4gRmlsZSBnaWQsIGxpa2V3 aXNlLgotIDQuIExhc3QgYWNjZXNzIHRpbWUsIGFzIGEgbGlzdCBvZiB0d28gaW50ZWdlcnMu Ci0gIEZpcnN0IGludGVnZXIgaGFzIGhpZ2gtb3JkZXIgMTYgYml0cyBvZiB0aW1lLCBzZWNv bmQgaGFzIGxvdyAxNiBiaXRzLgorIDQuIExhc3QgYWNjZXNzIHRpbWUsIGFzIGEgbGlzdCBv ZiBpbnRlZ2VycyAoSElHSCBMT1cgVVNFQyBQU0VDKSBpbiB0aGUKKyAgc2FtZSBzdHlsZSBh cyAoY3VycmVudC10aW1lKS4KICAgKFNlZSBhIG5vdGUgYmVsb3cgYWJvdXQgYWNjZXNzIHRp bWUgb24gRkFULWJhc2VkIGZpbGVzeXN0ZW1zLikKICA1LiBMYXN0IG1vZGlmaWNhdGlvbiB0 aW1lLCBsaWtld2lzZS4gIFRoaXMgaXMgdGhlIHRpbWUgb2YgdGhlIGxhc3QKICAgY2hhbmdl IHRvIHRoZSBmaWxlJ3MgY29udGVudHMuCkBAIC05NzYsOSArOTc3LDkgQEAKICAgZWxzZQog ICAgIHZhbHVlc1szXSA9IG1ha2VfZml4bnVtX29yX2Zsb2F0IChzLnN0X2dpZCk7CiAKLSAg dmFsdWVzWzRdID0gbWFrZV90aW1lIChzLnN0X2F0aW1lKTsKLSAgdmFsdWVzWzVdID0gbWFr ZV90aW1lIChzLnN0X210aW1lKTsKLSAgdmFsdWVzWzZdID0gbWFrZV90aW1lIChzLnN0X2N0 aW1lKTsKKyAgdmFsdWVzWzRdID0gbWFrZV9saXNwX3RpbWUgKGdldF9zdGF0X2F0aW1lICgm cykpOworICB2YWx1ZXNbNV0gPSBtYWtlX2xpc3BfdGltZSAoZ2V0X3N0YXRfbXRpbWUgKCZz KSk7CisgIHZhbHVlc1s2XSA9IG1ha2VfbGlzcF90aW1lIChnZXRfc3RhdF9jdGltZSAoJnMp KTsKIAogICAvKiBJZiB0aGUgZmlsZSBzaXplIGlzIGEgNC1ieXRlIHR5cGUsIGFzc3VtZSB0 aGF0IGZpbGVzIG9mIHNpemVzIGluCiAgICAgIHRoZSAyLTQgR2lCIHJhbmdlIHdyYXAgYXJv dW5kIHRvIG5lZ2F0aXZlIHZhbHVlcywgYXMgdGhpcyBpcyBhCgo9PT0gbW9kaWZpZWQgZmls ZSAnc3JjL2Rpc3BleHRlcm4uaCcKLS0tIHNyYy9kaXNwZXh0ZXJuLmgJMjAxMi0wMy0yNiAw NTo0MzowNSArMDAwMAorKysgc3JjL2Rpc3BleHRlcm4uaAkyMDEyLTA1LTA0IDA2OjQyOjAz ICswMDAwCkBAIC02OCw2ICs2OCwxMCBAQAogdHlwZWRlZiBYSW1hZ2VQdHIgWEltYWdlUHRy X29yX0RDOwogI2VuZGlmCiAKKyNpZmRlZiBIQVZFX1dJTkRPV19TWVNURU0KKyMgaW5jbHVk ZSAic3lzdGltZS5oIgorI2VuZGlmCisKICNpZm5kZWYgSEFWRV9XSU5ET1dfU1lTVEVNCiB0 eXBlZGVmIGludCBDdXJzb3I7CiAjZGVmaW5lIE5vX0N1cnNvciAoMCkKQEAgLTI3NjUsNyAr Mjc2OSw3IEBACiB7CiAgIC8qIFRoZSB0aW1lIGluIHNlY29uZHMgYXQgd2hpY2ggdGhlIGlt YWdlIHdhcyBsYXN0IGRpc3BsYXllZC4gIFNldAogICAgICBpbiBwcmVwYXJlX2ltYWdlX2Zv cl9kaXNwbGF5LiAgKi8KLSAgdGltZV90IHRpbWVzdGFtcDsKKyAgRU1BQ1NfVElNRSB0aW1l c3RhbXA7CiAKICAgLyogUGl4bWFwcyBvZiB0aGUgaW1hZ2UuICAqLwogICBQaXhtYXAgcGl4 bWFwLCBtYXNrOwoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9kaXNwbmV3LmMnCi0tLSBzcmMv ZGlzcG5ldy5jCTIwMTItMDUtMDEgMDA6MzA6MTEgKzAwMDAKKysrIHNyYy9kaXNwbmV3LmMJ MjAxMi0wNS0wNCAwNzo0OTo0OSArMDAwMApAQCAtMTM3LDI0ICsxMzcsMTEgQEAKIHN0YXRp YyB2b2lkIGFkanVzdF9mcmFtZV9nbHlwaHNfZm9yX2ZyYW1lX3JlZGlzcGxheSAoc3RydWN0 IGZyYW1lICopOwogCiAMCi0vKiBEZWZpbmUgUEVSSU9ESUNfUFJFRU1QVElPTl9DSEVDS0lO RyB0byAxLCBpZiBtaWNyby1zZWNvbmQgdGltZXJzCi0gICBhcmUgc3VwcG9ydGVkLCBzbyB3 ZSBjYW4gY2hlY2sgZm9yIGlucHV0IGR1cmluZyByZWRpc3BsYXkgYXQKLSAgIHJlZ3VsYXIg aW50ZXJ2YWxzLiAgKi8KLSNpZmRlZiBFTUFDU19IQVNfVVNFQ1MKLSNkZWZpbmUgUEVSSU9E SUNfUFJFRU1QVElPTl9DSEVDS0lORyAxCi0jZWxzZQotI2RlZmluZSBQRVJJT0RJQ19QUkVF TVBUSU9OX0NIRUNLSU5HIDAKLSNlbmRpZgotCi0jaWYgUEVSSU9ESUNfUFJFRU1QVElPTl9D SEVDS0lORwotCiAvKiBSZWRpc3BsYXkgcHJlZW1wdGlvbiB0aW1lcnMuICAqLwogCiBzdGF0 aWMgRU1BQ1NfVElNRSBwcmVlbXB0aW9uX3BlcmlvZDsKIHN0YXRpYyBFTUFDU19USU1FIHBy ZWVtcHRpb25fbmV4dF9jaGVjazsKIAotI2VuZGlmCi0KIC8qIE5vbnplcm8gdXBvbiBlbnRy eSB0byByZWRpc3BsYXkgbWVhbnMgZG8gbm90IGFzc3VtZSBhbnl0aGluZyBhYm91dAogICAg Y3VycmVudCBjb250ZW50cyBvZiBhY3R1YWwgdGVybWluYWwgZnJhbWU7IGNsZWFyIGFuZCBy ZWRyYXcgaXQuICAqLwogCkBAIC0zMjIwLDE0ICszMjA3LDEyIEBACiAKICAgaWYgKHJlZGlz cGxheV9kb250X3BhdXNlKQogICAgIGZvcmNlX3AgPSAxOwotI2lmIFBFUklPRElDX1BSRUVN UFRJT05fQ0hFQ0tJTkcKICAgZWxzZSBpZiAoTklMUCAoVnJlZGlzcGxheV9wcmVlbXB0aW9u X3BlcmlvZCkpCiAgICAgZm9yY2VfcCA9IDE7CiAgIGVsc2UgaWYgKCFmb3JjZV9wICYmIE5V TUJFUlAgKFZyZWRpc3BsYXlfcHJlZW1wdGlvbl9wZXJpb2QpKQogICAgIHsKICAgICAgIEVN QUNTX1RJTUUgdG07CiAgICAgICBkb3VibGUgcCA9IFhGTE9BVElOVCAoVnJlZGlzcGxheV9w cmVlbXB0aW9uX3BlcmlvZCk7Ci0gICAgICBpbnQgc2VjLCB1c2VjOwogCiAgICAgICBpZiAo ZGV0ZWN0X2lucHV0X3BlbmRpbmdfaWdub3JlX3NxdWVlemFibGVzICgpKQogCXsKQEAgLTMy MzUsMTQgKzMyMjAsMTAgQEAKIAkgIGdvdG8gZG9fcGF1c2U7CiAJfQogCi0gICAgICBzZWMg PSAoaW50KSBwOwotICAgICAgdXNlYyA9IChwIC0gc2VjKSAqIDEwMDAwMDA7Ci0KICAgICAg IEVNQUNTX0dFVF9USU1FICh0bSk7Ci0gICAgICBFTUFDU19TRVRfU0VDU19VU0VDUyAocHJl ZW1wdGlvbl9wZXJpb2QsIHNlYywgdXNlYyk7CisgICAgICBwcmVlbXB0aW9uX3BlcmlvZCA9 IEVNQUNTX1RJTUVfRlJPTV9ET1VCTEUgKHApOwogICAgICAgRU1BQ1NfQUREX1RJTUUgKHBy ZWVtcHRpb25fbmV4dF9jaGVjaywgdG0sIHByZWVtcHRpb25fcGVyaW9kKTsKICAgICB9Ci0j ZW5kaWYKIAogICBpZiAoRlJBTUVfV0lORE9XX1AgKGYpKQogICAgIHsKQEAgLTMzMjYsOSAr MzMwNyw3IEBACiAjZW5kaWYKICAgICB9CiAKLSNpZiBQRVJJT0RJQ19QUkVFTVBUSU9OX0NI RUNLSU5HCiAgZG9fcGF1c2U6Ci0jZW5kaWYKICAgLyogUmVzZXQgZmxhZ3MgaW5kaWNhdGlu ZyB0aGF0IGEgd2luZG93IHNob3VsZCBiZSB1cGRhdGVkLiAgKi8KICAgc2V0X3dpbmRvd191 cGRhdGVfZmxhZ3MgKHJvb3Rfd2luZG93LCAwKTsKIApAQCAtMzM4MSwyMyArMzM2MCwxNyBA QAogCiAgICAgICBpZiAocmVkaXNwbGF5X2RvbnRfcGF1c2UpCiAJZm9yY2VfcCA9IDE7Ci0j aWYgUEVSSU9ESUNfUFJFRU1QVElPTl9DSEVDS0lORwogICAgICAgZWxzZSBpZiAoTklMUCAo VnJlZGlzcGxheV9wcmVlbXB0aW9uX3BlcmlvZCkpCiAJZm9yY2VfcCA9IDE7CiAgICAgICBl bHNlIGlmICghZm9yY2VfcCAmJiBOVU1CRVJQIChWcmVkaXNwbGF5X3ByZWVtcHRpb25fcGVy aW9kKSkKIAl7CiAJICBFTUFDU19USU1FIHRtOwogCSAgZG91YmxlIHAgPSBYRkxPQVRJTlQg KFZyZWRpc3BsYXlfcHJlZW1wdGlvbl9wZXJpb2QpOwotCSAgaW50IHNlYywgdXNlYzsKLQot CSAgc2VjID0gKGludCkgcDsKLQkgIHVzZWMgPSAocCAtIHNlYykgKiAxMDAwMDAwOwogCiAJ ICBFTUFDU19HRVRfVElNRSAodG0pOwotCSAgRU1BQ1NfU0VUX1NFQ1NfVVNFQ1MgKHByZWVt cHRpb25fcGVyaW9kLCBzZWMsIHVzZWMpOworCSAgcHJlZW1wdGlvbl9wZXJpb2QgPSBFTUFD U19USU1FX0ZST01fRE9VQkxFIChwKTsKIAkgIEVNQUNTX0FERF9USU1FIChwcmVlbXB0aW9u X25leHRfY2hlY2ssIHRtLCBwcmVlbXB0aW9uX3BlcmlvZCk7CiAJfQotI2VuZGlmCiAKICAg ICAgIC8qIFVwZGF0ZSBXLiAgKi8KICAgICAgIHVwZGF0ZV9iZWdpbiAoZik7CkBAIC0zNjQz LDEwICszNjE2LDkgQEAKICNpZiBQRVJJT0RJQ19QUkVFTVBUSU9OX0NIRUNLSU5HCiAJICAg IGlmICghZm9yY2VfcCkKIAkgICAgICB7Ci0JCUVNQUNTX1RJTUUgdG0sIGRpZjsKKwkJRU1B Q1NfVElNRSB0bTsKIAkJRU1BQ1NfR0VUX1RJTUUgKHRtKTsKLQkJRU1BQ1NfU1VCX1RJTUUg KGRpZiwgcHJlZW1wdGlvbl9uZXh0X2NoZWNrLCB0bSk7Ci0JCWlmIChFTUFDU19USU1FX05F R19QIChkaWYpKQorCQlpZiAoRU1BQ1NfVElNRV9MVCAocHJlZW1wdGlvbl9uZXh0X2NoZWNr LCB0bSkpCiAJCSAgewogCQkgICAgRU1BQ1NfQUREX1RJTUUgKHByZWVtcHRpb25fbmV4dF9j aGVjaywgdG0sIHByZWVtcHRpb25fcGVyaW9kKTsKIAkJICAgIGlmIChkZXRlY3RfaW5wdXRf cGVuZGluZ19pZ25vcmVfc3F1ZWV6YWJsZXMgKCkpCkBAIC00NzQ5LDEwICs0NzIxLDkgQEAK ICNpZiBQRVJJT0RJQ19QUkVFTVBUSU9OX0NIRUNLSU5HCiAJICBpZiAoIWZvcmNlX3ApCiAJ ICAgIHsKLQkgICAgICBFTUFDU19USU1FIHRtLCBkaWY7CisJICAgICAgRU1BQ1NfVElNRSB0 bTsKIAkgICAgICBFTUFDU19HRVRfVElNRSAodG0pOwotCSAgICAgIEVNQUNTX1NVQl9USU1F IChkaWYsIHByZWVtcHRpb25fbmV4dF9jaGVjaywgdG0pOwotCSAgICAgIGlmIChFTUFDU19U SU1FX05FR19QIChkaWYpKQorCSAgICAgIGlmIChFTUFDU19USU1FX0xUIChwcmVlbXB0aW9u X25leHRfY2hlY2ssIHRtKSkKIAkJewogCQkgIEVNQUNTX0FERF9USU1FIChwcmVlbXB0aW9u X25leHRfY2hlY2ssIHRtLCBwcmVlbXB0aW9uX3BlcmlvZCk7CiAJCSAgaWYgKGRldGVjdF9p bnB1dF9wZW5kaW5nX2lnbm9yZV9zcXVlZXphYmxlcyAoKSkKQEAgLTU5NzAsNDYgKzU5NDEs MjQgQEAKICAgICAgICBkb2M6IC8qIFBhdXNlLCB3aXRob3V0IHVwZGF0aW5nIGRpc3BsYXks IGZvciBTRUNPTkRTIHNlY29uZHMuCiBTRUNPTkRTIG1heSBiZSBhIGZsb2F0aW5nLXBvaW50 IHZhbHVlLCBtZWFuaW5nIHRoYXQgeW91IGNhbiB3YWl0IGZvciBhCiBmcmFjdGlvbiBvZiBh IHNlY29uZC4gIE9wdGlvbmFsIHNlY29uZCBhcmcgTUlMTElTRUNPTkRTIHNwZWNpZmllcyBh bgotYWRkaXRpb25hbCB3YWl0IHBlcmlvZCwgaW4gbWlsbGlzZWNvbmRzOyB0aGlzIG1heSBi ZSB1c2VmdWwgaWYgeW91cgotRW1hY3Mgd2FzIGJ1aWx0IHdpdGhvdXQgZmxvYXRpbmcgcG9p bnQgc3VwcG9ydC4KK2FkZGl0aW9uYWwgd2FpdCBwZXJpb2QsIGluIG1pbGxpc2Vjb25kczsg dGhpcyBpcyBmb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHkuCiBcKE5vdCBhbGwgb3BlcmF0 aW5nIHN5c3RlbXMgc3VwcG9ydCB3YWl0aW5nIGZvciBhIGZyYWN0aW9uIG9mIGEgc2Vjb25k LikgICovKQogICAoTGlzcF9PYmplY3Qgc2Vjb25kcywgTGlzcF9PYmplY3QgbWlsbGlzZWNv bmRzKQogewotICBpbnQgc2VjLCB1c2VjOwotCi0gIGlmIChOSUxQIChtaWxsaXNlY29uZHMp KQotICAgIFhTRVRJTlQgKG1pbGxpc2Vjb25kcywgMCk7Ci0gIGVsc2UKLSAgICBDSEVDS19O VU1CRVIgKG1pbGxpc2Vjb25kcyk7Ci0gIHVzZWMgPSBYSU5UIChtaWxsaXNlY29uZHMpICog MTAwMDsKLQotICB7Ci0gICAgZG91YmxlIGR1cmF0aW9uID0gZXh0cmFjdF9mbG9hdCAoc2Vj b25kcyk7Ci0gICAgc2VjID0gKGludCkgZHVyYXRpb247Ci0gICAgdXNlYyArPSAoZHVyYXRp b24gLSBzZWMpICogMTAwMDAwMDsKLSAgfQotCi0jaWZuZGVmIEVNQUNTX0hBU19VU0VDUwot ICBpZiAoc2VjID09IDAgJiYgdXNlYyAhPSAwKQotICAgIGVycm9yICgiTWlsbGlzZWNvbmQg YHNsZWVwLWZvcicgbm90IHN1cHBvcnRlZCBvbiAlcyIsIFNZU1RFTV9UWVBFKTsKLSNlbmRp ZgotCi0gIC8qIEFzc3VyZSB0aGF0IDAgPD0gdXNlYyA8IDEwMDAwMDAuICAqLwotICBpZiAo dXNlYyA8IDApCi0gICAgewotICAgICAgLyogV2UgY2FuJ3QgcmVseSBvbiB0aGUgcm91bmRp bmcgYmVpbmcgY29ycmVjdCBpZiB1c2VjIGlzIG5lZ2F0aXZlLiAgKi8KLSAgICAgIGlmICgt MTAwMDAwMCA8IHVzZWMpCi0Jc2VjLS0sIHVzZWMgKz0gMTAwMDAwMDsKLSAgICAgIGVsc2UK LQlzZWMgLT0gLXVzZWMgLyAxMDAwMDAwLCB1c2VjID0gMTAwMDAwMCAtICgtdXNlYyAlIDEw MDAwMDApOwotICAgIH0KLSAgZWxzZQotICAgIHNlYyArPSB1c2VjIC8gMTAwMDAwMCwgdXNl YyAlPSAxMDAwMDAwOwotCi0gIGlmIChzZWMgPCAwIHx8IChzZWMgPT0gMCAmJiB1c2VjID09 IDApKQotICAgIHJldHVybiBRbmlsOwotCi0gIHdhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1 dCAoc2VjLCB1c2VjLCAwLCAwLCBRbmlsLCBOVUxMLCAwKTsKKyAgZG91YmxlIGR1cmF0aW9u ID0gZXh0cmFjdF9mbG9hdCAoc2Vjb25kcyk7CisKKyAgaWYgKCFOSUxQIChtaWxsaXNlY29u ZHMpKQorICAgIHsKKyAgICAgIENIRUNLX05VTUJFUiAobWlsbGlzZWNvbmRzKTsKKyAgICAg IGR1cmF0aW9uICs9IFhJTlQgKG1pbGxpc2Vjb25kcykgLyAxMDAwLjA7CisgICAgfQorCisg IGlmICgwIDwgZHVyYXRpb24pCisgICAgeworICAgICAgRU1BQ1NfVElNRSB0ID0gRU1BQ1Nf VElNRV9GUk9NX0RPVUJMRSAoZHVyYXRpb24pOworICAgICAgd2FpdF9yZWFkaW5nX3Byb2Nl c3Nfb3V0cHV0IChtaW4gKEVNQUNTX1NFQ1MgKHQpLCBJTlRNQVhfTUFYKSwKKwkJCQkgICBF TUFDU19OU0VDUyAodCksIDAsIDAsIFFuaWwsIE5VTEwsIDApOworICAgIH0KIAogICByZXR1 cm4gUW5pbDsKIH0KQEAgLTYwMjgsNyArNTk3Nyw4IEBACiBMaXNwX09iamVjdAogc2l0X2Zv ciAoTGlzcF9PYmplY3QgdGltZW91dCwgaW50IHJlYWRpbmcsIGludCBkb19kaXNwbGF5KQog ewotICBpbnQgc2VjLCB1c2VjOworICBpbnRtYXhfdCBzZWM7CisgIGludCBuc2VjOwogCiAg IHN3YWxsb3dfZXZlbnRzIChkb19kaXNwbGF5KTsKIApAQCAtNjA0MiwzMCArNTk5MiwzNiBA QAogICBpZiAoSU5URUdFUlAgKHRpbWVvdXQpKQogICAgIHsKICAgICAgIHNlYyA9IFhJTlQg KHRpbWVvdXQpOwotICAgICAgdXNlYyA9IDA7CisgICAgICBpZiAoISAoMCA8IHNlYykpCisJ cmV0dXJuIFF0OworICAgICAgbnNlYyA9IDA7CiAgICAgfQogICBlbHNlIGlmIChGTE9BVFAg KHRpbWVvdXQpKQogICAgIHsKICAgICAgIGRvdWJsZSBzZWNvbmRzID0gWEZMT0FUX0RBVEEg KHRpbWVvdXQpOwotICAgICAgc2VjID0gKGludCkgc2Vjb25kczsKLSAgICAgIHVzZWMgPSAo aW50KSAoKHNlY29uZHMgLSBzZWMpICogMTAwMDAwMCk7CisgICAgICBpZiAoISAoMCA8IHNl Y29uZHMpKQorCXJldHVybiBRdDsKKyAgICAgIGVsc2UKKwl7CisJICBFTUFDU19USU1FIHQg PSBFTUFDU19USU1FX0ZST01fRE9VQkxFIChzZWNvbmRzKTsKKwkgIHNlYyA9IG1pbiAoRU1B Q1NfU0VDUyAodCksIElOVE1BWF9NQVgpOworCSAgbnNlYyA9IEVNQUNTX05TRUNTICh0KTsK Kwl9CiAgICAgfQogICBlbHNlIGlmIChFUSAodGltZW91dCwgUXQpKQogICAgIHsKICAgICAg IHNlYyA9IDA7Ci0gICAgICB1c2VjID0gMDsKKyAgICAgIG5zZWMgPSAwOwogICAgIH0KICAg ZWxzZQogICAgIHdyb25nX3R5cGVfYXJndW1lbnQgKFFudW1iZXJwLCB0aW1lb3V0KTsKIAot ICBpZiAoc2VjID09IDAgJiYgdXNlYyA9PSAwICYmICFFUSAodGltZW91dCwgUXQpKQotICAg IHJldHVybiBRdDsKIAogI2lmZGVmIFNJR0lPCiAgIGdvYmJsZV9pbnB1dCAoMCk7CiAjZW5k aWYKIAotICB3YWl0X3JlYWRpbmdfcHJvY2Vzc19vdXRwdXQgKHNlYywgdXNlYywgcmVhZGlu ZyA/IC0xIDogMSwgZG9fZGlzcGxheSwKKyAgd2FpdF9yZWFkaW5nX3Byb2Nlc3Nfb3V0cHV0 IChzZWMsIG5zZWMsIHJlYWRpbmcgPyAtMSA6IDEsIGRvX2Rpc3BsYXksCiAJCQkgICAgICAg UW5pbCwgTlVMTCwgMCk7CiAKICAgcmV0dXJuIGRldGVjdF9pbnB1dF9wZW5kaW5nICgpID8g UW5pbCA6IFF0OwoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9lZGl0Zm5zLmMnCi0tLSBzcmMv ZWRpdGZucy5jCTIwMTItMDUtMDMgMjA6MDQ6MjkgKzAwMDAKKysrIHNyYy9lZGl0Zm5zLmMJ MjAxMi0wNS0wNCAwNzo0OTo0OSArMDAwMApAQCAtNzcsOSArNzcsOCBAQAogZXh0ZXJuIExp c3BfT2JqZWN0IHczMl9nZXRfaW50ZXJuYWxfcnVuX3RpbWUgKHZvaWQpOwogI2VuZGlmCiAK LXN0YXRpYyB2b2lkIHRpbWVfb3ZlcmZsb3cgKHZvaWQpIE5PX1JFVFVSTjsKLXN0YXRpYyBM aXNwX09iamVjdCBmb3JtYXRfdGltZV9zdHJpbmcgKGNoYXIgY29uc3QgKiwgcHRyZGlmZl90 LCBMaXNwX09iamVjdCwKLQkJCQkgICAgICAgaW50LCB0aW1lX3QgKiwgc3RydWN0IHRtICop Oworc3RhdGljIExpc3BfT2JqZWN0IGZvcm1hdF90aW1lX3N0cmluZyAoY2hhciBjb25zdCAq LCBwdHJkaWZmX3QsIEVNQUNTX1RJTUUsCisJCQkJICAgICAgIGludCwgc3RydWN0IHRtICop Owogc3RhdGljIGludCB0bV9kaWZmIChzdHJ1Y3QgdG0gKiwgc3RydWN0IHRtICopOwogc3Rh dGljIHZvaWQgdXBkYXRlX2J1ZmZlcl9wcm9wZXJ0aWVzIChFTUFDU19JTlQsIEVNQUNTX0lO VCk7CiAKQEAgLTEzOTcsMTQgKzEzOTYsMTMgQEAKICNlbmRpZgogCiAvKiBSZXBvcnQgdGhh dCBhIHRpbWUgdmFsdWUgaXMgb3V0IG9mIHJhbmdlIGZvciBFbWFjcy4gICovCi1zdGF0aWMg dm9pZAordm9pZAogdGltZV9vdmVyZmxvdyAodm9pZCkKIHsKICAgZXJyb3IgKCJTcGVjaWZp ZWQgdGltZSBpcyBub3QgcmVwcmVzZW50YWJsZSIpOwogfQogCi0vKiBSZXR1cm4gdGhlIHVw cGVyIHBhcnQgb2YgdGhlIHRpbWUgVCAoZXZlcnl0aGluZyBidXQgdGhlIGJvdHRvbSAxNiBi aXRzKSwKLSAgIG1ha2luZyBzdXJlIHRoYXQgaXQgaXMgcmVwcmVzZW50YWJsZS4gICovCisv KiBSZXR1cm4gdGhlIHVwcGVyIHBhcnQgb2YgdGhlIHRpbWUgVCAoZXZlcnl0aGluZyBidXQg dGhlIGJvdHRvbSAxNiBiaXRzKS4gICovCiBzdGF0aWMgRU1BQ1NfSU5UCiBoaV90aW1lICh0 aW1lX3QgdCkKIHsKQEAgLTE0MzIsNDAgKzE0MzAsMzMgQEAKIAogREVGVU4gKCJjdXJyZW50 LXRpbWUiLCBGY3VycmVudF90aW1lLCBTY3VycmVudF90aW1lLCAwLCAwLCAwLAogICAgICAg IGRvYzogLyogUmV0dXJuIHRoZSBjdXJyZW50IHRpbWUsIGFzIHRoZSBudW1iZXIgb2Ygc2Vj b25kcyBzaW5jZSAxOTcwLTAxLTAxIDAwOjAwOjAwLgotVGhlIHRpbWUgaXMgcmV0dXJuZWQg YXMgYSBsaXN0IG9mIHRocmVlIGludGVnZXJzLiAgVGhlIGZpcnN0IGhhcyB0aGUKLW1vc3Qg c2lnbmlmaWNhbnQgMTYgYml0cyBvZiB0aGUgc2Vjb25kcywgd2hpbGUgdGhlIHNlY29uZCBo YXMgdGhlCi1sZWFzdCBzaWduaWZpY2FudCAxNiBiaXRzLiAgVGhlIHRoaXJkIGludGVnZXIg Z2l2ZXMgdGhlIG1pY3Jvc2Vjb25kCi1jb3VudC4KLQotVGhlIG1pY3Jvc2Vjb25kIGNvdW50 IGlzIHplcm8gb24gc3lzdGVtcyB0aGF0IGRvIG5vdCBwcm92aWRlCi1yZXNvbHV0aW9uIGZp bmVyIHRoYW4gYSBzZWNvbmQuICAqLykKK1RoZSB0aW1lIGlzIHJldHVybmVkIGFzIGEgbGlz dCBvZiBpbnRlZ2VycyAoSElHSCBMT1cgVVNFQyBQU0VDKS4KK0hJR0ggaGFzIHRoZSBtb3N0 IHNpZ25pZmljYW50IGJpdHMgb2YgdGhlIHNlY29uZHMsIHdoaWxlIExPVyBoYXMgdGhlCits ZWFzdCBzaWduaWZpY2FudCAxNiBiaXRzLiAgVVNFQyBhbmQgUFNFQyBhcmUgdGhlIG1pY3Jv c2Vjb25kIGFuZAorcGljb3NlY29uZCBjb3VudHMuICAqLykKICAgKHZvaWQpCiB7CiAgIEVN QUNTX1RJTUUgdDsKIAogICBFTUFDU19HRVRfVElNRSAodCk7Ci0gIHJldHVybiBsaXN0MyAo bWFrZV9udW1iZXIgKGhpX3RpbWUgKEVNQUNTX1NFQ1MgKHQpKSksCi0JCW1ha2VfbnVtYmVy IChsb190aW1lIChFTUFDU19TRUNTICh0KSkpLAotCQltYWtlX251bWJlciAoRU1BQ1NfVVNF Q1MgKHQpKSk7CisgIHJldHVybiBtYWtlX2xpc3BfdGltZSAodCk7CiB9CiAKIERFRlVOICgi Z2V0LWludGVybmFsLXJ1bi10aW1lIiwgRmdldF9pbnRlcm5hbF9ydW5fdGltZSwgU2dldF9p bnRlcm5hbF9ydW5fdGltZSwKICAgICAgICAwLCAwLCAwLAogICAgICAgIGRvYzogLyogUmV0 dXJuIHRoZSBjdXJyZW50IHJ1biB0aW1lIHVzZWQgYnkgRW1hY3MuCi1UaGUgdGltZSBpcyBy ZXR1cm5lZCBhcyBhIGxpc3Qgb2YgdGhyZWUgaW50ZWdlcnMuICBUaGUgZmlyc3QgaGFzIHRo ZQotbW9zdCBzaWduaWZpY2FudCAxNiBiaXRzIG9mIHRoZSBzZWNvbmRzLCB3aGlsZSB0aGUg c2Vjb25kIGhhcyB0aGUKLWxlYXN0IHNpZ25pZmljYW50IDE2IGJpdHMuICBUaGUgdGhpcmQg aW50ZWdlciBnaXZlcyB0aGUgbWljcm9zZWNvbmQKLWNvdW50LgorVGhlIHRpbWUgaXMgcmV0 dXJuZWQgYXMgYSBsaXN0IChISUdIIExPVyBVU0VDIFBTRUMpLCB1c2luZyB0aGUgc2FtZQor c3R5bGUgYXMgKGN1cnJlbnQtdGltZSkuCiAKIE9uIHN5c3RlbXMgdGhhdCBjYW4ndCBkZXRl cm1pbmUgdGhlIHJ1biB0aW1lLCBgZ2V0LWludGVybmFsLXJ1bi10aW1lJwotZG9lcyB0aGUg c2FtZSB0aGluZyBhcyBgY3VycmVudC10aW1lJy4gIFRoZSBtaWNyb3NlY29uZCBjb3VudCBp cyB6ZXJvCi1vbiBzeXN0ZW1zIHRoYXQgZG8gbm90IHByb3ZpZGUgcmVzb2x1dGlvbiBmaW5l ciB0aGFuIGEgc2Vjb25kLiAgKi8pCitkb2VzIHRoZSBzYW1lIHRoaW5nIGFzIGBjdXJyZW50 LXRpbWUnLiAgKi8pCiAgICh2b2lkKQogewogI2lmZGVmIEhBVkVfR0VUUlVTQUdFCiAgIHN0 cnVjdCBydXNhZ2UgdXNhZ2U7CiAgIHRpbWVfdCBzZWNzOwogICBpbnQgdXNlY3M7CisgIEVN QUNTX1RJTUUgdDsKIAogICBpZiAoZ2V0cnVzYWdlIChSVVNBR0VfU0VMRiwgJnVzYWdlKSA8 IDApCiAgICAgLyogVGhpcyBzaG91bGRuJ3QgaGFwcGVuLiAgV2hhdCBhY3Rpb24gaXMgYXBw cm9wcmlhdGU/ICAqLwpAQCAtMTQ3OSwxMCArMTQ3MCw4IEBACiAgICAgICB1c2VjcyAtPSAx MDAwMDAwOwogICAgICAgc2VjcysrOwogICAgIH0KLQotICByZXR1cm4gbGlzdDMgKG1ha2Vf bnVtYmVyIChoaV90aW1lIChzZWNzKSksCi0JCW1ha2VfbnVtYmVyIChsb190aW1lIChzZWNz KSksCi0JCW1ha2VfbnVtYmVyICh1c2VjcykpOworICBFTUFDU19TRVRfU0VDU19VU0VDUyAo dCwgc2VjcywgdXNlY3MpOworICByZXR1cm4gbWFrZV9saXNwX3RpbWUgKHQpOwogI2Vsc2Ug LyogISBIQVZFX0dFVFJVU0FHRSAgKi8KICNpZmRlZiBXSU5ET1dTTlQKICAgcmV0dXJuIHcz Ml9nZXRfaW50ZXJuYWxfcnVuX3RpbWUgKCk7CkBAIC0xNDkzLDEwMSArMTQ4MiwxNzQgQEAK IH0KIAwKIAotLyogTWFrZSBhIExpc3AgbGlzdCB0aGF0IHJlcHJlc2VudHMgdGhlIHRpbWUg VC4gICovCi1MaXNwX09iamVjdAorLyogTWFrZSBhIExpc3AgbGlzdCB0aGF0IHJlcHJlc2Vu dHMgdGhlIHRpbWUgVCB3aXRoIGZyYWN0aW9uIFRBSUwuICAqLworc3RhdGljIExpc3BfT2Jq ZWN0CittYWtlX3RpbWVfdGFpbCAodGltZV90IHQsIExpc3BfT2JqZWN0IHRhaWwpCit7Cisg IHJldHVybiBGY29ucyAobWFrZV9udW1iZXIgKGhpX3RpbWUgKHQpKSwKKwkJRmNvbnMgKG1h a2VfbnVtYmVyIChsb190aW1lICh0KSksIHRhaWwpKTsKK30KKworLyogTWFrZSBhIExpc3Ag bGlzdCB0aGF0IHJlcHJlc2VudHMgdGhlIHN5c3RlbSB0aW1lIFQuICAqLworc3RhdGljIExp c3BfT2JqZWN0CiBtYWtlX3RpbWUgKHRpbWVfdCB0KQogewotICByZXR1cm4gbGlzdDIgKG1h a2VfbnVtYmVyIChoaV90aW1lICh0KSksCi0JCW1ha2VfbnVtYmVyIChsb190aW1lICh0KSkp OworICByZXR1cm4gbWFrZV90aW1lX3RhaWwgKHQsIFFuaWwpOworfQorCisvKiBNYWtlIGEg TGlzcCBsaXN0IHRoYXQgcmVwcmVzZW50cyB0aGUgRW1hY3MgdGltZSBULiAgVCBtYXkgYmUg YW4KKyAgIGludmFsaWQgdGltZSwgd2l0aCBhIHNsaWdodGx5IG5lZ2F0aXZlIHR2X25zZWMg dmFsdWUgc3VjaCBhcworICAgVU5LTk9XTl9NT0RUSU1FX05TRUNTOyBpbiB0aGF0IGNhc2Us IHRoZSBMaXNwIGxpc3QgY29udGFpbnMgYQorICAgY29ycmVzcG9uZGluZ2x5IG5lZ2F0aXZl IHBpY29zZWNvbmQgY291bnQuICAqLworTGlzcF9PYmplY3QKK21ha2VfbGlzcF90aW1lIChF TUFDU19USU1FIHQpCit7CisgIGludCBucyA9IEVNQUNTX05TRUNTICh0KTsKKyAgcmV0dXJu IG1ha2VfdGltZV90YWlsIChFTUFDU19TRUNTICh0KSwKKwkJCSBsaXN0MiAobWFrZV9udW1i ZXIgKG5zIC8gMTAwMCksCisJCQkJbWFrZV9udW1iZXIgKG5zICUgMTAwMCAqIDEwMDApKSk7 CiB9CiAKIC8qIERlY29kZSBhIExpc3AgbGlzdCBTUEVDSUZJRURfVElNRSB0aGF0IHJlcHJl c2VudHMgYSB0aW1lLgotICAgSWYgU1BFQ0lGSUVEX1RJTUUgaXMgbmlsLCB1c2UgdGhlIGN1 cnJlbnQgdGltZS4KLSAgIFNldCAqUkVTVUxUIHRvIHNlY29uZHMgc2luY2UgdGhlIEVwb2No LgotICAgSWYgVVNFQyBpcyBub3QgbnVsbCwgc2V0ICpVU0VDIHRvIHRoZSBtaWNyb3NlY29u ZHMgY29tcG9uZW50LgorICAgU2V0ICpQSElHSCwgKlBMT1csICpQVVNFQywgKlBQU0VDIHRv IGl0cyBwYXJ0czsgZG8gbm90IGNoZWNrIHRoZWlyIHZhbHVlcy4KICAgIFJldHVybiBub256 ZXJvIGlmIHN1Y2Nlc3NmdWwuICAqLwotaW50Ci1saXNwX3RpbWVfYXJndW1lbnQgKExpc3Bf T2JqZWN0IHNwZWNpZmllZF90aW1lLCB0aW1lX3QgKnJlc3VsdCwgaW50ICp1c2VjKQorc3Rh dGljIGludAorZGlzYXNzZW1ibGVfbGlzcF90aW1lIChMaXNwX09iamVjdCBzcGVjaWZpZWRf dGltZSwgTGlzcF9PYmplY3QgKnBoaWdoLAorCQkgICAgICAgTGlzcF9PYmplY3QgKnBsb3cs IExpc3BfT2JqZWN0ICpwdXNlYywKKwkJICAgICAgIExpc3BfT2JqZWN0ICpwcHNlYykKIHsK LSAgaWYgKE5JTFAgKHNwZWNpZmllZF90aW1lKSkKLSAgICB7Ci0gICAgICBpZiAodXNlYykK LSAgICAgICAgewotICAgICAgICAgIEVNQUNTX1RJTUUgdDsKLQotICAgICAgICAgIEVNQUNT X0dFVF9USU1FICh0KTsKLSAgICAgICAgICAqdXNlYyA9IEVNQUNTX1VTRUNTICh0KTsKLSAg ICAgICAgICAqcmVzdWx0ID0gRU1BQ1NfU0VDUyAodCk7Ci0gICAgICAgICAgcmV0dXJuIDE7 Ci0gICAgICAgIH0KLSAgICAgIGVsc2UKLSAgICAgICAgcmV0dXJuIHRpbWUgKHJlc3VsdCkg IT0gLTE7Ci0gICAgfQotICBlbHNlCi0gICAgewotICAgICAgTGlzcF9PYmplY3QgaGlnaCwg bG93OwotICAgICAgRU1BQ1NfSU5UIGhpOwotICAgICAgaGlnaCA9IEZjYXIgKHNwZWNpZmll ZF90aW1lKTsKLSAgICAgIENIRUNLX05VTUJFUiAoaGlnaCk7Ci0gICAgICBsb3cgPSBGY2Ry IChzcGVjaWZpZWRfdGltZSk7CisgIGlmIChDT05TUCAoc3BlY2lmaWVkX3RpbWUpKQorICAg IHsKKyAgICAgIExpc3BfT2JqZWN0IGxvdyA9IFhDRFIgKHNwZWNpZmllZF90aW1lKTsKKyAg ICAgIExpc3BfT2JqZWN0IHVzZWMgPSBtYWtlX251bWJlciAoMCk7CisgICAgICBMaXNwX09i amVjdCBwc2VjID0gbWFrZV9udW1iZXIgKDApOwogICAgICAgaWYgKENPTlNQIChsb3cpKQot ICAgICAgICB7Ci0gICAgICAgICAgaWYgKHVzZWMpCi0gICAgICAgICAgICB7Ci0gICAgICAg ICAgICAgIExpc3BfT2JqZWN0IHVzZWNfbCA9IEZjZHIgKGxvdyk7Ci0gICAgICAgICAgICAg IGlmIChDT05TUCAodXNlY19sKSkKLSAgICAgICAgICAgICAgICB1c2VjX2wgPSBGY2FyICh1 c2VjX2wpOwotICAgICAgICAgICAgICBpZiAoTklMUCAodXNlY19sKSkKLSAgICAgICAgICAg ICAgICAqdXNlYyA9IDA7Ci0gICAgICAgICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICB7 Ci0gICAgICAgICAgICAgICAgICBDSEVDS19OVU1CRVIgKHVzZWNfbCk7Ci0gICAgICAgICAg ICAgICAgICAqdXNlYyA9IFhJTlQgKHVzZWNfbCk7Ci0gICAgICAgICAgICAgICAgfQotICAg ICAgICAgICAgfQotICAgICAgICAgIGxvdyA9IEZjYXIgKGxvdyk7Ci0gICAgICAgIH0KLSAg ICAgIGVsc2UgaWYgKHVzZWMpCi0gICAgICAgICp1c2VjID0gMDsKLSAgICAgIENIRUNLX05V TUJFUiAobG93KTsKLSAgICAgIGhpID0gWElOVCAoaGlnaCk7Ci0KLSAgICAgIC8qIENoZWNr IGZvciBvdmVyZmxvdywgaGVscGluZyB0aGUgY29tcGlsZXIgZm9yIGNvbW1vbiBjYXNlcwot CSB3aGVyZSBubyBydW50aW1lIGNoZWNrIGlzIG5lZWRlZCwgYW5kIHRha2luZyBjYXJlIG5v dCB0bwotCSBjb252ZXJ0IG5lZ2F0aXZlIG51bWJlcnMgdG8gdW5zaWduZWQgYmVmb3JlIGNv bXBhcmluZyB0aGVtLiAgKi8KLSAgICAgIGlmICghICgoVFlQRV9TSUdORUQgKHRpbWVfdCkK LQkgICAgICA/IChUSU1FX1RfTUlOID4+IDE2IDw9IE1PU1RfTkVHQVRJVkVfRklYTlVNCi0J CSB8fCBUSU1FX1RfTUlOID4+IDE2IDw9IGhpKQotCSAgICAgIDogMCA8PSBoaSkKLQkgICAg ICYmIChNT1NUX1BPU0lUSVZFX0ZJWE5VTSA8PSBUSU1FX1RfTUFYID4+IDE2Ci0JCSB8fCBo aSA8PSBUSU1FX1RfTUFYID4+IDE2KSkpCi0JcmV0dXJuIDA7Ci0KLSAgICAgICpyZXN1bHQg PSAoaGkgPDwgMTYpICsgKFhJTlQgKGxvdykgJiAweGZmZmYpOworCXsKKwkgIExpc3BfT2Jq ZWN0IGxvd190YWlsID0gWENEUiAobG93KTsKKwkgIGxvdyA9IFhDQVIgKGxvdyk7CisJICBp ZiAoQ09OU1AgKGxvd190YWlsKSkKKwkgICAgeworCSAgICAgIHVzZWMgPSBYQ0FSIChsb3df dGFpbCk7CisJICAgICAgbG93X3RhaWwgPSBYQ0RSIChsb3dfdGFpbCk7CisJICAgICAgaWYg KENPTlNQIChsb3dfdGFpbCkpCisJCXBzZWMgPSBYQ0FSIChsb3dfdGFpbCk7CisJICAgIH0K KwkgIGVsc2UgaWYgKCFOSUxQIChsb3dfdGFpbCkpCisJICAgIHVzZWMgPSBsb3dfdGFpbDsK Kwl9CisKKyAgICAgICpwaGlnaCA9IFhDQVIgKHNwZWNpZmllZF90aW1lKTsKKyAgICAgICpw bG93ID0gbG93OworICAgICAgKnB1c2VjID0gdXNlYzsKKyAgICAgICpwcHNlYyA9IHBzZWM7 CiAgICAgICByZXR1cm4gMTsKICAgICB9CisKKyAgcmV0dXJuIDA7Cit9CisKKy8qIEZyb20g dGhlIHRpbWUgY29tcG9uZW50cyBISUdILCBMT1csIFVTRUMgYW5kIFBTRUMgdGFrZW4gZnJv bSBhIExpc3AKKyAgIGxpc3QsIGdlbmVyYXRlIHRoZSBjb3JyZXNwb25kaW5nIEVNQUNTX1RJ TUUgdmFsdWUgKlJFU1VMVCwgYW5kCisgICBpZiBSRVNVTFRfUFNFQyBpcyBub3QgbnVsbCBz dG9yZSBpbnRvICpSRVNVTFRfUFNFQyB0aGUKKyAgIChub25uZWdhdGl2ZSkgZGlmZmVyZW5j ZSBpbiBwaWNvc2Vjb25kcyBiZXR3ZWVuIHRoZSBpbnB1dCB0aW1lIGFuZAorICAgdGhlIHJl dHVybmVkIHRpbWUuICBSZXR1cm4gbm9uemVybyBpZiBzdWNjZXNzZnVsLiAgKi8KK2ludAor ZGVjb2RlX3RpbWVfY29tcG9uZW50cyAoTGlzcF9PYmplY3QgaGlnaCwgTGlzcF9PYmplY3Qg bG93LCBMaXNwX09iamVjdCB1c2VjLAorCQkJTGlzcF9PYmplY3QgcHNlYywgRU1BQ1NfVElN RSAqcmVzdWx0LCBpbnQgKnJlc3VsdF9wc2VjKQoreworICBFTUFDU19JTlQgaGksIGxvLCB1 cywgcHM7CisgIHRpbWVfdCBzZWM7CisgIGlmICghIChJTlRFR0VSUCAoaGlnaCkgJiYgSU5U RUdFUlAgKGxvdykKKwkgJiYgSU5URUdFUlAgKHVzZWMpICYmIElOVEVHRVJQIChwc2VjKSkp CisgICAgcmV0dXJuIDA7CisgIGhpID0gWElOVCAoaGlnaCk7CisgIGxvID0gWElOVCAobG93 KTsKKyAgdXMgPSBYSU5UICh1c2VjKTsKKyAgcHMgPSBYSU5UIChwc2VjKTsKKworICAvKiBO b3JtYWxpemUgb3V0LW9mLXJhbmdlIGxvd2VyLW9yZGVyIGNvbXBvbmVudHMgYnkgY2Fycnlp bmcKKyAgICAgZWFjaCBvdmVyZmxvdyBpbnRvIHRoZSBuZXh0IGhpZ2hlci1vcmRlciBjb21w b25lbnQuICAqLworICB1cyArPSBwcyAvIDEwMDAwMDAgLSAocHMgJSAxMDAwMDAwIDwgMCk7 CisgIGxvICs9IHVzIC8gMTAwMDAwMCAtICh1cyAlIDEwMDAwMDAgPCAwKTsKKyAgaGkgKz0g bG8gPj4gMTY7CisgIHBzID0gcHMgJSAxMDAwMDAwICsgMTAwMDAwMCAqIChwcyAlIDEwMDAw MDAgPCAwKTsKKyAgdXMgPSB1cyAlIDEwMDAwMDAgKyAxMDAwMDAwICogKHVzICUgMTAwMDAw MCA8IDApOworICBsbyAmPSAoMSA8PCAxNikgLSAxOworCisgIC8qIENoZWNrIGZvciBvdmVy ZmxvdyBpbiB0aGUgaGlnaGVzdC1vcmRlciBjb21wb25lbnQuICAqLworICBpZiAoISAoKFRZ UEVfU0lHTkVEICh0aW1lX3QpID8gVElNRV9UX01JTiA+PiAxNiA8PSBoaSA6IDAgPD0gaGkp CisJICYmIGhpIDw9IFRJTUVfVF9NQVggPj4gMTYpKQorICAgIHJldHVybiAwOworCisgIHNl YyA9IGhpOworICBFTUFDU19TRVRfU0VDU19OU0VDUyAoKnJlc3VsdCwgKHNlYyA8PCAxNikg KyBsbywgdXMgKiAxMDAwICsgcHMgLyAxMDAwKTsKKyAgaWYgKHJlc3VsdF9wc2VjKQorICAg ICpyZXN1bHRfcHNlYyA9IHBzICUgMTAwMDsKKyAgcmV0dXJuIDE7Cit9CisKKy8qIERlY29k ZSBhIExpc3AgbGlzdCBTUEVDSUZJRURfVElNRSB0aGF0IHJlcHJlc2VudHMgYSB0aW1lLgor ICAgSWYgU1BFQ0lGSUVEX1RJTUUgaXMgbmlsLCB1c2UgdGhlIGN1cnJlbnQgdGltZS4KKyAg IFJvdW5kIHRoZSB0aW1lIGRvd24gdG8gdGhlIG5lYXJlc3QgRU1BQ1NfVElNRSB2YWx1ZSwg YW5kCisgICBpZiBQUFNFQyBpcyBub3QgbnVsbCBzdG9yZSBpbnRvICpQUFNFQyB0aGUgKG5v bm5lZ2F0aXZlKSBkaWZmZXJlbmNlIGluCisgICBwaWNvc2Vjb25kcyBiZXR3ZWVuIHRoZSBp bnB1dCB0aW1lIGFuZCB0aGUgcmV0dXJuZWQgdGltZS4KKyAgIFJldHVybiBzZWNvbmRzIHNp bmNlIHRoZSBFcG9jaC4KKyAgIFNpZ25hbCBhbiBlcnJvciBpZiB1bnN1Y2Nlc3NmdWwuICAq LworRU1BQ1NfVElNRQorbGlzcF90aW1lX2FyZ3VtZW50IChMaXNwX09iamVjdCBzcGVjaWZp ZWRfdGltZSwgaW50ICpwcHNlYykKK3sKKyAgRU1BQ1NfVElNRSB0OworICBpZiAoTklMUCAo c3BlY2lmaWVkX3RpbWUpKQorICAgIEVNQUNTX0dFVF9USU1FICh0KTsKKyAgZWxzZQorICAg IHsKKyAgICAgIExpc3BfT2JqZWN0IGhpZ2gsIGxvdywgdXNlYywgcHNlYzsKKyAgICAgIGlm ICghIChkaXNhc3NlbWJsZV9saXNwX3RpbWUgKHNwZWNpZmllZF90aW1lLCAmaGlnaCwgJmxv dywgJnVzZWMsICZwc2VjKQorCSAgICAgJiYgZGVjb2RlX3RpbWVfY29tcG9uZW50cyAoaGln aCwgbG93LCB1c2VjLCBwc2VjLCAmdCwgcHBzZWMpKSkKKwllcnJvciAoIkludmFsaWQgdGlt ZSBzcGVjaWZpY2F0aW9uIik7CisgICAgfQorICByZXR1cm4gdDsKK30KKworLyogTGlrZSBs aXNwX3RpbWVfYXJndW1lbnQsIGV4Y2VwdCBkZWNvZGUgb25seSB0aGUgc2Vjb25kcyBwYXJ0 LAorICAgYW5kIGRvIG5vdCBjaGVjayB0aGUgc3Vic2Vjb25kcyBwYXJ0LCBhbmQgYWx3YXlz IHJvdW5kIGRvd24uICAqLworc3RhdGljIHRpbWVfdAorbGlzcF9zZWNvbmRzX2FyZ3VtZW50 IChMaXNwX09iamVjdCBzcGVjaWZpZWRfdGltZSkKK3sKKyAgaWYgKE5JTFAgKHNwZWNpZmll ZF90aW1lKSkKKyAgICByZXR1cm4gdGltZSAoTlVMTCk7CisgIGVsc2UKKyAgICB7CisgICAg ICBMaXNwX09iamVjdCBoaWdoLCBsb3csIHVzZWMsIHBzZWM7CisgICAgICBFTUFDU19USU1F IHQ7CisgICAgICBpZiAoISAoZGlzYXNzZW1ibGVfbGlzcF90aW1lIChzcGVjaWZpZWRfdGlt ZSwgJmhpZ2gsICZsb3csICZ1c2VjLCAmcHNlYykKKwkgICAgICYmIGRlY29kZV90aW1lX2Nv bXBvbmVudHMgKGhpZ2gsIGxvdywgbWFrZV9udW1iZXIgKDApLAorCQkJCQltYWtlX251bWJl ciAoMCksICZ0LCAwKSkpCisJZXJyb3IgKCJJbnZhbGlkIHRpbWUgc3BlY2lmaWNhdGlvbiIp OworICAgICAgcmV0dXJuIEVNQUNTX1NFQ1MgKHQpOworICAgIH0KIH0KIAogREVGVU4gKCJm bG9hdC10aW1lIiwgRmZsb2F0X3RpbWUsIFNmbG9hdF90aW1lLCAwLCAxLCAwLAogICAgICAg IGRvYzogLyogUmV0dXJuIHRoZSBjdXJyZW50IHRpbWUsIGFzIGEgZmxvYXQgbnVtYmVyIG9m IHNlY29uZHMgc2luY2UgdGhlIGVwb2NoLgogSWYgU1BFQ0lGSUVELVRJTUUgaXMgZ2l2ZW4s IGl0IGlzIHRoZSB0aW1lIHRvIGNvbnZlcnQgdG8gZmxvYXQKIGluc3RlYWQgb2YgdGhlIGN1 cnJlbnQgdGltZS4gIFRoZSBhcmd1bWVudCBzaG91bGQgaGF2ZSB0aGUgZm9ybQotKEhJR0gg TE9XKSBvciAoSElHSCBMT1cgVVNFQykuIFRodXMsIHlvdSBjYW4gdXNlIHRpbWVzIG9idGFp bmVkIGZyb20KLWBjdXJyZW50LXRpbWUnIGFuZCBmcm9tIGBmaWxlLWF0dHJpYnV0ZXMnLiAg U1BFQ0lGSUVELVRJTUUgY2FuIGFsc28KLWhhdmUgdGhlIGZvcm0gKEhJR0ggLiBMT1cpLCBi dXQgdGhpcyBpcyBjb25zaWRlcmVkIG9ic29sZXRlLgorKEhJR0ggTE9XKSBvciAoSElHSCBM T1cgVVNFQykgb3IgKEhJR0ggTE9XIFVTRUMgUFNFQykuICBUaHVzLAoreW91IGNhbiB1c2Ug dGltZXMgZnJvbSBgY3VycmVudC10aW1lJyBhbmQgZnJvbSBgZmlsZS1hdHRyaWJ1dGVzJy4K K1NQRUNJRklFRC1USU1FIGNhbiBhbHNvIGhhdmUgdGhlIGZvcm0gKEhJR0ggLiBMT1cpLCBi dXQgdGhpcyBpcworY29uc2lkZXJlZCBvYnNvbGV0ZS4KIAogV0FSTklORzogU2luY2UgdGhl IHJlc3VsdCBpcyBmbG9hdGluZyBwb2ludCwgaXQgbWF5IG5vdCBiZSBleGFjdC4KIElmIHBy ZWNpc2UgdGltZSBzdGFtcHMgYXJlIHJlcXVpcmVkLCB1c2UgZWl0aGVyIGBjdXJyZW50LXRp bWUnLAogb3IgKGlmIHlvdSBuZWVkIHRpbWUgYXMgYSBzdHJpbmcpIGBmb3JtYXQtdGltZS1z dHJpbmcnLiAgKi8pCiAgIChMaXNwX09iamVjdCBzcGVjaWZpZWRfdGltZSkKIHsKLSAgdGlt ZV90IHNlYzsKLSAgaW50IHVzZWM7Ci0KLSAgaWYgKCEgbGlzcF90aW1lX2FyZ3VtZW50IChz cGVjaWZpZWRfdGltZSwgJnNlYywgJnVzZWMpKQotICAgIGVycm9yICgiSW52YWxpZCB0aW1l IHNwZWNpZmljYXRpb24iKTsKLQotICByZXR1cm4gbWFrZV9mbG9hdCAoKHNlYyAqIDFlNiAr IHVzZWMpIC8gMWU2KTsKKyAgaW50IHBzZWM7CisgIEVNQUNTX1RJTUUgdCA9IGxpc3BfdGlt ZV9hcmd1bWVudCAoc3BlY2lmaWVkX3RpbWUsICZwc2VjKTsKKyAgZG91YmxlIHBzID0gKDEw MDAgKiAxMDAwICogMTAwMCA8PSBJTlRNQVhfTUFYIC8gMTAwMAorCSAgICAgICA/IEVNQUNT X05TRUNTICh0KSAqIChpbnRtYXhfdCkgMTAwMCArIHBzZWMKKwkgICAgICAgOiBFTUFDU19O U0VDUyAodCkgKiAxZTMgKyBwc2VjKTsKKyAgcmV0dXJuIG1ha2VfZmxvYXQgKEVNQUNTX1NF Q1MgKHQpICsgcHMgLyAxZTEyKTsKIH0KIAogLyogV3JpdGUgaW5mb3JtYXRpb24gaW50byBi dWZmZXIgUyBvZiBzaXplIE1BWFNJWkUsIGFjY29yZGluZyB0byB0aGUKQEAgLTE2NDIsNyAr MTcwNCw3IEBACiAKIERFRlVOICgiZm9ybWF0LXRpbWUtc3RyaW5nIiwgRmZvcm1hdF90aW1l X3N0cmluZywgU2Zvcm1hdF90aW1lX3N0cmluZywgMSwgMywgMCwKICAgICAgICBkb2M6IC8q IFVzZSBGT1JNQVQtU1RSSU5HIHRvIGZvcm1hdCB0aGUgdGltZSBUSU1FLCBvciBub3cgaWYg b21pdHRlZC4KLVRJTUUgaXMgc3BlY2lmaWVkIGFzIChISUdIIExPVyAuIElHTk9SRUQpLCBh cyByZXR1cm5lZCBieQorVElNRSBpcyBzcGVjaWZpZWQgYXMgKEhJR0ggTE9XIFVTRUMgUFNF QyksIGFzIHJldHVybmVkIGJ5CiBgY3VycmVudC10aW1lJyBvciBgZmlsZS1hdHRyaWJ1dGVz Jy4gIFRoZSBvYnNvbGV0ZSBmb3JtIChISUdIIC4gTE9XKQogaXMgYWxzbyBzdGlsbCBhY2Nl cHRlZC4KIFRoZSB0aGlyZCwgb3B0aW9uYWwsIGFyZ3VtZW50IFVOSVZFUlNBTCwgaWYgbm9u LW5pbCwgbWVhbnMgZGVzY3JpYmUgVElNRQpAQCAtMTY5Niw0MiArMTc1OCwzNiBAQAogdXNh Z2U6IChmb3JtYXQtdGltZS1zdHJpbmcgRk9STUFULVNUUklORyAmb3B0aW9uYWwgVElNRSBV TklWRVJTQUwpICAqLykKICAgKExpc3BfT2JqZWN0IGZvcm1hdF9zdHJpbmcsIExpc3BfT2Jq ZWN0IHRpbWV2YWwsIExpc3BfT2JqZWN0IHVuaXZlcnNhbCkKIHsKLSAgdGltZV90IHQ7Cisg IEVNQUNTX1RJTUUgdCA9IGxpc3BfdGltZV9hcmd1bWVudCAodGltZXZhbCwgMCk7CiAgIHN0 cnVjdCB0bSB0bTsKIAogICBDSEVDS19TVFJJTkcgKGZvcm1hdF9zdHJpbmcpOwogICBmb3Jt YXRfc3RyaW5nID0gY29kZV9jb252ZXJ0X3N0cmluZ19ub3JlY29yZCAoZm9ybWF0X3N0cmlu ZywKIAkJCQkJCVZsb2NhbGVfY29kaW5nX3N5c3RlbSwgMSk7CiAgIHJldHVybiBmb3JtYXRf dGltZV9zdHJpbmcgKFNTREFUQSAoZm9ybWF0X3N0cmluZyksIFNCWVRFUyAoZm9ybWF0X3N0 cmluZyksCi0JCQkgICAgIHRpbWV2YWwsICEgTklMUCAodW5pdmVyc2FsKSwgJnQsICZ0bSk7 CisJCQkgICAgIHQsICEgTklMUCAodW5pdmVyc2FsKSwgJnRtKTsKIH0KIAogc3RhdGljIExp c3BfT2JqZWN0CiBmb3JtYXRfdGltZV9zdHJpbmcgKGNoYXIgY29uc3QgKmZvcm1hdCwgcHRy ZGlmZl90IGZvcm1hdGxlbiwKLQkJICAgIExpc3BfT2JqZWN0IHRpbWV2YWwsIGludCB1dCwg dGltZV90ICp0dmFsLCBzdHJ1Y3QgdG0gKnRtcCkKKwkJICAgIEVNQUNTX1RJTUUgdCwgaW50 IHV0LCBzdHJ1Y3QgdG0gKnRtcCkKIHsKICAgY2hhciBidWZmZXJbNDAwMF07CiAgIGNoYXIg KmJ1ZiA9IGJ1ZmZlcjsKLSAgc2l6ZV90IHNpemUgPSBzaXplb2YgYnVmZmVyOworICBwdHJk aWZmX3Qgc2l6ZSA9IHNpemVvZiBidWZmZXI7CiAgIHNpemVfdCBsZW47CiAgIExpc3BfT2Jq ZWN0IGJ1ZnN0cmluZzsKLSAgaW50IHVzZWM7Ci0gIGludCBuczsKKyAgaW50IG5zID0gRU1B Q1NfTlNFQ1MgKHQpOwogICBzdHJ1Y3QgdG0gKnRtOwogICBVU0VfU0FGRV9BTExPQ0E7CiAK LSAgaWYgKCEgKGxpc3BfdGltZV9hcmd1bWVudCAodGltZXZhbCwgdHZhbCwgJnVzZWMpCi0J ICYmIDAgPD0gdXNlYyAmJiB1c2VjIDwgMTAwMDAwMCkpCi0gICAgZXJyb3IgKCJJbnZhbGlk IHRpbWUgc3BlY2lmaWNhdGlvbiIpOwotICBucyA9IHVzZWMgKiAxMDAwOwotCiAgIHdoaWxl ICgxKQogICAgIHsKICAgICAgIEJMT0NLX0lOUFVUOwogCiAgICAgICBzeW5jaHJvbml6ZV9z eXN0ZW1fdGltZV9sb2NhbGUgKCk7CiAKLSAgICAgIHRtID0gdXQgPyBnbXRpbWUgKHR2YWwp IDogbG9jYWx0aW1lICh0dmFsKTsKKyAgICAgIHRtID0gdXQgPyBnbXRpbWUgKEVNQUNTX1NF Q1NfQUREUiAodCkpIDogbG9jYWx0aW1lIChFTUFDU19TRUNTX0FERFIgKHQpKTsKICAgICAg IGlmICghIHRtKQogCXsKIAkgIFVOQkxPQ0tfSU5QVVQ7CkBAIC0xNzc2LDE3ICsxODMyLDEz IEBACiBET1cgYW5kIFpPTkUuKSAgKi8pCiAgIChMaXNwX09iamVjdCBzcGVjaWZpZWRfdGlt ZSkKIHsKLSAgdGltZV90IHRpbWVfc3BlYzsKKyAgdGltZV90IHRpbWVfc3BlYyA9IGxpc3Bf c2Vjb25kc19hcmd1bWVudCAoc3BlY2lmaWVkX3RpbWUpOwogICBzdHJ1Y3QgdG0gc2F2ZV90 bTsKICAgc3RydWN0IHRtICpkZWNvZGVkX3RpbWU7CiAgIExpc3BfT2JqZWN0IGxpc3RfYXJn c1s5XTsKIAotICBpZiAoISBsaXNwX3RpbWVfYXJndW1lbnQgKHNwZWNpZmllZF90aW1lLCAm dGltZV9zcGVjLCBOVUxMKSkKLSAgICBlcnJvciAoIkludmFsaWQgdGltZSBzcGVjaWZpY2F0 aW9uIik7Ci0KICAgQkxPQ0tfSU5QVVQ7CiAgIGRlY29kZWRfdGltZSA9IGxvY2FsdGltZSAo JnRpbWVfc3BlYyk7Ci0gIC8qIE1ha2UgYSBjb3B5LCBpbiBjYXNlIGEgc2lnbmFsIGhhbmRs ZXIgbW9kaWZpZXMgVFogb3IgdGhlIHN0cnVjdC4gICovCiAgIGlmIChkZWNvZGVkX3RpbWUp CiAgICAgc2F2ZV90bSA9ICpkZWNvZGVkX3RpbWU7CiAgIFVOQkxPQ0tfSU5QVVQ7CkBAIC0x OTM0LDE0ICsxOTg2LDExIEBACiBidXQgdGhpcyBpcyBjb25zaWRlcmVkIG9ic29sZXRlLiAg Ki8pCiAgIChMaXNwX09iamVjdCBzcGVjaWZpZWRfdGltZSkKIHsKLSAgdGltZV90IHZhbHVl OworICB0aW1lX3QgdmFsdWUgPSBsaXNwX3NlY29uZHNfYXJndW1lbnQgKHNwZWNpZmllZF90 aW1lKTsKICAgc3RydWN0IHRtICp0bTsKICAgY2hhciBidWZbc2l6ZW9mICJNb24gQXByIDMw IDEyOjQ5OjE3ICIgKyBJTlRfU1RSTEVOX0JPVU5EIChpbnQpICsgMV07CiAgIGludCBsZW4g SUZfTElOVCAoPSAwKTsKIAotICBpZiAoISBsaXNwX3RpbWVfYXJndW1lbnQgKHNwZWNpZmll ZF90aW1lLCAmdmFsdWUsIE5VTEwpKQotICAgIGVycm9yICgiSW52YWxpZCB0aW1lIHNwZWNp ZmljYXRpb24iKTsKLQogICAvKiBDb252ZXJ0IHRvIGEgc3RyaW5nIGluIGN0aW1lIGZvcm1h dCwgZXhjZXB0IHdpdGhvdXQgdGhlIHRyYWlsaW5nCiAgICAgIG5ld2xpbmUsIGFuZCB3aXRo b3V0IHRoZSA0LWRpZ2l0IHllYXIgbGltaXQuICBEb24ndCB1c2UgYXNjdGltZQogICAgICBv ciBjdGltZSwgYXMgdGhleSBtaWdodCBkdW1wIGNvcmUgaWYgdGhlIHllYXIgaXMgb3V0c2lk ZSB0aGUKQEAgLTIwMDksMTcgKzIwNTgsMTcgQEAKIHRoZSBkYXRhIGl0IGNhbid0IGZpbmQu ICAqLykKICAgKExpc3BfT2JqZWN0IHNwZWNpZmllZF90aW1lKQogewotICB0aW1lX3QgdmFs dWU7CisgIEVNQUNTX1RJTUUgdmFsdWU7CiAgIGludCBvZmZzZXQ7CiAgIHN0cnVjdCB0bSAq dDsKICAgc3RydWN0IHRtIGxvY2FsdG07CiAgIExpc3BfT2JqZWN0IHpvbmVfb2Zmc2V0LCB6 b25lX25hbWU7CiAKICAgem9uZV9vZmZzZXQgPSBRbmlsOwotICB6b25lX25hbWUgPSBmb3Jt YXRfdGltZV9zdHJpbmcgKCIlWiIsIHNpemVvZiAiJVoiIC0gMSwgc3BlY2lmaWVkX3RpbWUs Ci0JCQkJICAwLCAmdmFsdWUsICZsb2NhbHRtKTsKKyAgRU1BQ1NfU0VUX1NFQ1NfTlNFQ1Mg KHZhbHVlLCBsaXNwX3NlY29uZHNfYXJndW1lbnQgKHNwZWNpZmllZF90aW1lKSwgMCk7Cisg IHpvbmVfbmFtZSA9IGZvcm1hdF90aW1lX3N0cmluZyAoIiVaIiwgc2l6ZW9mICIlWiIgLSAx LCB2YWx1ZSwgMCwgJmxvY2FsdG0pOwogICBCTE9DS19JTlBVVDsKLSAgdCA9IGdtdGltZSAo JnZhbHVlKTsKKyAgdCA9IGdtdGltZSAoRU1BQ1NfU0VDU19BRERSICh2YWx1ZSkpOwogICBp ZiAodCkKICAgICBvZmZzZXQgPSB0bV9kaWZmICgmbG9jYWx0bSwgdCk7CiAgIFVOQkxPQ0tf SU5QVVQ7Cgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2ZpbGVpby5jJwotLS0gc3JjL2ZpbGVp by5jCTIwMTItMDQtMjcgMDM6MTA6MzggKzAwMDAKKysrIHNyYy9maWxlaW8uYwkyMDEyLTA1 LTA0IDA3OjEyOjU5ICswMDAwCkBAIC03Niw2ICs3Niw3IEBACiAjZW5kaWYKIAogI2luY2x1 ZGUgInN5c3RpbWUuaCIKKyNpbmNsdWRlIDxzdGF0LXRpbWUuaD4KIAogI2lmZGVmIEhQVVgK ICNpbmNsdWRlIDxuZXRpby5oPgpAQCAtMTkzMSw3ICsxOTMyLDcgQEAKICAgICAgIC8qIEVu c3VyZSBmaWxlIGlzIHdyaXRhYmxlIHdoaWxlIGl0cyBtb2RpZmllZCB0aW1lIGlzIHNldC4g ICovCiAgICAgICBhdHRyaWJ1dGVzID0gR2V0RmlsZUF0dHJpYnV0ZXMgKGZpbGVuYW1lKTsK ICAgICAgIFNldEZpbGVBdHRyaWJ1dGVzIChmaWxlbmFtZSwgYXR0cmlidXRlcyAmIH5GSUxF X0FUVFJJQlVURV9SRUFET05MWSk7Ci0gICAgICBpZiAoc2V0X2ZpbGVfdGltZXMgKGZpbGVu YW1lLCBub3csIG5vdykpCisgICAgICBpZiAoc2V0X2ZpbGVfdGltZXMgKC0xLCBmaWxlbmFt ZSwgbm93LCBub3cpKQogCXsKIAkgIC8qIFJlc3RvcmUgb3JpZ2luYWwgYXR0cmlidXRlcy4g ICovCiAJICBTZXRGaWxlQXR0cmlidXRlcyAoZmlsZW5hbWUsIGF0dHJpYnV0ZXMpOwpAQCAt MjA1NCwyNCArMjA1NSwyMSBAQAogICAgIH0KICNlbmRpZgogCi0gIC8qIENsb3NpbmcgdGhl IG91dHB1dCBjbG9iYmVycyB0aGUgZmlsZSB0aW1lcyBvbiBzb21lIHN5c3RlbXMuICAqLwot ICBpZiAoZW1hY3NfY2xvc2UgKG9mZCkgPCAwKQotICAgIHJlcG9ydF9maWxlX2Vycm9yICgi SS9PIGVycm9yIiwgRmNvbnMgKG5ld25hbWUsIFFuaWwpKTsKLQogICBpZiAoaW5wdXRfZmls ZV9zdGF0YWJsZV9wKQogICAgIHsKICAgICAgIGlmICghTklMUCAoa2VlcF90aW1lKSkKIAl7 Ci0JICBFTUFDU19USU1FIGF0aW1lLCBtdGltZTsKLQkgIEVNQUNTX1NFVF9TRUNTX1VTRUNT IChhdGltZSwgc3Quc3RfYXRpbWUsIDApOwotCSAgRU1BQ1NfU0VUX1NFQ1NfVVNFQ1MgKG10 aW1lLCBzdC5zdF9tdGltZSwgMCk7Ci0JICBpZiAoc2V0X2ZpbGVfdGltZXMgKFNTREFUQSAo ZW5jb2RlZF9uZXduYW1lKSwKLQkJCSAgICAgIGF0aW1lLCBtdGltZSkpCisJICBFTUFDU19U SU1FIGF0aW1lID0gZ2V0X3N0YXRfYXRpbWUgKCZzdCk7CisJICBFTUFDU19USU1FIG10aW1l ID0gZ2V0X3N0YXRfbXRpbWUgKCZzdCk7CisJICBpZiAoc2V0X2ZpbGVfdGltZXMgKG9mZCwg U1NEQVRBIChlbmNvZGVkX25ld25hbWUpLCBhdGltZSwgbXRpbWUpKQogCSAgICB4c2lnbmFs MiAoUWZpbGVfZGF0ZV9lcnJvciwKIAkJICAgICAgYnVpbGRfc3RyaW5nICgiQ2Fubm90IHNl dCBmaWxlIGRhdGUiKSwgbmV3bmFtZSk7CiAJfQogICAgIH0KIAorICBpZiAoZW1hY3NfY2xv c2UgKG9mZCkgPCAwKQorICAgIHJlcG9ydF9maWxlX2Vycm9yICgiSS9PIGVycm9yIiwgRmNv bnMgKG5ld25hbWUsIFFuaWwpKTsKKwogICBlbWFjc19jbG9zZSAoaWZkKTsKIAogI2lmZGVm IE1TRE9TCkBAIC0zMDMyLDExICszMDMwLDcgQEAKIHsKICAgTGlzcF9PYmplY3QgYWJzbmFt ZSwgZW5jb2RlZF9hYnNuYW1lOwogICBMaXNwX09iamVjdCBoYW5kbGVyOwotICB0aW1lX3Qg c2VjOwotICBpbnQgdXNlYzsKLQotICBpZiAoISBsaXNwX3RpbWVfYXJndW1lbnQgKHRpbWVz dGFtcCwgJnNlYywgJnVzZWMpKQotICAgIGVycm9yICgiSW52YWxpZCB0aW1lIHNwZWNpZmlj YXRpb24iKTsKKyAgRU1BQ1NfVElNRSB0ID0gbGlzcF90aW1lX2FyZ3VtZW50ICh0aW1lc3Rh bXAsIDApOwogCiAgIGFic25hbWUgPSBGZXhwYW5kX2ZpbGVfbmFtZSAoZmlsZW5hbWUsIEJW QVIgKGN1cnJlbnRfYnVmZmVyLCBkaXJlY3RvcnkpKTsKIApAQCAtMzA0OSwxMiArMzA0Myw3 IEBACiAgIGVuY29kZWRfYWJzbmFtZSA9IEVOQ09ERV9GSUxFIChhYnNuYW1lKTsKIAogICB7 Ci0gICAgRU1BQ1NfVElNRSB0OwotCi0gICAgRU1BQ1NfU0VUX1NFQ1MgKHQsIHNlYyk7Ci0g ICAgRU1BQ1NfU0VUX1VTRUNTICh0LCB1c2VjKTsKLQotICAgIGlmIChzZXRfZmlsZV90aW1l cyAoU1NEQVRBIChlbmNvZGVkX2Fic25hbWUpLCB0LCB0KSkKKyAgICBpZiAoc2V0X2ZpbGVf dGltZXMgKC0xLCBTU0RBVEEgKGVuY29kZWRfYWJzbmFtZSksIHQsIHQpKQogICAgICAgewog I2lmZGVmIERPU19OVAogICAgICAgICBzdHJ1Y3Qgc3RhdCBzdDsKQEAgLTQyMDEsNyArNDE5 MCw3IEBACiAKICAgICAgIGlmIChOSUxQIChoYW5kbGVyKSkKIAl7Ci0JICBjdXJyZW50X2J1 ZmZlci0+bW9kdGltZSA9IHN0LnN0X210aW1lOworCSAgY3VycmVudF9idWZmZXItPm1vZHRp bWUgPSBnZXRfc3RhdF9tdGltZSAoJnN0KTsKIAkgIGN1cnJlbnRfYnVmZmVyLT5tb2R0aW1l X3NpemUgPSBzdC5zdF9zaXplOwogCSAgQlZBUiAoY3VycmVudF9idWZmZXIsIGZpbGVuYW1l KSA9IG9yaWdfZmlsZW5hbWU7CiAJfQpAQCAtNDM1Niw3ICs0MzQ1LDcgQEAKICAgICB9CiAK ICAgaWYgKCFOSUxQICh2aXNpdCkKLSAgICAgICYmIGN1cnJlbnRfYnVmZmVyLT5tb2R0aW1l ID09IC0xKQorICAgICAgJiYgRU1BQ1NfTlNFQ1MgKGN1cnJlbnRfYnVmZmVyLT5tb2R0aW1l KSA9PSBOT05FWElTVEVOVF9NT0RUSU1FX05TRUNTKQogICAgIHsKICAgICAgIC8qIElmIHZp c2l0aW5nIG5vbmV4aXN0ZW50IGZpbGUsIHJldHVybiBuaWwuICAqLwogICAgICAgZXJybm8g PSBzYXZlX2Vycm5vOwpAQCAtNDc5NCw3ICs0NzgzLDcgQEAKICAgICAgbmV4dCBhdHRlbXB0 IHRvIHNhdmUuICAqLwogICBpZiAodmlzaXRpbmcpCiAgICAgewotICAgICAgY3VycmVudF9i dWZmZXItPm1vZHRpbWUgPSBzdC5zdF9tdGltZTsKKyAgICAgIGN1cnJlbnRfYnVmZmVyLT5t b2R0aW1lID0gZ2V0X3N0YXRfbXRpbWUgKCZzdCk7CiAgICAgICBjdXJyZW50X2J1ZmZlci0+ bW9kdGltZV9zaXplID0gc3Quc3Rfc2l6ZTsKICAgICB9CiAKQEAgLTUwNzEsNiArNTA2MCw3 IEBACiAgIHN0cnVjdCBzdGF0IHN0OwogICBMaXNwX09iamVjdCBoYW5kbGVyOwogICBMaXNw X09iamVjdCBmaWxlbmFtZTsKKyAgRU1BQ1NfVElNRSBtdGltZSwgZGlmZiwgb25lX3NlY29u ZDsKIAogICBpZiAoTklMUCAoYnVmKSkKICAgICBiID0gY3VycmVudF9idWZmZXI7CkBAIC01 MDgxLDcgKzUwNzEsNyBAQAogICAgIH0KIAogICBpZiAoIVNUUklOR1AgKEJWQVIgKGIsIGZp bGVuYW1lKSkpIHJldHVybiBRdDsKLSAgaWYgKGItPm1vZHRpbWUgPT0gMCkgcmV0dXJuIFF0 OworICBpZiAoRU1BQ1NfTlNFQ1MgKGItPm1vZHRpbWUpID09IFVOS05PV05fTU9EVElNRV9O U0VDUykgcmV0dXJuIFF0OwogCiAgIC8qIElmIHRoZSBmaWxlIG5hbWUgaGFzIHNwZWNpYWwg Y29uc3RydWN0cyBpbiBpdCwKICAgICAgY2FsbCB0aGUgY29ycmVzcG9uZGluZyBmaWxlIGhh bmRsZXIuICAqLwpAQCAtNTA5MiwyMCArNTA4MiwyNSBAQAogCiAgIGZpbGVuYW1lID0gRU5D T0RFX0ZJTEUgKEJWQVIgKGIsIGZpbGVuYW1lKSk7CiAKLSAgaWYgKHN0YXQgKFNTREFUQSAo ZmlsZW5hbWUpLCAmc3QpIDwgMCkKKyAgaWYgKHN0YXQgKFNTREFUQSAoZmlsZW5hbWUpLCAm c3QpID09IDApCisgICAgbXRpbWUgPSBnZXRfc3RhdF9tdGltZSAoJnN0KTsKKyAgZWxzZQog ICAgIHsKICAgICAgIC8qIElmIHRoZSBmaWxlIGRvZXNuJ3QgZXhpc3Qgbm93IGFuZCBkaWRu J3QgZXhpc3QgYmVmb3JlLAogCSB3ZSBzYXkgdGhhdCBpdCBpc24ndCBtb2RpZmllZCwgcHJv dmlkZWQgdGhlIGVycm9yIGlzIGEgdGFtZSBvbmUuICAqLwotICAgICAgaWYgKGVycm5vID09 IEVOT0VOVCB8fCBlcnJubyA9PSBFQUNDRVMgfHwgZXJybm8gPT0gRU5PVERJUikKLQlzdC5z dF9tdGltZSA9IC0xOwotICAgICAgZWxzZQotCXN0LnN0X210aW1lID0gMDsKKyAgICAgIGlu dCBucyA9IChlcnJubyA9PSBFTk9FTlQgfHwgZXJybm8gPT0gRUFDQ0VTIHx8IGVycm5vID09 IEVOT1RESVIKKwkJPyBOT05FWElTVEVOVF9NT0RUSU1FX05TRUNTCisJCTogVU5LTk9XTl9N T0RUSU1FX05TRUNTKTsKKyAgICAgIEVNQUNTX1NFVF9TRUNTX05TRUNTIChtdGltZSwgMCwg bnMpOwogICAgIH0KLSAgaWYgKChzdC5zdF9tdGltZSA9PSBiLT5tb2R0aW1lCi0gICAgICAg LyogSWYgYm90aCBhcmUgcG9zaXRpdmUsIGFjY2VwdCB0aGVtIGlmIHRoZXkgYXJlIG9mZiBi eSBvbmUgc2Vjb25kLiAgKi8KLSAgICAgICB8fCAoc3Quc3RfbXRpbWUgPiAwICYmIGItPm1v ZHRpbWUgPiAwCi0JICAgJiYgKHN0LnN0X210aW1lIC0gMSA9PSBiLT5tb2R0aW1lCi0JICAg ICAgIHx8IHN0LnN0X210aW1lID09IGItPm1vZHRpbWUgLSAxKSkpCisgIGlmICgoRU1BQ1Nf VElNRV9FUSAobXRpbWUsIGItPm1vZHRpbWUpCisgICAgICAgLyogSWYgYm90aCBleGlzdCwg YWNjZXB0IHRoZW0gaWYgdGhleSBhcmUgb2ZmIGJ5IG9uZSBzZWNvbmQuICAqLworICAgICAg IHx8IChFTUFDU19USU1FX1ZBTElEX1AgKG10aW1lKSAmJiBFTUFDU19USU1FX1ZBTElEX1Ag KGItPm1vZHRpbWUpCisJICAgJiYgKChFTUFDU19USU1FX0xUIChtdGltZSwgYi0+bW9kdGlt ZSkKKwkJPyBFTUFDU19TVUJfVElNRSAoZGlmZiwgYi0+bW9kdGltZSwgbXRpbWUpCisJCTog RU1BQ1NfU1VCX1RJTUUgKGRpZmYsIG10aW1lLCBiLT5tb2R0aW1lKSksCisJICAgICAgIEVN QUNTX1NFVF9TRUNTX05TRUNTIChvbmVfc2Vjb25kLCAxLCAwKSwKKwkgICAgICAgRU1BQ1Nf VElNRV9MRSAoZGlmZiwgb25lX3NlY29uZCkpKSkKICAgICAgICYmIChzdC5zdF9zaXplID09 IGItPm1vZHRpbWVfc2l6ZQogICAgICAgICAgIHx8IGItPm1vZHRpbWVfc2l6ZSA8IDApKQog ICAgIHJldHVybiBRdDsKQEAgLTUxMTgsNyArNTExMyw3IEBACiBOZXh0IGF0dGVtcHQgdG8g c2F2ZSB3aWxsIGNlcnRhaW5seSBub3QgY29tcGxhaW4gb2YgYSBkaXNjcmVwYW5jeS4gICov KQogICAodm9pZCkKIHsKLSAgY3VycmVudF9idWZmZXItPm1vZHRpbWUgPSAwOworICBFTUFD U19TRVRfU0VDU19OU0VDUyAoY3VycmVudF9idWZmZXItPm1vZHRpbWUsIDAsIFVOS05PV05f TU9EVElNRV9OU0VDUyk7CiAgIGN1cnJlbnRfYnVmZmVyLT5tb2R0aW1lX3NpemUgPSAtMTsK ICAgcmV0dXJuIFFuaWw7CiB9CkBAIC01MTI2LDE2ICs1MTIxLDE2IEBACiBERUZVTiAoInZp c2l0ZWQtZmlsZS1tb2R0aW1lIiwgRnZpc2l0ZWRfZmlsZV9tb2R0aW1lLAogICAgICAgIFN2 aXNpdGVkX2ZpbGVfbW9kdGltZSwgMCwgMCwgMCwKICAgICAgICBkb2M6IC8qIFJldHVybiB0 aGUgY3VycmVudCBidWZmZXIncyByZWNvcmRlZCB2aXNpdGVkIGZpbGUgbW9kaWZpY2F0aW9u IHRpbWUuCi1UaGUgdmFsdWUgaXMgYSBsaXN0IG9mIHRoZSBmb3JtIChISUdIIExPVyksIGxp a2UgdGhlIHRpbWUgdmFsdWVzIHRoYXQKK1RoZSB2YWx1ZSBpcyBhIGxpc3Qgb2YgdGhlIGZv cm0gKEhJR0ggTE9XIFVTRUMgUFNFQyksIGxpa2UgdGhlIHRpbWUgdmFsdWVzIHRoYXQKIGBm aWxlLWF0dHJpYnV0ZXMnIHJldHVybnMuICBJZiB0aGUgY3VycmVudCBidWZmZXIgaGFzIG5v IHJlY29yZGVkIGZpbGUKIG1vZGlmaWNhdGlvbiB0aW1lLCB0aGlzIGZ1bmN0aW9uIHJldHVy bnMgMC4gIElmIHRoZSB2aXNpdGVkIGZpbGUKIGRvZXNuJ3QgZXhpc3QsIEhJR0ggd2lsbCBi ZSAtMS4KIFNlZSBJbmZvIG5vZGUgYChlbGlzcClNb2RpZmljYXRpb24gVGltZScgZm9yIG1v cmUgZGV0YWlscy4gICovKQogICAodm9pZCkKIHsKLSAgaWYgKCEgY3VycmVudF9idWZmZXIt Pm1vZHRpbWUpCisgIGlmIChFTUFDU19OU0VDUyAoY3VycmVudF9idWZmZXItPm1vZHRpbWUp IDwgMCkKICAgICByZXR1cm4gbWFrZV9udW1iZXIgKDApOwotICByZXR1cm4gbWFrZV90aW1l IChjdXJyZW50X2J1ZmZlci0+bW9kdGltZSk7CisgIHJldHVybiBtYWtlX2xpc3BfdGltZSAo Y3VycmVudF9idWZmZXItPm1vZHRpbWUpOwogfQogCiBERUZVTiAoInNldC12aXNpdGVkLWZp bGUtbW9kdGltZSIsIEZzZXRfdmlzaXRlZF9maWxlX21vZHRpbWUsCkBAIC01MTQ1LDEyICs1 MTQwLDEyIEBACiBvciBpZiB0aGUgZmlsZSBpdHNlbGYgaGFzIGJlZW4gY2hhbmdlZCBmb3Ig c29tZSBrbm93biBiZW5pZ24gcmVhc29uLgogQW4gYXJndW1lbnQgc3BlY2lmaWVzIHRoZSBt b2RpZmljYXRpb24gdGltZSB2YWx1ZSB0byB1c2UKIFwoaW5zdGVhZCBvZiB0aGF0IG9mIHRo ZSB2aXNpdGVkIGZpbGUpLCBpbiB0aGUgZm9ybSBvZiBhIGxpc3QKLVwoSElHSCAuIExPVykg b3IgKEhJR0ggTE9XKS4gICovKQorXChISUdIIExPVyBVU0VDIFBTRUMpIGFzIHJldHVybmVk IGJ5IGBjdXJyZW50LXRpbWUnLiAgKi8pCiAgIChMaXNwX09iamVjdCB0aW1lX2xpc3QpCiB7 CiAgIGlmICghTklMUCAodGltZV9saXN0KSkKICAgICB7Ci0gICAgICBDT05TX1RPX0lOVEVH RVIgKHRpbWVfbGlzdCwgdGltZV90LCBjdXJyZW50X2J1ZmZlci0+bW9kdGltZSk7CisgICAg ICBjdXJyZW50X2J1ZmZlci0+bW9kdGltZSA9IGxpc3BfdGltZV9hcmd1bWVudCAodGltZV9s aXN0LCAwKTsKICAgICAgIGN1cnJlbnRfYnVmZmVyLT5tb2R0aW1lX3NpemUgPSAtMTsKICAg ICB9CiAgIGVsc2UKQEAgLTUxNzIsNyArNTE2Nyw3IEBACiAKICAgICAgIGlmIChzdGF0IChT U0RBVEEgKGZpbGVuYW1lKSwgJnN0KSA+PSAwKQogICAgICAgICB7Ci0JICBjdXJyZW50X2J1 ZmZlci0+bW9kdGltZSA9IHN0LnN0X210aW1lOworCSAgY3VycmVudF9idWZmZXItPm1vZHRp bWUgPSBnZXRfc3RhdF9tdGltZSAoJnN0KTsKICAgICAgICAgICBjdXJyZW50X2J1ZmZlci0+ bW9kdGltZV9zaXplID0gc3Quc3Rfc2l6ZTsKICAgICAgICAgfQogICAgIH0KCj09PSBtb2Rp ZmllZCBmaWxlICdzcmMvZm5zLmMnCi0tLSBzcmMvZm5zLmMJMjAxMi0wNC0wOSAxMzowNTo0 OCArMDAwMAorKysgc3JjL2Zucy5jCTIwMTItMDUtMDQgMDY6NDI6MDMgKzAwMDAKQEAgLTg0 LDcgKzg0LDcgQEAKICAgICB7CiAgICAgICBFTUFDU19USU1FIHQ7CiAgICAgICBFTUFDU19H RVRfVElNRSAodCk7Ci0gICAgICBzZWVkX3JhbmRvbSAoZ2V0cGlkICgpIF4gRU1BQ1NfU0VD UyAodCkgXiBFTUFDU19VU0VDUyAodCkpOworICAgICAgc2VlZF9yYW5kb20gKGdldHBpZCAo KSBeIEVNQUNTX1NFQ1MgKHQpIF4gRU1BQ1NfTlNFQ1MgKHQpKTsKICAgICB9CiAKICAgaWYg KE5BVE5VTVAgKGxpbWl0KSAmJiBYRkFTVElOVCAobGltaXQpICE9IDApCgo9PT0gbW9kaWZp ZWQgZmlsZSAnc3JjL2d0a3V0aWwuYycKLS0tIHNyYy9ndGt1dGlsLmMJMjAxMi0wNC0yMyAw NzozNDoyOSArMDAwMAorKysgc3JjL2d0a3V0aWwuYwkyMDEyLTA1LTA0IDA2OjQyOjAzICsw MDAwCkBAIC0xNjEyLDE2ICsxNjEyLDE2IEBACiB7CiAgIHN0cnVjdCB4Z19kaWFsb2dfZGF0 YSAqZGQgPSAoc3RydWN0IHhnX2RpYWxvZ19kYXRhICopIGRhdGE7CiAgIEVNQUNTX1RJTUUg bmV4dF90aW1lID0gdGltZXJfY2hlY2sgKCk7Ci0gIGxvbmcgc2VjcyA9IEVNQUNTX1NFQ1Mg KG5leHRfdGltZSk7Ci0gIGxvbmcgdXNlY3MgPSBFTUFDU19VU0VDUyAobmV4dF90aW1lKTsK IAogICBkZC0+dGltZXJpZCA9IDA7CiAKLSAgaWYgKHNlY3MgPj0gMCAmJiB1c2VjcyA+PSAw ICYmIHNlY3MgPCAoKGd1aW50KS0xKS8xMDAwKQorICBpZiAoRU1BQ1NfVElNRV9WQUxJRF9Q IChuZXh0X3RpbWUpKQogICAgIHsKLSAgICAgIGRkLT50aW1lcmlkID0gZ190aW1lb3V0X2Fk ZCAoc2VjcyAqIDEwMDAgKyB1c2Vjcy8xMDAwLAotICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB4Z19tYXliZV9hZGRfdGltZXIsCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGRkKTsKKyAgICAgIHRpbWVfdCBzID0gRU1BQ1NfU0VDUyAobmV4dF90 aW1lKTsKKyAgICAgIGludCBwZXJfbXMgPSBFTUFDU19USU1FX1JFU09MVVRJT04gLyAxMDAw OworICAgICAgaW50IG1zID0gKEVNQUNTX05TRUNTIChuZXh0X3RpbWUpICsgcGVyX21zIC0g MSkgLyBwZXJfbXM7CisgICAgICBpZiAocyA8PSAoKGd1aW50KSAtMSAtIG1zKSAvIDEwMDAp CisJZGQtPnRpbWVyaWQgPSBnX3RpbWVvdXRfYWRkIChzICogMTAwMCArIG1zLCB4Z19tYXli ZV9hZGRfdGltZXIsIGRkKTsKICAgICB9CiAgIHJldHVybiBGQUxTRTsKIH0KCj09PSBtb2Rp ZmllZCBmaWxlICdzcmMvaW1hZ2UuYycKLS0tIHNyYy9pbWFnZS5jCTIwMTItMDItMTUgMDY6 NDA6MDggKzAwMDAKKysrIHNyYy9pbWFnZS5jCTIwMTItMDUtMDQgMDY6NDI6MDMgKzAwMDAK QEAgLTEwNjIsMTEgKzEwNjIsOCBAQAogdm9pZAogcHJlcGFyZV9pbWFnZV9mb3JfZGlzcGxh eSAoc3RydWN0IGZyYW1lICpmLCBzdHJ1Y3QgaW1hZ2UgKmltZykKIHsKLSAgRU1BQ1NfVElN RSB0OwotCiAgIC8qIFdlJ3JlIGFib3V0IHRvIGRpc3BsYXkgSU1HLCBzbyBzZXQgaXRzIHRp bWVzdGFtcCB0byBgbm93Jy4gICovCi0gIEVNQUNTX0dFVF9USU1FICh0KTsKLSAgaW1nLT50 aW1lc3RhbXAgPSBFTUFDU19TRUNTICh0KTsKKyAgRU1BQ1NfR0VUX1RJTUUgKGltZy0+dGlt ZXN0YW1wKTsKIAogICAvKiBJZiBJTUcgZG9lc24ndCBoYXZlIGEgcGl4bWFwIHlldCwgbG9h ZCBpdCBub3csIHVzaW5nIHRoZSBpbWFnZQogICAgICB0eXBlIGRlcGVuZGVudCBsb2FkZXIg ZnVuY3Rpb24uICAqLwpAQCAtMTUxNCw4ICsxNTExLDggQEAKICAgICAgIGVsc2UgaWYgKElO VEVHRVJQIChWaW1hZ2VfY2FjaGVfZXZpY3Rpb25fZGVsYXkpKQogCXsKIAkgIC8qIEZyZWUg Y2FjaGUgYmFzZWQgb24gdGltZXN0YW1wLiAgKi8KLQkgIEVNQUNTX1RJTUUgdDsKLQkgIGRv dWJsZSBvbGQsIGRlbGF5OworCSAgRU1BQ1NfVElNRSBvbGQsIHQ7CisJICBkb3VibGUgZGVs YXk7CiAJICBwdHJkaWZmX3QgbmltYWdlcyA9IDA7CiAKIAkgIGZvciAoaSA9IDA7IGkgPCBj LT51c2VkOyArK2kpCkBAIC0xNTMwLDEyICsxNTI3LDEyIEBACiAJICBkZWxheSA9IG1heCAo ZGVsYXksIDEpOwogCiAJICBFTUFDU19HRVRfVElNRSAodCk7Ci0JICBvbGQgPSBFTUFDU19T RUNTICh0KSAtIGRlbGF5OworCSAgRU1BQ1NfU1VCX1RJTUUgKG9sZCwgdCwgRU1BQ1NfVElN RV9GUk9NX0RPVUJMRSAoZGVsYXkpKTsKIAogCSAgZm9yIChpID0gMDsgaSA8IGMtPnVzZWQ7 ICsraSkKIAkgICAgewogCSAgICAgIHN0cnVjdCBpbWFnZSAqaW1nID0gYy0+aW1hZ2VzW2ld OwotCSAgICAgIGlmIChpbWcgJiYgaW1nLT50aW1lc3RhbXAgPCBvbGQpCisJICAgICAgaWYg KGltZyAmJiBFTUFDU19USU1FX0xUIChpbWctPnRpbWVzdGFtcCwgb2xkKSkKIAkJewogCQkg IGZyZWVfaW1hZ2UgKGYsIGltZyk7CiAJCSAgKytuZnJlZWQ7CkBAIC0xNzA4LDcgKzE3MDUs NiBAQAogewogICBzdHJ1Y3QgaW1hZ2UgKmltZzsKICAgRU1BQ1NfVUlOVCBoYXNoOwotICBF TUFDU19USU1FIG5vdzsKIAogICAvKiBGIG11c3QgYmUgYSB3aW5kb3ctc3lzdGVtIGZyYW1l LCBhbmQgU1BFQyBtdXN0IGJlIGEgdmFsaWQgaW1hZ2UKICAgICAgc3BlY2lmaWNhdGlvbi4g ICovCkBAIC0xODAwLDggKzE3OTYsNyBAQAogICAgIH0KIAogICAvKiBXZSdyZSB1c2luZyBJ TUcsIHNvIHNldCBpdHMgdGltZXN0YW1wIHRvIGBub3cnLiAgKi8KLSAgRU1BQ1NfR0VUX1RJ TUUgKG5vdyk7Ci0gIGltZy0+dGltZXN0YW1wID0gRU1BQ1NfU0VDUyAobm93KTsKKyAgRU1B Q1NfR0VUX1RJTUUgKGltZy0+dGltZXN0YW1wKTsKIAogICAvKiBWYWx1ZSBpcyB0aGUgaW1h Z2UgaWQuICAqLwogICByZXR1cm4gaW1nLT5pZDsKCj09PSBtb2RpZmllZCBmaWxlICdzcmMv a2V5Ym9hcmQuYycKLS0tIHNyYy9rZXlib2FyZC5jCTIwMTItMDUtMDEgMTY6MTA6MDIgKzAw MDAKKysrIHNyYy9rZXlib2FyZC5jCTIwMTItMDUtMDQgMDc6MTI6NTkgKzAwMDAKQEAgLTIw MTcsMTIgKzIwMTcsMTMgQEAKICAgICAgIGlmIChwb2xsX3RpbWVyID09IE5VTEwKIAkgIHx8 IEVNQUNTX1NFQ1MgKHBvbGxfdGltZXItPmludGVydmFsKSAhPSBwb2xsaW5nX3BlcmlvZCkK IAl7CisJICB0aW1lX3QgcGVyaW9kID0gbWF4ICgxLCBtaW4gKHBvbGxpbmdfcGVyaW9kLCBU WVBFX01BWElNVU0gKHRpbWVfdCkpKTsKIAkgIEVNQUNTX1RJTUUgaW50ZXJ2YWw7CiAKIAkg IGlmIChwb2xsX3RpbWVyKQogCSAgICBjYW5jZWxfYXRpbWVyIChwb2xsX3RpbWVyKTsKIAot CSAgRU1BQ1NfU0VUX1NFQ1NfVVNFQ1MgKGludGVydmFsLCBwb2xsaW5nX3BlcmlvZCwgMCk7 CisJICBFTUFDU19TRVRfU0VDU19VU0VDUyAoaW50ZXJ2YWwsIHBlcmlvZCwgMCk7CiAJICBw b2xsX3RpbWVyID0gc3RhcnRfYXRpbWVyIChBVElNRVJfQ09OVElOVU9VUywgaW50ZXJ2YWws CiAJCQkJICAgICBwb2xsX2Zvcl9pbnB1dCwgTlVMTCk7CiAJfQpAQCAtMjA5MCw3ICsyMDkx LDcgQEAKIGJpbmRfcG9sbGluZ19wZXJpb2QgKGludCBuKQogewogI2lmZGVmIFBPTExfRk9S X0lOUFVUCi0gIGludCBuZXcgPSBwb2xsaW5nX3BlcmlvZDsKKyAgRU1BQ1NfSU5UIG5ldyA9 IHBvbGxpbmdfcGVyaW9kOwogCiAgIGlmIChuID4gbmV3KQogICAgIG5ldyA9IG47CkBAIC0y MjIwLDcgKzIyMjEsNyBAQAogLyogSW5wdXQgb2Ygc2luZ2xlIGNoYXJhY3RlcnMgZnJvbSBr ZXlib2FyZCAqLwogCiBzdGF0aWMgTGlzcF9PYmplY3Qga2JkX2J1ZmZlcl9nZXRfZXZlbnQg KEtCT0FSRCAqKmticCwgaW50ICp1c2VkX21vdXNlX21lbnUsCi0JCQkJCSBzdHJ1Y3QgdGlt ZXZhbCAqZW5kX3RpbWUpOworCQkJCQkgRU1BQ1NfVElNRSAqZW5kX3RpbWUpOwogc3RhdGlj IHZvaWQgcmVjb3JkX2NoYXIgKExpc3BfT2JqZWN0IGMpOwogCiBzdGF0aWMgTGlzcF9PYmpl Y3QgaGVscF9mb3JtX3NhdmVkX3dpbmRvd19jb25maWdzOwpAQCAtMjI3Miw3ICsyMjczLDcg QEAKIExpc3BfT2JqZWN0CiByZWFkX2NoYXIgKGludCBjb21tYW5kZmxhZywgcHRyZGlmZl90 IG5tYXBzLCBMaXNwX09iamVjdCAqbWFwcywKIAkgICBMaXNwX09iamVjdCBwcmV2X2V2ZW50 LAotCSAgIGludCAqdXNlZF9tb3VzZV9tZW51LCBzdHJ1Y3QgdGltZXZhbCAqZW5kX3RpbWUp CisJICAgaW50ICp1c2VkX21vdXNlX21lbnUsIEVNQUNTX1RJTUUgKmVuZF90aW1lKQogewog ICB2b2xhdGlsZSBMaXNwX09iamVjdCBjOwogICBpbnQgam1wY291bnQ7CkBAIC0zNzc2LDcg KzM3NzcsNyBAQAogc3RhdGljIExpc3BfT2JqZWN0CiBrYmRfYnVmZmVyX2dldF9ldmVudCAo S0JPQVJEICoqa2JwLAogICAgICAgICAgICAgICAgICAgICAgIGludCAqdXNlZF9tb3VzZV9t ZW51LAotICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCB0aW1ldmFsICplbmRfdGltZSkK KyAgICAgICAgICAgICAgICAgICAgICBFTUFDU19USU1FICplbmRfdGltZSkKIHsKICAgcmVn aXN0ZXIgaW50IGM7CiAgIExpc3BfT2JqZWN0IG9iajsKQEAgLTM4NDksOCArMzg1MCw5IEBA CiAJICBlbHNlCiAJICAgIHsKIAkgICAgICBFTUFDU19TVUJfVElNRSAoZHVyYXRpb24sICpl bmRfdGltZSwgZHVyYXRpb24pOwotCSAgICAgIHdhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1 dCAoRU1BQ1NfU0VDUyAoZHVyYXRpb24pLAotCQkJCQkgICBFTUFDU19VU0VDUyAoZHVyYXRp b24pLAorCSAgICAgIHdhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1dCAobWluIChFTUFDU19T RUNTIChkdXJhdGlvbiksCisJCQkJCQlJTlRNQVhfTUFYKSwKKwkJCQkJICAgRU1BQ1NfTlNF Q1MgKGR1cmF0aW9uKSwKIAkJCQkJICAgLTEsIDEsIFFuaWwsIE5VTEwsIDApOwogCSAgICB9 CiAJfQpAQCAtNDI0NSw3ICs0MjQ3LDcgQEAKICAgTGlzcF9PYmplY3QgdGltZXJzOwogCiAg IC8qIElmIHdlIGFyZSBhbHJlYWR5IGluIHRoZSBpZGxlIHN0YXRlLCBkbyBub3RoaW5nLiAg Ki8KLSAgaWYgKCEgRU1BQ1NfVElNRV9ORUdfUCAodGltZXJfaWRsZW5lc3Nfc3RhcnRfdGlt ZSkpCisgIGlmIChFTUFDU19USU1FX1ZBTElEX1AgKHRpbWVyX2lkbGVuZXNzX3N0YXJ0X3Rp bWUpKQogICAgIHJldHVybjsKIAogICBFTUFDU19HRVRfVElNRSAodGltZXJfaWRsZW5lc3Nf c3RhcnRfdGltZSk7CkBAIC00MjU5LDcgKzQyNjEsNyBAQAogCiAgICAgICB0aW1lciA9IFhD QVIgKHRpbWVycyk7CiAKLSAgICAgIGlmICghVkVDVE9SUCAodGltZXIpIHx8IEFTSVpFICh0 aW1lcikgIT0gOCkKKyAgICAgIGlmICghVkVDVE9SUCAodGltZXIpIHx8IEFTSVpFICh0aW1l cikgIT0gOSkKIAljb250aW51ZTsKICAgICAgIFhWRUNUT1IgKHRpbWVyKS0+Y29udGVudHNb MF0gPSBRbmlsOwogICAgIH0KQEAgLTQyNzAsNyArNDI3Miw3IEBACiBzdGF0aWMgdm9pZAog dGltZXJfc3RvcF9pZGxlICh2b2lkKQogewotICBFTUFDU19TRVRfU0VDU19VU0VDUyAodGlt ZXJfaWRsZW5lc3Nfc3RhcnRfdGltZSwgLTEsIC0xKTsKKyAgRU1BQ1NfU0VUX0lOVkFMSURf VElNRSAodGltZXJfaWRsZW5lc3Nfc3RhcnRfdGltZSk7CiB9CiAKIC8qIFJlc3VtZSBpZGxl IHRpbWVyIGZyb20gbGFzdCBpZGxlIHN0YXJ0IHRpbWUuICAqLwpAQCAtNDI3OCw3ICs0Mjgw LDcgQEAKIHN0YXRpYyB2b2lkCiB0aW1lcl9yZXN1bWVfaWRsZSAodm9pZCkKIHsKLSAgaWYg KCEgRU1BQ1NfVElNRV9ORUdfUCAodGltZXJfaWRsZW5lc3Nfc3RhcnRfdGltZSkpCisgIGlm IChFTUFDU19USU1FX1ZBTElEX1AgKHRpbWVyX2lkbGVuZXNzX3N0YXJ0X3RpbWUpKQogICAg IHJldHVybjsKIAogICB0aW1lcl9pZGxlbmVzc19zdGFydF90aW1lID0gdGltZXJfbGFzdF9p ZGxlbmVzc19zdGFydF90aW1lOwpAQCAtNDI5Miw2ICs0Mjk0LDI0IEBACiAgICAuLi4pLiAg RWFjaCBlbGVtZW50IGhhcyB0aGUgZm9ybSAoRlVOIC4gQVJHUykuICAqLwogTGlzcF9PYmpl Y3QgcGVuZGluZ19mdW5jYWxsczsKIAorLyogSWYgVElNRVIgaXMgYSB2YWxpZCB0aW1lciwg cmV0dXJuIG5vbnplcm8gYW5kIHBsYWNlIGl0cyB2YWx1ZSBpbnRvCisgICAqUkVTVUxULiAg T3RoZXJ3aXNlIHJldHVybiB6ZXJvLiAgKi8KK3N0YXRpYyBpbnQKK2RlY29kZV90aW1lciAo TGlzcF9PYmplY3QgdGltZXIsIEVNQUNTX1RJTUUgKnJlc3VsdCkKK3sKKyAgTGlzcF9PYmpl Y3QgKnZlY3RvcjsKKworICBpZiAoISAoVkVDVE9SUCAodGltZXIpICYmIEFTSVpFICh0aW1l cikgPT0gOSkpCisgICAgcmV0dXJuIDA7CisgIHZlY3RvciA9IFhWRUNUT1IgKHRpbWVyKS0+ Y29udGVudHM7CisgIGlmICghIE5JTFAgKHZlY3RvclswXSkpCisgICAgcmV0dXJuIDA7CisK KyAgcmV0dXJuIGRlY29kZV90aW1lX2NvbXBvbmVudHMgKHZlY3RvclsxXSwgdmVjdG9yWzJd LCB2ZWN0b3JbM10sIHZlY3Rvcls0XSwKKwkJCQkgcmVzdWx0LCAwKTsKK30KKworCiAvKiBD aGVjayB3aGV0aGVyIGEgdGltZXIgaGFzIGZpcmVkLiAgVG8gcHJldmVudCBsYXJnZXIgcHJv YmxlbXMgd2Ugc2ltcGx5CiAgICBkaXNyZWdhcmQgZWxlbWVudHMgdGhhdCBhcmUgbm90IHBy b3BlciB0aW1lcnMuICBEbyBub3QgbWFrZSBhIGNpcmN1bGFyCiAgICB0aW1lciBsaXN0IGZv ciB0aGUgdGltZSBiZWluZy4KQEAgLTQzMDksMTcgKzQzMjksMTYgQEAKIHsKICAgRU1BQ1Nf VElNRSBuZXh0dGltZTsKICAgRU1BQ1NfVElNRSBub3c7Ci0gIEVNQUNTX1RJTUUgaWRsZW5l c3Nfbm93IElGX0xJTlQgKD0gezB9KTsKKyAgRU1BQ1NfVElNRSBpZGxlbmVzc19ub3c7CiAg IExpc3BfT2JqZWN0IHRpbWVycywgaWRsZV90aW1lcnMsIGNob3Nlbl90aW1lcjsKICAgc3Ry dWN0IGdjcHJvIGdjcHJvMSwgZ2Nwcm8yLCBnY3BybzM7CiAKLSAgRU1BQ1NfU0VUX1NFQ1Mg KG5leHR0aW1lLCAtMSk7Ci0gIEVNQUNTX1NFVF9VU0VDUyAobmV4dHRpbWUsIC0xKTsKKyAg RU1BQ1NfU0VUX0lOVkFMSURfVElNRSAobmV4dHRpbWUpOwogCiAgIC8qIEFsd2F5cyBjb25z aWRlciB0aGUgb3JkaW5hcnkgdGltZXJzLiAgKi8KICAgdGltZXJzID0gVnRpbWVyX2xpc3Q7 CiAgIC8qIENvbnNpZGVyIHRoZSBpZGxlIHRpbWVycyBvbmx5IGlmIEVtYWNzIGlzIGlkbGUu ICAqLwotICBpZiAoISBFTUFDU19USU1FX05FR19QICh0aW1lcl9pZGxlbmVzc19zdGFydF90 aW1lKSkKKyAgaWYgKEVNQUNTX1RJTUVfVkFMSURfUCAodGltZXJfaWRsZW5lc3Nfc3RhcnRf dGltZSkpCiAgICAgaWRsZV90aW1lcnMgPSBWdGltZXJfaWRsZV9saXN0OwogICBlbHNlCiAg ICAgaWRsZV90aW1lcnMgPSBRbmlsOwpAQCAtNDMzNyw4ICs0MzU2LDEwIEBACiAgIGlmIChD T05TUCAodGltZXJzKSB8fCBDT05TUCAoaWRsZV90aW1lcnMpKQogICAgIHsKICAgICAgIEVN QUNTX0dFVF9USU1FIChub3cpOwotICAgICAgaWYgKCEgRU1BQ1NfVElNRV9ORUdfUCAodGlt ZXJfaWRsZW5lc3Nfc3RhcnRfdGltZSkpCisgICAgICBpZiAoRU1BQ1NfVElNRV9WQUxJRF9Q ICh0aW1lcl9pZGxlbmVzc19zdGFydF90aW1lKSkKIAlFTUFDU19TVUJfVElNRSAoaWRsZW5l c3Nfbm93LCBub3csIHRpbWVyX2lkbGVuZXNzX3N0YXJ0X3RpbWUpOworICAgICAgZWxzZQor CUVNQUNTX1NFVF9TRUNTX05TRUNTIChpZGxlbmVzc19ub3csIDAsIDApOwogICAgIH0KIAog ICB3aGlsZSAoQ09OU1AgKHRpbWVycykgfHwgQ09OU1AgKGlkbGVfdGltZXJzKSkKQEAgLTQz NDcsMTEzICs0MzY4LDg0IEBACiAgICAgICBMaXNwX09iamVjdCB0aW1lciA9IFFuaWwsIGlk bGVfdGltZXIgPSBRbmlsOwogICAgICAgRU1BQ1NfVElNRSB0aW1lcl90aW1lLCBpZGxlX3Rp bWVyX3RpbWU7CiAgICAgICBFTUFDU19USU1FIGRpZmZlcmVuY2U7Ci0gICAgICBFTUFDU19U SU1FIHRpbWVyX2RpZmZlcmVuY2UgSUZfTElOVCAoPSB7MH0pOwotICAgICAgRU1BQ1NfVElN RSBpZGxlX3RpbWVyX2RpZmZlcmVuY2UgSUZfTElOVCAoPSB7MH0pOwotCi0gICAgICAvKiBT a2lwIHBhc3QgaW52YWxpZCB0aW1lcnMgYW5kIHRpbWVycyBhbHJlYWR5IGhhbmRsZWQuICAq LwotICAgICAgaWYgKENPTlNQICh0aW1lcnMpKQotCXsKLQkgIHRpbWVyID0gWENBUiAodGlt ZXJzKTsKLQkgIGlmICghVkVDVE9SUCAodGltZXIpIHx8IEFTSVpFICh0aW1lcikgIT0gOCkK LQkgICAgewotCSAgICAgIHRpbWVycyA9IFhDRFIgKHRpbWVycyk7Ci0JICAgICAgY29udGlu dWU7Ci0JICAgIH0KLQkgIHZlY3RvciA9IFhWRUNUT1IgKHRpbWVyKS0+Y29udGVudHM7Ci0K LQkgIGlmICghSU5URUdFUlAgKHZlY3RvclsxXSkgfHwgIUlOVEVHRVJQICh2ZWN0b3JbMl0p Ci0JICAgICAgfHwgIUlOVEVHRVJQICh2ZWN0b3JbM10pCi0JICAgICAgfHwgISBOSUxQICh2 ZWN0b3JbMF0pKQotCSAgICB7Ci0JICAgICAgdGltZXJzID0gWENEUiAodGltZXJzKTsKLQkg ICAgICBjb250aW51ZTsKLQkgICAgfQotCX0KLSAgICAgIGlmIChDT05TUCAoaWRsZV90aW1l cnMpKQotCXsKLQkgIHRpbWVyID0gWENBUiAoaWRsZV90aW1lcnMpOwotCSAgaWYgKCFWRUNU T1JQICh0aW1lcikgfHwgQVNJWkUgKHRpbWVyKSAhPSA4KQotCSAgICB7Ci0JICAgICAgaWRs ZV90aW1lcnMgPSBYQ0RSIChpZGxlX3RpbWVycyk7Ci0JICAgICAgY29udGludWU7Ci0JICAg IH0KLQkgIHZlY3RvciA9IFhWRUNUT1IgKHRpbWVyKS0+Y29udGVudHM7Ci0KLQkgIGlmICgh SU5URUdFUlAgKHZlY3RvclsxXSkgfHwgIUlOVEVHRVJQICh2ZWN0b3JbMl0pCi0JICAgICAg fHwgIUlOVEVHRVJQICh2ZWN0b3JbM10pCi0JICAgICAgfHwgISBOSUxQICh2ZWN0b3JbMF0p KQotCSAgICB7Ci0JICAgICAgaWRsZV90aW1lcnMgPSBYQ0RSIChpZGxlX3RpbWVycyk7Ci0J ICAgICAgY29udGludWU7Ci0JICAgIH0KLQl9Ci0KLSAgICAgIC8qIFNldCBUSU1FUiwgVElN RVJfVElNRSBhbmQgVElNRVJfRElGRkVSRU5DRQorICAgICAgRU1BQ1NfVElNRSB0aW1lcl9k aWZmZXJlbmNlLCBpZGxlX3RpbWVyX2RpZmZlcmVuY2U7CisgICAgICBpbnQgcmlwZSwgdGlt ZXJfcmlwZSA9IDAsIGlkbGVfdGltZXJfcmlwZSA9IDA7CisKKyAgICAgIEVNQUNTX1NFVF9J TlZBTElEX1RJTUUgKHRpbWVyX2RpZmZlcmVuY2UpOworICAgICAgRU1BQ1NfU0VUX0lOVkFM SURfVElNRSAoaWRsZV90aW1lcl9kaWZmZXJlbmNlKTsKKworICAgICAgLyogU2V0IFRJTUVS IGFuZCBUSU1FUl9ESUZGRVJFTkNFCiAJIGJhc2VkIG9uIHRoZSBuZXh0IG9yZGluYXJ5IHRp bWVyLgogCSBUSU1FUl9ESUZGRVJFTkNFIGlzIHRoZSBkaXN0YW5jZSBpbiB0aW1lIGZyb20g Tk9XIHRvIHdoZW4KLQkgdGhpcyB0aW1lciBiZWNvbWVzIHJpcGUgKG5lZ2F0aXZlIGlmIGl0 J3MgYWxyZWFkeSByaXBlKS4gICovCisJIHRoaXMgdGltZXIgYmVjb21lcyByaXBlIChuZWdh dGl2ZSBpZiBpdCdzIGFscmVhZHkgcmlwZSkuCisgICAgICAgICBTa2lwIHBhc3QgaW52YWxp ZCB0aW1lcnMgYW5kIHRpbWVycyBhbHJlYWR5IGhhbmRsZWQuICAqLwogICAgICAgaWYgKENP TlNQICh0aW1lcnMpKQogCXsKIAkgIHRpbWVyID0gWENBUiAodGltZXJzKTsKLQkgIHZlY3Rv ciA9IFhWRUNUT1IgKHRpbWVyKS0+Y29udGVudHM7Ci0JICBFTUFDU19TRVRfU0VDUyAodGlt ZXJfdGltZSwKLQkJCSAgKFhJTlQgKHZlY3RvclsxXSkgPDwgMTYpIHwgKFhJTlQgKHZlY3Rv clsyXSkpKTsKLQkgIEVNQUNTX1NFVF9VU0VDUyAodGltZXJfdGltZSwgWElOVCAodmVjdG9y WzNdKSk7Ci0JICBFTUFDU19TVUJfVElNRSAodGltZXJfZGlmZmVyZW5jZSwgdGltZXJfdGlt ZSwgbm93KTsKKwkgIGlmICghIGRlY29kZV90aW1lciAodGltZXIsICZ0aW1lcl90aW1lKSkK KwkgICAgeworCSAgICAgIHRpbWVycyA9IFhDRFIgKHRpbWVycyk7CisJICAgICAgY29udGlu dWU7CisJICAgIH0KKworCSAgdGltZXJfcmlwZSA9IEVNQUNTX1RJTUVfTEUgKHRpbWVyX3Rp bWUsIG5vdyk7CisJICBpZiAodGltZXJfcmlwZSkKKwkgICAgRU1BQ1NfU1VCX1RJTUUgKHRp bWVyX2RpZmZlcmVuY2UsIG5vdywgdGltZXJfdGltZSk7CisJICBlbHNlCisJICAgIEVNQUNT X1NVQl9USU1FICh0aW1lcl9kaWZmZXJlbmNlLCB0aW1lcl90aW1lLCBub3cpOwogCX0KIAot ICAgICAgLyogU2V0IElETEVfVElNRVIsIElETEVfVElNRVJfVElNRSBhbmQgSURMRV9USU1F Ul9ESUZGRVJFTkNFCisgICAgICAvKiBMaWtld2lzZSBmb3IgSURMRV9USU1FUiBhbmQgSURM RV9USU1FUl9ESUZGRVJFTkNFCiAJIGJhc2VkIG9uIHRoZSBuZXh0IGlkbGUgdGltZXIuICAq LwogICAgICAgaWYgKENPTlNQIChpZGxlX3RpbWVycykpCiAJewogCSAgaWRsZV90aW1lciA9 IFhDQVIgKGlkbGVfdGltZXJzKTsKLQkgIHZlY3RvciA9IFhWRUNUT1IgKGlkbGVfdGltZXIp LT5jb250ZW50czsKLQkgIEVNQUNTX1NFVF9TRUNTIChpZGxlX3RpbWVyX3RpbWUsCi0JCQkg IChYSU5UICh2ZWN0b3JbMV0pIDw8IDE2KSB8IChYSU5UICh2ZWN0b3JbMl0pKSk7Ci0JICBF TUFDU19TRVRfVVNFQ1MgKGlkbGVfdGltZXJfdGltZSwgWElOVCAodmVjdG9yWzNdKSk7Ci0J ICBFTUFDU19TVUJfVElNRSAoaWRsZV90aW1lcl9kaWZmZXJlbmNlLCBpZGxlX3RpbWVyX3Rp bWUsIGlkbGVuZXNzX25vdyk7CisJICBpZiAoISBkZWNvZGVfdGltZXIgKGlkbGVfdGltZXIs ICZpZGxlX3RpbWVyX3RpbWUpKQorCSAgICB7CisJICAgICAgaWRsZV90aW1lcnMgPSBYQ0RS IChpZGxlX3RpbWVycyk7CisJICAgICAgY29udGludWU7CisJICAgIH0KKworCSAgaWRsZV90 aW1lcl9yaXBlID0gRU1BQ1NfVElNRV9MRSAoaWRsZV90aW1lcl90aW1lLCBpZGxlbmVzc19u b3cpOworCSAgaWYgKGlkbGVfdGltZXJfcmlwZSkKKwkgICAgRU1BQ1NfU1VCX1RJTUUgKGlk bGVfdGltZXJfZGlmZmVyZW5jZSwKKwkJCSAgICBpZGxlbmVzc19ub3csIGlkbGVfdGltZXJf dGltZSk7CisJICBlbHNlCisJICAgIEVNQUNTX1NVQl9USU1FIChpZGxlX3RpbWVyX2RpZmZl cmVuY2UsCisJCQkgICAgaWRsZV90aW1lcl90aW1lLCBpZGxlbmVzc19ub3cpOwogCX0KIAog ICAgICAgLyogRGVjaWRlIHdoaWNoIHRpbWVyIGlzIHRoZSBuZXh0IHRpbWVyLAotCSBhbmQg c2V0IENIT1NFTl9USU1FUiwgVkVDVE9SIGFuZCBESUZGRVJFTkNFIGFjY29yZGluZ2x5Lgor CSBhbmQgc2V0IENIT1NFTl9USU1FUiwgRElGRkVSRU5DRSwgYW5kIFJJUEUgYWNjb3JkaW5n bHkuCiAJIEFsc28gc3RlcCBkb3duIHRoZSBsaXN0IHdoZXJlIHdlIGZvdW5kIHRoYXQgdGlt ZXIuICAqLwogCi0gICAgICBpZiAoQ09OU1AgKHRpbWVycykgJiYgQ09OU1AgKGlkbGVfdGlt ZXJzKSkKLQl7Ci0JICBFTUFDU19USU1FIHRlbXA7Ci0JICBFTUFDU19TVUJfVElNRSAodGVt cCwgdGltZXJfZGlmZmVyZW5jZSwgaWRsZV90aW1lcl9kaWZmZXJlbmNlKTsKLQkgIGlmIChF TUFDU19USU1FX05FR19QICh0ZW1wKSkKLQkgICAgewotCSAgICAgIGNob3Nlbl90aW1lciA9 IHRpbWVyOwotCSAgICAgIHRpbWVycyA9IFhDRFIgKHRpbWVycyk7Ci0JICAgICAgZGlmZmVy ZW5jZSA9IHRpbWVyX2RpZmZlcmVuY2U7Ci0JICAgIH0KLQkgIGVsc2UKLQkgICAgewotCSAg ICAgIGNob3Nlbl90aW1lciA9IGlkbGVfdGltZXI7Ci0JICAgICAgaWRsZV90aW1lcnMgPSBY Q0RSIChpZGxlX3RpbWVycyk7Ci0JICAgICAgZGlmZmVyZW5jZSA9IGlkbGVfdGltZXJfZGlm ZmVyZW5jZTsKLQkgICAgfQotCX0KLSAgICAgIGVsc2UgaWYgKENPTlNQICh0aW1lcnMpKQor ICAgICAgaWYgKEVNQUNTX1RJTUVfVkFMSURfUCAodGltZXJfZGlmZmVyZW5jZSkKKwkgICYm ICghIEVNQUNTX1RJTUVfVkFMSURfUCAoaWRsZV90aW1lcl9kaWZmZXJlbmNlKQorCSAgICAg IHx8IGlkbGVfdGltZXJfcmlwZSA8IHRpbWVyX3JpcGUKKwkgICAgICB8fCAoaWRsZV90aW1l cl9yaXBlID09IHRpbWVyX3JpcGUKKwkJICAmJiAodGltZXJfcmlwZQorCQkgICAgICA/IEVN QUNTX1RJTUVfTFQgKGlkbGVfdGltZXJfZGlmZmVyZW5jZSwKKwkJCQkgICAgICAgdGltZXJf ZGlmZmVyZW5jZSkKKwkJICAgICAgOiBFTUFDU19USU1FX0xUICh0aW1lcl9kaWZmZXJlbmNl LAorCQkJCSAgICAgICBpZGxlX3RpbWVyX2RpZmZlcmVuY2UpKSkpKQogCXsKIAkgIGNob3Nl bl90aW1lciA9IHRpbWVyOwogCSAgdGltZXJzID0gWENEUiAodGltZXJzKTsKIAkgIGRpZmZl cmVuY2UgPSB0aW1lcl9kaWZmZXJlbmNlOworCSAgcmlwZSA9IHRpbWVyX3JpcGU7CiAJfQog ICAgICAgZWxzZQogCXsKIAkgIGNob3Nlbl90aW1lciA9IGlkbGVfdGltZXI7CiAJICBpZGxl X3RpbWVycyA9IFhDRFIgKGlkbGVfdGltZXJzKTsKIAkgIGRpZmZlcmVuY2UgPSBpZGxlX3Rp bWVyX2RpZmZlcmVuY2U7CisJICByaXBlID0gaWRsZV90aW1lcl9yaXBlOwogCX0KLSAgICAg IHZlY3RvciA9IFhWRUNUT1IgKGNob3Nlbl90aW1lciktPmNvbnRlbnRzOwogCiAgICAgICAv KiBJZiB0aW1lciBpcyByaXBlLCBydW4gaXQgaWYgaXQgaGFzbid0IGJlZW4gcnVuLiAgKi8K LSAgICAgIGlmIChFTUFDU19USU1FX05FR19QIChkaWZmZXJlbmNlKQotCSAgfHwgKEVNQUNT X1NFQ1MgKGRpZmZlcmVuY2UpID09IDAKLQkgICAgICAmJiBFTUFDU19VU0VDUyAoZGlmZmVy ZW5jZSkgPT0gMCkpCisgICAgICBpZiAocmlwZSkKIAl7CisJICB2ZWN0b3IgPSBYVkVDVE9S IChjaG9zZW5fdGltZXIpLT5jb250ZW50czsKIAkgIGlmIChOSUxQICh2ZWN0b3JbMF0pKQog CSAgICB7CiAJICAgICAgaW50IGNvdW50ID0gU1BFQ1BETF9JTkRFWCAoKTsKQEAgLTQ1MDAs NyArNDQ5Miw3IEBACiAgICB0aW1lciBsaXN0IGZvciB0aGUgdGltZSBiZWluZy4KIAogICAg UmV0dXJucyB0aGUgdGltZSB0byB3YWl0IHVudGlsIHRoZSBuZXh0IHRpbWVyIGZpcmVzLgot ICAgSWYgbm8gdGltZXIgaXMgYWN0aXZlLCByZXR1cm4gLTEuCisgICBJZiBubyB0aW1lciBp cyBhY3RpdmUsIHJldHVybiBhbiBpbnZhbGlkIHZhbHVlLgogCiAgICBBcyBsb25nIGFzIGFu eSB0aW1lciBpcyByaXBlLCB3ZSBydW4gaXQuICAqLwogCkBAIC00NTEzLDMzICs0NTA1LDI5 IEBACiAgICAgewogICAgICAgbmV4dHRpbWUgPSB0aW1lcl9jaGVja18yICgpOwogICAgIH0K LSAgd2hpbGUgKEVNQUNTX1NFQ1MgKG5leHR0aW1lKSA9PSAwICYmIEVNQUNTX1VTRUNTIChu ZXh0dGltZSkgPT0gMCk7CisgIHdoaWxlIChFTUFDU19TRUNTIChuZXh0dGltZSkgPT0gMCAm JiBFTUFDU19OU0VDUyAobmV4dHRpbWUpID09IDApOwogCiAgIHJldHVybiBuZXh0dGltZTsK IH0KIAogREVGVU4gKCJjdXJyZW50LWlkbGUtdGltZSIsIEZjdXJyZW50X2lkbGVfdGltZSwg U2N1cnJlbnRfaWRsZV90aW1lLCAwLCAwLCAwLAogICAgICAgIGRvYzogLyogUmV0dXJuIHRo ZSBjdXJyZW50IGxlbmd0aCBvZiBFbWFjcyBpZGxlbmVzcywgb3IgbmlsLgotVGhlIHZhbHVl IHdoZW4gRW1hY3MgaXMgaWRsZSBpcyBhIGxpc3Qgb2YgdGhyZWUgaW50ZWdlcnMuICBUaGUg Zmlyc3QgaGFzCi10aGUgbW9zdCBzaWduaWZpY2FudCAxNiBiaXRzIG9mIHRoZSBzZWNvbmRz LCB3aGlsZSB0aGUgc2Vjb25kIGhhcyB0aGUgbGVhc3QKLXNpZ25pZmljYW50IDE2IGJpdHMu ICBUaGUgdGhpcmQgaW50ZWdlciBnaXZlcyB0aGUgbWljcm9zZWNvbmQgY291bnQuCitUaGUg dmFsdWUgd2hlbiBFbWFjcyBpcyBpZGxlIGlzIGEgbGlzdCBvZiBmb3VyIGludGVnZXJzIChI SUdIIExPVyBVU0VDIFBTRUMpCitpbiB0aGUgc2FtZSBzdHlsZSBhcyAoY3VycmVudC10aW1l KS4KIAogVGhlIHZhbHVlIHdoZW4gRW1hY3MgaXMgbm90IGlkbGUgaXMgbmlsLgogCi1UaGUg bWljcm9zZWNvbmQgY291bnQgaXMgemVybyBvbiBzeXN0ZW1zIHRoYXQgZG8gbm90IHByb3Zp ZGUKLXJlc29sdXRpb24gZmluZXIgdGhhbiBhIHNlY29uZC4gICovKQorTlNFQyBpcyBhIG11 bHRpcGxlIG9mIHRoZSBzeXN0ZW0gY2xvY2sgcmVzb2x1dGlvbi4gICovKQogICAodm9pZCkK IHsKLSAgaWYgKCEgRU1BQ1NfVElNRV9ORUdfUCAodGltZXJfaWRsZW5lc3Nfc3RhcnRfdGlt ZSkpCisgIGlmIChFTUFDU19USU1FX1ZBTElEX1AgKHRpbWVyX2lkbGVuZXNzX3N0YXJ0X3Rp bWUpKQogICAgIHsKICAgICAgIEVNQUNTX1RJTUUgbm93LCBpZGxlbmVzc19ub3c7CiAKICAg ICAgIEVNQUNTX0dFVF9USU1FIChub3cpOwogICAgICAgRU1BQ1NfU1VCX1RJTUUgKGlkbGVu ZXNzX25vdywgbm93LCB0aW1lcl9pZGxlbmVzc19zdGFydF90aW1lKTsKIAotICAgICAgcmV0 dXJuIGxpc3QzIChtYWtlX251bWJlciAoKEVNQUNTX1NFQ1MgKGlkbGVuZXNzX25vdykgPj4g MTYpICYgMHhmZmZmKSwKLQkJICAgIG1ha2VfbnVtYmVyICgoRU1BQ1NfU0VDUyAoaWRsZW5l c3Nfbm93KSA+PiAwKSAgJiAweGZmZmYpLAotCQkgICAgbWFrZV9udW1iZXIgKEVNQUNTX1VT RUNTIChpZGxlbmVzc19ub3cpKSk7CisgICAgICByZXR1cm4gbWFrZV9saXNwX3RpbWUgKGlk bGVuZXNzX25vdyk7CiAgICAgfQogCiAgIHJldHVybiBRbmlsOwpAQCAtMTA3MjIsNyArMTA3 MTAsNyBAQAogfQogDAogdm9pZAotc2V0X3dhaXRpbmdfZm9yX2lucHV0IChzdHJ1Y3QgdGlt ZXZhbCAqdGltZV90b19jbGVhcikKK3NldF93YWl0aW5nX2Zvcl9pbnB1dCAoRU1BQ1NfVElN RSAqdGltZV90b19jbGVhcikKIHsKICAgaW5wdXRfYXZhaWxhYmxlX2NsZWFyX3RpbWUgPSB0 aW1lX3RvX2NsZWFyOwogCkBAIC0xMTM0NSw3ICsxMTMzMyw3IEBACiAgIHF1aXRfY2hhciA9 IEN0bCAoJ2cnKTsKICAgVnVucmVhZF9jb21tYW5kX2V2ZW50cyA9IFFuaWw7CiAgIHVucmVh ZF9jb21tYW5kX2NoYXIgPSAtMTsKLSAgRU1BQ1NfU0VUX1NFQ1NfVVNFQ1MgKHRpbWVyX2lk bGVuZXNzX3N0YXJ0X3RpbWUsIC0xLCAtMSk7CisgIEVNQUNTX1NFVF9JTlZBTElEX1RJTUUg KHRpbWVyX2lkbGVuZXNzX3N0YXJ0X3RpbWUpOwogICB0b3RhbF9rZXlzID0gMDsKICAgcmVj ZW50X2tleXNfaW5kZXggPSAwOwogICBrYmRfZmV0Y2hfcHRyID0ga2JkX2J1ZmZlcjsKCj09 PSBtb2RpZmllZCBmaWxlICdzcmMvbGlzcC5oJwotLS0gc3JjL2xpc3AuaAkyMDEyLTA0LTE2 IDAxOjEwOjQyICswMDAwCisrKyBzcmMvbGlzcC5oCTIwMTItMDUtMDQgMDY6NDI6MDMgKzAw MDAKQEAgLTMwNDEsNiArMzA0MSw3IEBACiBFWEZVTiAoRndpZGVuLCAwKTsKIEVYRlVOIChG dXNlcl9sb2dpbl9uYW1lLCAxKTsKIEVYRlVOIChGc3lzdGVtX25hbWUsIDApOworZXh0ZXJu IHZvaWQgdGltZV9vdmVyZmxvdyAodm9pZCkgTk9fUkVUVVJOOwogRVhGVU4gKEZjdXJyZW50 X3RpbWUsIDApOwogRVhGVU4gKEZnZXRfaW50ZXJuYWxfcnVuX3RpbWUsIDApOwogZXh0ZXJu IEVNQUNTX0lOVCBjbGlwX3RvX2JvdW5kcyAoRU1BQ1NfSU5ULCBFTUFDU19JTlQsIEVNQUNT X0lOVCk7CkBAIC0zMzMyLDcgKzMzMzMsNyBAQAogRVhGVU4gKEZ3YWl0aW5nX2Zvcl91c2Vy X2lucHV0X3AsIDApOwogZXh0ZXJuIExpc3BfT2JqZWN0IFFwcm9jZXNzcDsKIGV4dGVybiB2 b2lkIGtpbGxfYnVmZmVyX3Byb2Nlc3NlcyAoTGlzcF9PYmplY3QpOwotZXh0ZXJuIGludCB3 YWl0X3JlYWRpbmdfcHJvY2Vzc19vdXRwdXQgKGludCwgaW50LCBpbnQsIGludCwKK2V4dGVy biBpbnQgd2FpdF9yZWFkaW5nX3Byb2Nlc3Nfb3V0cHV0IChpbnRtYXhfdCwgaW50LCBpbnQs IGludCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMaXNwX09i amVjdCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qg TGlzcF9Qcm9jZXNzICosCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgaW50KTsKCj09PSBtb2RpZmllZCBmaWxlICdzcmMvbHJlYWQuYycKLS0tIHNyYy9scmVh ZC5jCTIwMTItMDQtMTQgMDE6NDY6MDYgKzAwMDAKKysrIHNyYy9scmVhZC5jCTIwMTItMDUt MDQgMDY6NDI6MDMgKzAwMDAKQEAgLTYwNCwxNCArNjA0LDEwIEBACiAgIC8qIENvbXB1dGUg dGltZW91dC4gICovCiAgIGlmIChOVU1CRVJQIChzZWNvbmRzKSkKICAgICB7Ci0gICAgICBF TUFDU19USU1FIHdhaXRfdGltZTsKLSAgICAgIGludCBzZWMsIHVzZWM7CiAgICAgICBkb3Vi bGUgZHVyYXRpb24gPSBleHRyYWN0X2Zsb2F0IChzZWNvbmRzKTsKKyAgICAgIEVNQUNTX1RJ TUUgd2FpdF90aW1lID0gRU1BQ1NfVElNRV9GUk9NX0RPVUJMRSAoZHVyYXRpb24pOwogCi0g ICAgICBzZWMgID0gKGludCkgZHVyYXRpb247Ci0gICAgICB1c2VjID0gKGR1cmF0aW9uIC0g c2VjKSAqIDEwMDAwMDA7CiAgICAgICBFTUFDU19HRVRfVElNRSAoZW5kX3RpbWUpOwotICAg ICAgRU1BQ1NfU0VUX1NFQ1NfVVNFQ1MgKHdhaXRfdGltZSwgc2VjLCB1c2VjKTsKICAgICAg IEVNQUNTX0FERF9USU1FIChlbmRfdGltZSwgZW5kX3RpbWUsIHdhaXRfdGltZSk7CiAgICAg fQogCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL21zZG9zLmMnCi0tLSBzcmMvbXNkb3MuYwky MDEyLTA0LTA5IDEzOjA1OjQ4ICswMDAwCisrKyBzcmMvbXNkb3MuYwkyMDEyLTA1LTA0IDA2 OjQyOjAzICswMDAwCkBAIC00MDcyLDEzICs0MDcyLDYgQEAKICNpZm5kZWYgSEFWRV9TRUxF Q1QKICNpbmNsdWRlICJzeXNzZWxlY3QuaCIKIAotI2lmbmRlZiBFTUFDU19USU1FX1pFUk9f T1JfTkVHX1AKLSNkZWZpbmUgRU1BQ1NfVElNRV9aRVJPX09SX05FR19QKHRpbWUpCVwKLSAg KChsb25nKSh0aW1lKS50dl9zZWMgPCAwCQlcCi0gICB8fCAoKHRpbWUpLnR2X3NlYyA9PSAw CQlcCi0gICAgICAgJiYgKGxvbmcpKHRpbWUpLnR2X3VzZWMgPD0gMCkpCi0jZW5kaWYKLQog LyogVGhpcyB5aWVsZHMgdGhlIHJlc3Qgb2YgdGhlIGN1cnJlbnQgdGltZSBzbGljZSB0byB0 aGUgdGFzayBtYW5hZ2VyLgogICAgSXQgc2hvdWxkIGJlIGNhbGxlZCBieSBhbnkgY29kZSB3 aGljaCBrbm93cyB0aGF0IGl0IGhhcyBub3RoaW5nCiAgICB1c2VmdWwgdG8gZG8gZXhjZXB0 IGlkbGUuCkBAIC00MTQ3LDEyICs0MTQwLDEyIEBACiAKIAkgIC8qIFdoZW4gc2Vjb25kcyB3 cmFwIGFyb3VuZCwgd2UgYXNzdW1lIHRoYXQgbm8gbW9yZSB0aGFuCiAJICAgICAxIG1pbnV0 ZSBwYXNzZWQgc2luY2UgbGFzdCBgZ2V0dGltZScuICAqLwotCSAgaWYgKEVNQUNTX1RJTUVf TkVHX1AgKGNsZGlmZikpCisJICBpZiAoRU1BQ1NfVElNRV9TSUdOIChjbGRpZmYpIDwgMCkK IAkgICAgRU1BQ1NfU0VUX1NFQ1MgKGNsZGlmZiwgRU1BQ1NfU0VDUyAoY2xkaWZmKSArIDYw KTsKIAkgIEVNQUNTX1NVQl9USU1FICgqdGltZW91dCwgKnRpbWVvdXQsIGNsZGlmZik7CiAK IAkgIC8qIFN0b3Agd2hlbiB0aW1lb3V0IHZhbHVlIGNyb3NzZXMgemVyby4gICovCi0JICBp ZiAoRU1BQ1NfVElNRV9aRVJPX09SX05FR19QICgqdGltZW91dCkpCisJICBpZiAoRU1BQ1Nf VElNRV9TSUdOICgqdGltZW91dCkgPD0gMCkKIAkgICAgcmV0dXJuIDA7CiAJICBjbGxhc3Qg PSBjbG5vdzsKIAkgIGRvc195aWVsZF90aW1lX3NsaWNlICgpOwoKPT09IG1vZGlmaWVkIGZp bGUgJ3NyYy9uc3Rlcm0uaCcKLS0tIHNyYy9uc3Rlcm0uaAkyMDEyLTAxLTE5IDA3OjIxOjI1 ICswMDAwCisrKyBzcmMvbnN0ZXJtLmgJMjAxMi0wNS0wNCAwNjo0MjowMyArMDAwMApAQCAt ODI0LDcgKzgyNCw4IEBACiAKIC8qIFRoaXMgaW4gbnN0ZXJtLm0gKi8KIGV4dGVybiBpbnQg bnNfc2VsZWN0IChpbnQgbmZkcywgZmRfc2V0ICpyZWFkZmRzLCBmZF9zZXQgKndyaXRlZmRz LAotICAgICAgICAgICAgICAgICAgICAgIGZkX3NldCAqZXhjZXB0ZmRzLCBzdHJ1Y3QgdGlt ZXZhbCAqdGltZW91dCk7CisgICAgICAgICAgICAgICAgICAgICAgZmRfc2V0ICpleGNlcHRm ZHMsIEVNQUNTX1RJTUUgKnRpbWVvdXQsCisJCSAgICAgIHNpZ3NldF90ICpzaWdtYXNrKTsK IGV4dGVybiB1bnNpZ25lZCBsb25nIG5zX2dldF9yZ2JfY29sb3IgKHN0cnVjdCBmcmFtZSAq ZiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsb2F0IHIsIGZs b2F0IGcsIGZsb2F0IGIsIGZsb2F0IGEpOwogZXh0ZXJuIE5TUG9pbnQgbGFzdF9tb3VzZV9t b3Rpb25fcG9zaXRpb247Cgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL25zdGVybS5tJwotLS0g c3JjL25zdGVybS5tCTIwMTItMDQtMDkgMTA6MDE6MDQgKzAwMDAKKysrIHNyYy9uc3Rlcm0u bQkyMDEyLTA1LTA0IDA2OjQyOjAzICswMDAwCkBAIC0xODMsNyArMTgzLDYgQEAKIHN0YXRp YyBOU1RpbWVyICpmZF9lbnRyeSA9IG5pbDsKIHN0YXRpYyBOU1RpbWVyICpzY3JvbGxfcmVw ZWF0X2VudHJ5ID0gbmlsOwogc3RhdGljIGZkX3NldCBzZWxlY3RfcmVhZGZkcywgdF9yZWFk ZmRzOwotc3RhdGljIHN0cnVjdCB0aW1ldmFsIHNlbGVjdF90aW1lb3V0Owogc3RhdGljIGlu dCBzZWxlY3RfbmZkczsKIHN0YXRpYyBOU0F1dG9yZWxlYXNlUG9vbCAqb3V0ZXJwb29sOwog c3RhdGljIHN0cnVjdCBpbnB1dF9ldmVudCAqZW1hY3NfZXZlbnQgPSBOVUxMOwpAQCAtMzg0 LDY3ICszODMsMzAgQEAKICAgICB9CiB9CiAKLQotc3RhdGljIGludAotdGltZXZhbF9zdWJ0 cmFjdCAoc3RydWN0IHRpbWV2YWwgKnJlc3VsdCwgc3RydWN0IHRpbWV2YWwgeCwgc3RydWN0 IHRpbWV2YWwgeSkKLS8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0gICBTdWJ0cmFjdCB0aGUg YHN0cnVjdCB0aW1ldmFsJyB2YWx1ZXMgWCBhbmQgWSwgc3RvcmluZyB0aGUgcmVzdWx0IGlu IFJFU1VMVC4KLSAgIFJldHVybiAxIGlmIHRoZSBkaWZmZXJlbmNlIGlzIG5lZ2F0aXZlLCBv dGhlcndpc2UgMC4KLSAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCi17Ci0gIC8qIFBlcmZv cm0gdGhlIGNhcnJ5IGZvciB0aGUgbGF0ZXIgc3VidHJhY3Rpb24gYnkgdXBkYXRpbmcgeS4K LSAgICAgVGhpcyBpcyBzYWZlciBiZWNhdXNlIG9uIHNvbWUgc3lzdGVtcwotICAgICB0aGUg dHZfc2VjIG1lbWJlciBpcyB1bnNpZ25lZC4gICovCi0gIGlmICh4LnR2X3VzZWMgPCB5LnR2 X3VzZWMpCi0gICAgewotICAgICAgaW50IG5zZWMgPSAoeS50dl91c2VjIC0geC50dl91c2Vj KSAvIDEwMDAwMDAgKyAxOwotICAgICAgeS50dl91c2VjIC09IDEwMDAwMDAgKiBuc2VjOwot ICAgICAgeS50dl9zZWMgKz0gbnNlYzsKLSAgICB9Ci0gIGlmICh4LnR2X3VzZWMgLSB5LnR2 X3VzZWMgPiAxMDAwMDAwKQotICAgIHsKLSAgICAgIGludCBuc2VjID0gKHkudHZfdXNlYyAt IHgudHZfdXNlYykgLyAxMDAwMDAwOwotICAgICAgeS50dl91c2VjICs9IDEwMDAwMDAgKiBu c2VjOwotICAgICAgeS50dl9zZWMgLT0gbnNlYzsKLSAgICB9Ci0KLSAgLyogQ29tcHV0ZSB0 aGUgdGltZSByZW1haW5pbmcgdG8gd2FpdC4gIHR2X3VzZWMgaXMgY2VydGFpbmx5IHBvc2l0 aXZlLiAgKi8KLSAgcmVzdWx0LT50dl9zZWMgPSB4LnR2X3NlYyAtIHkudHZfc2VjOwotICBy ZXN1bHQtPnR2X3VzZWMgPSB4LnR2X3VzZWMgLSB5LnR2X3VzZWM7Ci0KLSAgLyogUmV0dXJu IGluZGljYXRpb24gb2Ygd2hldGhlciB0aGUgcmVzdWx0IHNob3VsZCBiZSBjb25zaWRlcmVk IG5lZ2F0aXZlLiAgKi8KLSAgcmV0dXJuIHgudHZfc2VjIDwgeS50dl9zZWM7Ci19Ci0KIHN0 YXRpYyB2b2lkCiBuc190aW1lb3V0IChpbnQgdXNlY3MpCiAvKiAtLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQogICAgICBCbG9ja2luZyB0aW1lciB1dGlsaXR5IHVzZWQgYnkgbnNfcmluZ19iZWxs CiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogewotICBzdHJ1Y3QgdGltZXZhbCB3YWtl dXA7CisgIEVNQUNTX1RJTUUgd2FrZXVwLCBkZWxheTsKIAogICBFTUFDU19HRVRfVElNRSAo d2FrZXVwKTsKLQotICAvKiBDb21wdXRlIHRpbWUgdG8gd2FpdCB1bnRpbCwgcHJvcGFnYXRp bmcgY2FycnkgZnJvbSB1c2Vjcy4gICovCi0gIHdha2V1cC50dl91c2VjICs9IHVzZWNzOwot ICB3YWtldXAudHZfc2VjICs9ICh3YWtldXAudHZfdXNlYyAvIDEwMDAwMDApOwotICB3YWtl dXAudHZfdXNlYyAlPSAxMDAwMDAwOworICBFTUFDU19TRVRfU0VDU19VU0VDUyAoZGVsYXks IDAsIHVzZWNzKTsKKyAgRU1BQ1NfQUREX1RJTUUgKHdha2V1cCwgd2FrZXVwLCBkZWxheSk7 CiAKICAgLyogS2VlcCB3YWl0aW5nIHVudGlsIHBhc3QgdGhlIHRpbWUgd2FrZXVwLiAgKi8K ICAgd2hpbGUgKDEpCiAgICAgewotICAgICAgc3RydWN0IHRpbWV2YWwgdGltZW91dDsKKyAg ICAgIEVNQUNTX1RJTUUgdGltZW91dDsKIAogICAgICAgRU1BQ1NfR0VUX1RJTUUgKHRpbWVv dXQpOwotCi0gICAgICAvKiBJbiBlZmZlY3QsIHRpbWVvdXQgPSB3YWtldXAgLSB0aW1lb3V0 LgotCSBCcmVhayBpZiByZXN1bHQgd291bGQgYmUgbmVnYXRpdmUuICAqLwotICAgICAgaWYg KHRpbWV2YWxfc3VidHJhY3QgKCZ0aW1lb3V0LCB3YWtldXAsIHRpbWVvdXQpKQorICAgICAg aWYgKEVNQUNTX1RJTUVfTEUgKHdha2V1cCwgdGltZW91dCkpCiAJYnJlYWs7CisgICAgICBF TUFDU19TVUJfVElNRSAodGltZW91dCwgd2FrZXVwLCB0aW1lb3V0KTsKIAogICAgICAgLyog VHJ5IHRvIHdhaXQgdGhhdCBsb25nLS1idXQgd2UgbWlnaHQgd2FrZSB1cCBzb29uZXIuICAq LwotICAgICAgc2VsZWN0ICgwLCBOVUxMLCBOVUxMLCBOVUxMLCAmdGltZW91dCk7CisgICAg ICBwc2VsZWN0ICgwLCBOVUxMLCBOVUxMLCBOVUxMLCAmdGltZW91dCwgTlVMTCk7CiAgICAg fQogfQogCkBAIC0zNDc0LDcgKzM0MzYsNyBAQAogCiBpbnQKIG5zX3NlbGVjdCAoaW50IG5m ZHMsIGZkX3NldCAqcmVhZGZkcywgZmRfc2V0ICp3cml0ZWZkcywKLSAgICAgICAgICAgZmRf c2V0ICpleGNlcHRmZHMsIHN0cnVjdCB0aW1ldmFsICp0aW1lb3V0KQorICAgICAgICAgICBm ZF9zZXQgKmV4Y2VwdGZkcywgRU1BQ1NfVElNRSAqdGltZW91dCwgc2lnc2V0X3QgKnNpZ21h c2spCiAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogICAgICBSZXBsYWNlbWVudCBmb3Igc2Vs ZWN0LCBjaGVja2luZyBmb3IgZXZlbnRzCiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwpA QCAtMzQ4MiwxMiArMzQ0NCwxNCBAQAogICBpbnQgcmVzdWx0OwogICBkb3VibGUgdGltZTsK ICAgTlNFdmVudCAqZXY7CisgIHN0cnVjdCB0aW1lc3BlYyBzZWxlY3RfdGltZW91dDsKKwog LyogIE5TVFJBQ0UgKG5zX3NlbGVjdCk7ICovCiAKICAgaWYgKE5TQXBwID09IG5pbCB8fCBp bk5zU2VsZWN0ID09IDEgLyogfHwgKFtOU0FwcCBpc0FjdGl2ZV0gPT0gTk8gJiYKICAgICAg ICAgICAgICAgICAgICAgICBbTlNBcHAgbmV4dEV2ZW50TWF0Y2hpbmdNYXNrOk5TQW55RXZl bnRNYXNrIHVudGlsRGF0ZTpuaWwKICBpbk1vZGU6TlNEZWZhdWx0UnVuTG9vcE1vZGUgZGVx dWV1ZTpOT10gPT0gbmlsKSAqLykKLSAgICByZXR1cm4gc2VsZWN0IChuZmRzLCByZWFkZmRz LCB3cml0ZWZkcywgZXhjZXB0ZmRzLCB0aW1lb3V0KTsKKyAgICByZXR1cm4gcHNlbGVjdCAo bmZkcywgcmVhZGZkcywgd3JpdGVmZHMsIGV4Y2VwdGZkcywgdGltZW91dCwgc2lnbWFzayk7 CiAKICAgLyogU2F2ZSBmaWxlIGRlc2NyaXB0b3Igc2V0LCB3aGljaCBnZXRzIG92ZXJ3cml0 dGVuIGluIGNhbGxzIHRvIHNlbGVjdCAoKQogICAgICBOb3RlLCB0aGlzIGlzIGNhbGxlZCBm cm9tIHByb2Nlc3MuYywgYW5kIG9ubHkgcmVhZGZkcyBpcyBldmVyIHNldCAqLwpAQCAtMzUw MCw4ICszNDY0LDkgQEAKICAgICBzZWxlY3RfbmZkcyA9IDA7CiAKICAgICAvKiBUcnkgYW4g aW5pdGlhbCBzZWxlY3QgZm9yIHBlbmRpbmcgZGF0YSBvbiBpbnB1dCBmaWxlcyAqLwotICBz ZWxlY3RfdGltZW91dC50dl9zZWMgPSBzZWxlY3RfdGltZW91dC50dl91c2VjID0gMDsKLSAg cmVzdWx0ID0gc2VsZWN0IChuZmRzLCByZWFkZmRzLCB3cml0ZWZkcywgZXhjZXB0ZmRzLCAm c2VsZWN0X3RpbWVvdXQpOworICBzZWxlY3RfdGltZW91dC50dl9zZWMgPSBzZWxlY3RfdGlt ZW91dC50dl9uc2VjID0gMDsKKyAgcmVzdWx0ID0gcHNlbGVjdCAobmZkcywgcmVhZGZkcywg d3JpdGVmZHMsIGV4Y2VwdGZkcywKKwkJICAgICZzZWxlY3RfdGltZW91dCwgc2lnbWFzayk7 CiAgIGlmIChyZXN1bHQpCiAgICAgcmV0dXJuIHJlc3VsdDsKIApAQCAtMzUxMCw3ICszNDc1 LDcgQEAKIAogICAgIC8qIHNldCBhIHRpbWVvdXQgYW5kIHJ1biB0aGUgbWFpbiBBcHBLaXQg ZXZlbnQgbG9vcCB3aGlsZSBjb250aW51aW5nCiAgICAgICAgdG8gbW9uaXRvciB0aGUgZmls ZXMgKi8KLSAgdGltZSA9ICgoZG91YmxlKSB0aW1lb3V0LT50dl9zZWMpICsgKChkb3VibGUp IHRpbWVvdXQtPnR2X3VzZWMpLzEwMDAwMDAuMDsKKyAgdGltZSA9IEVNQUNTX1RJTUVfVE9f RE9VQkxFICgqdGltZW91dCk7CiAgIHRpbWVkX2VudHJ5ID0gW1tOU1RpbWVyIHNjaGVkdWxl ZFRpbWVyV2l0aFRpbWVJbnRlcnZhbDogdGltZQogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHRhcmdldDogTlNBcHAKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgc2VsZWN0b3I6IEBzZWxlY3RvciAodGltZW91dF9oYW5k bGVyOikKQEAgLTM1MTgsNyArMzQ4Myw3IEBACiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICByZXBlYXRzOiBZRVNdIC8qIGZvciBzYWZlIHJlbW92YWwgKi8K ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHJldGFpbl07CiAKLSAgLyogc2V0IGEgcGVyaW9kaWMgdGFzayB0byB0cnkgdGhlIHNl bGVjdCAoKSBhZ2FpbiAqLworICAvKiBzZXQgYSBwZXJpb2RpYyB0YXNrIHRvIHRyeSB0aGUg cHNlbGVjdCAoKSBhZ2FpbiAqLwogICBmZF9lbnRyeSA9IFtbTlNUaW1lciBzY2hlZHVsZWRU aW1lcldpdGhUaW1lSW50ZXJ2YWw6IDAuMQogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB0YXJnZXQ6IE5TQXBwCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBzZWxlY3RvcjogQHNlbGVjdG9yIChmZF9oYW5k bGVyOikKQEAgLTM1NjAsNyArMzUyNSw3IEBACiAgICAgICAgIH0KICAgICAgIGVsc2UKICAg ICAgICAgewotICAgICAgICAgIC8qIFJlY2VpdmVkIGJhY2sgZnJvbSBzZWxlY3QgKCkgaW4g ZmRfaGFuZGxlcjsgY29weSB0aGUgcmVzdWx0cyAqLworICAgICAgICAgIC8qIFJlY2VpdmVk IGJhY2sgZnJvbSBwc2VsZWN0ICgpIGluIGZkX2hhbmRsZXI7IGNvcHkgdGhlIHJlc3VsdHMg Ki8KICAgICAgICAgICBpZiAocmVhZGZkcykKICAgICAgICAgICAgIG1lbWNweSAocmVhZGZk cywgJnNlbGVjdF9yZWFkZmRzLCBzaXplb2YgKGZkX3NldCkpOwogICAgICAgICAgIHJldHVy biB0OwpAQCAtNDU0MCw2ICs0NTA1LDcgQEAKICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICov CiB7CiAgIGludCByZXN1bHQ7CisgIHN0cnVjdCB0aW1lc3BlYyBzZWxlY3RfdGltZW91dDsK ICAgLyogTlNUUkFDRSAoZmRfaGFuZGxlcik7ICovCiAKICAgaWYgKHNlbGVjdF9uZmRzID09 IDApCkBAIC00NTQ3LDkgKzQ1MTMsOCBAQAogCiAgIG1lbWNweSAoJnRfcmVhZGZkcywgJnNl bGVjdF9yZWFkZmRzLCBzaXplb2YgKGZkX3NldCkpOwogCi0gIHNlbGVjdF90aW1lb3V0LnR2 X3NlYyA9IHNlbGVjdF90aW1lb3V0LnR2X3VzZWMgPSAwOwotICByZXN1bHQgPSBzZWxlY3Qg KHNlbGVjdF9uZmRzLCAmdF9yZWFkZmRzLCAoU0VMRUNUX1RZUEUgKikwLCAoU0VMRUNUX1RZ UEUgKikwLAotICAgICAgICAgICAgICAgICAgJnNlbGVjdF90aW1lb3V0KTsKKyAgc2VsZWN0 X3RpbWVvdXQudHZfc2VjID0gc2VsZWN0X3RpbWVvdXQudHZfbnNlYyA9IDA7CisgIHJlc3Vs dCA9IHBzZWxlY3QgKHNlbGVjdF9uZmRzLCAmdF9yZWFkZmRzLCBOVUxMLCBOVUxMLCAmc2Vs ZWN0X3RpbWVvdXQsIE5VTEwpOwogICBpZiAocmVzdWx0KQogICAgIHsKICAgICAgIG1lbWNw eSAoJnNlbGVjdF9yZWFkZmRzLCAmdF9yZWFkZmRzLCBzaXplb2YgKGZkX3NldCkpOwoKPT09 IG1vZGlmaWVkIGZpbGUgJ3NyYy9wcm9jZXNzLmMnCi0tLSBzcmMvcHJvY2Vzcy5jCTIwMTIt MDQtMjAgMDg6NDg6NTAgKzAwMDAKKysrIHNyYy9wcm9jZXNzLmMJMjAxMi0wNS0wNCAwNjo0 MjowMyArMDAwMApAQCAtMjI4LDEzICsyMjgsMTEgQEAKICNlbmRpZgogCiAjaWYgIWRlZmlu ZWQgKEFEQVBUSVZFX1JFQURfQlVGRkVSSU5HKSAmJiAhZGVmaW5lZCAoTk9fQURBUFRJVkVf UkVBRF9CVUZGRVJJTkcpCi0jaWZkZWYgRU1BQ1NfSEFTX1VTRUNTCiAjZGVmaW5lIEFEQVBU SVZFX1JFQURfQlVGRkVSSU5HCiAjZW5kaWYKLSNlbmRpZgogCiAjaWZkZWYgQURBUFRJVkVf UkVBRF9CVUZGRVJJTkcKLSNkZWZpbmUgUkVBRF9PVVRQVVRfREVMQVlfSU5DUkVNRU5UIDEw MDAwCisjZGVmaW5lIFJFQURfT1VUUFVUX0RFTEFZX0lOQ1JFTUVOVCAoRU1BQ1NfVElNRV9S RVNPTFVUSU9OIC8gMTAwKQogI2RlZmluZSBSRUFEX09VVFBVVF9ERUxBWV9NQVggICAgICAg KFJFQURfT1VUUFVUX0RFTEFZX0lOQ1JFTUVOVCAqIDUpCiAjZGVmaW5lIFJFQURfT1VUUFVU X0RFTEFZX01BWF9NQVggICAoUkVBRF9PVVRQVVRfREVMQVlfSU5DUkVNRU5UICogNykKIApA QCAtMzI5NCw3ICszMjkyLDcgQEAKIAl7CiAJICAvKiBVbmxpa2UgbW9zdCBvdGhlciBzeXNj YWxscyBjb25uZWN0KCkgY2Fubm90IGJlIGNhbGxlZAogCSAgICAgYWdhaW4uICAoVGhhdCB3 b3VsZCByZXR1cm4gRUFMUkVBRFkuKSAgVGhlIHByb3BlciB3YXkgdG8KLQkgICAgIHdhaXQg Zm9yIGNvbXBsZXRpb24gaXMgc2VsZWN0KCkuICovCisJICAgICB3YWl0IGZvciBjb21wbGV0 aW9uIGlzIHBzZWxlY3QoKS4gKi8KIAkgIGludCBzYzsKIAkgIHNvY2tsZW5fdCBsZW47CiAJ ICBTRUxFQ1RfVFlQRSBmZHNldDsKQEAgLTMzMDIsOCArMzMwMCw3IEBACiAJICBGRF9aRVJP ICgmZmRzZXQpOwogCSAgRkRfU0VUIChzLCAmZmRzZXQpOwogCSAgUVVJVDsKLQkgIHNjID0g c2VsZWN0IChzICsgMSwgKFNFTEVDVF9UWVBFICopMCwgJmZkc2V0LCAoU0VMRUNUX1RZUEUg KikwLAotCQkgICAgICAgKEVNQUNTX1RJTUUgKikwKTsKKwkgIHNjID0gcHNlbGVjdCAocyAr IDEsIE5VTEwsICZmZHNldCwgTlVMTCwgTlVMTCwgTlVMTCk7CiAJICBpZiAoc2MgPT0gLTEp CiAJICAgIHsKIAkgICAgICBpZiAoZXJybm8gPT0gRUlOVFIpCkBAIC0zOTY0LDcgKzM5NjEs OCBAQAogUmV0dXJuIG5vbi1uaWwgaWYgd2UgcmVjZWl2ZWQgYW55IG91dHB1dCBiZWZvcmUg dGhlIHRpbWVvdXQgZXhwaXJlZC4gICovKQogICAocmVnaXN0ZXIgTGlzcF9PYmplY3QgcHJv Y2VzcywgTGlzcF9PYmplY3Qgc2Vjb25kcywgTGlzcF9PYmplY3QgbWlsbGlzZWMsIExpc3Bf T2JqZWN0IGp1c3RfdGhpc19vbmUpCiB7Ci0gIGludCBzZWNzLCB1c2VjcyA9IDA7CisgIGlu dG1heF90IHNlY3M7CisgIGludCBuc2VjczsKIAogICBpZiAoISBOSUxQIChwcm9jZXNzKSkK ICAgICBDSEVDS19QUk9DRVNTIChwcm9jZXNzKTsKQEAgLTM5ODMsMjcgKzM5ODEsMzYgQEAK IAl9CiAgICAgfQogCisgIHNlY3MgPSAwOworICBuc2VjcyA9IC0xOworCiAgIGlmICghTklM UCAoc2Vjb25kcykpCiAgICAgewogICAgICAgaWYgKElOVEVHRVJQIChzZWNvbmRzKSkKLQlz ZWNzID0gWElOVCAoc2Vjb25kcyk7CisJeworCSAgaWYgKDAgPCBYSU5UIChzZWNvbmRzKSkK KwkgICAgeworCSAgICAgIHNlY3MgPSBYSU5UIChzZWNvbmRzKTsKKwkgICAgICBuc2VjcyA9 IDA7CisJICAgIH0KKwl9CiAgICAgICBlbHNlIGlmIChGTE9BVFAgKHNlY29uZHMpKQogCXsK LQkgIGRvdWJsZSB0aW1lb3V0ID0gWEZMT0FUX0RBVEEgKHNlY29uZHMpOwotCSAgc2VjcyA9 IChpbnQpIHRpbWVvdXQ7Ci0JICB1c2VjcyA9IChpbnQpICgodGltZW91dCAtIChkb3VibGUp IHNlY3MpICogMTAwMDAwMCk7CisJICBpZiAoMCA8IFhGTE9BVF9EQVRBIChzZWNvbmRzKSkK KwkgICAgeworCSAgICAgIEVNQUNTX1RJTUUgdCA9IEVNQUNTX1RJTUVfRlJPTV9ET1VCTEUg KFhGTE9BVF9EQVRBIChzZWNvbmRzKSk7CisJICAgICAgc2VjcyA9IG1pbiAoRU1BQ1NfU0VD UyAodCksIElOVE1BWF9NQVgpOworCSAgICAgIG5zZWNzID0gRU1BQ1NfTlNFQ1MgKHQpOwor CSAgICB9CiAJfQogICAgICAgZWxzZQogCXdyb25nX3R5cGVfYXJndW1lbnQgKFFudW1iZXJw LCBzZWNvbmRzKTsKLQotICAgICAgaWYgKHNlY3MgPCAwIHx8IChzZWNzID09IDAgJiYgdXNl Y3MgPT0gMCkpCi0Jc2VjcyA9IC0xLCB1c2VjcyA9IDA7CiAgICAgfQotICBlbHNlCi0gICAg c2VjcyA9IE5JTFAgKHByb2Nlc3MpID8gLTEgOiAwOworICBlbHNlIGlmICghIE5JTFAgKHBy b2Nlc3MpKQorICAgIG5zZWNzID0gMDsKIAogICByZXR1cm4KLSAgICAod2FpdF9yZWFkaW5n X3Byb2Nlc3Nfb3V0cHV0IChzZWNzLCB1c2VjcywgMCwgMCwKKyAgICAod2FpdF9yZWFkaW5n X3Byb2Nlc3Nfb3V0cHV0IChzZWNzLCBuc2VjcywgMCwgMCwKIAkJCQkgIFFuaWwsCiAJCQkJ ICAhTklMUCAocHJvY2VzcykgPyBYUFJPQ0VTUyAocHJvY2VzcykgOiBOVUxMLAogCQkJCSAg TklMUCAoanVzdF90aGlzX29uZSkgPyAwIDoKQEAgLTQyNDQsMzQgKzQyNTEsMTkgQEAKIHsK IH0KIAotLyogVXNlIGEgd3JhcHBlciBhcm91bmQgc2VsZWN0IHRvIHdvcmsgYXJvdW5kIGEg YnVnIGluIGdkYiA1LjMuCi0gICBOb3JtYWxseSwgdGhlIHdyYXBwZXIgaXMgb3B0aW1pemVk IGF3YXkgYnkgaW5saW5pbmcuCi0KLSAgIElmIGVtYWNzIGlzIHN0b3BwZWQgaW5zaWRlIHNl bGVjdCwgdGhlIGdkYiBiYWNrdHJhY2UgZG9lc24ndAotICAgc2hvdyB0aGUgZnVuY3Rpb24g d2hpY2ggY2FsbGVkIHNlbGVjdCwgc28gaXQgaXMgcHJhY3RpY2FsbHkKLSAgIGltcG9zc2li bGUgdG8gc3RlcCB0aHJvdWdoIHdhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1dC4gICovCi0K LSNpZm5kZWYgc2VsZWN0Ci1zdGF0aWMgaW5saW5lIGludAotc2VsZWN0X3dyYXBwZXIgKGlu dCBuLCBmZF9zZXQgKnJmZCwgZmRfc2V0ICp3ZmQsIGZkX3NldCAqeGZkLCBzdHJ1Y3QgdGlt ZXZhbCAqdG1vKQotewotICByZXR1cm4gc2VsZWN0IChuLCByZmQsIHdmZCwgeGZkLCB0bW8p OwotfQotI2RlZmluZSBzZWxlY3Qgc2VsZWN0X3dyYXBwZXIKLSNlbmRpZgotCiAvKiBSZWFk IGFuZCBkaXNwb3NlIG9mIHN1YnByb2Nlc3Mgb3V0cHV0IHdoaWxlIHdhaXRpbmcgZm9yIHRp bWVvdXQgdG8KICAgIGVsYXBzZSBhbmQvb3Iga2V5Ym9hcmQgaW5wdXQgdG8gYmUgYXZhaWxh YmxlLgogCiAgICBUSU1FX0xJTUlUIGlzOgotICAgICB0aW1lb3V0IGluIHNlY29uZHMsIG9y Ci0gICAgIHplcm8gZm9yIG5vIGxpbWl0LCBvcgotICAgICAtMSBtZWFucyBnb2JibGUgZGF0 YSBpbW1lZGlhdGVseSBhdmFpbGFibGUgYnV0IGRvbid0IHdhaXQgZm9yIGFueS4KKyAgICAg dGltZW91dCBpbiBzZWNvbmRzCisgICAgIElmIG5lZ2F0aXZlLCBnb2JibGUgZGF0YSBpbW1l ZGlhdGVseSBhdmFpbGFibGUgYnV0IGRvbid0IHdhaXQgZm9yIGFueS4KIAotICAgTUlDUk9T RUNTIGlzOgotICAgICBhbiBhZGRpdGlvbmFsIGR1cmF0aW9uIHRvIHdhaXQsIG1lYXN1cmVk IGluIG1pY3Jvc2Vjb25kcy4KLSAgICAgSWYgdGhpcyBpcyBub256ZXJvIGFuZCB0aW1lX2xp bWl0IGlzIDAsIHRoZW4gdGhlIHRpbWVvdXQKLSAgICAgY29uc2lzdHMgb2YgTUlDUk9TRUNT IG9ubHkuCisgICBOU0VDUyBpczoKKyAgICAgYW4gYWRkaXRpb25hbCBkdXJhdGlvbiB0byB3 YWl0LCBtZWFzdXJlZCBpbiBuYW5vc2Vjb25kcworICAgICBJZiBUSU1FX0xJTUlUIGlzIHpl cm8sIHRoZW46CisgICAgICAgSWYgTlNFQ1MgPT0gMCwgdGhlcmUgaXMgbm8gbGltaXQuCisg ICAgICAgSWYgTlNFQ1MgPiAwLCB0aGUgdGltZW91dCBjb25zaXN0cyBvZiBOU0VDIG9ubHku CisgICAgICAgSWYgTlNFQ1MgPCAwLCBnb2JibGUgZGF0YSBpbW1lZGlhdGVseSwgYXMgaWYg VElNRV9MSU1JVCB3ZXJlIG5lZ2F0aXZlLgogCiAgICBSRUFEX0tCRCBpcyBhIGxpc3AgdmFs dWU6CiAgICAgIDAgdG8gaWdub3JlIGtleWJvYXJkIGlucHV0LCBvcgpAQCAtNDI5OCw3ICs0 MjkwLDcgQEAKICAgIE90aGVyd2lzZSwgcmV0dXJuIHRydWUgaWYgd2UgcmVjZWl2ZWQgaW5w dXQgZnJvbSBhbnkgcHJvY2Vzcy4gICovCiAKIGludAotd2FpdF9yZWFkaW5nX3Byb2Nlc3Nf b3V0cHV0IChpbnQgdGltZV9saW1pdCwgaW50IG1pY3Jvc2VjcywgaW50IHJlYWRfa2JkLAor d2FpdF9yZWFkaW5nX3Byb2Nlc3Nfb3V0cHV0IChpbnRtYXhfdCB0aW1lX2xpbWl0LCBpbnQg bnNlY3MsIGludCByZWFkX2tiZCwKIAkJCSAgICAgaW50IGRvX2Rpc3BsYXksCiAJCQkgICAg IExpc3BfT2JqZWN0IHdhaXRfZm9yX2NlbGwsCiAJCQkgICAgIHN0cnVjdCBMaXNwX1Byb2Nl c3MgKndhaXRfcHJvYywgaW50IGp1c3Rfd2FpdF9wcm9jKQpAQCAtNDMxOCw3ICs0MzEwLDcg QEAKICAgRkRfWkVSTyAoJkF2YWlsYWJsZSk7CiAgIEZEX1pFUk8gKCZXcml0ZW9rKTsKIAot ICBpZiAodGltZV9saW1pdCA9PSAwICYmIG1pY3Jvc2VjcyA9PSAwICYmIHdhaXRfcHJvYyAm JiAhTklMUCAoVmluaGliaXRfcXVpdCkKKyAgaWYgKHRpbWVfbGltaXQgPT0gMCAmJiBuc2Vj cyA9PSAwICYmIHdhaXRfcHJvYyAmJiAhTklMUCAoVmluaGliaXRfcXVpdCkKICAgICAgICYm ICEoQ09OU1AgKHdhaXRfcHJvYy0+c3RhdHVzKSAmJiBFUSAoWENBUiAod2FpdF9wcm9jLT5z dGF0dXMpLCBRZXhpdCkpKQogICAgIG1lc3NhZ2UgKCJCbG9ja2luZyBjYWxsIHRvIGFjY2Vw dC1wcm9jZXNzLW91dHB1dCB3aXRoIHF1aXQgaW5oaWJpdGVkISEiKTsKIApAQCAtNDMzMCwx MiArNDMyMiwyMCBAQAogCQkJIG1ha2VfbnVtYmVyICh3YWl0aW5nX2Zvcl91c2VyX2lucHV0 X3ApKTsKICAgd2FpdGluZ19mb3JfdXNlcl9pbnB1dF9wID0gcmVhZF9rYmQ7CiAKKyAgaWYg KHRpbWVfbGltaXQgPCAwKQorICAgIHsKKyAgICAgIHRpbWVfbGltaXQgPSAwOworICAgICAg bnNlY3MgPSAtMTsKKyAgICB9CisgIGVsc2UgaWYgKFRZUEVfTUFYSU1VTSAodGltZV90KSA8 IHRpbWVfbGltaXQpCisgICAgdGltZV9saW1pdCA9IFRZUEVfTUFYSU1VTSAodGltZV90KTsK KwogICAvKiBTaW5jZSB3ZSBtYXkgbmVlZCB0byB3YWl0IHNldmVyYWwgdGltZXMsCiAgICAg IGNvbXB1dGUgdGhlIGFic29sdXRlIHRpbWUgdG8gcmV0dXJuIGF0LiAgKi8KLSAgaWYgKHRp bWVfbGltaXQgfHwgbWljcm9zZWNzKQorICBpZiAodGltZV9saW1pdCB8fCBuc2VjcykgLyog RklYTUUgbmVpdGhlciBzaG91bGQgYmUgbmVnYXRpdmUsIG5vPyAqLwogICAgIHsKICAgICAg IEVNQUNTX0dFVF9USU1FIChlbmRfdGltZSk7Ci0gICAgICBFTUFDU19TRVRfU0VDU19VU0VD UyAodGltZW91dCwgdGltZV9saW1pdCwgbWljcm9zZWNzKTsKKyAgICAgIEVNQUNTX1NFVF9T RUNTX05TRUNTICh0aW1lb3V0LCB0aW1lX2xpbWl0LCBuc2Vjcyk7CiAgICAgICBFTUFDU19B RERfVElNRSAoZW5kX3RpbWUsIGVuZF90aW1lLCB0aW1lb3V0KTsKICAgICB9CiAKQEAgLTQz NTksNyArNDM1OSw3IEBACiAKICAgICAgIC8qIENvbXB1dGUgdGltZSBmcm9tIG5vdyB0aWxs IHdoZW4gdGltZSBsaW1pdCBpcyB1cCAqLwogICAgICAgLyogRXhpdCBpZiBhbHJlYWR5IHJ1 biBvdXQgKi8KLSAgICAgIGlmICh0aW1lX2xpbWl0ID09IC0xKQorICAgICAgaWYgKG5zZWNz IDwgMCkKIAl7CiAJICAvKiAtMSBzcGVjaWZpZWQgZm9yIHRpbWVvdXQgbWVhbnMKIAkgICAg IGdvYmJsZSBvdXRwdXQgYXZhaWxhYmxlIG5vdwpAQCAtNDM2NywxMiArNDM2NywxMiBAQAog CiAJICBFTUFDU19TRVRfU0VDU19VU0VDUyAodGltZW91dCwgMCwgMCk7CiAJfQotICAgICAg ZWxzZSBpZiAodGltZV9saW1pdCB8fCBtaWNyb3NlY3MpCisgICAgICBlbHNlIGlmICh0aW1l X2xpbWl0IHx8IG5zZWNzKQogCXsKIAkgIEVNQUNTX0dFVF9USU1FICh0aW1lb3V0KTsKKwkg IGlmIChFTUFDU19USU1FX0xFIChlbmRfdGltZSwgdGltZW91dCkpCisJICAgIGJyZWFrOwog CSAgRU1BQ1NfU1VCX1RJTUUgKHRpbWVvdXQsIGVuZF90aW1lLCB0aW1lb3V0KTsKLQkgIGlm IChFTUFDU19USU1FX05FR19QICh0aW1lb3V0KSkKLQkgICAgYnJlYWs7CiAJfQogICAgICAg ZWxzZQogCXsKQEAgLTQ0MTgsMjEgKzQ0MTgsMjIgQEAKIAkgICAgICAmJiByZXF1ZXVlZF9l dmVudHNfcGVuZGluZ19wICgpKQogCSAgICBicmVhazsKIAotCSAgaWYgKCEgRU1BQ1NfVElN RV9ORUdfUCAodGltZXJfZGVsYXkpICYmIHRpbWVfbGltaXQgIT0gLTEpCi0JICAgIHsKLQkg ICAgICBFTUFDU19USU1FIGRpZmZlcmVuY2U7Ci0JICAgICAgRU1BQ1NfU1VCX1RJTUUgKGRp ZmZlcmVuY2UsIHRpbWVyX2RlbGF5LCB0aW1lb3V0KTsKLQkgICAgICBpZiAoRU1BQ1NfVElN RV9ORUdfUCAoZGlmZmVyZW5jZSkpCi0JCXsKLQkJICB0aW1lb3V0ID0gdGltZXJfZGVsYXk7 Ci0JCSAgdGltZW91dF9yZWR1Y2VkX2Zvcl90aW1lcnMgPSAxOwotCQl9Ci0JICAgIH0KLQkg IC8qIElmIHRpbWVfbGltaXQgaXMgLTEsIHdlIGFyZSBub3QgZ29pbmcgdG8gd2FpdCBhdCBh bGwuICAqLwotCSAgZWxzZSBpZiAodGltZV9saW1pdCAhPSAtMSkKLQkgICAgewotCSAgICAg IC8qIFRoaXMgaXMgc28gYSBicmVha3BvaW50IGNhbiBiZSBwdXQgaGVyZS4gICovCi0JICAg ICAgd2FpdF9yZWFkaW5nX3Byb2Nlc3Nfb3V0cHV0XzEgKCk7CisJICAvKiBJZiB0aW1lX2xp bWl0IGlzIG5lZ2F0aXZlLCB3ZSBhcmUgbm90IGdvaW5nIHRvIHdhaXQgYXQgYWxsLiAgKi8K KwkgIGlmICgwIDw9IG5zZWNzKQorCSAgICB7CisJICAgICAgaWYgKEVNQUNTX1RJTUVfVkFM SURfUCAodGltZXJfZGVsYXkpKQorCQl7CisJCSAgaWYgKEVNQUNTX1RJTUVfTFQgKHRpbWVy X2RlbGF5LCB0aW1lb3V0KSkKKwkJICAgIHsKKwkJICAgICAgdGltZW91dCA9IHRpbWVyX2Rl bGF5OworCQkgICAgICB0aW1lb3V0X3JlZHVjZWRfZm9yX3RpbWVycyA9IDE7CisJCSAgICB9 CisJCX0KKwkgICAgICBlbHNlCisJCXsKKwkJICAvKiBUaGlzIGlzIHNvIGEgYnJlYWtwb2lu dCBjYW4gYmUgcHV0IGhlcmUuICAqLworCQkgIHdhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1 dF8xICgpOworCQl9CiAJICAgIH0KIAl9CiAKQEAgLTQ0NjEsMTQgKzQ0NjIsMTQgQEAKIAkg IEN0ZW1wID0gd3JpdGVfbWFzazsKIAogCSAgRU1BQ1NfU0VUX1NFQ1NfVVNFQ1MgKHRpbWVv dXQsIDAsIDApOwotCSAgaWYgKChzZWxlY3QgKG1heCAobWF4X3Byb2Nlc3NfZGVzYywgbWF4 X2lucHV0X2Rlc2MpICsgMSwKLQkJICAgICAgICZBdGVtcCwKKwkgIGlmICgocHNlbGVjdCAo bWF4IChtYXhfcHJvY2Vzc19kZXNjLCBtYXhfaW5wdXRfZGVzYykgKyAxLAorCQkJJkF0ZW1w LAogI2lmZGVmIE5PTl9CTE9DS0lOR19DT05ORUNUCi0JCSAgICAgICAobnVtX3BlbmRpbmdf Y29ubmVjdHMgPiAwID8gJkN0ZW1wIDogKFNFTEVDVF9UWVBFICopMCksCisJCQkobnVtX3Bl bmRpbmdfY29ubmVjdHMgPiAwID8gJkN0ZW1wIDogTlVMTCksCiAjZWxzZQotCQkgICAgICAg KFNFTEVDVF9UWVBFICopMCwKKwkJCU5VTEwsCiAjZW5kaWYKLQkJICAgICAgIChTRUxFQ1Rf VFlQRSAqKTAsICZ0aW1lb3V0KQorCQkJTlVMTCwgJnRpbWVvdXQsIE5VTEwpCiAJICAgICAg IDw9IDApKQogCSAgICB7CiAJICAgICAgLyogSXQncyBva2F5IGZvciB1cyB0byBkbyB0aGlz IGFuZCB0aGVuIGNvbnRpbnVlIHdpdGgKQEAgLTQ1OTEsOSArNDU5Miw5IEBACiAJICAgICBW cHJvY2Vzc19hZGFwdGl2ZV9yZWFkX2J1ZmZlcmluZyBpcyBuaWwuICAqLwogCSAgaWYgKHBy b2Nlc3Nfb3V0cHV0X3NraXAgJiYgY2hlY2tfZGVsYXkgPiAwKQogCSAgICB7Ci0JICAgICAg aW50IHVzZWNzID0gRU1BQ1NfVVNFQ1MgKHRpbWVvdXQpOwotCSAgICAgIGlmIChFTUFDU19T RUNTICh0aW1lb3V0KSA+IDAgfHwgdXNlY3MgPiBSRUFEX09VVFBVVF9ERUxBWV9NQVgpCi0J CXVzZWNzID0gUkVBRF9PVVRQVVRfREVMQVlfTUFYOworCSAgICAgIGludCBuc2VjcyA9IEVN QUNTX05TRUNTICh0aW1lb3V0KTsKKwkgICAgICBpZiAoRU1BQ1NfU0VDUyAodGltZW91dCkg PiAwIHx8IG5zZWNzID4gUkVBRF9PVVRQVVRfREVMQVlfTUFYKQorCQluc2VjcyA9IFJFQURf T1VUUFVUX0RFTEFZX01BWDsKIAkgICAgICBmb3IgKGNoYW5uZWwgPSAwOyBjaGVja19kZWxh eSA+IDAgJiYgY2hhbm5lbCA8PSBtYXhfcHJvY2Vzc19kZXNjOyBjaGFubmVsKyspCiAJCXsK IAkJICBwcm9jID0gY2hhbl9wcm9jZXNzW2NoYW5uZWxdOwpAQCAtNDYwOCwxMSArNDYwOSwx MSBAQAogCQkJY29udGludWU7CiAJCSAgICAgIEZEX0NMUiAoY2hhbm5lbCwgJkF2YWlsYWJs ZSk7CiAJCSAgICAgIFhQUk9DRVNTIChwcm9jKS0+cmVhZF9vdXRwdXRfc2tpcCA9IDA7Ci0J CSAgICAgIGlmIChYUFJPQ0VTUyAocHJvYyktPnJlYWRfb3V0cHV0X2RlbGF5IDwgdXNlY3Mp Ci0JCQl1c2VjcyA9IFhQUk9DRVNTIChwcm9jKS0+cmVhZF9vdXRwdXRfZGVsYXk7CisJCSAg ICAgIGlmIChYUFJPQ0VTUyAocHJvYyktPnJlYWRfb3V0cHV0X2RlbGF5IDwgbnNlY3MpCisJ CQluc2VjcyA9IFhQUk9DRVNTIChwcm9jKS0+cmVhZF9vdXRwdXRfZGVsYXk7CiAJCSAgICB9 CiAJCX0KLQkgICAgICBFTUFDU19TRVRfU0VDU19VU0VDUyAodGltZW91dCwgMCwgdXNlY3Mp OworCSAgICAgIEVNQUNTX1NFVF9TRUNTX05TRUNTICh0aW1lb3V0LCAwLCBuc2Vjcyk7CiAJ ICAgICAgcHJvY2Vzc19vdXRwdXRfc2tpcCA9IDA7CiAJICAgIH0KICNlbmRpZgpAQCAtNDYy MSwxMiArNDYyMiwxMiBAQAogI2VsaWYgZGVmaW5lZCAoSEFWRV9OUykKIAkgIG5mZHMgPSBu c19zZWxlY3QKICNlbHNlCi0JICBuZmRzID0gc2VsZWN0CisJICBuZmRzID0gcHNlbGVjdAog I2VuZGlmCiAgICAgICAgICAgICAobWF4IChtYXhfcHJvY2Vzc19kZXNjLCBtYXhfaW5wdXRf ZGVzYykgKyAxLAogICAgICAgICAgICAgICZBdmFpbGFibGUsCiAgICAgICAgICAgICAgKGNo ZWNrX3dyaXRlID8gJldyaXRlb2sgOiAoU0VMRUNUX1RZUEUgKikwKSwKLSAgICAgICAgICAg ICAoU0VMRUNUX1RZUEUgKikwLCAmdGltZW91dCk7CisgICAgICAgICAgICAgTlVMTCwgJnRp bWVvdXQsIE5VTEwpOwogCiAjaWZkZWYgSEFWRV9HTlVUTFMKICAgICAgICAgICAvKiBHbnVU TFMgYnVmZmVycyBkYXRhIGludGVybmFsbHkuICBJbiBsb3dhdCBtb2RlIGl0IGxlYXZlcwpA QCAtNDY4NCw3ICs0Njg1LDcgQEAKICAgICAgIC8qICBJZiB3ZSB3b2tlIHVwIGR1ZSB0byBT SUdXSU5DSCwgYWN0dWFsbHkgY2hhbmdlIHNpemUgbm93LiAgKi8KICAgICAgIGRvX3BlbmRp bmdfd2luZG93X2NoYW5nZSAoMCk7CiAKLSAgICAgIGlmICh0aW1lX2xpbWl0ICYmIG5mZHMg PT0gMCAmJiAhIHRpbWVvdXRfcmVkdWNlZF9mb3JfdGltZXJzKQorICAgICAgaWYgKCh0aW1l X2xpbWl0IHx8IG5zZWNzKSAmJiBuZmRzID09IDAgJiYgISB0aW1lb3V0X3JlZHVjZWRfZm9y X3RpbWVycykKIAkvKiBXZSB3YW50ZWQgdGhlIGZ1bGwgc3BlY2lmaWVkIHRpbWUsIHNvIHJl dHVybiBub3cuICAqLwogCWJyZWFrOwogICAgICAgaWYgKG5mZHMgPCAwKQpAQCAtNDgzNiw3 ICs0ODM3LDcgQEAKIAkgICAgICBpZiAod2FpdF9jaGFubmVsID09IGNoYW5uZWwpCiAJCXsK IAkJICB3YWl0X2NoYW5uZWwgPSAtMTsKLQkJICB0aW1lX2xpbWl0ID0gLTE7CisJCSAgbnNl Y3MgPSAtMTsKIAkJICBnb3Rfc29tZV9pbnB1dCA9IDE7CiAJCX0KIAkgICAgICBwcm9jID0g Y2hhbl9wcm9jZXNzW2NoYW5uZWxdOwpAQCAtNTYxNywxMiArNTYxOCw4IEBACiAJCSAgICAg IGVsc2UgaWYgKFNUUklOR1AgKG9iamVjdCkpCiAJCQlvZmZzZXQgPSBidWYgLSBTU0RBVEEg KG9iamVjdCk7CiAKLSNpZmRlZiBFTUFDU19IQVNfVVNFQ1MKLQkJICAgICAgd2FpdF9yZWFk aW5nX3Byb2Nlc3Nfb3V0cHV0ICgwLCAyMDAwMCwgMCwgMCwgUW5pbCwgTlVMTCwgMCk7Ci0j ZWxzZQotCQkgICAgICB3YWl0X3JlYWRpbmdfcHJvY2Vzc19vdXRwdXQgKDEsIDAsIDAsIDAs IFFuaWwsIE5VTEwsIDApOwotI2VuZGlmCi0KKwkJICAgICAgd2FpdF9yZWFkaW5nX3Byb2Nl c3Nfb3V0cHV0ICgwLCAyMCAqIDEwMDAgKiAxMDAwLAorCQkJCQkJICAgMCwgMCwgUW5pbCwg TlVMTCwgMCk7CiAJCSAgICAgIGlmIChCVUZGRVJQIChvYmplY3QpKQogCQkJYnVmID0gKGNo YXIgKikgQlVGX0JZVEVfQUREUkVTUyAoWEJVRkZFUiAob2JqZWN0KSwKIAkJCQkJCQkgb2Zm c2V0KTsKQEAgLTY3NzYsOSArNjc3MywxNSBAQAogICAgV2FpdCBmb3IgdGltZW91dCB0byBl bGFwc2UgYW5kL29yIGtleWJvYXJkIGlucHV0IHRvIGJlIGF2YWlsYWJsZS4KIAogICAgdGlt ZV9saW1pdCBpczoKLSAgICAgdGltZW91dCBpbiBzZWNvbmRzLCBvcgotICAgICB6ZXJvIGZv ciBubyBsaW1pdCwgb3IKLSAgICAgLTEgbWVhbnMgZ29iYmxlIGRhdGEgaW1tZWRpYXRlbHkg YXZhaWxhYmxlIGJ1dCBkb24ndCB3YWl0IGZvciBhbnkuCisgICAgIHRpbWVvdXQgaW4gc2Vj b25kcworICAgICBJZiBuZWdhdGl2ZSwgZ29iYmxlIGRhdGEgaW1tZWRpYXRlbHkgYXZhaWxh YmxlIGJ1dCBkb24ndCB3YWl0IGZvciBhbnkuCisKKyAgIG5zZWMgaXM6CisgICAgIGFuIGFk ZGl0aW9uYWwgZHVyYXRpb24gdG8gd2FpdCwgbWVhc3VyZWQgaW4gbmFub3NlY29uZHMKKyAg ICAgSWYgVElNRV9MSU1JVCBpcyB6ZXJvLCB0aGVuOgorICAgICAgIElmIE5TRUMgPT0gMCwg dGhlcmUgaXMgbm8gbGltaXQuCisgICAgICAgSWYgTlNFQyA+IDAsIHRoZSB0aW1lb3V0IGNv bnNpc3RzIG9mIE5TRUMgb25seS4KKyAgICAgICBJZiBOU0VDUyA8IDAsIGdvYmJsZSBkYXRh IGltbWVkaWF0ZWx5LCBhcyBpZiBUSU1FX0xJTUlUIHdlcmUgbmVnYXRpdmUuCiAKICAgIHJl YWRfa2JkIGlzIGEgTGlzcF9PYmplY3Q6CiAgICAgIDAgdG8gaWdub3JlIGtleWJvYXJkIGlu cHV0LCBvcgpAQCAtNjc5NSw3ICs2Nzk4LDcgQEAKICAgIFJldHVybiB0cnVlIGlmIHdlIHJl Y2VpdmVkIGlucHV0IGZyb20gYW55IHByb2Nlc3MuICAqLwogCiBpbnQKLXdhaXRfcmVhZGlu Z19wcm9jZXNzX291dHB1dCAoaW50IHRpbWVfbGltaXQsIGludCBtaWNyb3NlY3MsIGludCBy ZWFkX2tiZCwKK3dhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1dCAoaW50bWF4X3QgdGltZV9s aW1pdCwgaW50IG5zZWNzLCBpbnQgcmVhZF9rYmQsCiAJCQkgICAgIGludCBkb19kaXNwbGF5 LAogCQkJICAgICBMaXNwX09iamVjdCB3YWl0X2Zvcl9jZWxsLAogCQkJICAgICBzdHJ1Y3Qg TGlzcF9Qcm9jZXNzICp3YWl0X3Byb2MsIGludCBqdXN0X3dhaXRfcHJvYykKQEAgLTY4MDUs MTEgKzY4MDgsMTkgQEAKICAgU0VMRUNUX1RZUEUgd2FpdGNoYW5uZWxzOwogICBpbnQgeGVy cm5vOwogCisgIGlmICh0aW1lX2xpbWl0IDwgMCkKKyAgICB7CisgICAgICB0aW1lX2xpbWl0 ID0gMDsKKyAgICAgIG5zZWNzID0gLTE7CisgICAgfQorICBlbHNlIGlmIChUWVBFX01BWElN VU0gKHRpbWVfdCkgPCB0aW1lX2xpbWl0KQorICAgIHRpbWVfbGltaXQgPSBUWVBFX01BWElN VU0gKHRpbWVfdCk7CisKICAgLyogV2hhdCBkb2VzIHRpbWVfbGltaXQgcmVhbGx5IG1lYW4/ ICAqLwotICBpZiAodGltZV9saW1pdCB8fCBtaWNyb3NlY3MpCisgIGlmICh0aW1lX2xpbWl0 IHx8IG5zZWNzKSAvKiBGSVhNRTogd2hhdCBpZiBuZWdhdGl2ZT8gKi8KICAgICB7CiAgICAg ICBFTUFDU19HRVRfVElNRSAoZW5kX3RpbWUpOwotICAgICAgRU1BQ1NfU0VUX1NFQ1NfVVNF Q1MgKHRpbWVvdXQsIHRpbWVfbGltaXQsIG1pY3Jvc2Vjcyk7CisgICAgICBFTUFDU19TRVRf U0VDU19OU0VDUyAodGltZW91dCwgdGltZV9saW1pdCwgbnNlY3MpOwogICAgICAgRU1BQ1Nf QUREX1RJTUUgKGVuZF90aW1lLCBlbmRfdGltZSwgdGltZW91dCk7CiAgICAgfQogCkBAIC02 ODM1LDcgKzY4NDYsNyBAQAogCiAgICAgICAvKiBDb21wdXRlIHRpbWUgZnJvbSBub3cgdGls bCB3aGVuIHRpbWUgbGltaXQgaXMgdXAgKi8KICAgICAgIC8qIEV4aXQgaWYgYWxyZWFkeSBy dW4gb3V0ICovCi0gICAgICBpZiAodGltZV9saW1pdCA9PSAtMSkKKyAgICAgIGlmIChuc2Vj cyA8IDApCiAJewogCSAgLyogLTEgc3BlY2lmaWVkIGZvciB0aW1lb3V0IG1lYW5zCiAJICAg ICBnb2JibGUgb3V0cHV0IGF2YWlsYWJsZSBub3cKQEAgLTY4NDMsMTIgKzY4NTQsMTIgQEAK IAogCSAgRU1BQ1NfU0VUX1NFQ1NfVVNFQ1MgKHRpbWVvdXQsIDAsIDApOwogCX0KLSAgICAg IGVsc2UgaWYgKHRpbWVfbGltaXQgfHwgbWljcm9zZWNzKQorICAgICAgZWxzZSBpZiAodGlt ZV9saW1pdCB8fCBuc2VjcykKIAl7CiAJICBFTUFDU19HRVRfVElNRSAodGltZW91dCk7CisJ ICBpZiAoRU1BQ1NfVElNRV9MRSAoZW5kX3RpbWUsIHRpbWVvdXQpKQorCSAgICBicmVhazsK IAkgIEVNQUNTX1NVQl9USU1FICh0aW1lb3V0LCBlbmRfdGltZSwgdGltZW91dCk7Ci0JICBp ZiAoRU1BQ1NfVElNRV9ORUdfUCAodGltZW91dCkpCi0JICAgIGJyZWFrOwogCX0KICAgICAg IGVsc2UKIAl7CkBAIC02ODgxLDExICs2ODkyLDkgQEAKIAkgICAgICAmJiByZXF1ZXVlZF9l dmVudHNfcGVuZGluZ19wICgpKQogCSAgICBicmVhazsKIAotCSAgaWYgKCEgRU1BQ1NfVElN RV9ORUdfUCAodGltZXJfZGVsYXkpICYmIHRpbWVfbGltaXQgIT0gLTEpCisJICBpZiAoRU1B Q1NfVElNRV9WQUxJRF9QICh0aW1lcl9kZWxheSkgJiYgMCA8PSBuc2VjcykKIAkgICAgewot CSAgICAgIEVNQUNTX1RJTUUgZGlmZmVyZW5jZTsKLQkgICAgICBFTUFDU19TVUJfVElNRSAo ZGlmZmVyZW5jZSwgdGltZXJfZGVsYXksIHRpbWVvdXQpOwotCSAgICAgIGlmIChFTUFDU19U SU1FX05FR19QIChkaWZmZXJlbmNlKSkKKwkgICAgICBpZiAoRU1BQ1NfVElNRV9MVCAodGlt ZXJfZGVsYXksIHRpbWVvdXQpKQogCQl7CiAJCSAgdGltZW91dCA9IHRpbWVyX2RlbGF5Owog CQkgIHRpbWVvdXRfcmVkdWNlZF9mb3JfdGltZXJzID0gMTsKQEAgLTY5MjEsOCArNjkzMCw3 IEBACiAJICBGRF9aRVJPICgmd2FpdGNoYW5uZWxzKTsKIAl9CiAgICAgICBlbHNlCi0JbmZk cyA9IHNlbGVjdCAoMSwgJndhaXRjaGFubmVscywgKFNFTEVDVF9UWVBFICopMCwgKFNFTEVD VF9UWVBFICopMCwKLQkJICAgICAgICZ0aW1lb3V0KTsKKwluZmRzID0gcHNlbGVjdCAoMSwg JndhaXRjaGFubmVscywgTlVMTCwgTlVMTCwgJnRpbWVvdXQsIE5VTEwpOwogCiAgICAgICB4 ZXJybm8gPSBlcnJubzsKIApAQCAtNjkzMiw3ICs2OTQwLDcgQEAKICAgICAgIC8qICBJZiB3 ZSB3b2tlIHVwIGR1ZSB0byBTSUdXSU5DSCwgYWN0dWFsbHkgY2hhbmdlIHNpemUgbm93LiAg Ki8KICAgICAgIGRvX3BlbmRpbmdfd2luZG93X2NoYW5nZSAoMCk7CiAKLSAgICAgIGlmICh0 aW1lX2xpbWl0ICYmIG5mZHMgPT0gMCAmJiAhIHRpbWVvdXRfcmVkdWNlZF9mb3JfdGltZXJz KQorICAgICAgaWYgKCh0aW1lX2xpbWl0IHx8IG5zZWNzKSAmJiBuZmRzID09IDAgJiYgISB0 aW1lb3V0X3JlZHVjZWRfZm9yX3RpbWVycykKIAkvKiBXZSB3YWl0ZWQgdGhlIGZ1bGwgc3Bl Y2lmaWVkIHRpbWUsIHNvIHJldHVybiBub3cuICAqLwogCWJyZWFrOwogCkBAIC03MjM1LDE5 ICs3MjQzLDIwIEBACiAgbWFqZmx0ICAtLSBudW1iZXIgb2YgbWFqb3IgcGFnZSBmYXVsdHMg KG51bWJlcikKICBjbWluZmx0IC0tIGN1bXVsYXRpdmUgbnVtYmVyIG9mIG1pbm9yIHBhZ2Ug ZmF1bHRzIChudW1iZXIpCiAgY21hamZsdCAtLSBjdW11bGF0aXZlIG51bWJlciBvZiBtYWpv ciBwYWdlIGZhdWx0cyAobnVtYmVyKQotIHV0aW1lICAgLS0gdXNlciB0aW1lIHVzZWQgYnkg dGhlIHByb2Nlc3MsIGluIHRoZSAoSElHSCBMT1cgVVNFQykgZm9ybWF0Ci0gc3RpbWUgICAt LSBzeXN0ZW0gdGltZSB1c2VkIGJ5IHRoZSBwcm9jZXNzLCBpbiB0aGUgKEhJR0ggTE9XIFVT RUMpIGZvcm1hdAotIHRpbWUgICAgLS0gc3VtIG9mIHV0aW1lIGFuZCBzdGltZSwgaW4gdGhl IChISUdIIExPVyBVU0VDKSBmb3JtYXQKLSBjdXRpbWUgIC0tIHVzZXIgdGltZSB1c2VkIGJ5 IHRoZSBwcm9jZXNzIGFuZCBpdHMgY2hpbGRyZW4sIChISUdIIExPVyBVU0VDKQotIGNzdGlt ZSAgLS0gc3lzdGVtIHRpbWUgdXNlZCBieSB0aGUgcHJvY2VzcyBhbmQgaXRzIGNoaWxkcmVu LCAoSElHSCBMT1cgVVNFQykKLSBjdGltZSAgIC0tIHN1bSBvZiBjdXRpbWUgYW5kIGNzdGlt ZSwgaW4gdGhlIChISUdIIExPVyBVU0VDKSBmb3JtYXQKKyB1dGltZSAgIC0tIHVzZXIgdGlt ZSB1c2VkIGJ5IHRoZSBwcm9jZXNzLCBpbiAoY3VycmVudC10aW1lKSBmb3JtYXQsCisgICAg ICAgICAgICAgIHdoaWNoIGlzIGEgbGlzdCBvZiBpbnRlZ2VycyAoSElHSCBMT1cgVVNFQyBQ U0VDKQorIHN0aW1lICAgLS0gc3lzdGVtIHRpbWUgdXNlZCBieSB0aGUgcHJvY2VzcyAoY3Vy cmVudC10aW1lKQorIHRpbWUgICAgLS0gc3VtIG9mIHV0aW1lIGFuZCBzdGltZSAoY3VycmVu dC10aW1lKQorIGN1dGltZSAgLS0gdXNlciB0aW1lIHVzZWQgYnkgdGhlIHByb2Nlc3MgYW5k IGl0cyBjaGlsZHJlbiAoY3VycmVudC10aW1lKQorIGNzdGltZSAgLS0gc3lzdGVtIHRpbWUg dXNlZCBieSB0aGUgcHJvY2VzcyBhbmQgaXRzIGNoaWxkcmVuIChjdXJyZW50LXRpbWUpCisg Y3RpbWUgICAtLSBzdW0gb2YgY3V0aW1lIGFuZCBjc3RpbWUgKGN1cnJlbnQtdGltZSkKICBw cmkgICAgIC0tIHByaW9yaXR5IG9mIHRoZSBwcm9jZXNzIChudW1iZXIpCiAgbmljZSAgICAt LSBuaWNlIHZhbHVlIG9mIHRoZSBwcm9jZXNzIChudW1iZXIpCiAgdGhjb3VudCAtLSBwcm9j ZXNzIHRocmVhZCBjb3VudCAobnVtYmVyKQotIHN0YXJ0ICAgLS0gdGltZSB0aGUgcHJvY2Vz cyBzdGFydGVkLCBpbiB0aGUgKEhJR0ggTE9XIFVTRUMpIGZvcm1hdAorIHN0YXJ0ICAgLS0g dGltZSB0aGUgcHJvY2VzcyBzdGFydGVkIChjdXJyZW50LXRpbWUpCiAgdnNpemUgICAtLSB2 aXJ0dWFsIG1lbW9yeSBzaXplIG9mIHRoZSBwcm9jZXNzIGluIEtCJ3MgKG51bWJlcikKICBy c3MgICAgIC0tIHJlc2lkZW50IHNldCBzaXplIG9mIHRoZSBwcm9jZXNzIGluIEtCJ3MgKG51 bWJlcikKLSBldGltZSAgIC0tIGVsYXBzZWQgdGltZSB0aGUgcHJvY2VzcyBpcyBydW5uaW5n LCBpbiAoSElHSCBMT1cgVVNFQykgZm9ybWF0CisgZXRpbWUgICAtLSBlbGFwc2VkIHRpbWUg dGhlIHByb2Nlc3MgaXMgcnVubmluZywgaW4gKEhJR0ggTE9XIFVTRUMgUFNFQykgZm9ybWF0 CiAgcGNwdSAgICAtLSBwZXJjZW50cyBvZiBDUFUgdGltZSB1c2VkIGJ5IHRoZSBwcm9jZXNz IChmbG9hdGluZy1wb2ludCBudW1iZXIpCiAgcG1lbSAgICAtLSBwZXJjZW50cyBvZiB0b3Rh bCBwaHlzaWNhbCBtZW1vcnkgdXNlZCBieSBwcm9jZXNzJ3MgcmVzaWRlbnQgc2V0CiAgICAg ICAgICAgICAgIChmbG9hdGluZy1wb2ludCBudW1iZXIpCgo9PT0gbW9kaWZpZWQgZmlsZSAn c3JjL3Byb2Nlc3MuaCcKLS0tIHNyYy9wcm9jZXNzLmgJMjAxMi0wNC0xNCAwMTo0NjowNiAr MDAwMAorKysgc3JjL3Byb2Nlc3MuaAkyMDEyLTA1LTA0IDA2OjQyOjAzICswMDAwCkBAIC0x MDQsOCArMTA0LDggQEAKICAgICAgICBPbiBzb21lIHN5c3RlbXMsIGUuZy4gR05VL0xpbnV4 LCBFbWFjcyBpcyBzZWVuIGFzCiAgICAgICAgYW4gaW50ZXJhY3RpdmUgYXBwIGFsc28gd2hl biByZWFkaW5nIHByb2Nlc3Mgb3V0cHV0LCBtZWFuaW5nCiAgICAgICAgdGhhdCBwcm9jZXNz IG91dHB1dCBjYW4gYmUgcmVhZCBpbiBhcyBsaXR0bGUgYXMgMSBieXRlIGF0IGEKLSAgICAg ICB0aW1lLiAgVmFsdWUgaXMgbWljcm8tc2Vjb25kcyB0byBkZWxheSByZWFkaW5nIG91dHB1 dCBmcm9tCi0gICAgICAgdGhpcyBwcm9jZXNzLiAgUmFuZ2UgaXMgMCAuLiA1MDAwMC4gICov CisgICAgICAgdGltZS4gIFZhbHVlIGlzIG5hbm9zZWNvbmRzIHRvIGRlbGF5IHJlYWRpbmcg b3V0cHV0IGZyb20KKyAgICAgICB0aGlzIHByb2Nlc3MuICBSYW5nZSBpcyAwIC4uIDUwICog MTAwMCAqIDEwMDAuICAqLwogICAgIGludCByZWFkX291dHB1dF9kZWxheTsKICAgICAvKiBT aG91bGQgd2UgZGVsYXkgcmVhZGluZyBvdXRwdXQgZnJvbSB0aGlzIHByb2Nlc3MuCiAgICAg ICAgSW5pdGlhbGl6ZWQgZnJvbSBgVnByb2Nlc3NfYWRhcHRpdmVfcmVhZF9idWZmZXJpbmcn LgoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9zeXNkZXAuYycKLS0tIHNyYy9zeXNkZXAuYwky MDEyLTA0LTIyIDAyOjU4OjIzICswMDAwCisrKyBzcmMvc3lzZGVwLmMJMjAxMi0wNS0wNCAw Nzo0OTo0OSArMDAwMApAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgPGFsbG9jYXRvci5o PgogI2luY2x1ZGUgPGNhcmVhZGxpbmthdC5oPgogI2luY2x1ZGUgPGlnbm9yZS12YWx1ZS5o PgorI2luY2x1ZGUgPHV0aW1lbnMuaD4KIAogI2luY2x1ZGUgImxpc3AuaCIKICNpbmNsdWRl ICJzeXNzZWxlY3QuaCIKQEAgLTExMiwyMCArMTEzLDYgQEAKIAogI2luY2x1ZGUgInN5c3Np Z25hbC5oIgogI2luY2x1ZGUgInN5c3RpbWUuaCIKLSNpZmRlZiBIQVZFX1VUSU1FX0gKLSNp bmNsdWRlIDx1dGltZS5oPgotI2VuZGlmCi0KLSNpZm5kZWYgSEFWRV9VVElNRVMKLSNpZm5k ZWYgSEFWRV9TVFJVQ1RfVVRJTUJVRgotLyogV2Ugd2FudCB0byB1c2UgdXRpbWUgcmF0aGVy IHRoYW4gdXRpbWVzLCBidXQgd2UgY291bGRuJ3QgZmluZCB0aGUKLSAgIHN0cnVjdHVyZSBk ZWNsYXJhdGlvbi4gIFdlJ2xsIHVzZSB0aGUgdHJhZGl0aW9uYWwgb25lLiAgKi8KLXN0cnVj dCB1dGltYnVmIHsKLSAgbG9uZyBhY3RpbWU7Ci0gIGxvbmcgbW9kdGltZTsKLX07Ci0jZW5k aWYKLSNlbmRpZgogCiBzdGF0aWMgaW50IGVtYWNzX2dldF90dHkgKGludCwgc3RydWN0IGVt YWNzX3R0eSAqKTsKIHN0YXRpYyBpbnQgZW1hY3Nfc2V0X3R0eSAoaW50LCBzdHJ1Y3QgZW1h Y3NfdHR5ICosIGludCk7CkBAIC0yMDcwLDMwICsyMDU3LDYgQEAKICNlbmRpZiAvKiBIUFVY IGFuZCBub3QgSEFWRV9QRVJST1IgKi8KIAogLyoKLSAqCUdldHRpbWVvZmRheS4gIFNpbXVs YXRlIGFzIG11Y2ggYXMgcG9zc2libGUuICBPbmx5IGFjY3VyYXRlCi0gKgl0byBuZWFyZXN0 IHNlY29uZC4gIEVtYWNzIGRvZXNuJ3QgdXNlIHR6cCBzbyBpZ25vcmUgaXQgZm9yIG5vdy4K LSAqCU9ubHkgbmVlZGVkIHdoZW4gc3VicHJvY2Vzc2VzIGFyZSBkZWZpbmVkLgotICovCi0K LSNpZm5kZWYgSEFWRV9HRVRUSU1FT0ZEQVkKLSNpZmRlZiBIQVZFX1RJTUVWQUwKLQotaW50 Ci1nZXR0aW1lb2ZkYXkgKHN0cnVjdCB0aW1ldmFsICp0cCwgc3RydWN0IHRpbWV6b25lICp0 enApCi17Ci0gIGV4dGVybiBsb25nIHRpbWUgKGxvbmcpOwotCi0gIHRwLT50dl9zZWMgPSB0 aW1lICgobG9uZyAqKTApOwotICB0cC0+dHZfdXNlYyA9IDA7Ci0gIGlmICh0enAgIT0gMCkK LSAgICB0enAtPnR6X21pbnV0ZXN3ZXN0ID0gLTE7Ci0gIHJldHVybiAwOwotfQotCi0jZW5k aWYKLSNlbmRpZiAvKiAhSEFWRV9HRVRUSU1FT0ZEQVkgJiYgSEFWRV9USU1FVkFMICovCi0K LS8qCiAgKglUaGlzIGZ1bmN0aW9uIHdpbGwgZ28gYXdheSBhcyBzb29uIGFzIGFsbCB0aGUg c3R1YnMgZml4ZWQuIChmbmYpCiAgKi8KIApAQCAtMjEyOSwyMCArMjA5Miw0MyBAQAogI2Vu ZGlmIC8qIEhBVkVfRElSRU5UX0ggKi8KIAogDAorLyogUmV0dXJuIGEgc3RydWN0IHRpbWV2 YWwgdGhhdCBpcyByb3VnaGx5IGVxdWl2YWxlbnQgdG8gVC4KKyAgIFVzZSB0aGUgbGVhc3Qg dGltZXZhbCBub3QgbGVzcyB0aGFuIFQuCisgICBSZXR1cm4gYW4gZXh0cmVtYWwgdmFsdWUg aWYgdGhlIHJlc3VsdCB3b3VsZCBvdmVyZmxvdy4gICovCitzdHJ1Y3QgdGltZXZhbAorbWFr ZV90aW1ldmFsIChFTUFDU19USU1FIHQpCit7CisgIHN0cnVjdCB0aW1ldmFsIHR2OworICB0 di50dl9zZWMgPSB0LnR2X3NlYzsKKyAgdHYudHZfdXNlYyA9IHQudHZfbnNlYyAvIDEwMDA7 CisKKyAgaWYgKHQudHZfbnNlYyAlIDEwMDAgIT0gMCkKKyAgICB7CisgICAgICBpZiAodHYu dHZfdXNlYyA8IDk5OTk5OSkKKwl0di50dl91c2VjKys7CisgICAgICBlbHNlIGlmICh0di50 dl9zZWMgPCBUWVBFX01BWElNVU0gKHRpbWVfdCkpCisJeworCSAgdHYudHZfc2VjKys7CisJ ICB0di50dl91c2VjID0gMDsKKwl9CisgICAgfQorCisgIHJldHVybiB0djsKK30KKworLyog U2V0IHRoZSBhY2Nlc3MgYW5kIG1vZGlmaWNhdGlvbiB0aW1lIHN0YW1wcyBvZiBGRCAoYS5r LmEuIEZJTEUpIHRvIGJlCisgICBBVElNRSBhbmQgTVRJTUUsIHJlc3BlY3RpdmVseS4KKyAg IEZEIG11c3QgYmUgZWl0aGVyIG5lZ2F0aXZlIC0tIGluIHdoaWNoIGNhc2UgaXQgaXMgaWdu b3JlZCAtLQorICAgb3IgYSBmaWxlIGRlc2NyaXB0b3IgdGhhdCBpcyBvcGVuIG9uIEZJTEUu CisgICBJZiBGRCBpcyBub25uZWdhdGl2ZSwgdGhlbiBGSUxFIGNhbiBiZSBOVUxMLiAgKi8K IGludAotc2V0X2ZpbGVfdGltZXMgKGNvbnN0IGNoYXIgKmZpbGVuYW1lLCBFTUFDU19USU1F IGF0aW1lLCBFTUFDU19USU1FIG10aW1lKQorc2V0X2ZpbGVfdGltZXMgKGludCBmZCwgY29u c3QgY2hhciAqZmlsZW5hbWUsCisJCUVNQUNTX1RJTUUgYXRpbWUsIEVNQUNTX1RJTUUgbXRp bWUpCiB7Ci0jaWZkZWYgSEFWRV9VVElNRVMKLSAgc3RydWN0IHRpbWV2YWwgdHZbMl07Ci0g IHR2WzBdID0gYXRpbWU7Ci0gIHR2WzFdID0gbXRpbWU7Ci0gIHJldHVybiB1dGltZXMgKGZp bGVuYW1lLCB0dik7Ci0jZWxzZSAvKiBub3QgSEFWRV9VVElNRVMgKi8KLSAgc3RydWN0IHV0 aW1idWYgdXRiOwotICB1dGIuYWN0aW1lID0gRU1BQ1NfU0VDUyAoYXRpbWUpOwotICB1dGIu bW9kdGltZSA9IEVNQUNTX1NFQ1MgKG10aW1lKTsKLSAgcmV0dXJuIHV0aW1lIChmaWxlbmFt ZSwgJnV0Yik7Ci0jZW5kaWYgLyogbm90IEhBVkVfVVRJTUVTICovCisgIHN0cnVjdCB0aW1l c3BlYyB0aW1lc3BlY1syXTsKKyAgdGltZXNwZWNbMF0gPSBhdGltZTsKKyAgdGltZXNwZWNb MV0gPSBtdGltZTsKKyAgcmV0dXJuIGZkdXRpbWVucyAoZmQsIGZpbGVuYW1lLCB0aW1lc3Bl Yyk7CiB9CiAMCiAvKiBta2RpciBhbmQgcm1kaXIgZnVuY3Rpb25zLCBmb3Igc3lzdGVtcyB3 aGljaCBkb24ndCBoYXZlIHRoZW0uICAqLwpAQCAtMjU5Nyw2MCArMjU4Myw4MiBAQAogI2Vu ZGlmIC8qICFkZWZpbmVkIChXSU5ET1dTTlQpICovCiAKICNpZmRlZiBHTlVfTElOVVgKLXN0 YXRpYyB2b2lkCi10aW1lX2Zyb21famlmZmllcyAodW5zaWduZWQgbG9uZyBsb25nIHR2YWws IGxvbmcgaHosCi0JCSAgIHRpbWVfdCAqc2VjLCB1bnNpZ25lZCAqdXNlYykKK3N0YXRpYyBF TUFDU19USU1FCit0aW1lX2Zyb21famlmZmllcyAodW5zaWduZWQgbG9uZyBsb25nIHR2YWws IGxvbmcgaHopCiB7Ci0gIHVuc2lnbmVkIGxvbmcgbG9uZyB1bGxzZWM7CisgIHVuc2lnbmVk IGxvbmcgbG9uZyBzID0gdHZhbCAvIGh6OworICB1bnNpZ25lZCBsb25nIGxvbmcgZnJhYyA9 IHR2YWwgJSBoejsKKyAgaW50IG5zOworICBFTUFDU19USU1FIHQ7CiAKLSAgKnNlYyA9IHR2 YWwgLyBoejsKLSAgdWxsc2VjID0gKnNlYzsKLSAgdHZhbCAtPSB1bGxzZWMgKiBoejsKLSAg LyogQ2FyZWZ1bDogaWYgSFogPiAxIG1pbGxpb24sIHRoZW4gaW50ZWdlciBkaXZpc2lvbiBi eSBpdCB5aWVsZHMgemVyby4gICovCi0gIGlmIChoeiA8PSAxMDAwMDAwKQotICAgICp1c2Vj ID0gdHZhbCAqIDEwMDAwMDAgLyBoejsKKyAgaWYgKFRZUEVfTUFYSU1VTSAodGltZV90KSA8 IHMpCisgICAgdGltZV9vdmVyZmxvdyAoKTsKKyAgaWYgKExPTkdfTUFYIC0gMSA8PSBVTExP TkdfTUFYIC8gRU1BQ1NfVElNRV9SRVNPTFVUSU9OCisgICAgICB8fCBmcmFjIDw9IFVMTE9O R19NQVggLyBFTUFDU19USU1FX1JFU09MVVRJT04pCisgICAgbnMgPSBmcmFjICogRU1BQ1Nf VElNRV9SRVNPTFVUSU9OIC8gaHo7CiAgIGVsc2UKLSAgICAqdXNlYyA9IHR2YWwgLyAoaHog LyAxMDAwMDAwKTsKKyAgICB7CisgICAgICAvKiBUaGlzIGlzIHJlYWNoYWJsZSBvbmx5IGlu IHRoZSB1bmxpa2VseSBjYXNlIHRoYXQgSFogKiBIWgorCSBleGNlZWRzIFVMTE9OR19NQVgu ICBJdCBjYWxjdWxhdGVzIGFuIGFwcHJveGltYXRpb24gdGhhdCBpcworCSBndWFyYW50ZWVk IHRvIGJlIGluIHJhbmdlLiAgKi8KKyAgICAgIGxvbmcgaHpfcGVyX25zID0gKGh6IC8gRU1B Q1NfVElNRV9SRVNPTFVUSU9OCisJCQkrIChoeiAlIEVNQUNTX1RJTUVfUkVTT0xVVElPTiAh PSAwKSk7CisgICAgICBucyA9IGZyYWMgLyBoel9wZXJfbnM7CisgICAgfQorCisgIEVNQUNT X1NFVF9TRUNTX05TRUNTICh0LCBzLCBucyk7CisgIHJldHVybiB0OwogfQogCiBzdGF0aWMg TGlzcF9PYmplY3QKIGx0aW1lX2Zyb21famlmZmllcyAodW5zaWduZWQgbG9uZyBsb25nIHR2 YWwsIGxvbmcgaHopCiB7Ci0gIHRpbWVfdCBzZWM7Ci0gIHVuc2lnbmVkIHVzZWM7Ci0KLSAg dGltZV9mcm9tX2ppZmZpZXMgKHR2YWwsIGh6LCAmc2VjLCAmdXNlYyk7Ci0KLSAgcmV0dXJu IGxpc3QzIChtYWtlX251bWJlciAoKHNlYyA+PiAxNikgJiAweGZmZmYpLAotCQltYWtlX251 bWJlciAoc2VjICYgMHhmZmZmKSwKLQkJbWFrZV9udW1iZXIgKHVzZWMpKTsKKyAgRU1BQ1Nf VElNRSB0ID0gdGltZV9mcm9tX2ppZmZpZXMgKHR2YWwsIGh6KTsKKyAgcmV0dXJuIG1ha2Vf bGlzcF90aW1lICh0KTsKIH0KIAotc3RhdGljIHZvaWQKLWdldF91cF90aW1lICh0aW1lX3Qg KnNlYywgdW5zaWduZWQgKnVzZWMpCitzdGF0aWMgRU1BQ1NfVElNRQorZ2V0X3VwX3RpbWUg KHZvaWQpCiB7CiAgIEZJTEUgKmZ1cDsKKyAgRU1BQ1NfVElNRSB1cDsKIAotICAqc2VjID0g KnVzZWMgPSAwOworICBFTUFDU19TRVRfU0VDU19OU0VDUyAodXAsIDAsIDApOwogCiAgIEJM T0NLX0lOUFVUOwogICBmdXAgPSBmb3BlbiAoIi9wcm9jL3VwdGltZSIsICJyIik7CiAKICAg aWYgKGZ1cCkKICAgICB7Ci0gICAgICBkb3VibGUgdXB0aW1lLCBpZGxldGltZTsKKyAgICAg IHVuc2lnbmVkIGxvbmcgbG9uZyB1cHNlYywgdXBmcmFjLCBpZGxlc2VjLCBpZGxlZnJhYzsK KyAgICAgIGludCB1cGZyYWNfc3RhcnQsIHVwZnJhY19lbmQsIGlkbGVmcmFjX3N0YXJ0LCBp ZGxlZnJhY19lbmQ7CiAKLSAgICAgIC8qIFRoZSBudW1iZXJzIGluIC9wcm9jL3VwdGltZSB1 c2UgQy1sb2NhbGUgZGVjaW1hbCBwb2ludCwgYnV0Ci0JIHdlIGFscmVhZHkgc2V0IG91cnNl bHZlcyB0byB0aGUgQyBsb2NhbGUgKHNlZSBgZml4dXBfbG9jYWxlJwotCSBpbiBlbWFjcy5j KS4gICovCi0gICAgICBpZiAoMiA8PSBmc2NhbmYgKGZ1cCwgIiVsZiAlbGYiLCAmdXB0aW1l LCAmaWRsZXRpbWUpKQorICAgICAgaWYgKGZzY2FuZiAoZnVwLCAiJWxsdS4lbiVsbHUlbiAl bGx1LiVuJWxsdSVuIiwKKwkJICAmdXBzZWMsICZ1cGZyYWNfc3RhcnQsICZ1cGZyYWMsICZ1 cGZyYWNfZW5kLAorCQkgICZpZGxlc2VjLCAmaWRsZWZyYWNfc3RhcnQsICZpZGxlZnJhYywg JmlkbGVmcmFjX2VuZCkKKwkgID09IDQpCiAJewotCSAgKnNlYyA9IHVwdGltZTsKLQkgICp1 c2VjID0gKHVwdGltZSAtICpzZWMpICogMTAwMDAwMDsKKwkgIGlmIChUWVBFX01BWElNVU0g KHRpbWVfdCkgPCB1cHNlYykKKwkgICAgeworCSAgICAgIHVwc2VjID0gVFlQRV9NQVhJTVVN ICh0aW1lX3QpOworCSAgICAgIHVwZnJhYyA9IEVNQUNTX1RJTUVfUkVTT0xVVElPTiAtIDE7 CisJICAgIH0KKwkgIGVsc2UKKwkgICAgeworCSAgICAgIGludCB1cGZyYWNsZW4gPSB1cGZy YWNfZW5kIC0gdXBmcmFjX3N0YXJ0OworCSAgICAgIGZvciAoOyB1cGZyYWNsZW4gPCBMT0cx MF9FTUFDU19USU1FX1JFU09MVVRJT047IHVwZnJhY2xlbisrKQorCQl1cGZyYWMgKj0gMTA7 CisJICAgICAgZm9yICg7IExPRzEwX0VNQUNTX1RJTUVfUkVTT0xVVElPTiA8IHVwZnJhY2xl bjsgdXBmcmFjbGVuLS0pCisJCXVwZnJhYyAvPSAxMDsKKwkgICAgICB1cGZyYWMgPSBtaW4g KHVwZnJhYywgRU1BQ1NfVElNRV9SRVNPTFVUSU9OIC0gMSk7CisJICAgIH0KKwkgIEVNQUNT X1NFVF9TRUNTX05TRUNTICh1cCwgdXBzZWMsIHVwZnJhYyk7CiAJfQogICAgICAgZmNsb3Nl IChmdXApOwogICAgIH0KICAgVU5CTE9DS19JTlBVVDsKKworICByZXR1cm4gdXA7CiB9CiAK ICNkZWZpbmUgTUFKT1IoZCkgKCgodW5zaWduZWQpKGQpID4+IDgpICYgMHhmZmYpCkBAIC0y NzQ3LDkgKzI3NTUsNyBAQAogICB1bnNpZ25lZCBsb25nIGxvbmcgdV90aW1lLCBzX3RpbWUs IGN1dGltZSwgY3N0aW1lLCBzdGFydDsKICAgbG9uZyBwcmlvcml0eSwgbmljZW5lc3MsIHJz czsKICAgdW5zaWduZWQgbG9uZyBtaW5mbHQsIG1hamZsdCwgY21pbmZsdCwgY21hamZsdCwg dnNpemU7Ci0gIHRpbWVfdCBzZWM7Ci0gIHVuc2lnbmVkIHVzZWM7Ci0gIEVNQUNTX1RJTUUg dG5vdywgdHN0YXJ0LCB0Ym9vdCwgdGVsYXBzZWQ7CisgIEVNQUNTX1RJTUUgdG5vdywgdHN0 YXJ0LCB0Ym9vdCwgdGVsYXBzZWQsIHVzX3RpbWU7CiAgIGRvdWJsZSBwY3B1LCBwbWVtOwog ICBMaXNwX09iamVjdCBhdHRycyA9IFFuaWw7CiAgIExpc3BfT2JqZWN0IGNtZF9zdHIsIGRl Y29kZWRfY21kLCB0ZW07CkBAIC0yODc2LDM1ICsyODgyLDE4IEBACiAJICBhdHRycyA9IEZj b25zIChGY29ucyAoUW5pY2UsIG1ha2VfbnVtYmVyIChuaWNlbmVzcykpLCBhdHRycyk7CiAJ ICBhdHRycyA9IEZjb25zIChGY29ucyAoUXRoY291bnQsIG1ha2VfZml4bnVtX29yX2Zsb2F0 ICh0aGNvdW50X2VpbnQpKSwgYXR0cnMpOwogCSAgRU1BQ1NfR0VUX1RJTUUgKHRub3cpOwot CSAgZ2V0X3VwX3RpbWUgKCZzZWMsICZ1c2VjKTsKLQkgIEVNQUNTX1NFVF9TRUNTICh0ZWxh cHNlZCwgc2VjKTsKLQkgIEVNQUNTX1NFVF9VU0VDUyAodGVsYXBzZWQsIHVzZWMpOworCSAg dGVsYXBzZWQgPSBnZXRfdXBfdGltZSAoKTsKIAkgIEVNQUNTX1NVQl9USU1FICh0Ym9vdCwg dG5vdywgdGVsYXBzZWQpOwotCSAgdGltZV9mcm9tX2ppZmZpZXMgKHN0YXJ0LCBjbG9ja3Nf cGVyX3NlYywgJnNlYywgJnVzZWMpOwotCSAgRU1BQ1NfU0VUX1NFQ1MgKHRzdGFydCwgc2Vj KTsKLQkgIEVNQUNTX1NFVF9VU0VDUyAodHN0YXJ0LCB1c2VjKTsKKwkgIHRzdGFydCA9IHRp bWVfZnJvbV9qaWZmaWVzIChzdGFydCwgY2xvY2tzX3Blcl9zZWMpOwogCSAgRU1BQ1NfQURE X1RJTUUgKHRzdGFydCwgdGJvb3QsIHRzdGFydCk7Ci0JICBhdHRycyA9IEZjb25zIChGY29u cyAoUXN0YXJ0LAotCQkJCWxpc3QzIChtYWtlX251bWJlcgotCQkJCSAgICAgICAoKEVNQUNT X1NFQ1MgKHRzdGFydCkgPj4gMTYpICYgMHhmZmZmKSwKLQkJCQkgICAgICAgbWFrZV9udW1i ZXIKLQkJCQkgICAgICAgKEVNQUNTX1NFQ1MgKHRzdGFydCkgJiAweGZmZmYpLAotCQkJCSAg ICAgICBtYWtlX251bWJlcgotCQkJCSAgICAgICAoRU1BQ1NfVVNFQ1MgKHRzdGFydCkpKSks Ci0JCQkgYXR0cnMpOworCSAgYXR0cnMgPSBGY29ucyAoRmNvbnMgKFFzdGFydCwgbWFrZV9s aXNwX3RpbWUgKHRzdGFydCkpLCBhdHRycyk7CiAJICBhdHRycyA9IEZjb25zIChGY29ucyAo UXZzaXplLCBtYWtlX2ZpeG51bV9vcl9mbG9hdCAodnNpemUvMTAyNCkpLCBhdHRycyk7CiAJ ICBhdHRycyA9IEZjb25zIChGY29ucyAoUXJzcywgbWFrZV9maXhudW1fb3JfZmxvYXQgKDQq cnNzKSksIGF0dHJzKTsKIAkgIEVNQUNTX1NVQl9USU1FICh0ZWxhcHNlZCwgdG5vdywgdHN0 YXJ0KTsKLQkgIGF0dHJzID0gRmNvbnMgKEZjb25zIChRZXRpbWUsCi0JCQkJbGlzdDMgKG1h a2VfbnVtYmVyCi0JCQkJICAgICAgICgoRU1BQ1NfU0VDUyAodGVsYXBzZWQpID4+IDE2KSAm IDB4ZmZmZiksCi0JCQkJICAgICAgIG1ha2VfbnVtYmVyCi0JCQkJICAgICAgIChFTUFDU19T RUNTICh0ZWxhcHNlZCkgJiAweGZmZmYpLAotCQkJCSAgICAgICBtYWtlX251bWJlcgotCQkJ CSAgICAgICAoRU1BQ1NfVVNFQ1MgKHRlbGFwc2VkKSkpKSwKLQkJCSBhdHRycyk7Ci0JICB0 aW1lX2Zyb21famlmZmllcyAodV90aW1lICsgc190aW1lLCBjbG9ja3NfcGVyX3NlYywgJnNl YywgJnVzZWMpOwotCSAgcGNwdSA9IChzZWMgKyB1c2VjIC8gMTAwMDAwMC4wKSAvIChFTUFD U19TRUNTICh0ZWxhcHNlZCkgKyBFTUFDU19VU0VDUyAodGVsYXBzZWQpIC8gMTAwMDAwMC4w KTsKKwkgIGF0dHJzID0gRmNvbnMgKEZjb25zIChRZXRpbWUsIG1ha2VfbGlzcF90aW1lICh0 ZWxhcHNlZCkpLCBhdHRycyk7CisJICB1c190aW1lID0gdGltZV9mcm9tX2ppZmZpZXMgKHVf dGltZSArIHNfdGltZSwgY2xvY2tzX3Blcl9zZWMpOworCSAgcGNwdSA9IChFTUFDU19USU1F X1RPX0RPVUJMRSAodXNfdGltZSkKKwkJICAvIEVNQUNTX1RJTUVfVE9fRE9VQkxFICh0ZWxh cHNlZCkpOwogCSAgaWYgKHBjcHUgPiAxLjApCiAJICAgIHBjcHUgPSAxLjA7CiAJICBhdHRy cyA9IEZjb25zIChGY29ucyAoUXBjcHUsIG1ha2VfZmxvYXQgKDEwMCAqIHBjcHUpKSwgYXR0 cnMpOwpAQCAtMzA4NywyNyArMzA3NiwxMyBAQAogCQlRY3N0aW1lCiAJCUFyZSB0aGV5IGF2 YWlsYWJsZT8gKi8KIAotCSAgYXR0cnMgPSBGY29ucyAoRmNvbnMgKFF0aW1lLAotCSAgCQkJ bGlzdDMgKG1ha2VfbnVtYmVyIChwaW5mby5wcl90aW1lLnR2X3NlYyA+PiAxNiksCi0JICAJ CQkgICAgICAgbWFrZV9udW1iZXIgKHBpbmZvLnByX3RpbWUudHZfc2VjICYgMHhmZmZmKSwK LQkgIAkJCSAgICAgICBtYWtlX251bWJlciAocGluZm8ucHJfdGltZS50dl9uc2VjKSkpLAot CSAgCQkgYXR0cnMpOwotCi0JICBhdHRycyA9IEZjb25zIChGY29ucyAoUWN0aW1lLAotCSAg CQkJbGlzdDMgKG1ha2VfbnVtYmVyIChwaW5mby5wcl9jdGltZS50dl9zZWMgPj4gMTYpLAot CSAgCQkJICAgICAgIG1ha2VfbnVtYmVyIChwaW5mby5wcl9jdGltZS50dl9zZWMgJiAweGZm ZmYpLAotCSAgCQkJICAgICAgIG1ha2VfbnVtYmVyIChwaW5mby5wcl9jdGltZS50dl9uc2Vj KSkpLAotCSAgCQkgYXR0cnMpOwotCisJICBhdHRycyA9IEZjb25zIChGY29ucyAoUXRpbWUs IG1ha2VfbGlzcF90aW1lIChwaW5mby5wcl90aW1lKSksIGF0dHJzKTsKKwkgIGF0dHJzID0g RmNvbnMgKEZjb25zIChRY3RpbWUsIG1ha2VfbGlzcF90aW1lIChwaW5mby5wcl9jdGltZSkp LCBhdHRycyk7CiAJICBhdHRycyA9IEZjb25zIChGY29ucyAoUXByaSwgbWFrZV9udW1iZXIg KHBpbmZvLnByX2x3cC5wcl9wcmkpKSwgYXR0cnMpOwogCSAgYXR0cnMgPSBGY29ucyAoRmNv bnMgKFFuaWNlLCBtYWtlX251bWJlciAocGluZm8ucHJfbHdwLnByX25pY2UpKSwgYXR0cnMp OwogCSAgYXR0cnMgPSBGY29ucyAoRmNvbnMgKFF0aGNvdW50LCBtYWtlX2ZpeG51bV9vcl9m bG9hdCAocGluZm8ucHJfbmx3cCkpLCBhdHRycyk7CiAKLQkgIGF0dHJzID0gRmNvbnMgKEZj b25zIChRc3RhcnQsCi0JICAJCQlsaXN0MyAobWFrZV9udW1iZXIgKHBpbmZvLnByX3N0YXJ0 LnR2X3NlYyA+PiAxNiksCi0JICAJCQkgICAgICAgbWFrZV9udW1iZXIgKHBpbmZvLnByX3N0 YXJ0LnR2X3NlYyAmIDB4ZmZmZiksCi0JICAJCQkgICAgICAgbWFrZV9udW1iZXIgKHBpbmZv LnByX3N0YXJ0LnR2X25zZWMpKSksCi0JICAJCSBhdHRycyk7CisJICBhdHRycyA9IEZjb25z IChGY29ucyAoUXN0YXJ0LCBtYWtlX2xpc3BfdGltZSAocGluZm8ucHJfc3RhcnQpKSwgYXR0 cnMpOwogCSAgYXR0cnMgPSBGY29ucyAoRmNvbnMgKFF2c2l6ZSwgbWFrZV9maXhudW1fb3Jf ZmxvYXQgKHBpbmZvLnByX3NpemUpKSwgYXR0cnMpOwogCSAgYXR0cnMgPSBGY29ucyAoRmNv bnMgKFFyc3MsIG1ha2VfZml4bnVtX29yX2Zsb2F0IChwaW5mby5wcl9yc3NpemUpKSwgYXR0 cnMpOwogCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL3N5c3NlbGVjdC5oJwotLS0gc3JjL3N5 c3NlbGVjdC5oCTIwMTItMDEtMTkgMDc6MjE6MjUgKzAwMDAKKysrIHNyYy9zeXNzZWxlY3Qu aAkyMDEyLTA1LTA0IDA2OjQyOjAzICswMDAwCkBAIC0xNiw3ICsxNiw2IEBACiBZb3Ugc2hv dWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZQogYWxvbmcgd2l0aCBHTlUgRW1hY3MuICBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5n bnUub3JnL2xpY2Vuc2VzLz4uICAqLwogCi0jaWZkZWYgSEFWRV9TWVNfU0VMRUNUX0gKICNp ZiBkZWZpbmVkIChEQVJXSU5fT1MpCiAjdW5kZWYgaW5pdF9wcm9jZXNzCiAjZW5kaWYKQEAg LTI0LDcgKzIzLDYgQEAKICNpZiBkZWZpbmVkIChEQVJXSU5fT1MpCiAjZGVmaW5lIGluaXRf cHJvY2VzcyBlbWFjc19pbml0X3Byb2Nlc3MKICNlbmRpZgotI2VuZGlmCiAKIC8qIFRoZSB3 MzIgYnVpbGQgZGVmaW5lcyBzZWxlY3Qgc3R1ZmYgaW4gdzMyLmgsIHdoaWNoIGlzIGluY2x1 ZGVkCiAgICB3aGVyZSB3MzIgbmVlZHMgaXQsIGJ1dCBub3Qgd2hlcmUgc3lzc2VsZWN0Lmgg aXMgaW5jbHVkZWQuICBUaGUgdzMyCkBAIC01Miw0ICs1MCwzIEBACiAjaWYgIWRlZmluZWQg KEhBVkVfU0VMRUNUKQogI2RlZmluZSBzZWxlY3Qgc3lzX3NlbGVjdAogI2VuZGlmCi0KCj09 PSBtb2RpZmllZCBmaWxlICdzcmMvc3lzdGltZS5oJwotLS0gc3JjL3N5c3RpbWUuaAkyMDEy LTAxLTE5IDA3OjIxOjI1ICswMDAwCisrKyBzcmMvc3lzdGltZS5oCTIwMTItMDUtMDQgMDY6 NDI6MDMgKzAwMDAKQEAgLTE5LDE2ICsxOSw3IEBACiAjaWZuZGVmIEVNQUNTX1NZU1RJTUVf SAogI2RlZmluZSBFTUFDU19TWVNUSU1FX0gKIAotI2lmZGVmIFRJTUVfV0lUSF9TWVNfVElN RQotI2luY2x1ZGUgPHN5cy90aW1lLmg+Ci0jaW5jbHVkZSA8dGltZS5oPgotI2Vsc2UKLSNp ZmRlZiBIQVZFX1NZU19USU1FX0gKLSNpbmNsdWRlIDxzeXMvdGltZS5oPgotI2Vsc2UKLSNp bmNsdWRlIDx0aW1lLmg+Ci0jZW5kaWYKLSNlbmRpZgorI2luY2x1ZGUgPHRpbWVzcGVjLmg+ CiAKICNpZmRlZiBlbWFjcwogIyBpZmRlZiBIQVZFX1hfV0lORE9XUwpAQCAtNDgsOTEgKzM5 LDY0IEBACiAjZW5kaWYKICNlbmRpZgogDAotLyogRU1BQ1NfVElNRSBpcyB0aGUgdHlwZSB0 byB1c2UgdG8gcmVwcmVzZW50IHRlbXBvcmFsIGludGVydmFscyAtCi0gICBzdHJ1Y3QgdGlt ZXZhbCBvbiBzb21lIHN5c3RlbXMsIGludCBvbiBvdGhlcnMuICBJdCBjYW4gYmUgcGFzc2Vk IGFzCi0gICB0aGUgdGltZW91dCBhcmd1bWVudCB0byB0aGUgc2VsZWN0ICBzeXN0ZW0gY2Fs bC4KLQotICAgRU1BQ1NfU0VDUyAoVElNRSkgaXMgYW4gcnZhbHVlIGZvciB0aGUgc2Vjb25k cyBjb21wb25lbnQgb2YgVElNRS4KKy8qIFRoZSB0eXBlIHRvIHVzZSB0byByZXByZXNlbnQg dGVtcG9yYWwgaW50ZXJ2YWxzLiAgSXQgY2FuIGJlIHBhc3NlZAorICAgYXMgdGhlIHRpbWVv dXQgYXJndW1lbnQgdG8gdGhlIHBzZWxlY3Qgc3lzdGVtIGNhbGwuICAqLworI2RlZmluZSBF TUFDU19USU1FIHN0cnVjdCB0aW1lc3BlYworCisvKiBSZXNvbHV0aW9uIG9mIEVNQUNTX1RJ TUUgdGltZSBzdGFtcHMgKGluIHVuaXRzIHBlciBzZWNvbmQpLCBhbmQgbG9nCisgICBiYXNl IDEwIG9mIHRoZSByZXNvbHV0aW9uLiAgVGhlIGxvZyBtdXN0IGJlIGEgcG9zaXRpdmUgaW50 ZWdlci4gICovCisjZGVmaW5lIEVNQUNTX1RJTUVfUkVTT0xVVElPTgkJMTAwMDAwMDAwMAor I2RlZmluZSBMT0cxMF9FTUFDU19USU1FX1JFU09MVVRJT04JOQorCisvKiBFTUFDU19TRUNT IChUSU1FKSBpcyBhbiBydmFsdWUgZm9yIHRoZSBzZWNvbmRzIGNvbXBvbmVudCBvZiBUSU1F LgorICAgRU1BQ1NfU0VDU19BRERSICh0aW1lKSBpcyB0aGUgYWRkcmVzcyBvZiB0aGUgc2Vj b25kcyBjb21wb25lbnQuCiAgICBFTUFDU19TRVRfU0VDUyAoVElNRSwgU0VDT05EUykgc2V0 cyB0aGF0IHRvIFNFQ09ORFMuCiAKLSAgIEVNQUNTX0hBU19VU0VDUyBpcyBkZWZpbmVkIGlm IEVNQUNTX1RJTUUgaGFzIGEgdXNlY3MgY29tcG9uZW50LgotICAgRU1BQ1NfVVNFQ1MgKFRJ TUUpIGlzIGFuIHJ2YWx1ZSBmb3IgdGhlIG1pY3Jvc2Vjb25kcyBjb21wb25lbnQgb2YgVElN RS4KLSAgIAlUaGlzIHJldHVybnMgemVybyBpZiBFTUFDU19USU1FIGRvZXNuJ3QgaGF2ZSBh IG1pY3Jvc2Vjb25kcyBjb21wb25lbnQuCi0gICBFTUFDU19TRVRfVVNFQ1MgKFRJTUUsIE1J Q1JPU0VDT05EUykgc2V0cyB0aGF0IHRvIE1JQ1JPU0VDT05EUy4KLQlUaGlzIGRvZXMgbm90 aGluZyBpZiBFTUFDU19USU1FIGRvZXNuJ3QgaGF2ZSBhIG1pY3Jvc2Vjb25kcyBjb21wb25l bnQuCi0KLSAgIEVNQUNTX1NFVF9TRUNTX1VTRUNTIChUSU1FLCBTRUNTLCBVU0VDUykgc2V0 cyBib3RoIGNvbXBvbmVudHMgb2YgVElNRS4KLQotICAgRU1BQ1NfR0VUX1RJTUUgKFRJTUUp IHN0b3JlcyB0aGUgY3VycmVudCBzeXN0ZW0gdGltZSBpbiBUSU1FLCB3aGljaAotCXNob3Vs ZCBiZSBhbiBsdmFsdWUuCi0KLSAgIEVNQUNTX0FERF9USU1FIChERVNULCBTUkMxLCBTUkMy KSBhZGRzIFNSQzEgdG8gU1JDMiBhbmQgc3RvcmVzIHRoZQotCXJlc3VsdCBpbiBERVNULiAg U1JDIHNob3VsZCBub3QgYmUgbmVnYXRpdmUuCi0KLSAgIEVNQUNTX1NVQl9USU1FIChERVNU LCBTUkMxLCBTUkMyKSBzdWJ0cmFjdHMgU1JDMiBmcm9tIFNSQzEgYW5kCi0Jc3RvcmVzIHRo ZSByZXN1bHQgaW4gREVTVC4gIFNSQyBzaG91bGQgbm90IGJlIG5lZ2F0aXZlLgotICAgRU1B Q1NfVElNRV9ORUdfUCAoVElNRSkgaXMgdHJ1ZSBpZiBUSU1FIGlzIG5lZ2F0aXZlLgotCi0q LwotCi0jaWZkZWYgSEFWRV9USU1FVkFMCi0KLSNkZWZpbmUgRU1BQ1NfSEFTX1VTRUNTCi0K LSNkZWZpbmUgRU1BQ1NfVElNRSBzdHJ1Y3QgdGltZXZhbAorICAgRU1BQ1NfTlNFQ1MgKFRJ TUUpIGlzIGFuIHJ2YWx1ZSBmb3IgdGhlIG5hbm9zZWNvbmRzIGNvbXBvbmVudCBvZiBUSU1F LgorICAgRU1BQ1NfU0VUX05TRUNTIChUSU1FLCBOQU5PU0VDT05EUykgc2V0cyB0aGF0IHRv IE5BTk9TRUNPTkRTLgorCisgICBFTUFDU19TRVRfU0VDU19OU0VDUyAoVElNRSwgU0VDUywg TlNFQ1MpIHNldHMgYm90aCBjb21wb25lbnRzIG9mIFRJTUUuICAqLwogI2RlZmluZSBFTUFD U19TRUNTKHRpbWUpCQkgICAgKCh0aW1lKS50dl9zZWMgICsgMCkKLSNkZWZpbmUgRU1BQ1Nf VVNFQ1ModGltZSkJCSAgICAoKHRpbWUpLnR2X3VzZWMgKyAwKQorI2RlZmluZSBFTUFDU19O U0VDUyh0aW1lKQkJICAgICgodGltZSkudHZfbnNlYyArIDApCisjZGVmaW5lIEVNQUNTX1NF Q1NfQUREUih0aW1lKQkJICAgICgmKHRpbWUpLnR2X3NlYykKICNkZWZpbmUgRU1BQ1NfU0VU X1NFQ1ModGltZSwgc2Vjb25kcykJICAgICgodGltZSkudHZfc2VjICA9IChzZWNvbmRzKSkK LSNkZWZpbmUgRU1BQ1NfU0VUX1VTRUNTKHRpbWUsIG1pY3Jvc2Vjb25kcykgKCh0aW1lKS50 dl91c2VjID0gKG1pY3Jvc2Vjb25kcykpCi0KLS8qIE9uIFNWUjQsIHRoZSBjb21waWxlciBt YXkgY29tcGxhaW4gaWYgZ2l2ZW4gdGhpcyBleHRyYSBCU0QgYXJnLiAgKi8KLSNpZmRlZiBH RVRUSU1FT0ZEQVlfT05FX0FSR1VNRU5UCi0jZGVmaW5lIEVNQUNTX0dFVF9USU1FKHRpbWUp IGdldHRpbWVvZmRheSAoJih0aW1lKSkKLSNlbHNlIC8qIG5vdCBHRVRUSU1FT0ZEQVlfT05F X0FSR1VNRU5UICovCi0vKiBQcmVzdW1hYmx5IHRoZSBzZWNvbmQgYXJnIGlzIGlnbm9yZWQu ICAqLwotI2RlZmluZSBFTUFDU19HRVRfVElNRSh0aW1lKSBnZXR0aW1lb2ZkYXkgKCYodGlt ZSksIE5VTEwpCi0jZW5kaWYgLyogbm90IEdFVFRJTUVPRkRBWV9PTkVfQVJHVU1FTlQgKi8K LQotI2RlZmluZSBFTUFDU19BRERfVElNRShkZXN0LCBzcmMxLCBzcmMyKQkJXAotICBkbyB7 CQkJCQkJCVwKLSAgICAoZGVzdCkudHZfc2VjICA9IChzcmMxKS50dl9zZWMgICsgKHNyYzIp LnR2X3NlYzsJXAotICAgIChkZXN0KS50dl91c2VjID0gKHNyYzEpLnR2X3VzZWMgKyAoc3Jj MikudHZfdXNlYzsJXAotICAgIGlmICgoZGVzdCkudHZfdXNlYyA+IDEwMDAwMDApCQkJXAot ICAgICAgKGRlc3QpLnR2X3VzZWMgLT0gMTAwMDAwMCwgKGRlc3QpLnR2X3NlYysrOwlcCi0g IH0gd2hpbGUgKDApCi0KLSNkZWZpbmUgRU1BQ1NfU1VCX1RJTUUoZGVzdCwgc3JjMSwgc3Jj MikJCVwKLSAgZG8gewkJCQkJCQlcCi0gICAgKGRlc3QpLnR2X3NlYyAgPSAoc3JjMSkudHZf c2VjICAtIChzcmMyKS50dl9zZWM7CVwKLSAgICAoZGVzdCkudHZfdXNlYyA9IChzcmMxKS50 dl91c2VjIC0gKHNyYzIpLnR2X3VzZWM7CVwKLSAgICBpZiAoKGRlc3QpLnR2X3VzZWMgPCAw KQkJCQlcCi0gICAgICAoZGVzdCkudHZfdXNlYyArPSAxMDAwMDAwLCAoZGVzdCkudHZfc2Vj LS07CVwKLSAgfSB3aGlsZSAoMCkKLQotI2RlZmluZSBFTUFDU19USU1FX05FR19QKHRpbWUp CQkJCQlcCi0gICgobG9uZykodGltZSkudHZfc2VjIDwgMAkJCQkJXAotICAgfHwgKCh0aW1l KS50dl9zZWMgPT0gMAkJCQkJXAotICAgICAgICYmIChsb25nKSh0aW1lKS50dl91c2VjIDwg MCkpCi0KLSNlbHNlIC8qICEgZGVmaW5lZCAoSEFWRV9USU1FVkFMKSAqLwotCi0jZGVmaW5l IEVNQUNTX1RJTUUgaW50Ci0jZGVmaW5lIEVNQUNTX1NFQ1ModGltZSkJCSAgICAodGltZSkK LSNkZWZpbmUgRU1BQ1NfVVNFQ1ModGltZSkJCSAgICAwCi0jZGVmaW5lIEVNQUNTX1NFVF9T RUNTKHRpbWUsIHNlY29uZHMpCSAgICAoKHRpbWUpID0gKHNlY29uZHMpKQotI2RlZmluZSBF TUFDU19TRVRfVVNFQ1ModGltZSwgdXNlY3MpCSAgICAwCi0KLSNkZWZpbmUgRU1BQ1NfR0VU X1RJTUUodCkgKCh0KSA9IHRpbWUgKChsb25nICopIDApKQotI2RlZmluZSBFTUFDU19BRERf VElNRShkZXN0LCBzcmMxLCBzcmMyKSAoKGRlc3QpID0gKHNyYzEpICsgKHNyYzIpKQotI2Rl ZmluZSBFTUFDU19TVUJfVElNRShkZXN0LCBzcmMxLCBzcmMyKSAoKGRlc3QpID0gKHNyYzEp IC0gKHNyYzIpKQotI2RlZmluZSBFTUFDU19USU1FX05FR19QKHQpICgodCkgPCAwKQotCi0j ZW5kaWYgLyogISBkZWZpbmVkIChIQVZFX1RJTUVWQUwpICovCi0KKyNkZWZpbmUgRU1BQ1Nf U0VUX05TRUNTKHRpbWUsIG5zKQkgICAgKCh0aW1lKS50dl9uc2VjID0gKG5zKSkKKyNkZWZp bmUgRU1BQ1NfU0VUX1NFQ1NfTlNFQ1ModGltZSwgcywgbnMpCQkJCVwKKyAgKCh2b2lkKSAo RU1BQ1NfU0VUX1NFQ1MgKHRpbWUsIHMpLCBFTUFDU19TRVRfTlNFQ1MgKHRpbWUsIG5zKSkp CisKKy8qIENvbnZlbmllbmNlIG1hY3JvcyBmb3Igb2xkZXIgY29kZSB0aGF0IGNvdW50cyBt aWNyb3NlY29uZHMuICAqLworI2RlZmluZSBFTUFDU19TRVRfVVNFQ1ModGltZSwgdXMpICAo KHZvaWQpIEVNQUNTX1NFVF9OU0VDUyAodGltZSwgKHVzKSAqIDEwMDApKQogI2RlZmluZSBF TUFDU19TRVRfU0VDU19VU0VDUyh0aW1lLCBzZWNzLCB1c2VjcykgCQlcCiAgIChFTUFDU19T RVRfU0VDUyAodGltZSwgc2VjcyksIEVNQUNTX1NFVF9VU0VDUyAodGltZSwgdXNlY3MpKQog Ci1leHRlcm4gaW50IHNldF9maWxlX3RpbWVzIChjb25zdCBjaGFyICosIEVNQUNTX1RJTUUs IEVNQUNTX1RJTUUpOworLyogU2V0IFRJTUUgdG8gYW4gaW52YWxpZCB0aW1lIHN0YW1wLiAg Ki8KKyNkZWZpbmUgRU1BQ1NfU0VUX0lOVkFMSURfVElNRSh0aW1lKQkgICAgRU1BQ1NfU0VU X1NFQ1NfTlNFQ1ModGltZSwgMCwgLTEpCisKKy8qIFNldCBUSU1FIHRvIHRoZSBjdXJyZW50 IHN5c3RlbSB0aW1lLiAgKi8KKyNkZWZpbmUgRU1BQ1NfR0VUX1RJTUUodGltZSkJCSAgICBn ZXR0aW1lICgmKHRpbWUpKQorCisvKiBQdXQgaW50byBERVNUIHRoZSByZXN1bHQgb2YgYWRk aW5nIFNSQzEgdG8gU1JDMiwgb3Igb2Ygc3VidHJhY3RpbmcKKyAgIFNSQzIgZnJvbSBTUkMx LiAgT24gb3ZlcmZsb3csIHN0b3JlIGFuIGV4dHJlbWFsIHZhbHVlLiAgKi8KKyNkZWZpbmUg RU1BQ1NfQUREX1RJTUUoZGVzdCwgc3JjMSwgc3JjMikgKChkZXN0KSA9IHRpbWVzcGVjX2Fk ZCAoc3JjMSwgc3JjMikpCisjZGVmaW5lIEVNQUNTX1NVQl9USU1FKGRlc3QsIHNyYzEsIHNy YzIpICgoZGVzdCkgPSB0aW1lc3BlY19zdWIgKHNyYzEsIHNyYzIpKQorCisvKiBSZXR1cm4g dGhlIHNpZ24gb2YgdGhlIHZhbGlkIHRpbWUgc3RhbXAgVElNRSwgZWl0aGVyIC0xLCAwLCBv ciAxLiAgKi8KKyNkZWZpbmUgRU1BQ1NfVElNRV9TSUdOKHRpbWUpCQl0aW1lc3BlY19zaWdu ICh0aW1lKQorCisvKiBSZXR1cm4gMSBpZiBUSU1FIGlzIGEgdmFsaWQgdGltZSBzdGFtcC4g ICovCisjZGVmaW5lIEVNQUNTX1RJTUVfVkFMSURfUCh0aW1lKQkoMCA8PSAodGltZSkudHZf bnNlYykKKworLyogQ29udmVydCB0aGUgZG91YmxlIEQgdG8gdGhlIGdyZWF0ZXN0IEVNQUNT X1RJTUUgbm90IGdyZWF0ZXIgdGhhbiBELgorICAgT24gb3ZlcmZsb3csIHJldHVybiBhbiBl eHRyZW1hbCB2YWx1ZS4gIFJldHVybiB0aGUgbWluaW11bQorICAgRU1BQ1NfVElNRSBpZiBE IGlzIG5vdCBhIG51bWJlci4gICovCisjZGVmaW5lIEVNQUNTX1RJTUVfRlJPTV9ET1VCTEUo ZCkJZHRvdGltZXNwZWMgKGQpCisKKy8qIENvbnZlcnQgdGhlIEVtYWNzIHRpbWUgVCB0byBh biBhcHByb3hpbWF0ZSBkb3VibGUgdmFsdWUgRC4gICovCisjZGVmaW5lIEVNQUNTX1RJTUVf VE9fRE9VQkxFKHQpCQl0aW1lc3BlY3RvZCAodCkKKworLyogZGVmaW5lZCBpbiBzeXNkZXAu YyAqLworZXh0ZXJuIGludCBzZXRfZmlsZV90aW1lcyAoaW50LCBjb25zdCBjaGFyICosIEVN QUNTX1RJTUUsIEVNQUNTX1RJTUUpOworZXh0ZXJuIHN0cnVjdCB0aW1ldmFsIG1ha2VfdGlt ZXZhbCAoRU1BQ1NfVElNRSk7CiAKIC8qIGRlZmluZWQgaW4ga2V5Ym9hcmQuYyAqLwogZXh0 ZXJuIHZvaWQgc2V0X3dhaXRpbmdfZm9yX2lucHV0IChFTUFDU19USU1FICopOwpAQCAtMTQx LDI5ICsxMDUsMjAgQEAKICAgIGhhcHBlbiB3aGVuIHRoaXMgZmlsZXMgaXMgdXNlZCBvdXRz aWRlIHRoZSBzcmMgZGlyZWN0b3J5KS4KICAgIFVzZSBHQ1BSTzEgdG8gZGV0ZXJtaW5lIGlm IGxpc3AuaCB3YXMgaW5jbHVkZWQuICAqLwogI2lmZGVmIEdDUFJPMQotLyogZGVmaW5lZCBp biBlZGl0Zm5zLmMqLwotZXh0ZXJuIExpc3BfT2JqZWN0IG1ha2VfdGltZSAodGltZV90KTsK LWV4dGVybiBpbnQgbGlzcF90aW1lX2FyZ3VtZW50IChMaXNwX09iamVjdCwgdGltZV90ICos IGludCAqKTsKKy8qIGRlZmluZWQgaW4gZWRpdGZucy5jICovCitleHRlcm4gTGlzcF9PYmpl Y3QgbWFrZV9saXNwX3RpbWUgKEVNQUNTX1RJTUUpOworZXh0ZXJuIGludCBkZWNvZGVfdGlt ZV9jb21wb25lbnRzIChMaXNwX09iamVjdCwgTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0LAor CQkJCSAgIExpc3BfT2JqZWN0LCBFTUFDU19USU1FICosIGludCAqKTsKK2V4dGVybiBFTUFD U19USU1FIGxpc3BfdGltZV9hcmd1bWVudCAoTGlzcF9PYmplY3QsIGludCAqKTsKICNlbmRp ZgogCi0vKiBDb21wYXJlIHRpbWVzIFQxIGFuZCBUMi4gIFZhbHVlIGlzIDAgaWYgVDEgYW5k IFQyIGFyZSB0aGUgc2FtZS4KLSAgIFZhbHVlIGlzIDwgMCBpZiBUMSBpcyBsZXNzIHRoYW4g VDIuICBWYWx1ZSBpcyA+IDAgb3RoZXJ3aXNlLiAgKENhc3QKLSAgIHRvIGxvbmcgaXMgZm9y IHRob3NlIHBsYXRmb3JtcyB3aGVyZSB0aW1lX3QgaXMgYW4gdW5zaWduZWQKLSAgIHR5cGUs IGFuZCB3aGVyZSBvdGhlcndpc2UgVDEgd2lsbCBhbHdheXMgYmUgZ3JhdGVyIHRoYW4gVDIu KSAgKi8KLQotI2RlZmluZSBFTUFDU19USU1FX0NNUChUMSwgVDIpCQkJCVwKLSAgKChsb25n KUVNQUNTX1NFQ1MgKFQxKSAtIChsb25nKUVNQUNTX1NFQ1MgKFQyKQlcCi0gICArIChFTUFD U19TRUNTIChUMSkgPT0gRU1BQ1NfU0VDUyAoVDIpCQlcCi0gICAgICA/IEVNQUNTX1VTRUNT IChUMSkgLSBFTUFDU19VU0VDUyAoVDIpCQlcCi0gICAgICA6IDApKQotCiAvKiBDb21wYXJl IHRpbWVzIFQxIGFuZCBUMiBmb3IgZXF1YWxpdHksIGluZXF1YWxpdHkgZXRjLiAgKi8KIAot I2RlZmluZSBFTUFDU19USU1FX0VRKFQxLCBUMikgKEVNQUNTX1RJTUVfQ01QIChUMSwgVDIp ID09IDApCi0jZGVmaW5lIEVNQUNTX1RJTUVfTkUoVDEsIFQyKSAoRU1BQ1NfVElNRV9DTVAg KFQxLCBUMikgIT0gMCkKLSNkZWZpbmUgRU1BQ1NfVElNRV9HVChUMSwgVDIpIChFTUFDU19U SU1FX0NNUCAoVDEsIFQyKSA+IDApCi0jZGVmaW5lIEVNQUNTX1RJTUVfR0UoVDEsIFQyKSAo RU1BQ1NfVElNRV9DTVAgKFQxLCBUMikgPj0gMCkKLSNkZWZpbmUgRU1BQ1NfVElNRV9MVChU MSwgVDIpIChFTUFDU19USU1FX0NNUCAoVDEsIFQyKSA8IDApCi0jZGVmaW5lIEVNQUNTX1RJ TUVfTEUoVDEsIFQyKSAoRU1BQ1NfVElNRV9DTVAgKFQxLCBUMikgPD0gMCkKKyNkZWZpbmUg RU1BQ1NfVElNRV9FUShUMSwgVDIpICh0aW1lc3BlY19jbXAgKFQxLCBUMikgPT0gMCkKKyNk ZWZpbmUgRU1BQ1NfVElNRV9ORShUMSwgVDIpICh0aW1lc3BlY19jbXAgKFQxLCBUMikgIT0g MCkKKyNkZWZpbmUgRU1BQ1NfVElNRV9HVChUMSwgVDIpICh0aW1lc3BlY19jbXAgKFQxLCBU MikgPiAwKQorI2RlZmluZSBFTUFDU19USU1FX0dFKFQxLCBUMikgKHRpbWVzcGVjX2NtcCAo VDEsIFQyKSA+PSAwKQorI2RlZmluZSBFTUFDU19USU1FX0xUKFQxLCBUMikgKHRpbWVzcGVj X2NtcCAoVDEsIFQyKSA8IDApCisjZGVmaW5lIEVNQUNTX1RJTUVfTEUoVDEsIFQyKSAodGlt ZXNwZWNfY21wIChUMSwgVDIpIDw9IDApCiAKICNlbmRpZiAvKiBFTUFDU19TWVNUSU1FX0gg Ki8KCj09PSBtb2RpZmllZCBmaWxlICdzcmMvdGVybS5jJwotLS0gc3JjL3Rlcm0uYwkyMDEy LTA0LTIzIDA1OjQ0OjQ5ICswMDAwCisrKyBzcmMvdGVybS5jCTIwMTItMDUtMDQgMDY6NDI6 MDMgKzAwMDAKQEAgLTI0LDYgKzI0LDcgQEAKICNpbmNsdWRlIDxjdHlwZS5oPgogI2luY2x1 ZGUgPGVycm5vLmg+CiAjaW5jbHVkZSA8c3lzL2ZpbGUuaD4KKyNpbmNsdWRlIDxzeXMvdGlt ZS5oPgogI2luY2x1ZGUgPHVuaXN0ZC5oPgogI2luY2x1ZGUgPHNpZ25hbC5oPgogI2luY2x1 ZGUgPHNldGptcC5oPgpAQCAtMjYwOSw2ICsyNjEwLDE4IEBACiAgIHJldHVybiAwOwogfQog CisvKiBSZXR1cm4gdGhlIFRpbWUgdGhhdCBjb3JyZXNwb25kcyB0byBULiAgV3JhcCBhcm91 bmQgb24gb3ZlcmZsb3cuICAqLworc3RhdGljIFRpbWUKK3RpbWV2YWxfdG9fVGltZSAoc3Ry dWN0IHRpbWV2YWwgY29uc3QgKnQpCit7CisgIFRpbWUgc18xMDAwLCBtczsKKworICBzXzEw MDAgPSB0LT50dl9zZWM7CisgIHNfMTAwMCAqPSAxMDAwOworICBtcyA9IHQtPnR2X3VzZWMg LyAxMDAwOworICByZXR1cm4gc18xMDAwICsgbXM7Cit9CisKIC8qIFJldHVybiB0aGUgY3Vy cmVudCBwb3NpdGlvbiBvZiB0aGUgbW91c2UuCiAKICAgIFNldCAqZiB0byB0aGUgZnJhbWUg dGhlIG1vdXNlIGlzIGluLCBvciB6ZXJvIGlmIHRoZSBtb3VzZSBpcyBpbiBubwpAQCAtMjYy OCw3ICsyNjQxLDYgQEAKIAkJICAgICBMaXNwX09iamVjdCAqeSwgVGltZSAqdGltZXB0cikK IHsKICAgc3RydWN0IHRpbWV2YWwgbm93OwotICBUaW1lIHNlYywgdXNlYzsKIAogICAqZnAg PSBTRUxFQ1RFRF9GUkFNRSAoKTsKICAgKCpmcCktPm1vdXNlX21vdmVkID0gMDsKQEAgLTI2 MzksOSArMjY1MSw3IEBACiAgIFhTRVRJTlQgKCp4LCBsYXN0X21vdXNlX3gpOwogICBYU0VU SU5UICgqeSwgbGFzdF9tb3VzZV95KTsKICAgZ2V0dGltZW9mZGF5KCZub3csIDApOwotICBz ZWMgPSBub3cudHZfc2VjOwotICB1c2VjID0gbm93LnR2X3VzZWM7Ci0gICp0aW1lcHRyID0g KHNlYyAqIDEwMDApICsgKHVzZWMgLyAxMDAwKTsKKyAgKnRpbWVwdHIgPSB0aW1ldmFsX3Rv X1RpbWUgKCZub3cpOwogfQogCiAvKiBQcmVwYXJlIGEgbW91c2UtZXZlbnQgaW4gKlJFU1VM VCBmb3IgcGxhY2VtZW50IGluIHRoZSBpbnB1dCBxdWV1ZS4KQEAgLTI2NjUsNyArMjY3NSw3 IEBACiAgICAgICB9CiAgICAgfQogICBnZXR0aW1lb2ZkYXkoJm5vdywgMCk7Ci0gIHJlc3Vs dC0+dGltZXN0YW1wID0gKG5vdy50dl9zZWMgKiAxMDAwKSArIChub3cudHZfdXNlYyAvIDEw MDApOworICByZXN1bHQtPnRpbWVzdGFtcCA9IHRpbWV2YWxfdG9fVGltZSAoJm5vdyk7CiAK ICAgaWYgKGV2ZW50LT50eXBlICYgR1BNX1VQKQogICAgIHJlc3VsdC0+bW9kaWZpZXJzID0g dXBfbW9kaWZpZXI7Cgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL3VuZG8uYycKLS0tIHNyYy91 bmRvLmMJMjAxMi0wMS0xOSAwNzoyMToyNSArMDAwMAorKysgc3JjL3VuZG8uYwkyMDEyLTA1 LTA0IDA2OjQyOjAzICswMDAwCkBAIC0yMjUsNyArMjI1LDcgQEAKICAgICBiYXNlX2J1ZmZl ciA9IGJhc2VfYnVmZmVyLT5iYXNlX2J1ZmZlcjsKIAogICBCVkFSIChjdXJyZW50X2J1ZmZl ciwgdW5kb19saXN0KSA9Ci0gICAgRmNvbnMgKEZjb25zIChRdCwgSU5URUdFUl9UT19DT05T IChiYXNlX2J1ZmZlci0+bW9kdGltZSkpLAorICAgIEZjb25zIChGY29ucyAoUXQsIG1ha2Vf bGlzcF90aW1lIChiYXNlX2J1ZmZlci0+bW9kdGltZSkpLAogCSAgIEJWQVIgKGN1cnJlbnRf YnVmZmVyLCB1bmRvX2xpc3QpKTsKIH0KIApAQCAtNDk3LDEwICs0OTcsMjMgQEAKIAkgICAg ICBjZHIgPSBYQ0RSIChuZXh0KTsKIAkgICAgICBpZiAoRVEgKGNhciwgUXQpKQogCQl7Ci0J CSAgLyogRWxlbWVudCAodCBoaWdoIC4gbG93KSByZWNvcmRzIHByZXZpb3VzIG1vZHRpbWUu ICAqLworCQkgIC8qIEVsZW1lbnQgKHQgLiBUSU1FKSByZWNvcmRzIHByZXZpb3VzIG1vZHRp bWUuCisJCSAgICAgUHJlc2VydmUgYW55IGZsYWcgb2YgTk9ORVhJU1RFTlRfTU9EVElNRV9O U0VDUyBvcgorCQkgICAgIFVOS05PV05fTU9EVElNRV9OU0VDUy4gICovCiAJCSAgc3RydWN0 IGJ1ZmZlciAqYmFzZV9idWZmZXIgPSBjdXJyZW50X2J1ZmZlcjsKLQkJICB0aW1lX3QgbW9k X3RpbWU7Ci0JCSAgQ09OU19UT19JTlRFR0VSIChjZHIsIHRpbWVfdCwgbW9kX3RpbWUpOwor CQkgIEVNQUNTX1RJTUUgbW9kX3RpbWU7CisKKwkJICBpZiAoQ09OU1AgKGNkcikKKwkJICAg ICAgJiYgQ09OU1AgKFhDRFIgKGNkcikpCisJCSAgICAgICYmIENPTlNQIChYQ0RSIChYQ0RS IChjZHIpKSkKKwkJICAgICAgJiYgQ09OU1AgKFhDRFIgKFhDRFIgKFhDRFIgKGNkcikpKSkK KwkJICAgICAgJiYgSU5URUdFUlAgKFhDQVIgKFhDRFIgKFhDRFIgKFhDRFIgKGNkcikpKSkp CisJCSAgICAgICYmIFhJTlQgKFhDQVIgKFhDRFIgKFhDRFIgKFhDRFIgKGNkcikpKSkpIDwg MCkKKwkJICAgIEVNQUNTX1NFVF9TRUNTX05TRUNTCisJCSAgICAgIChtb2RfdGltZSwgMCwK KwkJICAgICAgIFhJTlQgKFhDQVIgKFhDRFIgKFhDRFIgKFhDRFIgKGNkcikpKSkpIC8gMTAw MCk7CisJCSAgZWxzZQorCQkgICAgbW9kX3RpbWUgPSBsaXNwX3RpbWVfYXJndW1lbnQgKGNk ciwgMCk7CiAKIAkJICBpZiAoY3VycmVudF9idWZmZXItPmJhc2VfYnVmZmVyKQogCQkgICAg YmFzZV9idWZmZXIgPSBjdXJyZW50X2J1ZmZlci0+YmFzZV9idWZmZXI7CkBAIC01MDgsNyAr NTIxLDcgQEAKIAkJICAvKiBJZiB0aGlzIHJlY29yZHMgYW4gb2Jzb2xldGUgc2F2ZQogCQkg ICAgIChub3QgbWF0Y2hpbmcgdGhlIGFjdHVhbCBkaXNrIGZpbGUpCiAJCSAgICAgdGhlbiBk b24ndCBtYXJrIHVubW9kaWZpZWQuICAqLwotCQkgIGlmIChtb2RfdGltZSAhPSBiYXNlX2J1 ZmZlci0+bW9kdGltZSkKKwkJICBpZiAoRU1BQ1NfVElNRV9ORSAobW9kX3RpbWUsIGJhc2Vf YnVmZmVyLT5tb2R0aW1lKSkKIAkJICAgIGNvbnRpbnVlOwogI2lmZGVmIENMQVNIX0RFVEVD VElPTgogCQkgIEZ1bmxvY2tfYnVmZmVyICgpOwoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy93 MzIuYycKLS0tIHNyYy93MzIuYwkyMDEyLTA0LTEwIDE0OjE2OjA1ICswMDAwCisrKyBzcmMv dzMyLmMJMjAxMi0wNS0wNCAwNjo0MjowMyArMDAwMApAQCAtMzE4LDggKzMxOCwxMCBAQAog ICByZXR1cm4gc19iX3JldDsKIH0KIAorc3RhdGljIExpc3BfT2JqZWN0IGx0aW1lIChVTE9O R0xPTkcpOworCiAvKiBHZXQgdG90YWwgdXNlciBhbmQgc3lzdGVtIHRpbWVzIGZvciBnZXQt aW50ZXJuYWwtcnVuLXRpbWUuCi0gICBSZXR1cm5zIGEgbGlzdCBvZiB0aHJlZSBpbnRlZ2Vy cyBpZiB0aGUgdGltZXMgYXJlIHByb3ZpZGVkIGJ5IHRoZSBPUworICAgUmV0dXJucyBhIGxp c3Qgb2YgaW50ZWdlcnMgaWYgdGhlIHRpbWVzIGFyZSBwcm92aWRlZCBieSB0aGUgT1MKICAg IChOVCBkZXJpdmF0aXZlcyksIG90aGVyd2lzZSBpdCByZXR1cm5zIHRoZSByZXN1bHQgb2Yg Y3VycmVudC10aW1lLiAqLwogTGlzcF9PYmplY3QKIHczMl9nZXRfaW50ZXJuYWxfcnVuX3Rp bWUgKHZvaWQpCkBAIC0zMzEsMjcgKzMzMywxMyBAQAogICAgICAgaWYgKCgqZ2V0X3Byb2Nl c3NfdGltZXNfZm4pIChwcm9jLCAmY3JlYXRlLCAmZXhpdCwgJmtlcm5lbCwgJnVzZXIpKQog ICAgICAgICB7CiAgICAgICAgICAgTEFSR0VfSU5URUdFUiB1c2VyX2ludCwga2VybmVsX2lu dCwgdG90YWw7Ci0gICAgICAgICAgaW50IG1pY3Jvc2Vjb25kczsKKwkgIGludCB0aW1lXzEw MG5zOwogICAgICAgICAgIHVzZXJfaW50Lkxvd1BhcnQgPSB1c2VyLmR3TG93RGF0ZVRpbWU7 CiAgICAgICAgICAgdXNlcl9pbnQuSGlnaFBhcnQgPSB1c2VyLmR3SGlnaERhdGVUaW1lOwog ICAgICAgICAgIGtlcm5lbF9pbnQuTG93UGFydCA9IGtlcm5lbC5kd0xvd0RhdGVUaW1lOwog ICAgICAgICAgIGtlcm5lbF9pbnQuSGlnaFBhcnQgPSBrZXJuZWwuZHdIaWdoRGF0ZVRpbWU7 CiAgICAgICAgICAgdG90YWwuUXVhZFBhcnQgPSB1c2VyX2ludC5RdWFkUGFydCArIGtlcm5l bF9pbnQuUXVhZFBhcnQ7Ci0gICAgICAgICAgLyogRklMRVRJTUUgaXMgMTAwIG5hbm9zZWNv bmQgaW5jcmVtZW50cywgRW1hY3Mgb25seSB3YW50cwotICAgICAgICAgICAgIG1pY3Jvc2Vj b25kIHJlc29sdXRpb24uICAqLwotICAgICAgICAgIHRvdGFsLlF1YWRQYXJ0IC89IDEwOwot ICAgICAgICAgIG1pY3Jvc2Vjb25kcyA9IHRvdGFsLlF1YWRQYXJ0ICUgMTAwMDAwMDsKLSAg ICAgICAgICB0b3RhbC5RdWFkUGFydCAvPSAxMDAwMDAwOwotCi0gICAgICAgICAgLyogU2Fu aXR5IGNoZWNrIHRvIG1ha2Ugc3VyZSB3ZSBjYW4gcmVwcmVzZW50IHRoZSByZXN1bHQuICAq LwotICAgICAgICAgIGlmICh0b3RhbC5IaWdoUGFydCA9PSAwKQotICAgICAgICAgICAgewot ICAgICAgICAgICAgICBpbnQgc2VjcyA9IHRvdGFsLkxvd1BhcnQ7Ci0KLSAgICAgICAgICAg ICAgcmV0dXJuIGxpc3QzIChtYWtlX251bWJlciAoKHNlY3MgPj4gMTYpICYgMHhmZmZmKSwK LSAgICAgICAgICAgICAgICAgICAgICAgICAgICBtYWtlX251bWJlciAoc2VjcyAmIDB4ZmZm ZiksCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgbWFrZV9udW1iZXIgKG1pY3Jvc2Vj b25kcykpOwotICAgICAgICAgICAgfQorCSAgcmV0dXJuIGx0aW1lICh0b3RhbC5RdWFkUGFy dCk7CiAgICAgICAgIH0KICAgICB9CiAKQEAgLTQwNzAsMTUgKzQwNTgsMTcgQEAKICAgcmV0 dXJuIHJldF92YWw7CiB9CiAKLXN0YXRpYyBMaXNwX09iamVjdAotbHRpbWUgKGxvbmcgdGlt ZV9zZWMsIGxvbmcgdGltZV91c2VjKQorbHRpbWUgKFVMT05HTE9ORyB0aW1lXzEwMG5zKQog ewotICByZXR1cm4gbGlzdDMgKG1ha2VfbnVtYmVyICgodGltZV9zZWMgPj4gMTYpICYgMHhm ZmZmKSwKKyAgVUxPTkdMT05HIHRpbWVfc2VjID0gdGltZV8xMDBucyAvIDEwMDAwMDAwOwor ICBpbnQgc3Vic2VjID0gdGltZV8xMDBucyAlIDEwMDAwMDAwOworICByZXR1cm4gbGlzdDQg KG1ha2VfbnVtYmVyICh0aW1lX3NlYyA+PiAxNiksCiAJCW1ha2VfbnVtYmVyICh0aW1lX3Nl YyAmIDB4ZmZmZiksCi0JCW1ha2VfbnVtYmVyICh0aW1lX3VzZWMpKTsKKwkJbWFrZV9udW1i ZXIgKHN1YnNlYyAvIDEwKSwKKwkJbWFrZV9udW1iZXIgKHN1YnNlYyAlIDEwICogMTAwMDAw KSk7CiB9CiAKLSNkZWZpbmUgVTY0X1RPX0xJU1BfVElNRSh0aW1lKSBsdGltZSAoKHRpbWUp IC8gMTAwMDAwMEwsICh0aW1lKSAlIDEwMDAwMDBMKQorI2RlZmluZSBVNjRfVE9fTElTUF9U SU1FKHRpbWUpIGx0aW1lICh0aW1lKQogCiBzdGF0aWMgaW50CiBwcm9jZXNzX3RpbWVzIChI QU5ETEUgaF9wcm9jLCBMaXNwX09iamVjdCAqY3RpbWUsIExpc3BfT2JqZWN0ICpldGltZSwK QEAgLTQwOTcsMTEgKzQwODcsOSBAQAogICBHZXRTeXN0ZW1UaW1lQXNGaWxlVGltZSAoJmZ0 X2N1cnJlbnQpOwogCiAgIEZJTEVUSU1FX1RPX1U2NCAodGVtMSwgZnRfa2VybmVsKTsKLSAg dGVtMSAvPSAxMEw7CiAgICpzdGltZSA9IFU2NF9UT19MSVNQX1RJTUUgKHRlbTEpOwogCiAg IEZJTEVUSU1FX1RPX1U2NCAodGVtMiwgZnRfdXNlcik7Ci0gIHRlbTIgLz0gMTBMOwogICAq dXRpbWUgPSBVNjRfVE9fTElTUF9USU1FICh0ZW0yKTsKIAogICB0ZW0zID0gdGVtMSArIHRl bTI7CkBAIC00MTEwLDEzICs0MDk4LDEzIEBACiAgIEZJTEVUSU1FX1RPX1U2NCAodGVtLCBm dF9jcmVhdGlvbik7CiAgIC8qIFByb2Nlc3Mgbm8gNCAoU3lzdGVtKSByZXR1cm5zIHplcm8g Y3JlYXRpb24gdGltZS4gICovCiAgIGlmICh0ZW0pCi0gICAgdGVtID0gKHRlbSAtIHV0Y19i YXNlKSAvIDEwTDsKKyAgICB0ZW0gLT0gdXRjX2Jhc2U7CiAgICpjdGltZSA9IFU2NF9UT19M SVNQX1RJTUUgKHRlbSk7CiAKICAgaWYgKHRlbSkKICAgICB7CiAgICAgICBGSUxFVElNRV9U T19VNjQgKHRlbTMsIGZ0X2N1cnJlbnQpOwotICAgICAgdGVtID0gKHRlbTMgLSB1dGNfYmFz ZSkgLyAxMEwgLSB0ZW07CisgICAgICB0ZW0gPSAodGVtMyAtIHV0Y19iYXNlKSAtIHRlbTsK ICAgICB9CiAgICpldGltZSA9IFU2NF9UT19MSVNQX1RJTUUgKHRlbSk7CiAKQEAgLTYyNzUs NyArNjI2Myw3IEBACiB7CiAgIGludCBuLCBzYywgZXJyOwogICBTRUxFQ1RfVFlQRSBmZHNl dDsKLSAgRU1BQ1NfVElNRSB0aW1lb3V0OworICBzdHJ1Y3QgdGltZXZhbCB0aW1lb3V0Owog ICBzdHJ1Y3QgTGlzcF9Qcm9jZXNzICpwcm9jZXNzID0gKHN0cnVjdCBMaXNwX1Byb2Nlc3Mg KilwOwogICBpbnQgZmQgPSBwcm9jZXNzLT5pbmZkOwogCkBAIC02MjkxLDcgKzYyNzksOCBA QAogICAgICAgaWYgKGVyciA9PSBFV09VTERCTE9DSykKICAgICAgICAgewogICAgICAgICAg IC8qIFNldCBhIHNtYWxsIHRpbWVvdXQuICAqLwotICAgICAgICAgIEVNQUNTX1NFVF9TRUNT X1VTRUNTICh0aW1lb3V0LCAxLCAwKTsKKwkgIHRpbWVvdXQudHZfc2VjID0gMTsKKwkgIHRp bWVvdXQudHZfdXNlYyA9IDA7CiAgICAgICAgICAgRkRfWkVSTyAoJmZkc2V0KTsKICAgICAg ICAgICBGRF9TRVQgKChpbnQpZmQsICZmZHNldCk7CiAKCj09PSBtb2RpZmllZCBmaWxlICdz cmMveGRpc3AuYycKLS0tIHNyYy94ZGlzcC5jCTIwMTItMDUtMDIgMDc6MjA6MjkgKzAwMDAK KysrIHNyYy94ZGlzcC5jCTIwMTItMDUtMDQgMDc6MTI6NTkgKzAwMDAKQEAgLTI4ODg0LDI1 ICsyODg4NCwyMCBAQAogewogI2lmIGRlZmluZWQgKEhBVkVfV0lORE9XX1NZU1RFTSkKICAg RU1BQ1NfVElNRSBkZWxheTsKLSAgaW50IHNlY3MsIHVzZWNzID0gMDsKIAogICBjYW5jZWxf aG91cmdsYXNzICgpOwogCiAgIGlmIChJTlRFR0VSUCAoVmhvdXJnbGFzc19kZWxheSkKICAg ICAgICYmIFhJTlQgKFZob3VyZ2xhc3NfZGVsYXkpID4gMCkKLSAgICBzZWNzID0gWEZBU1RJ TlQgKFZob3VyZ2xhc3NfZGVsYXkpOworICAgIEVNQUNTX1NFVF9TRUNTX05TRUNTIChkZWxh eSwKKwkJCSAgbWluIChYSU5UIChWaG91cmdsYXNzX2RlbGF5KSwgVFlQRV9NQVhJTVVNICh0 aW1lX3QpKSwKKwkJCSAgMCk7CiAgIGVsc2UgaWYgKEZMT0FUUCAoVmhvdXJnbGFzc19kZWxh eSkKIAkgICAmJiBYRkxPQVRfREFUQSAoVmhvdXJnbGFzc19kZWxheSkgPiAwKQotICAgIHsK LSAgICAgIExpc3BfT2JqZWN0IHRlbTsKLSAgICAgIHRlbSA9IEZ0cnVuY2F0ZSAoVmhvdXJn bGFzc19kZWxheSwgUW5pbCk7Ci0gICAgICBzZWNzID0gWEZBU1RJTlQgKHRlbSk7Ci0gICAg ICB1c2VjcyA9IChYRkxPQVRfREFUQSAoVmhvdXJnbGFzc19kZWxheSkgLSBzZWNzKSAqIDEw MDAwMDA7Ci0gICAgfQorICAgIGRlbGF5ID0gRU1BQ1NfVElNRV9GUk9NX0RPVUJMRSAoWEZM T0FUX0RBVEEgKFZob3VyZ2xhc3NfZGVsYXkpKTsKICAgZWxzZQotICAgIHNlY3MgPSBERUZB VUxUX0hPVVJHTEFTU19ERUxBWTsKKyAgICBFTUFDU19TRVRfU0VDU19OU0VDUyAoZGVsYXks IERFRkFVTFRfSE9VUkdMQVNTX0RFTEFZLCAwKTsKIAotICBFTUFDU19TRVRfU0VDU19VU0VD UyAoZGVsYXksIHNlY3MsIHVzZWNzKTsKICAgaG91cmdsYXNzX2F0aW1lciA9IHN0YXJ0X2F0 aW1lciAoQVRJTUVSX1JFTEFUSVZFLCBkZWxheSwKIAkJCQkgICBzaG93X2hvdXJnbGFzcywg TlVMTCk7CiAjZW5kaWYKCj09PSBtb2RpZmllZCBmaWxlICdzcmMveGdzZWxlY3QuYycKLS0t IHNyYy94Z3NlbGVjdC5jCTIwMTItMDEtMTkgMDc6MjE6MjUgKzAwMDAKKysrIHNyYy94Z3Nl bGVjdC5jCTIwMTItMDUtMDQgMDY6NDI6MDMgKzAwMDAKQEAgLTMzLDE0ICszMywxNCBAQAog CiBpbnQKIHhnX3NlbGVjdCAoaW50IG1heF9mZHMsIFNFTEVDVF9UWVBFICpyZmRzLCBTRUxF Q1RfVFlQRSAqd2ZkcywgU0VMRUNUX1RZUEUgKmVmZHMsCi0JICAgRU1BQ1NfVElNRSAqdGlt ZW91dCkKKwkgICBFTUFDU19USU1FICp0aW1lb3V0LCBzaWdzZXRfdCAqc2lnbWFzaykKIHsK ICAgU0VMRUNUX1RZUEUgYWxsX3JmZHMsIGFsbF93ZmRzOwogICBFTUFDU19USU1FIHRtbywg KnRtb3AgPSB0aW1lb3V0OwogCiAgIEdNYWluQ29udGV4dCAqY29udGV4dCA9IGdfbWFpbl9j b250ZXh0X2RlZmF1bHQgKCk7CiAgIGludCBoYXZlX3dmZHMgPSB3ZmRzICE9IE5VTEw7Ci0g IGludCBuX2dmZHMgPSAwLCBvdXJfdG1vID0gMCwgcmV0dmFsID0gMCwgb3VyX2ZkcyA9IDA7 CisgIGludCBuX2dmZHMgPSAwLCByZXR2YWwgPSAwLCBvdXJfZmRzID0gMDsKICAgaW50IGks IG5mZHMsIHRtb19pbl9taWxsaXNlYzsKIAogICBpZiAocmZkcykgbWVtY3B5ICgmYWxsX3Jm ZHMsIHJmZHMsIHNpemVvZiAoYWxsX3JmZHMpKTsKQEAgLTg1LDIwICs4NSwxMiBAQAogICAg IHsKICAgICAgIEVNQUNTX1NFVF9TRUNTX1VTRUNTICh0bW8sIHRtb19pbl9taWxsaXNlYy8x MDAwLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIDEwMDAgKiAodG1vX2luX21pbGxp c2VjICUgMTAwMCkpOwotICAgICAgaWYgKCF0aW1lb3V0KSBvdXJfdG1vID0gMTsKLSAgICAg IGVsc2UKLSAgICAgICAgewotICAgICAgICAgIEVNQUNTX1RJTUUgZGlmZmVyZW5jZTsKLQot ICAgICAgICAgIEVNQUNTX1NVQl9USU1FIChkaWZmZXJlbmNlLCB0bW8sICp0aW1lb3V0KTsK LSAgICAgICAgICBpZiAoRU1BQ1NfVElNRV9ORUdfUCAoZGlmZmVyZW5jZSkpIG91cl90bW8g PSAxOwotICAgICAgICB9Ci0KLSAgICAgIGlmIChvdXJfdG1vKSB0bW9wID0gJnRtbzsKKyAg ICAgIGlmICghdGltZW91dCB8fCBFTUFDU19USU1FX0xUICh0bW8sICp0aW1lb3V0KSkKKwl0 bW9wID0gJnRtbzsKICAgICB9CiAKLSAgbmZkcyA9IHNlbGVjdCAobWF4X2ZkcysxLCAmYWxs X3JmZHMsIGhhdmVfd2ZkcyA/ICZhbGxfd2ZkcyA6IE5VTEwsCi0gICAgICAgICAgICAgICAg IGVmZHMsIHRtb3ApOworICBuZmRzID0gcHNlbGVjdCAobWF4X2ZkcysxLCAmYWxsX3JmZHMs IGhhdmVfd2ZkcyA/ICZhbGxfd2ZkcyA6IE5VTEwsCisJCSAgZWZkcywgdG1vcCwgc2lnbWFz ayk7CiAKICAgaWYgKG5mZHMgPCAwKQogICAgIHJldHZhbCA9IG5mZHM7CkBAIC0xMjcsNyAr MTE5LDcgQEAKICAgICAgICAgfQogICAgIH0KIAotICBpZiAob3VyX2ZkcyA+IDAgfHwgKG5m ZHMgPT0gMCAmJiBvdXJfdG1vKSkKKyAgaWYgKG91cl9mZHMgPiAwIHx8IChuZmRzID09IDAg JiYgdG1vcCA9PSAmdG1vKSkKICAgICB7CiAKICAgICAgIC8qIElmIEd0aysgaXMgaW4gdXNl IGV2ZW50dWFsbHkgZ3RrX21haW5faXRlcmF0aW9uIHdpbGwgYmUgY2FsbGVkLAoKPT09IG1v ZGlmaWVkIGZpbGUgJ3NyYy94Z3NlbGVjdC5oJwotLS0gc3JjL3hnc2VsZWN0LmgJMjAxMi0w MS0xOSAwNzoyMToyNSArMDAwMAorKysgc3JjL3hnc2VsZWN0LmgJMjAxMi0wNS0wNCAwNjo0 MjowMyArMDAwMApAQCAtMjgsOSArMjgsOSBAQAogICAgICAgICAgICAgICAgICAgICAgIFNF TEVDVF9UWVBFICpyZmRzLAogICAgICAgICAgICAgICAgICAgICAgIFNFTEVDVF9UWVBFICp3 ZmRzLAogICAgICAgICAgICAgICAgICAgICAgIFNFTEVDVF9UWVBFICplZmRzLAotICAgICAg ICAgICAgICAgICAgICAgIEVNQUNTX1RJTUUgKnRpbWVvdXQpOworICAgICAgICAgICAgICAg ICAgICAgIEVNQUNTX1RJTUUgKnRpbWVvdXQsCisJCSAgICAgIHNpZ3NldF90ICpzaWdtYXNr KTsKIAogZXh0ZXJuIHZvaWQgeGdzZWxlY3RfaW5pdGlhbGl6ZSAodm9pZCk7CiAKICNlbmRp ZiAvKiBYR1NFTEVDVF9IICovCi0KCj09PSBtb2RpZmllZCBmaWxlICdzcmMveG1lbnUuYycK LS0tIHNyYy94bWVudS5jCTIwMTItMDEtMTkgMDc6MjE6MjUgKzAwMDAKKysrIHNyYy94bWVu dS5jCTIwMTItMDUtMDQgMDY6NDI6MDMgKzAwMDAKQEAgLTM5MSw4ICszOTEsNiBAQAogICAg ICAgICAgKQogICAgIHsKICAgICAgIEVNQUNTX1RJTUUgbmV4dF90aW1lID0gdGltZXJfY2hl Y2sgKCksICpudHA7Ci0gICAgICBsb25nIHNlY3MgPSBFTUFDU19TRUNTIChuZXh0X3RpbWUp OwotICAgICAgbG9uZyB1c2VjcyA9IEVNQUNTX1VTRUNTIChuZXh0X3RpbWUpOwogICAgICAg U0VMRUNUX1RZUEUgcmVhZF9mZHM7CiAgICAgICBzdHJ1Y3QgeF9kaXNwbGF5X2luZm8gKmRw eWluZm87CiAgICAgICBpbnQgbiA9IDA7CkBAIC00MDYsNyArNDA0LDcgQEAKICAgICAgICAg ICBYRmx1c2ggKGRweWluZm8tPmRpc3BsYXkpOwogICAgICAgICB9CiAKLSAgICAgIGlmIChz ZWNzIDwgMCAmJiB1c2VjcyA8IDApCisgICAgICBpZiAoISBFTUFDU19USU1FX1ZBTElEX1Ag KG5leHRfdGltZSkpCiAgICAgICAgIG50cCA9IDA7CiAgICAgICBlbHNlCiAgICAgICAgIG50 cCA9ICZuZXh0X3RpbWU7CkBAIC00MTYsOSArNDE0LDkgQEAKICAgICAgICAgIG92ZXIgYW4g YXJyb3csIGEgdGltZW91dCBzY3JvbGxzIGl0IGEgYml0LiAgVXNlIHhnX3NlbGVjdCBzbyB0 aGF0CiAgICAgICAgICB0aW1lb3V0IGdldHMgdHJpZ2dlcmVkLiAgKi8KIAotICAgICAgeGdf c2VsZWN0IChuICsgMSwgJnJlYWRfZmRzLCAoU0VMRUNUX1RZUEUgKikwLCAoU0VMRUNUX1RZ UEUgKikwLCBudHApOworICAgICAgeGdfc2VsZWN0IChuICsgMSwgJnJlYWRfZmRzLCBOVUxM LCBOVUxMLCBudHApOwogI2Vsc2UKLSAgICAgIHNlbGVjdCAobiArIDEsICZyZWFkX2Zkcywg KFNFTEVDVF9UWVBFICopMCwgKFNFTEVDVF9UWVBFICopMCwgbnRwKTsKKyAgICAgIHBzZWxl Y3QgKG4gKyAxLCAmcmVhZF9mZHMsIE5VTEwsIE5VTEwsIG50cCwgTlVMTCk7CiAjZW5kaWYK ICAgICB9CiB9Cgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL3hzZWxlY3QuYycKLS0tIHNyYy94 c2VsZWN0LmMJMjAxMi0wNC0yNCAwMjo1ODoyNiArMDAwMAorKysgc3JjL3hzZWxlY3QuYwky MDEyLTA1LTA0IDA3OjEyOjU5ICswMDAwCkBAIC0xMTQwLDcgKzExNDAsNiBAQAogc3RhdGlj IHZvaWQKIHdhaXRfZm9yX3Byb3BlcnR5X2NoYW5nZSAoc3RydWN0IHByb3BfbG9jYXRpb24g KmxvY2F0aW9uKQogewotICBpbnQgc2VjcywgdXNlY3M7CiAgIGludCBjb3VudCA9IFNQRUNQ RExfSU5ERVggKCk7CiAKICAgaWYgKHByb3BlcnR5X2NoYW5nZV9yZXBseV9vYmplY3QpCkBA IC0xMTU3LDEwICsxMTU2LDExIEBACiAgICAgIHByb3BlcnR5X2NoYW5nZV9yZXBseSwgYmVj YXVzZSBwcm9wZXJ0eV9jaGFuZ2VfcmVwbHlfb2JqZWN0IHNheXMgc28uICAqLwogICBpZiAo ISBsb2NhdGlvbi0+YXJyaXZlZCkKICAgICB7Ci0gICAgICBzZWNzID0geF9zZWxlY3Rpb25f dGltZW91dCAvIDEwMDA7Ci0gICAgICB1c2VjcyA9ICh4X3NlbGVjdGlvbl90aW1lb3V0ICUg MTAwMCkgKiAxMDAwOwotICAgICAgVFJBQ0UyICgiICBXYWl0aW5nICVkIHNlY3MsICVkIHVz ZWNzIiwgc2VjcywgdXNlY3MpOwotICAgICAgd2FpdF9yZWFkaW5nX3Byb2Nlc3Nfb3V0cHV0 IChzZWNzLCB1c2VjcywgMCwgMCwKKyAgICAgIEVNQUNTX0lOVCB0aW1lb3V0ID0gbWF4ICgw LCB4X3NlbGVjdGlvbl90aW1lb3V0KTsKKyAgICAgIEVNQUNTX0lOVCBzZWNzID0gdGltZW91 dCAvIDEwMDA7CisgICAgICBpbnQgbnNlY3MgPSAodGltZW91dCAlIDEwMDApICogMTAwMDAw MDsKKyAgICAgIFRSQUNFMiAoIiAgV2FpdGluZyAlInBJImQgc2VjcywgJWQgbnNlY3MiLCBz ZWNzLCBuc2Vjcyk7CisgICAgICB3YWl0X3JlYWRpbmdfcHJvY2Vzc19vdXRwdXQgKHNlY3Ms IG5zZWNzLCAwLCAwLAogCQkJCSAgIHByb3BlcnR5X2NoYW5nZV9yZXBseSwgTlVMTCwgMCk7 CiAKICAgICAgIGlmIChOSUxQIChYQ0FSIChwcm9wZXJ0eV9jaGFuZ2VfcmVwbHkpKSkKQEAg LTEyMjksNyArMTIyOSw4IEBACiAgIEF0b20gdHlwZV9hdG9tID0gKENPTlNQICh0YXJnZXRf dHlwZSkKIAkJICAgID8gc3ltYm9sX3RvX3hfYXRvbSAoZHB5aW5mbywgWENBUiAodGFyZ2V0 X3R5cGUpKQogCQkgICAgOiBzeW1ib2xfdG9feF9hdG9tIChkcHlpbmZvLCB0YXJnZXRfdHlw ZSkpOwotICBpbnQgc2VjcywgdXNlY3M7CisgIEVNQUNTX0lOVCB0aW1lb3V0LCBzZWNzOwor ICBpbnQgbnNlY3M7CiAKICAgaWYgKCFGUkFNRV9MSVZFX1AgKGYpKQogICAgIHJldHVybiBR bmlsOwpAQCAtMTI2NSwxMCArMTI2NiwxMSBAQAogICBVTkJMT0NLX0lOUFVUOwogCiAgIC8q IFRoaXMgYWxsb3dzIHF1aXRzLiAgQWxzbywgZG9uJ3Qgd2FpdCBmb3JldmVyLiAgKi8KLSAg c2VjcyA9IHhfc2VsZWN0aW9uX3RpbWVvdXQgLyAxMDAwOwotICB1c2VjcyA9ICh4X3NlbGVj dGlvbl90aW1lb3V0ICUgMTAwMCkgKiAxMDAwOwotICBUUkFDRTEgKCIgIFN0YXJ0IHdhaXRp bmcgJWQgc2VjcyBmb3IgU2VsZWN0aW9uTm90aWZ5Iiwgc2Vjcyk7Ci0gIHdhaXRfcmVhZGlu Z19wcm9jZXNzX291dHB1dCAoc2VjcywgdXNlY3MsIDAsIDAsCisgIHRpbWVvdXQgPSBtYXgg KDAsIHhfc2VsZWN0aW9uX3RpbWVvdXQpOworICBzZWNzID0gdGltZW91dCAvIDEwMDA7Cisg IG5zZWNzID0gKHRpbWVvdXQgJSAxMDAwKSAqIDEwMDAwMDA7CisgIFRSQUNFMSAoIiAgU3Rh cnQgd2FpdGluZyAlInBJImQgc2VjcyBmb3IgU2VsZWN0aW9uTm90aWZ5Iiwgc2Vjcyk7Cisg IHdhaXRfcmVhZGluZ19wcm9jZXNzX291dHB1dCAoc2VjcywgbnNlY3MsIDAsIDAsCiAJCQkg ICAgICAgcmVhZGluZ19zZWxlY3Rpb25fcmVwbHksIE5VTEwsIDApOwogICBUUkFDRTEgKCIg IEdvdCBldmVudCA9ICVkIiwgIU5JTFAgKFhDQVIgKHJlYWRpbmdfc2VsZWN0aW9uX3JlcGx5 KSkpOwogCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL3h0ZXJtLmMnCi0tLSBzcmMveHRlcm0u YwkyMDEyLTA1LTAyIDEwOjE3OjAzICswMDAwCisrKyBzcmMveHRlcm0uYwkyMDEyLTA1LTA0 IDA3OjEyOjU5ICswMDAwCkBAIC04NSwxMCArODUsNiBAQAogI2luY2x1ZGUgPFgxMS9TaGVs bC5oPgogI2VuZGlmCiAKLSNpZmRlZiBIQVZFX1NZU19USU1FX0gKLSNpbmNsdWRlIDxzeXMv dGltZS5oPgotI2VuZGlmCi0KICNpbmNsdWRlIDx1bmlzdGQuaD4KIAogI2lmZGVmIFVTRV9H VEsKQEAgLTI5OTcsNDQgKzI5OTMsNiBAQAogDAogLyogSW52ZXJ0IHRoZSBtaWRkbGUgcXVh cnRlciBvZiB0aGUgZnJhbWUgZm9yIC4xNSBzZWMuICAqLwogCi0vKiBXZSB1c2UgdGhlIHNl bGVjdCBzeXN0ZW0gY2FsbCB0byBkbyB0aGUgd2FpdGluZywgc28gd2UgaGF2ZSB0byBtYWtl Ci0gICBzdXJlIGl0J3MgYXZhaWxhYmxlLiAgSWYgaXQgaXNuJ3QsIHdlIGp1c3Qgd29uJ3Qg ZG8gdmlzdWFsIGJlbGxzLiAgKi8KLQotI2lmIGRlZmluZWQgKEhBVkVfVElNRVZBTCkgJiYg ZGVmaW5lZCAoSEFWRV9TRUxFQ1QpCi0KLQotLyogU3VidHJhY3QgdGhlIGBzdHJ1Y3QgdGlt ZXZhbCcgdmFsdWVzIFggYW5kIFksIHN0b3JpbmcgdGhlIHJlc3VsdCBpbgotICAgKlJFU1VM VC4gIFJldHVybiAxIGlmIHRoZSBkaWZmZXJlbmNlIGlzIG5lZ2F0aXZlLCBvdGhlcndpc2Ug MC4gICovCi0KLXN0YXRpYyBpbnQKLXRpbWV2YWxfc3VidHJhY3QgKHN0cnVjdCB0aW1ldmFs ICpyZXN1bHQsIHN0cnVjdCB0aW1ldmFsIHgsIHN0cnVjdCB0aW1ldmFsIHkpCi17Ci0gIC8q IFBlcmZvcm0gdGhlIGNhcnJ5IGZvciB0aGUgbGF0ZXIgc3VidHJhY3Rpb24gYnkgdXBkYXRp bmcgeS4gIFRoaXMKLSAgICAgaXMgc2FmZXIgYmVjYXVzZSBvbiBzb21lIHN5c3RlbXMgdGhl IHR2X3NlYyBtZW1iZXIgaXMgdW5zaWduZWQuICAqLwotICBpZiAoeC50dl91c2VjIDwgeS50 dl91c2VjKQotICAgIHsKLSAgICAgIGludCBuc2VjID0gKHkudHZfdXNlYyAtIHgudHZfdXNl YykgLyAxMDAwMDAwICsgMTsKLSAgICAgIHkudHZfdXNlYyAtPSAxMDAwMDAwICogbnNlYzsK LSAgICAgIHkudHZfc2VjICs9IG5zZWM7Ci0gICAgfQotCi0gIGlmICh4LnR2X3VzZWMgLSB5 LnR2X3VzZWMgPiAxMDAwMDAwKQotICAgIHsKLSAgICAgIGludCBuc2VjID0gKHkudHZfdXNl YyAtIHgudHZfdXNlYykgLyAxMDAwMDAwOwotICAgICAgeS50dl91c2VjICs9IDEwMDAwMDAg KiBuc2VjOwotICAgICAgeS50dl9zZWMgLT0gbnNlYzsKLSAgICB9Ci0KLSAgLyogQ29tcHV0 ZSB0aGUgdGltZSByZW1haW5pbmcgdG8gd2FpdC4gIHR2X3VzZWMgaXMgY2VydGFpbmx5Ci0g ICAgIHBvc2l0aXZlLiAgKi8KLSAgcmVzdWx0LT50dl9zZWMgPSB4LnR2X3NlYyAtIHkudHZf c2VjOwotICByZXN1bHQtPnR2X3VzZWMgPSB4LnR2X3VzZWMgLSB5LnR2X3VzZWM7Ci0KLSAg LyogUmV0dXJuIGluZGljYXRpb24gb2Ygd2hldGhlciB0aGUgcmVzdWx0IHNob3VsZCBiZSBj b25zaWRlcmVkCi0gICAgIG5lZ2F0aXZlLiAgKi8KLSAgcmV0dXJuIHgudHZfc2VjIDwgeS50 dl9zZWM7Ci19Ci0KIHN0YXRpYyB2b2lkCiBYVGZsYXNoIChzdHJ1Y3QgZnJhbWUgKmYpCiB7 CkBAIC0zMTM1LDM0ICszMDkzLDI5IEBACiAgICAgICB4X2ZsdXNoIChmKTsKIAogICAgICAg ewotCXN0cnVjdCB0aW1ldmFsIHdha2V1cDsKKwlFTUFDU19USU1FIHdha2V1cCwgZGVsYXk7 CiAKIAlFTUFDU19HRVRfVElNRSAod2FrZXVwKTsKLQotCS8qIENvbXB1dGUgdGltZSB0byB3 YWl0IHVudGlsLCBwcm9wYWdhdGluZyBjYXJyeSBmcm9tIHVzZWNzLiAgKi8KLQl3YWtldXAu dHZfdXNlYyArPSAxNTAwMDA7Ci0Jd2FrZXVwLnR2X3NlYyArPSAod2FrZXVwLnR2X3VzZWMg LyAxMDAwMDAwKTsKLQl3YWtldXAudHZfdXNlYyAlPSAxMDAwMDAwOworCUVNQUNTX1NFVF9T RUNTX05TRUNTIChkZWxheSwgMCwgMTUwICogMTAwMCAqIDEwMDApOworCUVNQUNTX0FERF9U SU1FICh3YWtldXAsIHdha2V1cCwgZGVsYXkpOwogCiAJLyogS2VlcCB3YWl0aW5nIHVudGls IHBhc3QgdGhlIHRpbWUgd2FrZXVwIG9yIGFueSBpbnB1dCBnZXRzCiAJICAgYXZhaWxhYmxl LiAgKi8KIAl3aGlsZSAoISBkZXRlY3RfaW5wdXRfcGVuZGluZyAoKSkKIAkgIHsKLQkgICAg c3RydWN0IHRpbWV2YWwgY3VycmVudDsKLQkgICAgc3RydWN0IHRpbWV2YWwgdGltZW91dDsK KwkgICAgRU1BQ1NfVElNRSBjdXJyZW50LCB0aW1lb3V0OwogCiAJICAgIEVNQUNTX0dFVF9U SU1FIChjdXJyZW50KTsKIAotCSAgICAvKiBCcmVhayBpZiByZXN1bHQgd291bGQgYmUgbmVn YXRpdmUuICAqLwotCSAgICBpZiAodGltZXZhbF9zdWJ0cmFjdCAoJmN1cnJlbnQsIHdha2V1 cCwgY3VycmVudCkpCisJICAgIC8qIEJyZWFrIGlmIHJlc3VsdCB3b3VsZCBub3QgYmUgcG9z aXRpdmUuICAqLworCSAgICBpZiAoRU1BQ1NfVElNRV9MRSAod2FrZXVwLCBjdXJyZW50KSkK IAkgICAgICBicmVhazsKIAogCSAgICAvKiBIb3cgbG9uZyBgc2VsZWN0JyBzaG91bGQgd2Fp dC4gICovCi0JICAgIHRpbWVvdXQudHZfc2VjID0gMDsKLQkgICAgdGltZW91dC50dl91c2Vj ID0gMTAwMDA7CisJICAgIEVNQUNTX1NFVF9TRUNTX05TRUNTICh0aW1lb3V0LCAwLCAxMCAq IDEwMDAgKiAxMDAwKTsKIAogCSAgICAvKiBUcnkgdG8gd2FpdCB0aGF0IGxvbmctLWJ1dCB3 ZSBtaWdodCB3YWtlIHVwIHNvb25lci4gICovCi0JICAgIHNlbGVjdCAoMCwgTlVMTCwgTlVM TCwgTlVMTCwgJnRpbWVvdXQpOworCSAgICBwc2VsZWN0ICgwLCBOVUxMLCBOVUxMLCBOVUxM LCAmdGltZW91dCwgTlVMTCk7CiAJICB9CiAgICAgICB9CiAKQEAgLTMyMDMsOCArMzE1Niw2 IEBACiAgIFVOQkxPQ0tfSU5QVVQ7CiB9CiAKLSNlbmRpZiAvKiBkZWZpbmVkIChIQVZFX1RJ TUVWQUwpICYmIGRlZmluZWQgKEhBVkVfU0VMRUNUKSAqLwotCiAKIHN0YXRpYyB2b2lkCiBY VHRvZ2dsZV9pbnZpc2libGVfcG9pbnRlciAoRlJBTUVfUFRSIGYsIGludCBpbnZpc2libGUp CkBAIC0zMjMxLDExICszMTgyLDkgQEAKIHsKICAgaWYgKEZSQU1FX1hfRElTUExBWSAoZikp CiAgICAgewotI2lmIGRlZmluZWQgKEhBVkVfVElNRVZBTCkgJiYgZGVmaW5lZCAoSEFWRV9T RUxFQ1QpCiAgICAgICBpZiAodmlzaWJsZV9iZWxsKQogCVhUZmxhc2ggKGYpOwogICAgICAg ZWxzZQotI2VuZGlmCiAJewogCSAgQkxPQ0tfSU5QVVQ7CiAJICBYQmVsbCAoRlJBTUVfWF9E SVNQTEFZIChmKSwgMCk7CkBAIC04ODAzLDkgKzg3NTIsMTEgQEAKICAgICAgIEZEX1NFVCAo ZmQsICZmZHMpOwogCiAgICAgICBFTUFDU19HRVRfVElNRSAodGltZV9ub3cpOworICAgICAg aWYgKEVNQUNTX1RJTUVfTFQgKHRtb19hdCwgdGltZV9ub3cpKQorCWJyZWFrOworCiAgICAg ICBFTUFDU19TVUJfVElNRSAodG1vLCB0bW9fYXQsIHRpbWVfbm93KTsKLQotICAgICAgaWYg KEVNQUNTX1RJTUVfTkVHX1AgKHRtbykgfHwgc2VsZWN0IChmZCsxLCAmZmRzLCBOVUxMLCBO VUxMLCAmdG1vKSA9PSAwKQorICAgICAgaWYgKHBzZWxlY3QgKGZkICsgMSwgJmZkcywgTlVM TCwgTlVMTCwgJnRtbywgTlVMTCkgPT0gMCkKICAgICAgICAgYnJlYWs7IC8qIFRpbWVvdXQg Ki8KICAgICB9CiAgIHBlbmRpbmdfZXZlbnRfd2FpdC5mID0gMDsK --------------000801010703000000030508 Content-Type: application/x-gzip; name="emacs-ns-gnulib-diff.txt.gz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="emacs-ns-gnulib-diff.txt.gz" H4sICLQ9pE8CA2VtYWNzLW5zLWdudWxpYi1kaWZmLnR4dADsW+lz20aW/7z6K3qs0VgKD5Eg JVFKlJFLPqKUD5XlJFMVZJQm0CQR4RoAtEjT/N/39153gwApyXKyH7a21pVAZOP163f1u7p5 enoqosQPRoHyxSgIlXg6nAah35LT2X6UfFStYNTyJjIeq6dbrVZL3Pf2v5xOt9vqHLc6R6I7 OHEOT/pd0ejg31aj0XhwmtPqHLQ6fdE9Pjk4OOkfmGlnZ6LlNLs90eDn2dmW2Bavgxsloo/i 713xd6cJtIUIRqKYKCY+FzJT/C2XkWqKP6Z5IXwVqkJhRpsQXBWymOYiyMUnlSU0OZ96nsrz 0TRsijiJeTgBjuw2yBXmbLV+fvH+6uLd29OnmsduyxkIp3PSOX76LTD+9OF8q1EFcQikcyg6 RydOrwTBnw8gzFejIA6KIImFHEIUIiIaw0CJ26CYBLHhJcPgAMMxeMJgkvkqIxSjJGOIF5H0 clEEkWrlhYxScZsFYHKSJDdiVxZCxf6eKBIxTX2J8aBg5i9GYp5MhRY98EAKrHNaWqNsijRU MlcCMuOFVngJgQ+JFbn4Ixm2hXhnhdS0yzDGvMiCeCwiGU9lGM5ZgtviPEnnWTCeFGL3fA/S 6zgtPI6a9PG4RYIVLzOlxFUyKm5Jiy+TaQykEFRTXMRee6txD5Ku86WZQgsftKVZMs5kROof 0ZzczDnRcpGxyJQfEAewLBKbkLG/D5nzHpkTHowBvdJqKFQW5SLRFvjq7U/ilYpVJkNxOR2G gQdz9VQMaUosTSP5BNtsOGfb7jnNI9HgJ9m2EK3WRIWpoH+gIQ3lXAuUR0GHULOg0IAfVZaT CYlkWqTYA/Z7EMNAIqnNq5yx1SLL+yizQA6h7fM3l5fv371idodKTHPQBFPJU+WBR8wTMgRj MdDAPvHG/d2L0qfQwF9D81RjgTbeqzTJCuzecU4vvsOH1jiehsHwDH/aSTb+vv0EgFunD7mn PA7SVBX712+TTBXTLG5P1n3UHSDGUR21nL5wnJMuPM7RnY7qnrkPeKtusy8a9IA+W9vBCGYy EuV0GDC8zd/YAYCbclz84x/i+vrqw/Pza+NFrq/Fd4LI7DpscSOx2xPfnQIKJnaOt58/i93y C0TkEI5BBeTNxdt376+v94S7JfQ/TOnMDrrdjoa6+uktlHd9vkcLaKekKiRdX8vCbAKssIvF YvMKSPceqReZjVtwqNBreL9makBfrZuN2Q9q54C0c8C7bf8b8Uycw0l58PbkVH3lhZIdVzGB /9RWjB2MFaaRiuH02FHHSUHG/van16/bWy3IdcMlPdKZ3Tv1Md4M//4n3JnQ7uQv+rNHWoPX aMDM8vstoQT4aiuozfwKCzgHNi+JUkiXHNpoGnvsObUtaC/KFpLfretu50/rWk/9v6pr0BW3 kriFmHC/vmtAX63zjdl/euerKCgK2viEEn9zcrhyZQ0QOMW2/zeBB0zAT7z9KMi9/QIZB3KQ Nv5qvd/1pqwVnEPhdE96nZPuoKLs+6Y8oOFeEzpo8JN0vCNeJ9JHKiuRO0ObsaIMX2bzpgja qt2ksWwak7aNNCgnVzNI21WzFFKTI8jGDUYz18tj1BJiFBX010VirUfcTIVy5gYx5V+8kjsK sPRWy4Uzcg3tJjFblBz32p3j5VbjHhiw2Efp0O52l4QKjKyspns8OGjS85CfA3oed/jZ5afD zx4/+/w8aBIKfOApx0f81BOPOfPu8LPLT4efPX72+XnAz8PmVmtHlMn6QKfsTbZgfn7Z+h+e zs8v7wMWB++Dil1o+/vaDUGYyj3xp/aD9ivdw+YhPAv+HBm7u0LZNE1B1Qx74xZlW84+5kU8 pt3DtogMQoaZkv5c5IrqMjYzWBGBP4Nzi/1g5hJROlEU7piMZQ1gYT8s2eyqOM4nMiXrraCo 4zAAC/OXMTSqGFSWJfX5axgYYMHPzfVJJWuT67MJYEGPzbnYRWsz1+YG8SKIN+ddYNLsIn8R pcV8A0MNQRVyscvfyH4Ufd9jxNx4cI5JtU6vY3sPQMP8ekkMuyu4NO8ebokl7JIs/IzfRvl4 8ebq1RLl8fOEzSigFVoh9S3YtdBWh43FAmCVBgYFHkID642fwqGobKS8Ap6qeJqzzRAuKNxa J1gJfcxX5MNg6Ly6iMjNjVWTMZELg6mFvAGNyymJdIdqjKlZAmt1mcY4GSWU57p+YqGso1qN bHcXhMOss9juLgFDhi99X3gT5d2wvbuhzAvYJyrAOVV47B/ByKr7kUNCF5oVgtUSIES3CtUv 9g5ijhRunAyxVW6aPJyQZG5lXBDKABsRNWSEugTZuvQUuwjS3eDomCrrweDIbEvmIU1Sqqa5 TVRI74b5qI2wCSwN+J0va7xfxFzdhlr0J2Qh3HkiaNISTaVAkZfm1YawWlCGWcLiXywpyMOC 4FxIZWRamhFw0IMVDuDI+4faw2BuKrNcoS4hHHrKYoftMxhN4NUUJypQgSrcGJZqYH7gJEQP 65F8OizfsXmH+T1zf35g7s88F9sGM3nOwp2AK1AzppqRVZNvd7Ep85sAtkYvsWdaSxMoDQUw rB1CoZ9Cw7msfDMg/Y8y9pQ7yYNPSgznogV6RgVhvR+CQ2cFhGRLVmtXKRfYJOlnsnWGd2+g 6HIxAWZ4oMRNewC4Ssk8TgKNDYFyRgFD0IZuO3CVjmFKmUJemMYmchtPQmUNu01Xolxo9BUZ Nr4gwcaX5NeoSa9Ryq5B3GMAur/1ELQtQ2b310j7mbWMuTvcCw18JcVEZRzAbdeWkk1w5mIf ZQWmTpEAuB4+J1P4l6ZQhdc+gc/UaOyeMQh045R9ifV/CLI6j58g5GKcXUmsdLPqNkiVRpRM tbRjNdYNK9plpC7tZ7htB6I0rhIVue+8CMJQI0kz9RH0YNEUHkKwgJjBdsVArFs8rXlJBghG 8TSqg33fpSRXuB+JGNcSxRH7ngnI7Y7hJPS3tTXtvMeZ9Q6ZlnZNeSpiYduNCEimNQ03h+y1 CDy4QbZz69+qPipPF5p8WmIIi+W5tID1e0lELRbRbrfplbidBN6EVKo3kI9xDbduJ3Ymv9XA hASxGIHSfKc5MuaGPmIHRyPd05bCzq74ZDNUD4+eLDz41d/df//7zanLqAi+HD4zg5WhxebQ sjpVLzObzSCDxV0LmKRlBbjdxcsF1R9M1SqUsA85dUtRsDAgf4laMZ1QaIdo357/8Oz9lc5a O4Pj5kGH8lbk5E7fZK7cBDNtZ3MMAW2zqprcS6ZjCKYMIHBobSpKpzlvp4nkDu8W+64p9VJk PBdDBMIcJj5h4MppgRRcUnFO9AQh3ldPsBPDENkMoQjYYjNFm46zAHgWtotdN95rgtAwTG71 hkyaAkmQAvq3SJHGSUJl+o6YFEV6sr9/e3vbjotxOw73U2z0LJJBuI+BVurDN8z2qdBp/TgN 5/vYYocH/fakiEKav0v8kjcmEky8B6faw1DIh2Qgb+O3ZEFVBLUJUrIugvqg/kV4pjkVFokV Cr2pCIWlWp40iUjemLMrfYDyUYYBmMsTwkSrIH+6pcU4FdoDo/TCyttjp1UVOd5utRZVK+1U rNE9dfUcBL8zMrUz/bXEoBGbcHxm5525p2flPIyT8Z2eadhy6pJDKVH3IYFtxH7I7hSlE1sL N1Klj3wMukURNoKDJKeZplkivQlYDhCFzAxKiAkTl02aSW8C4/YoZkLvkzkUm6lR2y9mYld7 jomsuAkgBW0R1WyskT1DUU5K44MvPmSRkfykj62oLwSdZYrtHB9vNOEEGgXwKYRHH6Hp4u6D KUeR0LIZgPpw6sNyOLStqstXl6/JZskQg5zKAEI0ypKI38ppMUmypvhBBTeJeDdUqHXUjdbi Djyn9X2angqFbPHbjn1vRskX6Dc9+4YqlyyBo1b/mSqSsOHeWpxei93gD/PL3L+aDvNiu7vt bPe0GaxevdeLbONtd3vbcV+8fW4TN4zZ5IrqM5deu3ZklWIC0NmxH4H0PZ8uPKOY/TJYlG/4 XXVBXsu+LdM4nX7qr+4MZILkWienhqSHOAQsNuULk3hsWKtRAahRsMD/yHi0OWstyE1Jwjdq 0+PNvq4H2ou8QLlDtG3bnFdT3OXMijoW+jSGuhU5H7eWdeO36wkhHbcGURrOV/Lifzs6tyDX CsIUJYphSN06sjZkMQV2jGh9jzjtj6IbHyUOtzcrel/sLhdISGVY0owBmzhX4fbW4fYMHBed 1BFRf8kfk5ckPOvumOPPV/hjdsaE6K/748Yd/hjkaC5Et93rtDti15Nt6qHtUTzLEn/qUTiD OwqiwJyIEiK2FtAK9uhYdU4LEEZQy6f2DQL6s3bHfQANAJRsZm3be5wFKvdkqkC1zcp1Q8Uf 6ReabV2U6PpvB1G2woD8CP3RUfC3Ip8k09CnRcb8xvbSBdxjmIz/aee/obyAbi1o78t1TiQL bDedIbN/MLCkXbOFSVnrhFUIMcM6YkAGuSLONZaKfpsrBevzPRgOxZK8bcpbsw3XV+IuhxYQ tZ04a6Vqh87lkb0AOohgkfR1YWKByKcpHXHnop1SndD+I9VPNdZUtDFL8DTbSjzuNnsOJWWD XrPXNy0nruut/hmcU6cm+fvbwIf73o24OTxUusWwD20XuuREqgTfP1H6yMEPioKSBmHcuF/S XfXw5iWPM/7FtrMkfzFMZh2qWCb4sKgVtiBluTFXr7rY7tnJzn2Te1qyZrKl6avW3pz+dctr j6lZ2LG7mFNA2k+Xz18Kfaliz2q1rlTS5K6MEEQsCjaxfA8u4bUiL1FkJqWGs+Dmadta5+MW 80fNypJ2scYjF2tqrFwZ68xKF880OYfTTGLFGRMqZUQJ3mssxCaVs/k0Iq8E+6JNyjeKcqWR 4xELWe6zoIhk2tbC5JqElTFWs+LUZdM0r1aFVRn9E5SnILkLOyc2yQ8pVJbdShJQBSEZbIJs AKm7odbgfrx8dQ/YOmFQ832Aa6Ak7xK08SVcjUfjeFhYjXvpqQms8QDhdaE1HmSyJjix+Y9a pXxz6VSsOcn7oG1j9ZxjCSX8CO6+cXt8zgM/SAk3kC137tABRQ/b7LfGt4AgrY/4MjCYsg6h Bqzzyy/P15Q1HgNKst5ca2Olh+hsPGaVjUXWlniQusYXGY7X8NewP0RT4zFquwvtQ4Q0vqyc CkL70QuTXJFdGxdleyw6MjvOoDlAYHYcB391XLapisUQRJHyA+SntNyMLXZrg+5g5AfIvm/9 jvi+kxYmgFeC7d3QjoY2gbwaX2077yHstYh694S1BepBtCYo3W7UQcucWn/X7VXUD7+wEvhW TcNGmP1+s0u9J6c3aB6X0tyhW7gTqnfcpj0C07kfHaNSAUOxiLoEUNOqpVsERahszKkeYpkh KuaS0ajSsBDunW0OA08pP9L8qVrlneaNsSSqlCgBqx0h1Iu6KphJTaq5du21xp3LkaJCIg+K hX3Nad6iCrwUs/knbb/Lpc4NtUSPjpsO2+eR03Sciki5Bw2FDZFwCPELNQDIsY75TJsboIQ7 iPVFJ3uz2MjWIqGzTtsPpNMG0kamqm11SeeTgkpNc5xZoBRROVRY6lapiA4sTbcBJQzJ3PZ5 ooQuaSeeuWZHh/8xpUAh0g4k4FMPWrTXb0pFmNYkMbCo5JDqvteibEjU31ZTk3uw98vp1e7F jnjOXPi1CtIIivTVtpCLu01Olxt3Emv9512mVQGu+Lt1C6tAbdXdXZnnPgvzewthw4ZtB5ft oa9hhwynsk0eYoZALTOGMM0NZ65cot1H0p1qXy3deEg6RemjrIJX78Q4Qa5bbsLoJh3Hi3X5 L7edxSYbtEHL2s1aFHkW205f7NybClPVK+MJ0vgJnSLvU/cyRd49zLhcgRCGSXITyewmX4VD WiKahwyD+maEPaPo/IxrVzZautaw5KR8cVqCriPISgQjiTl6pkGzQrA8LUFLorfKrtN7Jelc zcPWDrGbqZ0BMY5VIfhokA+M8ukQr7LAdE8rAmzX96HMCgKcb3OPcXu7t73dXyx37MEOvc/X jypqGOD7YDzpJhLjOnsHh80uXQ3s9XtN57B0ncTJa3jFWDhitzNTco9YoNJKxrnuQoErKT6v WtHU/KW6nxpsKyRXhcw/qRvxi7zN5jcBgrD3iW5fiR9ROlG3S3T6J53jE6cvGp1up1MKYGdl ELNZ2dyhNhHF5OqZy4ooMWihCKt0x6nDVKKBkIJMPBnCbp8I9Z9pgDgHwcBlS7q4n2gxnlk/ rGIvoSNO8PWellwhipPbprgQ4ymyddDxNAz1abQ9rqbahm43wWqZRGpg3sp52/oqmPi75+/+ HDeNv87Nh6SCJqKkA4FJX1opkkSEQYGUQpgL/0L8SKzpkleJZ1fnFxeV5fIVJtOxs0GUcxFU 11lhPFVe4X+VTm1kLIKbs/xrGkkVz2oShW8Zaznp8KidQlVCZi+Q01wd3U1jOmerSN90qDSJ fL8FfF4ldBlNF/bTtCSWt9Fi4WqPQUtBQHQjrhJ7CIR6wHeAlAn2xqmT0KecZUyoyITuU7rw IWRE9g7NemLOPrYhKkenv552V+v8duoweeXA5nGsPY3VcFwpbDD56+K3ncr7DQ5/Xer3v9Xd PR1t20sfCx65vKRwxB+fLz7X0pHLS/d5ed0mT027Vbunoz7dY8JfZ3UJrRbMVx/07GV5SgN/ ZWVHRNjPeI6LyWmndjZSpfezJkBfaNlEZCPqOj4buy9Gq4taegl9tmV+RKGdR2VBfeyLNcqG VCzHY7uD+TK2PiU+47R8MUqS5ZNa1C+QwFVj/d2MMdjnVS97uXVPOSO+E93+qollrqFgK91w oJJxnPC3rVpZ45CKjui64NFhWdXo+Ek6JuW0djbH2pWxFDTondBi+er/lqbrrP/Tl3SItRwp QBF45f0MFpLLo0ASU4RSM0+ldLnVS2KfT4s4o4aXQpFVAEw3opG6B56+XvFR8j0a9gMm3Ohf xoym8ep3MG3D8cABp+B4MKAYqu8QEFqeQ1mKrs7ggXw60PinvWCBrUMXlFxA0p4YTSm9L++b acYKGQael2SZrjGISX1qUWV+Ya89ge7yBIMQ5fCRVUDqQNWlZmy7hs2lHxHx/Orw6QY2cxJQ lbWxP74JyRiC0yojZtAAn9ammoNBzcIG0qWZ6o/itWl6HEY9WVtKa6c/6LA99o9XPy+k/Jau YY6QfXsT2hd841KX7Tpt1Yd7JAjmkT4IOnkjk+CNRKU0R0pB15LMWQgHp2/oVP8bwb8eo6pw nqJqNz9ELMTvradsbb9fP6UodUYu2BjS0aHDN22P2NuZrUM7hLasLs+qzRaX6RC7C7pOp6wb qXf1eaow9+2Wezv2huIGT26FqdMaR2dyOMzYlJ+cJxFCUlv82H4irEOj/WbpB91Mf3nd9H8H /Tm2Lydm80CFvj5ItpsYAf8nypP4AsBZIbka59/CzGSUhpa1QW/QdDrgbXDgNPu297XUi9CV 5yCmJGMUFYuXbz68ffbmRfPy/bvzF1dXL563Prz414clC8yAZfK2BHv/7BcNwHeTL3RCj0yF ckoDQ79rhE/kI+/YHOiymzsL+MyEMeMDn3EaZ2d+tVfeG6rkSf5/s/fn/W3cSOI4/PfXn+dF dOSZUDQPkdQtxRnTEmVzR9eKVOyMk1+7RbakXpNsLpu0pHH83p86ADT6JEgpmcyOszuWhAYK V6FQqBMnT8pVFFawQRFZUQD7N3lAX+zZVDeUhj+Fywf08QX+J6wclbGAmjtd8r76Ew5T+RdU 0KMdjFZfqwI1njdkJUG4IiBDEZPUykY+RQdnxVVihCo4XOsIthSWvcwmNwFsN9rVjWDWuHLW lXstHlIBOz6GNzW925zPvke6d8A18pASzBN6IrlDhwj3A1m640dvyncGGtkNXWfEqnjCK94i Qq2yjg6o38cK/pcrZ/KVH1kOjccVBu3eKJjimxLejWTqjpCkVaBlvZ6JPj0UN1neEBVmaB9+ 5fYc0qBfW2PXH6OLu0N2mYJzQzAv6PXxQrDRMPkHwAUUkMm3CAJgI0HENWf0ADMjDKK6Q5im Qyb7dy4cyWhl8eiF/tzrqezB93Ux3MStiHcFmQG4A9RmA4eq+Hk2j2WLDeBOrpR0DcVp4iyg 79AnLzTxj2EnrvEvhCIS+6AkFSuhXMdj+HN658dQOVYfKuQjMtTJQmTxyQSRNbYf6BqJ6i3+ C7VRwi6XfLf4AoarUSqSbgZwCwXlr+SfALsy8G/QldNCUx4gcGN4mCHCwX1E6xctKiMNQUEm 0NIpbsqXr1XBw7yCZwcUbG1YtJbIMlCNl7+8YuCXwhdeiVr/d+aTCfFEWE5eMqmD5/OEjDim D2OXrFInZcQkhPGL28OHoUJlPJ0HJyyPZUeNvk9KMkJXhswsneTAEYr0ltDPPpzcW57wF+vV V+tV+O75An9N9L8c4s7FJOLvTYIxZyZG00A4uTPJmQbviBJ/ofhq6I98wiHmrHkAgEsW7Vq9 sf71q2o2MW+2+ZWMxeJCtIRUrBSvw7xauMovf/kiKmnNuNJEq4SD1CSELHMO/WfIrYbtiqxf vtBy/fJVEiDm3OGJ7+Faclu6MLki7LqUVKBPLQrsWBDA9/4uO9Cs1xp1wdIgFRlNgeG4GfhX zuCXvgeXBBplrLvDr8D/kXJJeCZd+eRHSVXQ7qK6uQlXM7nu9T6NEFl89L4coLCOrXwQGarW 6sdJAS95PNZSgiMERB/dApkqkLkV4RtQYVEFKWy1CPuQsBRBa/ZKdRt7h5cfGWAF13yv8Ld6 Fb7hETZsGnWP00GQXw5DYRcr+OUlwaL4Gbxc7BbyjL1byMXipfyU5nuxWd2hdeuM+fagmZZo RXifNjZq5KS2sbFZD1lP4fo2Gw4fcKy/3MzgfnCBwFLLzCrIAQywh/waDKSUUiXE71QIA/d/ U8uH3mgWpH4BYj1yP4mZAibSTLc2smdKRDZzCvQ1ew3oM03xymEbtESVSf4M0VhmkA4cEbzv 3kxcN1TcbWywzAA2T5MZJFpqVmAH8myz+Q2aJ2qv8rQR4yMmFSwaOY8ehumN4HXopzfDx3v6 B3Q7S/9AYxYz3hEzbuxkzxjftOkfRp9Ty6WcNPFBqeGTX5AwwpU2mwzSW2IYHfc6te2nq356 ufuQjuBwTfH0Nxu7PP3tbdSBCws/Muok+/cpOWuSLFZQbyFDll5LQ2esUXC8Dlm2zHBIUkVx DPBV95tUrxKysORaYy0DtOi6c4HS8ieG+jW0D/zy5Tfna8jRaTyCLA8Fnl+//Hal1dU4CCoP MfjUH1WkK/SALMqCsMdm80uz+VUcju3aJtkJbGxvytNB/t/VarVM6gXgxN+c7YX+9poSnc2q lTdkKeW7+iiEHxVpeape6sKCmtyW6G7VPVp7JAeEmw4W+spVUcMCbwgUwBm5/iygwFcwM9En wXkZwnymBJiyhBwP4J69dVWRWgwOFbWxvYOiklDBTz4AFeEIGzo8iEGuksg0sIQHGerVKUYT 4hYGcfJngVLQA+PtDILivsAZwDXhYSh83/AtPar0vaDnTNgcFyjBEJm0BwmD3XIQ/26gW2tV GnQ4lvRaK4r31RW+lMg3bgyvCRRGHIWihz2hn5ZgLesVrNI1BmWBfyu4nO5nd6J9/swHhf2s k98P3aA38cbIM4lrc3tjEw16NrZ3NzTh2F+tVfKr5v0K/TJ+IW62KO2yh+G6aP7J0gZF/Cm8 9bS9V06y9A/yHCjctSQHxFMgRSV5p01R5DFSce3Q84WCqcETxv/Ebz9sik8jbPIFqYTQ1H5B s4+vX6b+2Ot9pQlv7mzslusbVmlzZ3dbCmvVmXxHKjxnQGYYPZiWA0+0B6Ym/BhnRzIL5bO0 Crp7qsMXFO+50+vN4ATADsCerqJHlr7P4aMczVTHExeYKn6+Objnf7Xi6AVcXSm93LLe+ne4 zWU2DtKH6bG7PI0fwOOoGcxqpkupcJJk39JimUUK6CJKTPaVS26ifdSpCV/RSdRVlCZPmgye 4J3rTfoD3EkfTeDJZ7KMLyP0kxw8CCBXQW82kXKXmJMq03BkedmXFakS0xPCrIo8Us+krlhE xsAgMSSVEWIK9q3HRVPsshdM2Zng08i/GylHUetHBkPEomopcABHWzfSQZJYCO8qPu7hDgfs c8uAYjOKuQCS9T8SA3WUyL0iii50Qe0xODjoEiL8DM95JU4kwk8lfVmy1mOIIWKUD2tsdRhE uES8OuXYojDelEW8kZ5/M0IWnnbVg2NL1lQl+QITXhqIXdezAe+phI/Q6yxdxXO71djGwCKl rfXGpiJUf+WoCTBGhcBwQFBRApvONDgIrbNIaMcsmOb3fCtvOOlOzBSblLFjkpWiXAlPJszP gSutKFE+7BMmK9mXAWyc7kwW3Xh2LGJVm3aHmvg1z68uvZz1y1koRZk9+Ywvsiv1ghaGSKEL 8svaeCrB0e/6B9qF7e0t2oXtnXq4C0IfR1uFbrjW/4+E7vfANJatV2P+SXwaOlopCQqGEgsq UIQejywJwqvvF6z/vsxuHs/YvIEM6kJnD2lVJh/ZZGwSA0f+HmSCgVIsVBL9NQJlIx0KXjDw dTPxVYLhVdjeRBMZWIbGRnmjrsXVwMGT1ww/jgPX/fJVTOnD83qZ//tVilxitTv5tUXl5GcZ cQC3F646+A6/hUVi6FCME4p8Qt5eqq/T2nDcUvryV23M1P3zRvn5evn5Rvn5Zvn51q9fYvIZ XaXDHDId+zcoCZ7cBHREMM7AgE/G2nTieAM8otxEveFiw89wmZHyhsRcQzFG9JNUKP1VjU0I a8MFiXe1Ee0qtnaaU432IdaNFZ0TL2+8n82voYPp/MlX1IjqL6MzZejhCMKatZdz1qQStaF+ aSEBSC6zQg8rsczxzkMMaEcOlKVOLB+3VUAOmFiRYt4g7+LejwcevLWBoqM7HbKCDIeMmpi4 XHs3cNFT2ArphCiFpBgST1BRMZ1UHMH5WbpbH41NEQwaTXwkks/NCJLWaXVxdBVnNvUxCm2v Ii6DCtkChMHTLGGKoazKLoVoOOweGAO8VuhG+d8Zvl7wWfnJneqmVMRjzvAlrPezR5JnM1AR i8NczKtn2AHLoTOPjo9sDKq1FrFRR+d215mIkUSs8hJDshREdKuN2rqjQktay3nTatJZoA5M Cm5sJfQElk7pKgoG46l80DA3ryCqpW1mLGv6/MTESjkTi4894YeQPGI/ykO4zFz2o1hQ1ZxJ FtjsmKcHR1mCDhDPA92PhqwgkGsMty6xZfgFG1r8NK/q/jXUfpUdaYsLA9I9cNJmB7/cf3le 5438+uVrxLcmOkEciuLUWQ7Q88cPIcOgLSmxBju1HQrTvr2DHgi10AZi3L9+JkzgU0wdY94Z pTkuGJKX5/JAxWWgByk5y1O8H2ivaaplnAaqZovt+ivx6wJZbths1ZuQj7gen0yMyLC2fDEx FpHiTOASE2/2490oi+gQOMZVeh8OHooAErWa4sE/9PoYMMMPw9rr6Ksb5Gm+CcpimB3uRTCY AIWK6fb6knbMNedHNGPXhNCWP9WYX1ZUpqFiw8JpkjaVYtmR7LpHNuE4UcEQ0StD8EQKhlpF 1EYLZ3bhbg4vc2kLINHHTR11KeL+Ib8J349SzPlDNe36cIujuQgb8cB7Dw0UVE/KVT3NxUAC IfwJfRkibucSknKwknv5C6zHZ/ezFFCS1ZAyQ8TA3F/WXpMayvpQs+D/fhWCwu2djXq5sQsn cbfeKG80wpN4PfCd6S/v8d0IAyMiIO9+wZtQqJrQfkaxK4JFgZYTMqEpypAKyIUoTyOq6U11 cw1/NgGgeCOuHDGvUq82VqoqNAgQ/SijpZXm8yuWpchZMJoCMftrmkteFESWF4ynzd5Bx5Mb SV4lQ8Q3jFiGa+8aXrm4DGW60jE0RXIZlwMk1nIFMP2keXrZPEYrqOiC6Td8yezyVGblpEXU omjCqwvVOTHuVa0lr5S2pPyWXGPtkLWK8mDCqqKlvWel8LaimwOTGcBsdEsqVpKl8x91VmEj 6kRYP6DWRF0FtVBbxZIiPowoE5y4ZNVKniRM/NnqMJBkIrRC4lg/g4GEpZyLHQpkJiK1oQZG wGA/w3BIqJYh0TjK5MRWBhIacTl42KXolmQh1443IYktEDZ9bqjvcTwSzajx4sFU80T5zQBe 9hzhZEJGWmUVW2MqFObyggjZXOcGwNJN5011YMR54YqSca8rbLWkAYAImecpj7VMZjJ8sxPn Bxj08WPsmBUKRigmzkzUalxDEzPEEBghoTwKMQjRBKAnQIzSEyGGBCSM3JZDDDUaDT8WRIzI hhlz7H+1DkhCJShf+OylZXDSKKPuJiMfCCTm4jp4rX5JQyr56lbIJd0B2N5ejjcuwFhguD5q RRxOsaK4Mn67bxQxc1AIJpXiY8XNoiZZdwN0aPZIraMFNYy+ocjllhIF7eNGi3QvOmNYDnV2 wjlIVxmYrCbgSboEJ1zMJMuDvn76+hDzCrNiyGHHoTOcDbdeqOcrcpQ2Uq/QRJVu2lYYOJ5N xn7gyojcIahEHCTyFQjG6OmAChVfHQBlNCl649dDCIksyfjixq3SOK9qtfrLZzRTsoLp7Pqa A0+EAxIM1/YmyYZ3N3c1VaKlpEZZcWdiDIz2Gou45SN2RuvyPa755H/VXAU17Pj4YfiA8/+1 YH32HDhrHNeOz77I2INC/gk8NlCsU5oPg7UlCOXKHcDrNBOWnAmiFx0FBEJ4lcaTRXAEDXoB kZ3BnfMQSJtdUmAQ4+Dwa2BPLP4Oh/3f3t3aLq/ry69B1OdDDvHrhXCEkReourmw2i9Tz1UL P74hJlOFmpM+UJJJkrzSqM+uQWGQTraTP+MxOEJgL8gCvd+naGQrzfHprc1ZwVand17PLVZl FLUzpD4isGBI6VfEVQwX8bXvF9C3YkXlQ/N90oW6Hru5/dWiqIP8yoKnjYrfSQLFL+VyGVqU URl9BC1P+KpWAV9FlDmAsgI3hRWttsKhMclemQOSk2XCNQcMYq26P3BD2sBzek1a0VuyRcFG cBPRbQYohe5jTuDBnCk/Cwk6J3FWhyL9kvW0iAi2AtNawSt+IB6GUrsKhzagFC/i+AnDd0Ip 4g/wjf5X4blJzh7W6wcMaR6axV958DKdPFjbwZjxX1jkfKJAfeRIioaJCAa180TTiW0gAY4m VdVMzCXR59gcQKB4Aqtu9aZKbg3Eayi71D4ZzOIV8tYfu9czvDgU+4IaTwCLTwlsNkZi6mFw SLHYRzK8A3Z4BWvbw5EFmF7hjvxdH8ZuIFx4eRiYRQ6APnDwPaVjklZFsE+zCQXuJPteEsv1 XcyggBElXN2XInblKGctIVlX+htFLKF/Mq+ExY4oIDLJaZSwWCrUdhRIhLTiRtJLYESM49/i vA31BSxDODqOKoMiCRF+GIb5N3WvLswcMylXxETGlyuxRVJJxNXv8qWKZJd0vloYR1JLqcvy 4wdJZoFeo2883pr3ZMUmqSBFKC2wehgNJqaSoBNvE6HnLDfrc3h9PoqUS4R3Py7ZFUba6EhN zhCAgMQOq6ge0PM5ec/NBg7wvhzdvl5bpzj9jfq6yp8RSGNXGUo7QI/wGy13AhvwBtWiUM4F szGg5v/Asn9BRa5SpmN6wVrtFyBqcP8A7+1bL2usr/2r9UqWBtMHTh+CLwI47HCohO0dMHni 6sDFYXP5ea3aiVZs1R1pF4nUrPyXLYzPW6+LhdmivCI7qP/fUXp/KfgklsVBM+sykx4S0A4j CSSVOUwZqdJUZP5BztT/jKoQh4M4i2Au+ATAfQ/GA28qLw8aMdsn4F8YiWWqq7RGn/1PSDgC QjROtYOAZFMLLsCpDOoQd/O89l9NSXv+9a8Yqjt1FRqbjB7rW6HeXRpmXVM80ensBnMFYp6g NXccXGNCmKowxlahCFWQVZT+YS0iOXCqPJUmRDmnRD4H4XfJmWFUS7c/8rFeTNwUiXaG3/VI Z3p0MzlQlkFglpuyCAQpY2BLoaaQ6gEabBM6rO/shn7gSuLE4dHwEsXbIHAH1/CSFEHxp1Uh /9NkibwqVICBQlTYTV6BZHYH+SgG/JbB9l+J+IDSoMSx0MxC6GBUlAK8sWPB4UsZA4gaakBv BA9ZdhF38MoFkB5ROgD/GWgyBVf+HLpHhzpt7zrsIGaWN3T70mqKNXdsVMdRLPhORraKeYJw cUUEVY8oG4kcZJBd3YCGX9YspMIHB54sDCmBrw6glwNlFERLwTu7g8atpZ0NtHZdD21LNPO8 Y3yQhOuIk2JbJpRdUGx3Eb4JjwXmgRmhi5THwSiBaIw+exN/RM730iLzFdq6OzJ+MF6iQDzJ n+5MBFMh1dotGQ151wyIjPacqQhBPQay8tkdJNKy3KrgFJpBXjhKtgUa+VzEhGShIXITZfxH GjF0PDIYmOgtf3hUJ3UV6FkycSOhsIDupRwJ9r3i3pTfUtyasqwjFYa6oHhc5PxRYXYQT4DD 8mVcpInDJuvcO3UqAyClH1xxqOVix9DqLHwW0cirmsqOUHO9Rh7kOxuN9dBYHUkFk0h4FlXh 169/jWBsJXb8LHnisIpS5mjnC9Zl1HcGGIKUrfUTB5ipgwQTA+GkA8C+shcG5iDyOlASKf2t xnZ3u9s7dbKX3d0NEyQ8oztPph4rh+GyOL9EIjb9PtIA4U4YCa/FGQ5khjDaamSgMUR4WnB+ NGx8xUirQHz58mo6faX+BD4cIWAelrRIK2iYxs7drIfCITK5QB0zYT1yN13aDh+eOGFGFqIx 5GhHhIefeeQOh7j/S3wE5OaLLAosLk1dPp+gM1iiX0KjagIZPAyv/AE/H1alcTBBF28f1TFH raDOsaxHY8HXG7EddJsGpJr7a1gBl2Cl1thqFTkwP3vNivuEbrNw+OzsiGwVCR4QDoufHc2f MdzCMiyRELmR2+9I2cmI7gGeFnpbhN/vuz0PSU8YPwgXcWW7vtmzVnsAN7C2MZcFvP1YFn7t DPc1f2cL/sYXMWnH93kb4WHLgeBXNg+KwruYXs8IYEW+DRAIy7duYaWovWaMzcF/RUa6K3QJ GTp9mVECkCMTA9ETf0jb80rOurFbQwMAIj0JBAUG2kMkxaQR0cUHrineA2JtfINEQBLSsYVP C34nAdEmIjsbl7Gf+xAQLCysYLBHBvOvKKhLSn/PKvj9l4lzF7Zk9k8/3r+IWFwJ1KcIKrGY Rlntyf9BOKIDx1vQZJ/IwlN6CcEPE0B6fERLaKeFMyz2R4fhmiIsSr8eioMOw+LkHvq8vois HQkCIitHpyGrR4L8Sxvl3R0R0HN3d0elytMwhiGsha4OmFoeg8PA/6N0Y8Dnnw00SP4lw+4P 2YyfFeb8/roNUYFCBWBIC7RhR4So0L0fGjtL/IYj9lzElguTmHyPCMD3uzZWZzj+8v1Xvd7z 1Ho4jC/PIxX/mloRHqZ453z5K8kBCfXUHEIUxBLE4Vc968ijID1lXoSPtKsFgTtlxfZN7z3s lTwW4flAxt/IhaNcG4Don3G/gHH8xG9zziOKOiCmMq/uvlAkli8kPfz6lVPy3bkEpi+C86cM hBoptZk0ihmSt094DcLJTEsVO/Cu1tB3oOdUPZWxPVYoEsRuVRp1q76F2YBrejbglNq52X8x R6dwnFp7YZ24Q7zlGAART+EKQJn7KDxAIlsv5VIN06bWKypH6tac/L8pqX/nAMvJhEo8mGlW 4H3zrMC0TBv4FKF/BbOXkfz0mppO8EKbOt4gkIP5GXoThjn0lEIHH8CFPknwxw/ZaVVpvVVq VVKLhnl5xOz2RerUskjeJeTKkZUiOPG8sWVrE3fHGX0CKmB1ptAAgByR+cURUCJ4Rbz2ge+B 6idNq9ao12uV+nqtXiZol50mHIoXa7SLxkMEVoMa/KDlPbkZzUhWMWAgwdqPxLsDaItzUpNT zUwFYhHMkd08Pj47aNpviSujmBSvvQCDKgXBDNNoqAq0B1KxLTg4IX1mVFcZrXlG+WcTGMHk 2aRCdTZrDau2s9fY3GvspJ5NVXvps+lPAvUiHFJZCTE8/YgunYa7/gen4SZAS6YdDtNwW1cP mVvYc5CZQ12UM632wl2MlocbuUVbs763sRHbyGSDBfaSYsEyGsMcEEgou5xh0i/lD0EhDyj+ jVhxyvXDOXKs637Wfou81esh/eQU07uLk+Q5wJ6KJJtiiNHG3mZs7O2iG3v7Z9vYbwdZ7Hff J28JfatVkdjlRqWxCZPfq23uYargyC5H6i6wwUc4AE5dTHmqK4dnnbV33qiPvoXBQzCFl3Tm oaxV1GHaqFD6eJMzmb2teQD/fTfb6fejOz31KS0WPHd0ih0p/n/13e1aBfjFWt2qwY7j/8d3 PFI/f9dr5RrtOvF7Jdj2A3+EcmYVFN63FCwUES1/5Ljxk+xC6al2oSTSdWcNfd9iwwlLBoZd l50IiGXL5+DBq/Ake0Blh09BBoqU+xSd4FXbrBUIJ9qXcuVbf+xGDROvSMh0PRvwvYXmTO/a 3bdnl12refqz9a55cdE87f68r4gu6k2FYHc8QHoCMwP+d4ocOIE4aV0cvIU2zdft43b3Z7QH OWp3T1udjnV0dmE1rfPmRbd9cHncvLDOLy/OzzottHJ0XSlGz1vn5OuA577060BCJigZrDc/ XCXvPY/vZoaeUF7aZV49WOfObGC1bm7wBKjv8kiQ/I6PBYvPOq0DjgHPGSrCk2JZF4hD8BGW na3DWUiHPkkj8hd5YE0LmkxdkyEJRxtnOeIUIysOuBc10ufS8ueHng8wbqq3P0aKV1T3tyvR D3AvYwqBQHyIjfZZSSMY1qqYYeD2is9KX3Ds7mg2tL5YgCjH7bNT6yW5qFsvIj++7mNN0Xbo jeyJK5K1UMSGl1b35/OWfdI+bZ9cnlir2J09LUYaOffxRiz3X13lts33kbbQsxhrUQ2tZK3K XytWvVgUdhlrsgJ3GJu/Ndln9ISX2+p3mEsvPvofaDUEtC/S2GNSnX624UPu5FTFEdesiVKK 6UwSUtErfv4huQjze40tS2qv2qLE+4+BZyhWAI2gqQIm9uh64ujgXvCwK1YQdssGzdgeK6ti KCm9xH9/iJbLYrVFeou/vtRKZTmuF8GpFUPPuS+6E11Qqezrf3Pfcfi0BimrGqSu4CgIFw5/ EacVUedrNuc2GzciFzn9LXg24F22rEZ9b722V4+/ncOKCzBshzNUP5AOccTx82gkfRH6hiM2 O5p7T+xzptBrN2S7th/Fx2XC+rdk4XAP1usUI1FG3ntmPSf8FCYjlv2ufbresH77zVIlXGTb Rev7763vtPKDn9/AJ9vGXYDdxHgBfbc3QAstivQoBggcOEBsnreVJCcQN0ROoxG/tyT3ntIa Bi7GYvEAj1vNU7t5emifwC/0WV0/dwwG7x8rE/fxN7Kg1vA/LBOoXa/Ud63a9h4cg8Zm7Awk Kpueg7ChBf2S7NqRxqGM7Vf4Kw0V6wUZeL/D8tka/btO/+6QPRmjMMtq4+chFesXhMSngRD1 DzkRFO6zjtGw6F9cxpB3UKsJvAMLKSnhsorzJdRxBxPnwTo8ObJWD52pY514N4yC1pHT8wbA 7hTLoSKUQj1ZbzsnvAn8mAQ8bALngO0kInFC0o/B1O4PbRxEQXDF7CYVZo1XKmVh2IFNqD7p SyjdsBtMeaSyC9op0zEU0sZQyh1DwWQMuIcUdFWyxTI6LuZ/JRUfnU2gKW+bP7XsTtc+PLFP zg5beCLFeW13gPV4c9Hstg7to/ZxazWYOtNx0fpl/tm8TTmbmkyhBrzd3mZ9b7OWdTYXFu3O P42Z19BORd0f6+mHbwHdSx6wP4ug73rqO9AqQkFlkRLv1Tet+g7sUJKJiNRdhH6iQyfl1qYI XMg09HozMhTmfcsS2NWWFu9w039bLoBDejZ2xRpGyKfYBKKelfQnWVj9B1p7uljDsmDa9/xk GWwxFs5Dntsk8oQnvAYcaGOvvr5XW89AnttvyPM7I8/mDiIP/Svt6466Z81O98JuHr9r/tyx O+03p61DeIQ0ymIWuNLCeG8F/k+mcJAiBk73GewroyG239Rgt+LA8VYmh3UK8KO0ndmjSWkQ qd05bx607POzTrvb/qkFg9/QB3/uiLwjGDI10CMGsDOHPnQF8rh11LX/67LTbR/9nIn3N+4U ULDvfL7R6aZeqrAfKCbwnhsbe+u7MeyPV1/gALwR7jPMUFgIxnI+AzLcZF9tO5twG+3sEmOI LLGwDNhm+4CQU1xPOSMZDOcCAGMnh/Yo4/ScnnVbe8QAwiHxR2zU7c8mPRGpBA+UJ7wiHI8c mWWCmZvRDCkWB1+lWHr0r0D50+M28DawyZcH3UTi7bageiMMzFi9LZO9iVPFXC237MZ3amOY BMC29imgdqw5DpeaWiObHINcjIQ+EiEeiU65k3JaPvLof9Qr5sCaYCJD4mCZJ8NB2zyDU/sS xkKjsT6O7Nmoyn0W2FEEjyWu1EchgqJhFZis5QMrZAMrxIDhWI/bp5fv7ePD5k/EEkYn8sG2 B95odm/bZe3d+eseq3xCB/T5S5LAbnLJpIi6pTCwbvi0pAEdnp22njEZ6N4KdyZBdEmmUuH8 7o5w8mHnXcYh36fwIzJ4EJmjk4HYbIwuuZRu49rxBuwbL5zXVd458VQZyYSYzpji1kyFDxyh 8MPYtT6SDAuvrxcFnRRm1S8k6uPD4MYGEmCTD9HqalgD3v24avQhiXSHb+wO0Nj26dGZfXzW POTfUNBnUPen1kWnfXZq14r7eeTRH09jpJFKBFncrtR2UJWIfMF2kiyqqjkkkbPgaYebqAY3 puC0wi+NsoAgYPSpZMeJa7qB2eqMol/dieDC1srfXXeskRg8CBU2A+8NXGe0wmYvZWvqDD6R gebEHY/dySsh+ycg4qIkvzYOdPBdOkHeRqK5Fb7U9Tf6jjEVngvFjPRKtkWSVn39kNk4AP6C 1lCewI06ZbTlH3wCQ+ENWuUxN+mOAD2EuIk6kFoupFC8XQURsy6QtlbkezjhvENsdj/pW5cj 7161IEFUHFxhYXCyBe8bu++TA5AbhI9uinY7UTF3pF+qN+XAxIH6QlCm6JmDbgCAFuKZzdq6 IIxby+abWkYFvrGbgZyfjUe5QKaUAbneAbAhcIncl7haiBdsXrz5SZpr8isUoBQeBwWncRem QoODguZgQD/1yYio2uy4q8WBYF9vgoFNYCtIXoxbJDhiTrzu3k8BNZiaoucLCv4H7j35Titi SqGn5PJcksWawhnYEpksjKaj+fZgzHnSqSBn+P74Z/vg7OKiddCl9WEwhceAIWWFF+C3QCyq 8OoRrABrRZUrGd4/PoaimLoc75xQUB4k4MobFDI9dAAJn3BiJzF4Pb/u0GgCQKL18WwkV5bE QmplImjPTMQ7HJOqgGFnAhbgc2BFmeWDDchlYjY6ZBmdFTI6K8nOCot2Zgk1udp8Vn+SUxZe 2YAqaGzI88HM7SIi+0dCEg8xHepetLqXF6dwX9lnF4etC3EkwtqF/No4CNfp3VISAjFgPBwV jZ2LDkcaVpKl9QtoAuPfF0LMtkgXwOdLisnR70+CYxv9ALM8oM+ZosLw/yqDQnT18bE76oeC QF54WhRhmR9rIK30g1kP3jwB2UxDG6KOEiNgUQnC2UhkBtC+len5pOw9eXBh1B6EBQ8pDE5I jocSVBTjeM0CfMlEYHA2AhWAcBLIO4d18AtPqKAmxFo3fUKFZSdUSsHqxSfE3L3CKkV++TyE 15SQ0bKDLaGGJIBaUPuPCGXUL2hLg0nuESnQQY24XRmbRqQl0JsXFmyOY78FRomCT8j7gp1m cSMYffECuXYmVc3UuA6vv2rDCjDECsfsQb8LwPh6GBjjgbrjViIZtchFHTJ3XXVpYjQjuXIf MBa7DWsKsynzjJQCQDwwKDymIi3h3eUj5uCQRYgJn+K3ys3BJHMwNvQDHLvKdvAjbafoTySZ 1UZQoGtt4pI9Ma+G3NoHKYRmtC4kARUWBiTnNHLvZPa1MBxXOBFJfJQj5ANBH/qfyQ2Xdwpl +V7PohyctAWbnA58U89aIvkjWNnAC5hvwMyNyCgKLOaY/0zS7pAJ46QYqh9UMShd5HH79QGq J2XBZadln56dnp138XlxdNx808FlJyPBifTWCTC6I1kvORQC50bO+aNti6uSFxEmb18PnJug gEtuCKSQDUQo/VmlgO9IcnNhLQxlJj2bTcgpWF1fEtWFuRXFlhBgRHcMTT3mSKdb+dGOd24P 4Iz9aNVwsbCHH19aqdXQrAOqFoW0uI55dEviJ7MVFhkvOYr4hKzflDaRGNRCpcAej54MEe5Q xoeVygoySyuVyoq6rCWLGN7uArJ4G4cZHJXoRlSgE7XqULRsdZcJootDKBKaCqBaIkiaQfgK eASQCO8fBjyBBx26SPfRN8qbKjofXjawFMQhiE1MQGd1G44mpZqkXZKmaJNRjBITujjcyGjo tIWfCNRs3GehuLobiELhAcSaBZ2OMBMiybwaAWbaKFmR1XnMqEr6qAr6qAoGoyrooyJLGRf9 UPjk0AmUz6lQTxwfHiKszr5py86eK4gfI5/NCBM7WU7jX5j/7DLnKaYUuftj7B7zAPog5BIb jaCQNoKSHEFhyRHw8SUFs5Q4ct+YTQkPrl47ENlS8aoXL0jWKYdb5wfClJRnM1U3LUpXKGIM 3m8YSIcaAo3vdC/ap29YOiqpahiUkrNt3sBBHqJSJ3mCNVqW2HMOMTmKTBCllmz6qvrmUyPE gYW/FcQVqbzJpWjQEuFUmGqg5AiDV+Hew2d8/9B2LAunoMHBOSFrys7vkUY0qdkYbfaQbbni 4HXBFM12w66rGpHnB4k+YRZN4lERubAwoQ4KgGihmB32OIqFfJqVw33WjxmFLhH3GkWo0tGl LDP46BFCVVt+vUWq608qj08VdI1Czi6wFzRGjn8Ue0Ty0y4PVMEYFIk85MT5A3qzwVNOBLkT cQq0icuYZJER0PS8adacyszFUrh7Wcb4Sk9B3PyqNDzPmIsOopAFQlG5cPP1K/5jheQeH0sF Qb//d0ZWI6GdCWYD8/uBtOPOhFRgSAUjSPSKkCxXlFGNEhw+3sIMXIswf4VG57E3O90nF63/ vmxftMQrngMbylU49kc3FRTk9hVVolw6cikqBV0zCEvDO5DfrBBrVqgUlPDHmwiPFszbjh74 V1cT97NHvDw8mUhK7zC9Vp9E+Bl4isECEiAWG5GhNpA1DFDRu6XHMIc7E0yzotp8nzwwqRYX ppKtcKzdUFgp1lxkLMk6xjJyW5+WUfFXemOiIh9fFujMk6Ex30J8k0dv3kwxFK1IZKkjXEWN T6AjL5VCIF5jwPQiDHcgWNVRSDtZdBRhvQqB9RGKRQs+p+LpEIMUnsLsORfM5pwpDVt8zvxw XHjOBW3OpXDOhdQ5W+qxnRAOo06qQEqpAYXKBNQPIx/cuZIxIO98PgkiwCpcWSjoJezE+EnU VGIdPMSnPqm3+NVIITinnszEwdGQifGM+YIdn52+QYrEDMRnt4eWx5rOU8zfUkEi+cZj9jar cWFeY5IOiqeTxq04It6mtDzUFxP7ap8eajyyxqWJgchNS+AEB20T6uwap/StxcL/oigaX4Oa AMGiByKzhvthxa9i7aRW1FU5IiISTqKIzA2M0UMEo+lhrB3KtDCOJCzJhVMwgRNOooNBl7wp a2lgRWfA2YiTodWiN6d7zzEjGT8wfCNmmI2IPTjgOHIzxGOPskBRqKeYCkMNQcELhVPbOzuc oU+3pCFOC+33X/C7XLxtSiWx+IzyLCAGJMbIfYBpvduJtQrwmfstW73ivtwgEh33JmI/JI9P 8mvi+lA1R4ErSYxFwUko26TigTWFcgRWYWlYyisiOkfr5Uur8EutUJQLWyrpqMcBvnZIoMc/ opir+Obevl78NfxDT4AlpvPOVTGEPDkzODIfVcfAkox6bsQ7I7tZIdEsqgBXdUnhh8GAefGm nP1HJ/pTCksiLl1t2dQpZXYNth/+/fxBdVwq/SrXql6vs+iNf8ZXi/9DVANuPz5SfdnSlm7O 8mWu3Zz1y1u8J11Ak0W04mQxRFTr9PL4eF+s8jbLmPkn26JfA09ldVudrpBdH8BdhLpwIjKV Q/yCB4VN/ZEIub0Ze26JSFF0qQH3K185zOBhiO0we5Ou9Q4PaVbNQqQmDMvDtzvlkV2lmGGT m15ZEJYXuBzFeSYZ0Tg4WqEwzNisNHbRX2izkTT1jdXONVfbRHO1TeU0pHuL4GoJUOlmEbto 0LBBBg1boQG1FjQh2z8o3UJiEYC/k7HEToPjD4dnWlPR2xQUGUVakovCvdxXeiV8VXkToQ3E OEvk78k3C/NL5PwgonlTrePOa6tRrVXrRckx0XhngRLQf4wI4+03rS5wIvb5Reuo/Z68hsJv KNa3pfIsdC/WgBWWBabrFRwCOHG1M4BRcDGjM948V8AI4gMpmPart/TqE1h0S5f8M0FrUG3e lzYaqrr4EIRtUDWPFsSCexg8WHoI3sg4mQGrN3Yo45X4iduINgxwea0crFhfYqYu33T0f0Id vdivb6r6b6r6b6p6XVUvDgbyFCHvjmTsgCYaULhWlzdDRJuGyrdw8UxTZNUKlTgoLYc3WAZQ IQaINGvIbI0mbs+/GcGWK+lcxlwAoOD5thpkZiV+Cp4P465Hib1gWFjLnv4sD6SckwUDRBBD MzclB6Tnvc367E5IMmHG2t1vKW5IYwU0uQRhk4Fgw0AuQZhlIOYwASVVFSF34Qph0kfANVsI pfekpkp8K0S+8Smz1cKo/1ZhTWpFKaoShzCW0TN+K0keKQIOAdXjgETNlJtNyv0TMBpxGOpq 1FUFs6SGUa4JS9uELgrfIWyO6XPMZnSYV7aGUmsVuKwjF2ebL1qZo1uHTQK+O2lzKAZIqh4K +H810xWOciOWHFDJYEAFgwGRWb97jd5NMv1HdIHFyIT8S+CYL6TbKYKyvk9ycRbisMSQ4vej VgR+fIR5kYqN7l5im4Fz71dg4CSccUjeLeL/URsxP2balOpFpK3hQ6nEyrosVahg2IBiGpE5 87oKmS2fjOVnVJAzKi0zo0JiRiV9RoW8GRWyZoSbyn2sEikPg0+jxe3ArQw4InaKDUGoYuOl HbkYYhrZWqaRguwSKooVozHpSx9q6zXFbiA0SKOplGaTxD+cQvgIN+60EOm0oNui5HVaiHcq Azl8By/G4/ZrW7w/bCbPNvf/zIpQa77K2PelnuL7kgfKqmNN/ZFySmoqadzOCb7VGilazVud vIPCiBB5cApJOIU0OJbmbJ56K1hWTauSSu8tixO6NGrwRFu3SuKnMn66YGFjmtkOnwvSClBs aBR0VVWLSp0Imnz/pJptBAJ50pgT0hWJ3wk7ZYI05QPAfCIxO6EyVxsonx02zEIjA3Gdp8Ap LAonFMOyraNkX2gxhG0GJwT1mEXWrLqYIWB7xdikBZGfsh2LvCjJmSK0QWCVfFnEi3lgxTAx 2fAPN+ZbMPEWFe8xSi4UtRvgW2p+A2UdoFtNCBol7CbiJhNTZUVQJlqoeX1pd4IzkLk3dQ8A ERKnJzcE5UTho660ROvwBRUyYWpEpMYhmYquf5G8nhAwytrUnN4GpIqQOQYwtZw7GETcLuQb KHoGFKOn+i8s1H9pXv+FOf2H/FsQM39gtX1o+VBmzY/2vlOHhyBOKUVKX+ZHTYNSWAiKrooP Ysex8Eu9YLjdrPUOJcKp0yuxWjrmsCJJgcf6z0I+kMJcIFIMpDnLiPUArgX5Nk2OqbKyJV5n wlePJNm2bevCbNaYveDSz+WIBs224dk9wabBPHF3PemCWFc+iBgdC12z19eToUcidRcQdOsP u1BCqb3sWMIh+Gy8MPEc50rDt2PC6528wEAmroLzYf1OMvA6ugrWMfA7/Yzqtihr1r503ifZ NuY9KvQKe7oOiwQB19bqiry/GWWZ7fz416Dwy2iFLhvMdx/RYuW2LCRaGgytnz+0/tJD6z96 aH+DoeUfDfYoi58OLtXj/WLcrPW9jXrqAQmrL3BG2ugdiU/m/tNqhTaeWiu08bufiI0am3SE WqEADfwFGgiVPN5+6jXNYkrt1hHGrlF5NPozs4MrSk20b5RCh+wv3IkTth9wWg9gcEQk2gyP SNqZLK9IujM4qwBcQ9LCTQhqJcdIW2EAoZANQXOgkAxpit00asrYswjBSczig3Leuji57LbC bEnXzmww5Uw3mh1T5AXHRlDoGMQ+m40yIEWJf4i9kxFeOfe32wutoPEq4Cd81K4a09KMHtjL ldkEMpRCK3rkIdjekbgFoRCREwc+lIcr3YFIIRKXW0eUIlGLmIgSx9fsqGmLifyETyPKwcKp o2l3K1l7oysE8mEU5sKg10PW/gqclU5lcazWGWJpmxRljIHc9Ph9ELFIqkgeFJ4zN86kT3mW KyHCKRu7UKGFTFQ0UV9cYUUJWpl7Y554xHxxRBkYhqVgRk5K/b97idt4EIopUudUWHROpZQ5 FRaeEzGT0TkVsudUSJ0T8oQY+te2fVZqf+FsT7sYKpD+5eMFN8dbdhPXHK71N0TIY1oJEb6k xHSK+YBJ/0DdakyJesS9zioT4QWYcACc63MhoHDRcD/mLRhpHuYpJOMr0USPCxIbS2HRsZSi YyksNxZaXWbY9QHsh8Ua3NwAIWhKH2NAuCiMnATcxwbmlGikRE4K6y7AelCM7ZFHGfVuXacv 0vMBLvQ9IccXibzwuv5hgFEDp4Pq7Y/VjERNIRNNqQMaJrkIMtI0GYFaIIrSUyRsEv64eBJV 4uxFY7I/MmNTNBVSeDstmrEpEl+xIuIrLp2xKZqtKT8/k1GMeEvTRh63X79pdbut911MtfRc CDwjxULOWd/ZJEHwjhIEa7H7yLeUouemw8BIUD81L9rN18ctu9P+R8vG+P4/d6xfcH1WV1dt G7bjwLbR4XQdwwtTwRsuaHBoYRuDSbUPunbztNPGeMO/4IoYNg6NghJAhM0htet0Dw9U2CFq j9x6rX4MC2cVpV/xd0aTS0+JgfTEG7oxaQEXGaTCCOsapcFgd9wSiwuwIUYQvolGdOsN/N6n jFQYOm1YJLz1t9wY33Jj/DlzY7xLzY3x+JwUP8BpWqOjyS2SkRPp+FFGqRfdjuqQAiGU5Olc jadyeIGSR8xaoUImnzZPz7rtkxauzgh9pandlDIWPOcECPCLpRlJHhyfHfzdvmg1j7EdkkMC xMVIxgQ0NLknYmCr4USbli3oBs3wZaYC5rqxY6Hro50XuQu0qQDfb00/C0GUAO5f950Ha/X7 6ecyWQVIOdU0qPyochdMP4s8BtGPI/3rDP/grB1UixIaCANJmcsggwrTGFJIsSg3p8eygRFR rm9uSKp8PvE/Y0SByJqQ5x37IDFh4PBxdIg8DFRFNYR9DEYMvJr4n9xRVjojTsXJQaE3fwdC vv/nJ+Qko4lTbWFL+I1y/7GUe3GGNZHU6L+8oXXiPrCYKpduQ7uOUG85oXdVNtUOP0QKZbT6 nzs20sHXwCyXtBCEEgjFr1akhxsK+np2dNj8GUnu69fAXdqY3JSpMbCd3X90Wt2Ub/LGwugv zoTzL2GotxlG3mTfXEkm7lBJCSsToSNAy68wbLI6MCL2jkhnyHpvv+cMiNaT9hQxApXNQpwi 8zV1BS5FyZRIuMHmDCdOzzrrWO+BDldr1Q1r1au68Og5dCZ3MNh6db26XUTbUDEYxoerAT32 Uc40/Scq/CYu6cylafXIRam0M2GaSGp6R8gXOv7AmUCVRnWzjP9U62xo0KhuKawR85UXEVzB QxvNamxegf2UGi/UgohKNlwd6NHzfaItosCMnlGqzbOS0DmmAZQZjYSG8UUxAuNmmAWAv6S3 lpEpyWbiboJxkPh2UL0iozRVhuOkGIQtk3ijLpLk9krsScEcZYOueikEFDJlMNUsrKO202Wy 2pgwCuOaogegCk4Ux0uCkYmbAYvQ5SarlXpWmowHduaC419jmQNMawb/e2nFWo2LWg6tDJxI IIXgirJQaDrcj+Raor+/SjKFNq9OwL5Z0qdEbD3idWQxQjd67kEsRmIp0lEndx30Jn/sIjDd pJDjy9NMdR1c55JVeeqI6qhDR8mqmRCt4u9zzhjVLEfYNfQjIr6MoQzDc5RBhPOOEm8qPxBw N/WRid0jxPnMGAKtyOA9zSAwpzchreU+9XtGmftjt0oCFeJLgB2/zKCYxImLATNnn0lZEQ7j QHhzZq55hN/OI21ivfHOcHqfRJxlcWMRO3hHkYSQ76LrRsn4IzUJirIsovsqUJQHPSRL0ddM 7M3zAvdk4mEJvHIIvbSif4qXnbgANEAaz6GfBfGum3M8/ii8iG3FouihPRkjr1W5djCFQnQ5 C5RccuLBW47YQI7A/zfB0lnySHPlWF5EhOiLJ6hHEc9pWi/jr1EfN0rfxn+i58uLIu7WviSF snH4EA7TDX7WXq9+/Pmqvs8iFWZhja+0MCKNYc5A84cZX1sDjJl3PCMvfJkskMbGbExE8kCY ax9Jaqt2wiYumQYMndCU7Wu+b74XhbzKkWUUX6r4U/86i34ewgvMw3tMigLCpST0QMGtRLKz v9vdMxvDQNY7LAihKsInaOUMaUm9AvB9QPqRj3aEAxaU4qT9wUwLmQFUSLzTMRg3xpn+2wrL puV/K+1rCz0Oe7qbNx6lymFyIDLOzgqNSCx6yopYq6HUJLogau6JDRNforKRNJ0Z57YYftIk I7JIyDg2Ko26Vd/eq28mc+3E6xqlGnn+3Do8w9D6Vuuw3f0OcPa0RTnArOZl9+ykCa/c5vHx z99RzXMRQiIMn09r6symPjnNc5SJ/gx4KMzQhTXQmfxZ5XmKiNssUU9Wy/l5ep6jLXnEWmcp +Qla8D9ZgidK89ioK6N+xVCqEZDvEXUhjCfwHuHuANWlGFbMjrsWhj28/ZWp7w9oxS9cuRdX D3v6V6tSgfvXn0zhl743eVmFn/DtJfwPasEfnIqlcuUELhZCyXCD/xpuYBu/x3/BL/AnpaPj As5MV6k4s3uCfDXzBn38C8vwHn45DD73Kt4I74VIEQafnPh3qnDiYPQz+Rd8c52+GIpALPKl ealwHr5oSt5K3x0jTRj1PBcHNPJxhmLyQ6c38SvjCYC5f3kz4M8wBk6ghxH/ew4aDJCJDnY7 +oTmBJOH8dRfG/Y35a/BrVPXfm9sbml/bQKG9jn5lYVpWFU6SStMCiSMliq46pynqCK8rUVW L2uAbCvws6MH5Sc//ERkaMxrYgfezdAJPllypIDfvU8YTjaY9jGIBmX9wouACT78MvW9oXPP v83ot4cht3wIbOpP9oWn70+JRXBfjHz113VvNB1E/6rchn/TlB6Hf2yLFP7p3aDlHq27KoPF wzBXwf8ZpNWSeZsgsFReRBimhbFarLQBdjvTisDopfGc9gxrq39wthXgwMI/gtmVNcO/0HZe ngsL/+/krNM9/vkAE9xibqQOJofuIcf/ogrQe5/6s+FYhJVYpxsXfghTQrpM0YTLEicKL5sZ ZlHmxYcaJajB0QgTNcKE689KfNpsx+6cXV4c8CC0KlWqlN2ZBsrK6hD2nibM5ggbNJXdWrnB 9t3C2SyjC2HGU7nNmZFAmKzZKNV7zkw0EPmdiGce/l/rffeiaR+2O12tF6FQCr/njEirmz8s 2WnWCuuHRK10o0YegI3GppYT+p0rArBHU+eO2HoU2a8eOaVYP8BZI2pUvf0xNC3mNzq52Plu oJRb+IYh7oLSyIRsMnv+Cu4ZI5iEQPcs9TsGC7L+sgp0wCZCDRS7uCa0AXjKZgF8fde8OLXP TonjfluEgubFGwwFj7w0FNCjfknQB+/fH7aOOgx2Xj/W/4OiE/sneN+fFidDq3Jt/eVVZQr/ oH72F/j+xXJ7t75VQPtCE74YXsGFfWoJzy3Ymgrw8sHaq0KBHmPt0y4m3YLRFQqv1v6yGiss rt0UoC3tN2x0vQYbvrElqcT/42dMFOJh6+DYbp803x+2f9Jg6sUCak77Tveie4a14xDUB0MY l1kwLkMYpTiMi9b5MSZ1jI0iUZw1Bli/9YYNFezjLi4m/qagZHzMgbW1QdVb/21TNAcdUvJT FpzLSL+X8VFlfs6DF/Z+GR1ZxseU9V4LIy3Rm8V+c2wfXZ4e0EZdnB+vTSInKD6UtWiwMmyt HShqHD1gBgC0I0oAokdWB/ADfA0mPTr1EZqwL8/M1jbeRg24jUSCssyLaOxMb4EHyLmGBOuR djmIT/PuhUi1rHGoXrJugxjroy6E9cZ2GTPprW9q+YHTO4GmyE7eUqrg9F40FhZDBHnX1s3A Fq7lrVO0qTu0Y3X4pq9El0arA/OuyM9py5Oomj16rdusZQpGaCc9XbNPfZay8A35WsSrJQmF lEHIykLYGeixL0gGC69nct5gl531GmLVxma9vD5voacYWDwTpRSTmoZU6mP1NgdfIiAyu+k7 A9hyrPL6sg0ERlv1v6x2uofN4/abU7pn8UlnzkVIyGlcRCmXi6jClX5twXGX96YdDgM1ZhLu nhq9wW0PpC3/+i4tfX0j0ezB4EOKExkXV/lq/cj9ic6Gn2X3z0os8dQnNm8qcvzQlgWDaQ+K EKD2a2Wahk7acHMRSiGLlYNPmOjymZWBTUDy33IOms1dClm8tVkTNCl+jwmS8qbVPXjbvODr K1qWdQOGtQ5bx+2TeFMqnN/2uH3aijfFMtGykt2yE2/WmdPb2etOt3nwd/v8Aq7no0jr6KeF 4FDq6/c50LjCHJjnB8dnnehCcJHGgW7XySFne2tX+u5mADv5OyBq6+Q8ukKqdM5QTv5O1WJt qcysZSetaSeL2ZSzxUWyz85bp+fd6DJoH+YtYreDOZSjzblsXu9cy75Ia2vPOwLnl93W6U/R plQ0p9eL5unhWfTgcNGc/rhSbLCycF7bFpDVs4MUrI18MYBy3uy+TQDAQh1lNzY5RfQOvp3i KPubfK/oCPubeKqE6PpbcihaS4msYTtGVYNWnWQz2VsptV0MSWXbCIrm9RsiqGoq0DO3Vw05 Y+1gu/NaKgSTzQR65Y1R4NHbRCu4UgzaXSTbXeS3C1FJtZOI9FuISFvrFL0XSOBuKh7Jx+kJ ITEDi5ZljULVet09exdvSWVzW+pIGCvM2h9ZLba5ieJ5fSvaozdm4jOn5+iGxUvn9SuoRaxx y2ilo1seL53XutNKzpjLNHzZWcdHWGlnd7u8UZvzRmCpc94zAeXR6vGZ4LnQzFW8LG8XZuC1 touy8NmCwJIOdk8b/6MldiGH70yLf1k9+fth+8I+L2IXvzPzr2R3iAtvLpsXhyK4NWLCm+MM ZG+fHhxfHrbsU2DGGWX0kqwjcn7RfHPSRLtmOML221bzsEXH5FXah1f5QA7Oji9PTjt6c1GU 1RBHRjbVndZx66ArSXGiOJf0J9snitPa61wN14uyNVw2h69JaZjdTo34Xfu0c3bw90ZkvGFh /hWpulQXpOhxHvnVG8YK57VNa5rZcglBX+mxcrpSipwuRgvmv5tTH70aeYn8gQ9frQEQB1k/ 5UEcHUnek1inv1YekWZxj5VOouEjdEO3wyZpyXY3toTu5ikIgLUsAbCyCUC3mXL8qTALOeHA HJ6969hbG/brNjTokustg0j/lnbfaof56ODtydlhM3qcZeGcZ8IRjjXaEEtMWqW1Uy0pOkWN pIC7u+sGN7xCjbwrXkrxUrFHEwQueL0Lj5mnvdwZ6J4a9xIXe1Qx8G9906/ptx5aV0bUeWFh 1v3zb80lqPnqRELMN/+G181f48I09eGp72y1V8neE8VZfAZva/fiEtgYrPxT81jf78iHeUrO 5DDSvhioShODSf/2NErA0mOVgL8bc6Go0fKsBRM37ddUebre1xzmQVD2LNaBPqexDYLo03Wz yVa5te2dcmOOLpOsxfNshHQDofi8Qkf6nEnpAOb0gdZSWaY7ep1crWgc2Lw+g9nV3D6hjlmf DCxr82ZbG0oFu7vNhlz1+u6fl7G7PIWdPoxQbFlkyNSdHR3Z3VSWjr7MYegO3sJNHiH3VDKH KTt4e/buNNYKSua1Smg14kqN3d1t3rKNjZQti15W5803LcHNRu4qWT5f2wTk66LztnV8HAeh PsyDcXF2eW6ftE5et2LKMu3DnOdxu9PsdqMXLhfN6fs4uQfHJptw3D79e7QVFBi0ibHgXKRt Xb1W2+VosvXN7SybqFA3cJgYhyycr2w4TBlPWDyv/Ukc4alkrhCj+xbup4RCSSuf02/nuNWK qtGoZF6rn08SCyXKzFrGlkmVzmkN+JeiAlOlc/SxkoKJvHMRGLFvc9Y9BVItPGXHGdCsedCA +3mNbkTt0zfpg9MqmMLstN+ct89b6fDEx7mwEpvNRZFztrHFNHJ3M+NaY5HXu4t2N6JcooJ5 2hd5LjXtC59Kk3bNbkrLZjdfNBk5WUoyqZ2rvJ7lqVLt6EzltlAnKpSCnsydoX6aYu3U/Hh3 NnfYery2k7c7xMyjccPZm/ZpRE0W+5I7KllXuwrjYNRtaAJHvxDjgMI7MW832aQ0dUvjn+aP SCdCESghHcqDcdaJPETxzzl73LHPmxfNk4SMXJRG9nlrm2+7Rn2nXF/P1UIeXsa0gVAwT68F VRqJRo15rY6IA2jGxNCydJ4I+wiepqcHTUk1EsXzekcToXeH0cZcZtDy8Oyk2T4NcSb1kwGc yIlKlhtAIOatkwDAxQbto6cx5cO8fVAsodZc8IRzeldModZScIXzWiqaqJeYtIpjW5Im1mv8 Wm5sbpTrG/mvZU4Qm/NaFt49WQ9K8Vk3/pVvafkp7ykdQs96YX52J+Rn+sxKtcIVn7N8hnXn ET3YbrTcIOJusoGpC/HaC+HCYjlhdCLh+iwjbqn8ZRPpRSUCeCe8e3fM/IIzm853DJ4fPNc0 SKb1VLHVyJZyowx7Av9uxDJ+8eLatDOr90VrdfWLZZOzoX9t2xYW2fa99RJ/2xeBSrBk3/pa LMYTgunAhCqAIqn0nIGDUfUpcQnGH8IYFs7NDUYUn7rBPm1W3x1PXExPKsGMpyIITkXEV/FG AxwyxdwgSWG3e9F+fdnFe/b8ooVE//BZJWzNw7VejIvWFzn0MQwckUr11t/j5Ov60LFPlZA5 83AIj8PIwVBlBgnRo5UXORCqIYZ+xV/dydTjnGm4wDeIMOjQkHUMKHrgZmaIacMTEYfyb3k4 cnY39AmJbHBYLPZ4o9JoWI11Inz15B5H6+du8wbF98VtpuS58QXfMturzKbzNwiTH6cGUy1b ryezkW+9dbyrgVu2Dt2J+8k6n8Cq5mQuEb7I0smE8Bj+DXNedClqPIXcsylbdphd1QrGAw/j ZMJuuRWqRIEfb2bORGZApMDNKspM6PqG0aRUdGggFP912UF/LVaLCTFpWFvkUXwV8597JcKe YdwdjMsH9KJyUIKXLLkuUOqaH2OxhgKpW/VkRCGOURJGqu6NYRr4P4pgbekhrA8P7KOzi5Nm 1z5pHlycdTh6iQy9nVLBquvhRIiov9J1f6+sVySh1acUEmxB3ehyqJV3dwH3NrfgZ0NcECJs SrivThDMME8j6Xk5fyjmhXbvnR5mWltvWFceZlE4x4B+GFqC/PcpOud44EzhIhgS3Vd39dS3 fria3VQYS16JUJE/VlfU4CwRNcq15miZLHfaq1LitJ4/9iJ520tEMqMwUlRNiLaJtlZOW02r lNN2u7pTrWMgxYnPdyEuA3qHcwRLvAupbiWKyjqi6Lichibo7BRBsu5px76wuzC5VpejTqV/ EkHSu7Ap7tA69UcdzB50YQXAFLqB2ivAbPRlknuIocxoh4F8utcydx78918zwAK8EaxgNqa9 /+txn+KlYkq3vw5k3tJKyHyw5yP9I+bEynJr5XgF65Hfi1H9wYAbsBuZWBEVGuj8ot3fwYV8 Bb+JdbNfX5z9vXX6iuBzmCmqRn971/g3HJwd9H2kIjkGhrXSp/5kh8/DX2L9emb9eib9AqwV z7Bf36xfX+/3MqtjALbiG3Y8M+t4ZtQxAFuZGXZ8b9bxvVHHAGzl3rDj92YdvzfqGICtvDfs uF/fMkPq+lYUu+pbqWgN4Mzx2rBvz6xvBGeO24Z9+5G+LzM7R3jm+G3Y+cywc4RnjuOGnd8b do7wzPHcsPP3hp0jPHNcB/7CCNfXG1F8Y8/4BK4DOHNcN+zbM+sbwZnjumHffqTvy8zOEZ45 rht2PjPsHOGZ47ph5/eGnSM8c1w37Py9YecILw/XBcJw4AUB0Vp91Tw/P26hXg7z1zSPbbTy OXxl/S3k6I7PtzasPWT8UwJKvCpGxoFOnVBJ8UxiOAOdQzzpULKcKNd50j598w4mZueBg981 gPyaCvk1GB8ZWMqhWT/+aK3XMN5mPQdoFsMXXccErYAlydk8jVhsbSQIA7SNTSxOJhLkwbQ7 L9mdl+zOy8eSy0ehSUZ0jxREmT0xpszmoMrlaaf95rR1mIIzlxGkqacjzeyxWOObbqOf3EZf bKM+SX8O2sxM+5sl+5ul9Deb09+9aX/3yf7uU/q7n9Pfe9P+3if7e5/SXwb1TOMVjlvNTtfw wcd19VemBkGc/UzGYIGOvNSOJARx6jO5gAU68lM7khAEWmbe+At0NEvtSEIQ+Jh5uy/Q0X1q RxKCQMTMm3yBjt6ndiQhCAzM5FCpmumTTFROxbvwHZaPeKZPsPS+FAwj3DN9cqX3pWAYoZ/p Cyu9LwXDCANNH1TpfSkYRkho+n5K70vBMMJD0+eSqJyKh+EbKR8PTZ9H6X0pGEZ4aPocSu9L wTDCQ9PXT3pfCoYRHpo+dtL7UjCM8ND0bZPel4KRxMPUV0wSN43Zc1E7waNLKBoLn82dL9Sl l9Glp3Xpxbucy6En0diY18wYj6+Nx5+3BLOFupxldDnTupzN6/J+oS7vM7q817q8n9fl+4W6 fJ/R5Xuty/cZG51GdI/MOc4jxWN4dFxsKuD3TY7EinvQUV5qR5K1zEVb5uP2lhu3p8bt5Yxb 1DIXi5mP24+M+zI+8BxRmRq5nzNyUctcpmY+8tmyI5+pkc9yRi5qmQvkzEd+v+zI79XI73NG LmqZS/PMR/5+2ZG/VyN/nzNyUctc7H20wJviKGQbtRPKwve5pAU6MaEtC+mIFhi8t+zgvXDw cwnMQkqmBQbvRwd/mRj9HCLDw59LZRZSUy0w/Nnyw5+Fw59LahZSdC0w/Pvlh38fDn8uvVlI VbbA8N8vP/z34fDnEp2FlG1HC7wgj8JHgnZwecBzqQ50YkJ1FtLWLTB4b9nBe+Hg51KdhdR9 Cwzejw7+MjH6OVSHhz+X6iykMFxg+LPlhz8Lhz+X6iykclxg+PfLD/8+HP5cqrOQ0nKB4b9f fvjvw+HPpTrLqD0TlMhYXnCULi44WkBasEh/Xnp/3tFTiQoWGYyfPhj/aAE5wSL9zdL7mx0t ICRYpL/79P7ujxaQECzS3/v0/t4fLSUewDNldJtqqPAqI93EqwSCI/R51yjWWRkYX6KmA/aW GbAnBpx7dfKAjS9O0wH7+oAzU2ckhuyLIedelzxk48vSdMiz5YY8E0POvSJ5yMYXpOmQ75cb 8r0Ycu61yEM2vhRNh/x+uSG/F0POvQp5yAtosM+7F2b0AipGbc6gIJXbRogIDr+zSv3VAjy1 6Xg80/F4qeMxPu2m4/Gj47nMHpCfOiDjs2w6oJnxgGapAzI+qaYDujce0H3qgIzPoemA3hsP 6H3qgAxPWefg1MQngKrNs81nWCu3t0bnCWp7Zj17Jj171LNn2LNv1rOBXwADg659w65nZl3P jLqeUdczw67vzbq+N+r6nrq+N+zayEif6801lBfgVszxzLBzz6xzstI3RzXDzo3M9AW8FXNs M+x9Ztg72embI5xh7/eGvZOhvjnOmQgBuN5cg3UBbsUY5Qz79sz6NjeWRwwx7NvIWF7AWzFG OMPOZ4admxvLI34Ydn5v2Pk8Y/k/xl4dBvKUVshRcE9krx4BuoTlMZ4vI5kEV0ycTbSUjU4s 114dj5Rpd16yOy/Z3Z/BXh2PyxNjyu9qrx6FvxzW+Kbb6Ce30RfbaGyvznXN+psl+5ul9Deb 09+9aX/3yf7uU/q7N38XmJoMh3V1GzkNgnoSZN6WC3TlpXblhV15uV35C3Tlp3blh135uV3N FuhqltrVLOxqltvV/QJd3ad2dR92dZ/blbmBt1Y5FTE0Hj4fMUzZ9/TOQgtvI9QwZdfTOwtN vI2Qw5Q7T+8stPE2Qg9TZjy9s9DI2whBTHnvFOtaHcaKCX6Y8trpfRlZXqutNeWt0/sysrxW O2vKSqf3ZWR5rTbWlHNO7yvH8jpfuan22pj5S7NY1aFoDGI277dQl15Gl57W5SNUnAotjDmZ jPH42nj8eUswW6jLWUaXM63L2bwu7xfq8j6jy3uty3tD3SPixJE5M7OEiW/Yg45/g0R7YIJr 99vX19cZrUOhVmbbzJZh05juRatkLL8wXy5vueXy1HJ5SyyXtJRWYjjj5VItw6bJ5VrIEBuP m/lyLWeIHfahH+5BEgLN+jplxaSFthIdZjfObBq2TS7ZQhbgSC7Ml2y27JLN1JLNllkyaRqu 5J3mS6aahm2TS7aQ6TmSO/Mlu192ye7Vkt0vs2TSJl0Jac2XTDUN2yaXbCGbd0n3TB8rSxlf a51kkX4BIZ/2RzQaWRTc2O5c0jDTp9OyU/fCqXvLTF0ZpM+lxsZW65IWmT7kljQ81rrJJMn6 7DNpckSfk0VYjY3eJVkxfVkuP/tZOPvZUrNX5vBzaaSxzbykEKZP3eVnfx/O/n6p2Str+rnk ztjkXlIJ07f3UmbfWicRepdBsRZSmi0weG/ZwXvh4L2cwS9msy6Pqal0YEmzY62bCM3JIBoL 6e0WGP5s+eHPwuHPcoa/mM26PCimMozlh38fDv8+Z/gmNuvz5SJHi4hFjtKlIkcLCEUW6c9L 7887eiqJyCKD8dMH4x8tIA5ZpL9Zen+zowVkIYv0d5/e3/3RUoIQI0tQUXExm2YJfd69sIAR NiKS6YC9ZQbsiQHn3gULGGEjspkOeBkjbAl/Hv1fwAgb8dV0yLPlhjwTQ86l+QsYYSPKmw75 frkh34sh59L5XCPstMNnZP4pKs63IJYQl7NoRsw2HY9nOp5HWDQj2pqOx9CiWYJczqIZkdJ0 QDPjAT3CohlRznRA98YDWsiimZKeG8QtLz2nA2NSG6OWl57LAP4Uqt0sZjkA10OWl57HbYRL z1MClpfkXFSfz42jles9evN7FKHK5/foG/Xoaz1eZnQpgpTP73Jm1OXMoEsRnnx+l/dGXd4b dCkCk8/v8r1Rl+8NuhQhyed3mWPqHEHY+lYEf4TFawxlhcDPAGfNevVMepVhyA3w1qxXX+/1 MqtbGYDcAHfNup0ZdStDjxvgr1m390bdyqDjBjhs1u17o25luHEDPM5+TkfwGF7SOkaJh3MM j4UYyACPzXr1THqVVtMGeGzWq6/3epnVrbSXNsBjs25nRt1KS2kDPDbr9t6oW2kjbYDHZt2+ N+pWhhJP7TYqWyFgT2KWrQ0hGUUcR7KIqW02MDK0leAWMcnOBJlpW6st3wLxw0vPY+HDY6c9 NXp4TleeYVdeoqv0yOGZSHH5GKzItsKOrfvsSRFjlo8Zi1pgZ0NfBkl8w53zEzuXESw8p6+Z YV+zRF8ZgcJz+ro37Os+0VdGkPCcvt4b9vU+0VdGgPAk+qfc7vkWw5EbXhgMh2+5WGzw7Mvc vBMvrRM9Lnj23W3eiZ/WiR4TPPumNu9kltaJHg88+1427+Q+rRM9Fnj2LWzeyfu0TvQ44Nm8 4xyD4yR6MfOaEQN8DoIZPn1S+4nE/56DY4aPndR+IrG/56CZ4esmtZ9I3O85mGb4nEntJxLz ew6yGb5fUvuJxPueg2+GDxZpwpyCb+qZkotvhk+U1H4i1uZz8M3wUZLaT8TSfA6+Gb5CUvuJ WJnPwTfDZ0dqPxEL8zn4ZvjOSO0nEtd73ptikaDepedpMb1Lz/NCeuexzIt056V3Fw/nbc42 LxLKu/Q8LZJ36XleIO88LnCR7mbp3cWDeOcxgot0d5/eXTyAdx4vuEh379O7iwfvNmIHj4y5 wSPJE+Rae8cQOxK2uyRymqbWMRQTGY/XW2a80XDd6ePVbMQNBEzG4/X18eYZ7sZOUCRMd/qI NRNtA9mU8Yhny404Gp47fcSahbSBWMt4xPfLjTgaljt9xJqBsoFEzHjE75cbcTQcd/qItWDc BkLhI3O+/kixc/kmxSlkIAzDnUMrzHUj5oP2lht0LPx2DsEwV62YD9qPDDrXijWFIIRht3Oo hrlqxnzYs2WHHQu3nUM6zFU75sO+X3bYsTDbOfTDXDVkPuz3yw47Fl47h4iYq5aOzF9rR4pJ zzfzTSEQYVjtHCpirpkyH7S33KBj4bRzqIi5Yst80H5k0LlWsSkEIgyjnUNFzBVj5sOeLTvs WPjsHCpirlgzH/b9ssOOhc3OoSLmijnzYb9fdtixcNk5VGRRxd4CgbJLz1PiZKfQBLMX+AJ9 eal9xUJkL/n8XmAYfuowYsGx897eC/Q1S+0rFhg77+G9QF/3qX3FgmLnvboX6Ot9al+xgNhG T+4cA9bIDRjue7ZVcwyJtVDYGVefssE2uPgMB+otPlA9BHbGdadsrw0uO8OB+tpAcwyCY6dE C32dccUpm2uDC85wqLNlhqqHvM641pSttcGlZjjU+2WGqoe6zrjKlI21wUVmONT3ywxVD3Gd cX2pANdG5z/Hkjdy/tGQV7d1kma8sROdZQhucMANR+KZjSTTBNzgBBuOxI+M5DJzKJnG3wYn 1HAoM8OhZJp9G5xAw6HcGw4l0+Db4IQZDuW94VAyg1fPPUG5kavVUDhwda6dth62es4C5Mas 1vv05vepAlbP79M36nOudbgeqnp+pzOjTmcGnaog1fM7vTfq9N6gUxWeen6nJgbbIjR1vum0 HpjaAJPMuvVMulUhqQ2QyaxbA5NtPRi1AT6Z9Tsz6leFoTZAKbN+7436VQGoDbDK4EEtgk/n GzJroacNkMqsV8+kV0Pz6fyI0xGcmm/Zq4WbNkAps25nRt0amk/nR5mOYJRRt7nm03+EHXMi uvRjzFVTYks/1o7ZLLJ01uM+P6506XksrHTs2KVGlc7pyjPsykt0lR5R+l9px5wMJv1IxPgd 7ZgNA0nn7JxvuHN+Yucygkjn9DUz7GuW6CsjgHROX/eGfd0n+soIHm3ElxuamGqBo0MbrETc 6Oy7zrwbL62baMzo7MvNvBs/rZtovOjsy8y8m1laN9FY0dmXl3k392ndRONEZ3M/poafepDo FCQI2elcJDBkpVM7isaHnoMGhsxzakfR2NBzEMGQW07tKBoXeg4qGLLHqR1FY0LPQQZDfjhp lRmPBz0HFww54NR+DKxzDSJBJ1Eh3o+Bda5BFOgkJsT7MbDONYgAnUSEeD+Z1rm5CjuD4M+l 52mxn0vP80I/5zFoi3TnpXcXD/u8hNrOIORz6XlaxOfS87yAz3k8xyLdzdK7iwd7zmM7Funu Pr27eKBnI87jyJjxWNgsNBHiWfKvWSGLU9sq4VB2wOKMdqphVO8QDe5sICEwXiJvmSWKhnVe bIn0oM6LLFEkpHP6Epkb686N5hyh7kuYZSZCOcupZsbYTW2sxG45EXYzGqqWiWUytxCeG8E5 cjktt0zR8M0LLpMevHmhZYqEbk5fJnOz5LlRmyN363LLFA3ZvOAy6QGbF1qmSLjm9GUyt4We H6k5QbsXNNJNhmmOU5hEqOL01itz6LCZVfL8+MwJSrz4hGPBmReccCQ0cw5VNbNonh+VOUFX FzZWTYZkTmB0IipvevOVOSTSzBx6fizmBJFcZs6xQMyLzjkShjmH3pnZUs+PwJygeMvMORZ+ edE5R4Iv5xAvM0Ps+XGXE9RrQePgZNDlHApkriwyH7S33KBjwZZzqIi5rsl80MtZNCeDLOcQ AnNdlfmwZ8sOOxZcOecsm+u6zId9v+ywY0GVc47jorqyBcIpl56nRFNOOVxmYoYF+vJS+4oF Ul5SxrDAMPzUYcRCKOcJGBboa5baVyx8cp50YYG+7lP7ioVONhItmNgWyrDJC1jBxoImZ9B1 U3PdOfGSIyR98YHqwZIzaLmpue6cOMkRMr6wtWYsSHIG/TY1150THzlCupcZqh4cOYNmm5rr zomLHCHXywxVD4qcQadzzHVTDpWJOaEMhzzH8jQvGLLBqTEciWc2kmVtYOfEQI4cCxMTy7wA yAZobziUmeFQlrWBnRP3OILWhkOZbwNriaFYz6y1F9Z2dafasI5mo97U80eBde1PrJuJ60zd YFq58/rTW8sbTd0bd2JNH8ZuYL1Ye/bqlVWp17Y3y/WaVYJfdsuNdevVKx0yTvPVm9PL4/Zr u9O96J61ZSxynD9bRhy2Do5jH8V8g+lk6ntD5/5Zxb2fupMRjgH+tKfhJ2u1B+OdWr1bZ2K9 KIuf8AtULVr2m2O7efHGPj07hUEcW6ur9WJxX9KFi9b5cfOgpXdeErkMVkOLj954MAvwf2ir IYvFnE6bJ63OOcBg45LEuEtaKOpwyJPxwI7WEViBwz26PD2gJbk4h/GqamU19/KzkpX4b/FV wGXADwfv3zeP281Odn+5wHk1FaXM3tb09YnMuPNz5/eecXSt1dwze543d+t5Grx3zYtTDR7V i9gWCfQ5P+u03x+8bR38HQHFF8ciLKXFvGi+iy2oOH27tfIOHD44feV6nQ9f/Mhd0vJb6UdO fdR7n+lHbhY9c7Olz1zGVs9owWdPv9fpW5PT81w8z9ji2VJbPMvdYtyXZ89evnxpDX2YgwcA r72BaxUG3tXaIJg602qv8KxSqVhawf9r1Or1Sm23AqhQ39rbbOxtAnLU4L9npVIpXrNRqW1W ahtWfXdvc3NvY1PUJLwqbwFSwT+IUHA7vPMnnyxn4sPwLce6mt1Y/rVFoCx/ZAX+EKjbQzB1 hwEQ/Qps2IE/fph4N7dTa/WgCD3sblcatdpW2YJ/dyo4TOto4sJN5V9P75yJax0hbAfvnrLV HvWqhAVzoTTmQYErCP7r3nqBNZ74NxNnaMGv19goEI32rAd/ZvWckTVx+x5sjXc1m7qWN7Wc UX8NrkHagAcCBIW4g3AH3roWnI5hgAuBf8BuW2/ckTtxBtb57Grg9axjr+eOAtdyoG8sCW5h E68eaIE363hcS/zjFZ/OUW8w67vWD+5kMvKrtz+Km5mX+Q52ILBgINfuxB1NBw+48MfeaHaP w4QVGDgTmJnYhaplEd4BgroubcjHsTO9HTmwURM38AczXKMC9EmDvxn4QeBMHorw8X9nHtSA YuhULFkAmPNJgBkEBWvqfHLxTPgWnhcP1oOWnEBdO70pNz5qH7esW5i8Y00njjfwRjdWMHCC W9ralZTxrCw2HgRTeIrx4M7e3bojruJhjeBheOXjJkK1T7CaZ2mLDWyPWO8y9kVweLeuBR9l OQPgofoP1C8Op+8GMJ2+FbhDZzT1eoG1inNGRgvGI5cYQayuwBiw97WVshVcza6LBet/ZkCd cO7JSlVVqywXZj6UQh4UnA2cBMQzOeFdmr7rTAYenAE4DH0ftmbkT+VBa19nLzO1DcZuD6lZ Yo3LmcRu2N/USR39KQhdo1LftWrbe42dvcZujNCpeguQuZD9JVwajpEQnBxuWkMX8PEGts+7 AX4YzzyODw4/UAd36E8erKuB3/sUVGkVnF7Pn/Rx4gCGdx2uBI8QApoiQNj0i6MDq77eqAM1 8odWczzxBkjiGtV0ArpZQfpXxl93kQrWiQpu5pPVdCpqBipGW2lmSfoqqSvtF1JZZzLVaeIB nJurCZxlRBFa801iWDbL27Tq8F8O6bwm8jvBFZwCLgUSz34Gih3c+rNBH1DtM9KQnut9dvFy 6sFs5xNlWmNn4MMe3XnwtplqN8Q+XsmA1GXrbuIBAohNzLxpCBauRtnaxPV3Rp8Ao60OnGoX gBx519DB0cD3J2XrtR9McfFOmlatAVxbpb6Oy3/ZaQKRgSdVyWRYQNOtH26n0/He2trd3V31 ZjSr+pObtQHPLVj7kYHx/fEOJjEF4nb1YF0OJl7v1jqcuOMxHOAf+vzLKwTgeNWhN626/dmP hBmbEgZuWmMDtqvUWIetw01DJlPcVit4zm5X8NpXZT8E0z6gPF5hpUihM/BuRsliIN103UUK 4QwnCidwpuKFD8EaPUixnIa6uYEIhj8khqH/wABW4MeX1tZGkRDI+sKM8nfIbbVP3wADefDW no1ohG4f36Di1UYl/vUqdlIExLoO3CmgF3J+M7havjCX2NunZ7F1v299LVv3RQ3A5Snwi2T5 f746LgJ3uhp4/3RtYFzhr79K+NYq8qHrDSz/7qVVK2oGiAkIWHU8nWDd1Xwggn/GFdCgWKtA 44GRKKoKeAHiCeZ1CpfJEouVR5xvo8T51pA43y5InA/dHtxCjqSi14pW470CR9ERgolZgCME woF0NpgNBSHH65UuaCZHYfuF6O3G09HbjW/09v8evQWaQi88G5DPfgt/Sxce+tuq05ZsryM1 3W6ILUHshlV+ARuLOzAY+HfEO9ziAmhoDqtwNfNgC2ZjWiCoZw3cz+6AUd4bwcK8YKZXNfoI Jw1FTa4zLNBBoQI+/QV8ZMUbFOINCpEG2r3SRo4GCM8/SbIFtHAGAwQGHBBnREwfsJYuYgaf P9q7ajYh+TT1hm6E0RMlgpzUK+s1JBONxl6tEScnWtVcirKJFGUTV70CMzjwR59dOD6O9VFQ 8ylMGtAPSAnAs6fWZ2cwczMIxDqe6l06vw08ytv0667Z4zbSeyG/99KCvc9/FC9CRKjzkXgV 4/vVOndmA6t1c4OD/8Gln6+mgLLBbFSFvf5RUR66iOsb/1rKw8ebtvBPQ3kE4XkyFu+QiQyB gjnQQjl4AGHgMHtXyT5wgviAoZrecDxwh+5oKu9UWnBxliwp4G9slhtwETc2BO+nCSrgsF97 giGTEn88Vx2UB4mN6fl9l5/1Et+cAC5l+aIPiN1SqgUfTsQ10DVa6ABqk6TjbuKMAyF+qgrU JShjGnjPGRWm8CqF+vAOU5MdIhuH5J3alWFdJyTlgWcrVOrdur1PglEY+5OpcwWNYUBIrKDf Ci4CPO8IggDtDryhN3LwFEDFyWxElaqYCBUqiT14d9E8/wnXuY57iSugjRTGDWfaw0mcwafJ nRe4ZcnleVOCA01r+2K5/EnPZbkBUHhc0QDWBpaJFhXXryzYNsAZ62YG3BGso5g2HFRseADY iWgwgRVgGRJJJQa4Sv0ZCynGA2cKfQ3Fnty51qeR2APnyp9NGRkq8m6jKQoVzqptw9E7sG00 RdtABcmG9cNLS5SetE/PLmy7iIotKJfFNql4xhPnZuhYbw4OLB+WZ4gXyeoK7vXnFeKf5cLw ktYpSadMUhv5VNMTiso8nngumoRqPKuB64zhWAHO9vkuHftB4F0NYANmI3jL48kBIuPLfWGq 3+Y9vIXDLIQaH//p9QqIJkO8HekIQ2HlmDpg+IjmKNoq0MSQbpRSQRXSQBXmgMIzOkVhFeBx MBsj7gaRye2Hc8A6sM9XhNwoq4GDIuiG3MzjVvPc7rQOzk4POyir7rRfH7fwlIsVTv0u+Jit DWTRN4hAMGkQjZiGWMMHm3+T9IFoVev15RsmXaWnoRWlp6EVpUfTitJ8WlGiSovQCmLCUIlB L7Hn+acGK0mZnAV3Nl7OVBdF9vI+uen11H0C5f/0BgNnDe7YO2Dzbqq9G+9vXv/lZn17d/1H Zj7SaNWCdIrvuxRatQCdIhjptEqnU6UonRLxA5YjVEVd5QuFx+3XB8Lzf85GJMlXij2JJF8p piR4VH5yJ941YJqUguNdncC7VaBeKMsF1AFGjC6E3i1iDyAdVijKAy/6/ExAV5GolEUjWNui 4OEtEskLoYbzYVWr8DdA0z3g6n7dt74KDm9zexdfMps7NcHjsVSFHkC4VEisYB6kiqjWrZ1q Hf6NivRR7g5vmImgGatFHHoPNt7ts1C9QnhPU/0nsjI4wEC+M4gcEP6wshK4v8/OxIMD6lof p/9kyhncAjhxfpaAU4jCYYkIUIXAnaJqR5zc6T/hbxi9kvzfOoDbrjsSkxG7YAEWUVVrlTWG tN1ZjyLUkQyde13CoorEWwf+v27VtvZqG3vrG7FnUbyuybtIYyfPm923ZNuK+j0gDzCFC7l3 mtgt43nUYHkHPUtY4LHOYubMZ1L6Q8cAjpnkZL4mcN9QE0hrtk6Pm/VvYpU/VKyCOIm2e281 bkMrpIPk9PvRUxS4A7cX0Zerov9X392uoXABT1Ftj/4/fopU3fxTVCujFVR5m3ghZG1EQ6sC p2XUu534I38WWO21M2s4G0w9eHzdo1CyFMN7EneYPOO5YepDHpYS5ed6lccifemp1N8lZmAz Z7dvuR4yHHhTBUhJ4bzDMFbhsoCRTgQjzLyOM3qwgCEIK2dNOZyZovS3/lg8DWBad8AEIVEH /uV6NmB2BZWf79rdt2eXXat5+rP1rnlx0Tzt/rxPSA38hgUXF8PCpzSSbpgK8jV4cgnESevi 4C20ab5uH7e7P+M8jtrd01anYx2dXVhNoLEX3fbB5XHzwjq/vICLsgU433FduvpKi1IVnvtT iUyeSERRosNwF2qhdPkRf3+eIlKIFON1I45h/JOyltCrw0vBGYiq0Hnr3hmygATwHhi1yunR YYcPTd8NehNvPIW1hFs5YMXsYadsvaN/kfl+D78x1vo0aWBZCD+D8OniTTRA/LxkvT/uEf4G B52RKizGFcFiRAraJ/e+545ZCjtGvmB0Awv4zgHsxOqAp0Oguozd7ZMWYqV48fEwkfXmiVtD J/hkddpvTpqdvwuu+86h3gBi0wLiwPzQ2MfH1ATJBnA4+BvJjNj6c+Trc8I+YHFIj+0SGwUH gKeEgxsBYXCur2GD0LghHIVCAejoWUlSxFX4yxpd48iv+zZyQy+AqYADCt8mWKzZgCUq3KW3 u4+1kzJVGCkaHVhs2hXWj0xBNPFuAKY9TdSFDzgZoDlfsDqOnmdiQxWg5ftYqlr7E67OpeEw 4DlnTT+XrRfTz+N9Pqv4MhEDYYJmfZHjwU/fWas1fKWIKpUfp59tOFo9fJUkyn6w6jX5X7EY TuuLblBHp8V6abXapz81j/f1TxN3OpuMgLPRSr8KkoLI/7kKPWFH0fFAyX60zowrrSZGWLKA kStaazRQrdEYan8//SxKvuIPfimFn9GwT6wZCg00NB/ORjekbmCKBzTcmfpDr1cm+s2CTn6b XqHkEx6McNeJvvu+Eje4cCezikIyMLgB4cZj9TGqZBxAPC61VuGI2Z1WF49ZWSJJ2fpeIkBR jDiCKzAZeQr4BBDCC6wmJMYpFzUEiQ4iRJAQC+Wu0k+1sPnDVaMs0+IWVTMJTIcdbg3+IjAl fgS+Zr9joiOJcGLxT0Lds11pbFiNxl4duKztOEeW1maB9w2bxuErGnYcn3iCYJEND+ISkj/u I1U7vJz5ojFf92e0WczaWVwjMpHTtjQsU5YAjQbuyzpw1/G9jFZeYBM709mVul4Rwmoxfa9q 6wtr50yg/J/axuDWqetbyH+L7dvEo1jb2as39jbjmtewYu7WbdPLSG4dN4J3Uaq9Xedts55j cMdKKt3oLmlvd9rudKWpYY+1W0ft806lvgMv1WqqiTJsay20zVh/vLVyPsCnwB7Dlxsqlizh evEo7KE3yZ9HsfufacLX6fnTqfWmap3Ai9Xl03CA+z8N9lhfu0Wmepsppnp07v5wWz1hQFgn q7yN+jervN/fKo83OkbOb03J+SMM8wIzyzwi8cFsaG6QF6OmS9o+m0D5g4XJSJ2/0dR/lTwZ ETEiS+YCq553tBqbWzFeiUr4eBGPb9XW9zZ29jbXk8dLVV2MX6JmORwTfGfXFPgVjvfvxz41 MtmnzSfhmTb/r3h4CZP5jfR7GPfzX3MTr2+T5mp9+5t9/B9zE9NWJ8iFvI23Ko063sYbm3vr u+nk4g+5j2MEZNHL+dvhN3ljb9YbsZuDSsxuDlV1sZuDmuXcHPBdbvz6zreb409/c+B+/otu jh16w63vNNJujnpj5897dQC9ftStEbZf8sIIV8fgxqAtTpAJwxtDVf29b4wY4fh2Yzz9jcFq bG8UwYawUNwbtUpt22rUUVWSMF6J1V4AJ5o4gwqZFob69EwSvrX8Fm79e+9b3NoI3Z7Y2Fff tLDQwOJIr21kc1Tf2ZVGR9R24g7I9JisHbWDWMo4RHR+FtFtGNgV7f357YpkJwJiWdpwx02N vpkZ/S5mRnlSnSr5SyxhZ/Qu1c5I1VCCn26za6MZjf0WCqXwJyxEe+2EARJGzokyU3xIpZmR at85bx1Yq51uGYrs91BSlDYI4m/ko68AnXBtXwDLjGsFFyy7MkQNV8rIazifYeXRGllbF3IC iXRpn3aoVwIT73nkjHy2FyLu3x+hMbnYo/RRMZxY77IqHmw0gp7acLiGZfylJ38Z0i9oUTW1 r7zJ9Bb+Jlhkx9TrwROjTIRqFiCLN7pBxwJkMvgO7AlKA5WptbXao/go0uiPqNqEFmcKCDd4 CE+jC/g6dHoTX7j4TLzPDosqNZoaugko034KwATs6uVB16YlhWk2YZp29ydY1NZBGHGv+/N5 6+wotW67I4vlhkRi8uk7BSwurdQ9jAhZz2BarPwo/06NPBnb5zwAVWFvU4z4FQwMpsvQtTkv Ovbnz2lbisYd5nU0Z5rQl5ylUV/4047t6TKrCz/t2Cqr+J9ABC7YOCbvyMHZKgTiIFiht2UJ cRTIozca4KCIMJLZ3I07tfEbHTUXelVPJArfI6zVginbp5G/i4osqc9Ms92JkSoxX4RflBPb TyTEjC9TFjyiQzpILUSgalHb19Dz66KLF6EeC61h73dew97Tr2Hv91nDBMldaB2Hv/M6Dp9+ HYe/zzryJbXI2slLcbH1SyNsr9sX3bdJyj1nbWX/Oeub21leJ/qCq34ii46Py88+ejZiFDhp eTwboXBhBXnbERsqs95vFauie9q+4YaZUdcYlxUnsvm7wqzAErR1ny4rXoa4gTJPcBpa2QZT unRoPOG3EX9MvROK+hpN98ObKXWJDGlo9kr1fp+V6i27Ur38leotvVILUMrs1Rr+Pqs1XHa1 hvmrNVx6tUJ6GH276I7pApbDMU40VxMeJMoV5ZiuoJXl/u8Mred9q1JfcNkVrc1d+vRl40fC 6sIE2PpFGFNrmcPzGst29L5BC/E5ZHvfhOdNUOskCqi1SaBBvIK8JKjXMDb2u/YpJ08JfaSp SHhOf6eVH/z8Bj6h8zTdAKcOvt2sd96o798Fmlv3KspD0Ef84OHmzhsVrTGZ8bvWCsnY5FNQ 8+elsKGBIkffFVm2IWpI0cEw6I8a1aGHj0P/eoqRatb6bqXvrgmJ9Vp943bz0/b19epPnepO rVh1gvH9j+oeMiU3Nf0swkRfq9OAL3GcmIjaIH2Co7CF+4UOURQtf21G8xP8cei8aLuWOgMY i3Piuq87h0QKTt0p/ooOV3Q+pcE+hUy4CtxRjxyxMBLAwO3DZSbEgZY1C1A7+U934qPn03Tq DscUuuBOC2gs5U5AolDu1Bw4FM+V/NAlnk1c3DLrGkgZhrkiiRxKMzhEA+0ukJXhOCAAgV8W YxbNw5Ez4Qus/5mNPkkRYUgwrWvPHWAIj/j4BBwM4wBb6E1J2AgI0NPRSLgMKWyCE8juQ1Xd b6ia5zCkvEuSKKlKR7HirzqGRa4Juh7m+LjHQ1nHIlk3tlC1sV7bq++kSMkX9hrQA1lLmoOr GjANAYjp+o1HOA7s/nsro7dRLwT/NmoiunyaSNR6zoHNbXvkun2boyLjD76DbzHYy/PH3xz0 HMIg7PD34dm7jr21AcSDaEin/Y+WLjCjS55696LZkWTOB4xEzxTosH3B4TlEdPZkDYxprF5I WZ8Bu4ZAbO62NkR4n6uJ/8llrNICQ5StKwe1qMBE2vwJ48sjRlNr977qMCK9fhg78ILxVFiT lLk92cTi0Uei3BW+Xsmt0eZ40XqYfBmhqGzp7NULDCL9TKq5kzoyYZoQU23qxUZ6Mr2+kaZs tyYVZU24h6+CqTfFM4SkvN05sw7gjOuGE9Un8c7/5nr/TSf2BDqxZV3v01VixFi9nsxGvvXW 8Vi5E9WRIaHtdA/JyEVXk8XLqZO008MBs6IBmwZO7xPSNLFgFy7lM+i5wR4HSRNgVgeUeYjP S3/iXLPjuz5pwKFRBXqjmf/PtFdfC3qNxtrdTX0Dv6/1/V6wNqpvbteq4/71j4y1gSsMW7aq m9X16kYZftmubpat7Wp9U1zgpdIjB9Coc+djZwxHYw1JxtpovbHRSA7Equ9U67VquFnK5ggV TXA1OMBMEmM7wtNsN2OfH4hfZEYYP2GIKBFnIAwZBfUdLUar0PKtelW3WsZQXeiyzpxnUZzK QJ4isrzCvjBWFIcA4OhrdAXAebPc+/HEDRIEgDNVBBzc/s3BQQEGb4vJ2TZQEkzSgKb/HK8K iSDNxXKYALiAspMK1ELcQR5eTY+1iCPLv/of9KKmIwVjxpFW0VVDxGG7dzC8ZRnv2fudLT5N MI5yZBirfR+On1ukw6B9YDMAOob4T5G0iTs4WMBWXAi5DXp7VRi2E0HlXGtDBRmEnWIyahUq Q2pSYSAFXHZ8zGnqTEv4jMPy4MuRqWSftoIlJ3IxCu5oNiyoXSHBC5BsFqzgNsGbB8PdcfQ6 0oi+Pa9cvocnQBU4ux6LXJrt99Z6tVHdtO4HPaUmTbUyvLZSEmQxysAbCw+P9UNvgAyMbU9/ lLxBuMS37gBD0AsbPyjfx4rwv6t96+u+ppuTKJ+wEozD+gEr/Ij7e1VUT/D5YKLGhjQQQnoe SQhOcEhR00UFVqOOalheYMs1quunG3ZvtZlxtMNv8AfvsghD5k9CEwFhbRseiaZATbjWvLnH NHFI9sIoDxhUQA1yB7hWP4wnIPk7WCuqtp+ofeVMePfENUZzoJH2+9g7HtajszMW7+FBoF3A 0tdwCzOKythIVHlHnoWmHt8B0BijC+LJv/MVxeIYnwELi3CpCkGMJtIh5TAqinUIA+Dq1S0M 3ziV8SPpD0s8whsvXjR2kKpAF14PLnC4zIHBorieIhILVKmvY5WTzk8HCCRy9uQO4keMMuDP bm7DwUvOC85lrRydttpVghAedVh8gqUCPwoBk7bnAZQBlYWacEP/AGecCUyCJnRmI+vA2qzW 62UMjoHAaE0sZwZfJS6iCbnkAYFBoVjfGCeFuFNnpALiXDtIu9Si6nQtDHOOt712WbHhRkRM ZiFmhzhaQQsYwnMU65QVAuKjC5gZl6LQVFVl+VkYrBD9lDjG0t59jgvEU0CbdzjFGM46CYNv XewaBwwE2GXKqr5Hb++inLHiq1RgSXz52nb79Unk9/Nz/qt2v1mv1zg+Zefy9PzizD5I0DIn WHWKSG6mgr3G+0xSRXiEw19OsajMI+rrNYZ40jmwf2pdZMLru70BScB5NgQlkZdZNtGgyEVI +SQG5QQxmqgJJlV82Ch3iUuXLTnqO5OblDekKAz9XXdRhrTZSJMhRWovEn4i+nikAL4Th9Kq CPHSDwI4viJTZUqPMHv+o2MIPK1Mqd4gX9fGN1/XPzR24qs3l82LQ5kMlg7ZxRv0fs07YVe+ P0geMVWqIrzUtihaz/pebT15xiLVcw/ZBh6yjTBBQwzvUfQi/La3Fki0MAeKUcIE7RWtv5ph F+jnqx7g+LiKtzJuxI8cr/Tpw45+Ozr/iqPDd9Lrs7PjSFKXSHHOIcJnU+IMyUKza0qvvZAX R0zKybGv8ArRHnTlNEkNoYYXBDM3yHT7+DOoRf41V9i38L//shA4LWDUrdcD55MrK+QcPfR1 TBw9WahizdV28faqre81Gsmjp9d+9OXVULm/HnN5aVAWvbw0EXA5cpOVrQ6crs7UhVeZP+iX rXMyMHg9m9z5fj8na5AMNmx9Oxn/gpNBmcNIbG7t7mruvbnCd3Lnpewd6+vl+pbcqR+gqUym GEsbgHfdf112unb79OD48rCFabS7rRP4s4tv3Q7xkYiwZyOrOepP0FBl9TUsH+V3veoVy9Fc jTKLUKBl+7hyYawsH4FdR+GAfCsWOCNWgSQy7oTqqdCdPQeJNJnGMFBPBC/2OUwvKaOtW9dB wk/e7PucA1dKNun5T7UKgbaCfHG1+64zwMQirsRIEhLY9uv22Wkbn+84II42ynYZ/gizrYiR O9dTIbCh6fegnKaP0gpKDyAG0d8HOGjHIqA3Tw8vztqHAN4bwcicforXil5LmNro6Spgh2yx Nzbp1MMvqC23u/YhvATQfxmf6q/kxp623ndfWa/wB3I3sMH221dKoErE+I2LAjQ/cIVbMCEX nhqZ7lj2BFsU2QQxWUI22glAdl9l8sA7fEUiHOzBjq2SvqBwdgUWDHPeCRUgp232J5MHUg9g AhAgD6ySjHbH2KWlpnOsFRw49EQnYWMXT8LmTrmuaBYGh/WcmxEcZ68XyLNghQINuTK2reWZ l+FpMTD0eOJWWJWkncmoxDGw0FqCkFjp+IV4RZepP0fLHmFeAd0e2Adnp51uE3o/aR5cnHWo RmRkiSrCDEDKcOIAj9sn7Txo+vc4KGUyQFM/03Y7sIbOg0hGRnju4+ynJMq+mt3cPETOGi96 W+wYJd6hU67TJAyyi2cEdc8rKSENVp5JKXakGWAJntuJK1vMEO8+eeMxIgMqthE3SPh45fac WcBhDtf5KlsHErmlEjWionCn2qjCRTP0psQ+ypzW/cqd1weiLmXvfDaITlcoIEKayiRqApPc jYreaV3v1r13etPsLrHZW1QJ3Mk0Siol3ATI0qR366H5GCoEWXVAinn4RteflDRTlhe4KYDN KG1uNmQOOJm/pk0Y9t4C8oPrLk8FFq2+YlM/jpBANbuvytar1+0uUp+zo7Cs9op/tTuXRyia KNKKKYngd4svG+UrC1duo2qdsFcgXopx3cgyexQ/gpHO6pHuhkBzhrNhbKeineNLTY+lou7z rtu7HZGa4QAonXcDizIbWvUwM/NWDXPvlLbqG2WZhEuk4gtT8i28lHHqwaupyWiToiQihkzD wt5W024quImq1WqRKWrKyLJgR26wDG5EH0jeo8BPeRP4+pMg3/BQr7xsSAUCkhNRYYOd8pd/ YGsAvj2zvz0mzMRdoYLqx5fW+jPr1flF881JU56vt63mYevilbgWKPeXuhNS7AQsxS3619c2 mxwFHKIHOj0F5ocNIYd4oQumoRwy8dYNvhysRnWHdwBau7KoXsdLWK1C4hPbgAH/QVp2cV/x KCjF7tZG5cpjqxEcwSjijqByJKZmmedZoRYzqny7dh26TlEXLX1ekBW56fWkWjew0LgCR0t8 Kj/E6jsUspd/0FJGfDtgP47br20S3B28bR38HWk8G3Re99EGSU91ySU0hMGd84BG4hjaRxqJ V8h4tnlxap+d2pedlrXKDcrWimgJawGLsN7Qno7CbSERNb9irTwrmQAcZfl6JCAPPLRVQMBW 4r8VTHDCsgakNbOBmm2Yl9EbeNOHFS2zmog+vLnLQZF3F17hxAIvur5yNZ5odePgfr+1NVva 9Z1tXFr+wfyHWLmJm1g7LspcPSs5XW5RFlkAI0OW0BZd01xIv99yij7mLujW7m4ZpZD4E27+ LJYO0PeVwNs3rW7nlcjH+0raeCMndGZfAL0mc+/OK+SfZAv++NY+PTt9fXx28Pf26RsCgBB0 pi3kETW5goBx2kQnIeiKc/WKXb9xpwH/LUguFliT8cBWX0SCXtxrHNlh6+DYvjg/tlaxRllY lZetVf4lKBJWoKYSRouZSqzV1XqxCOtGIA7ev28et5udXBBYWSYPjjSCa21Oo9i8tMFLIIiw DAT3Ek1hSQoEFP/BmjgTYeiMTEHf/ewO0PLRooyXKAK6ng0G9Pqc+AN6S+JTltEdri28FkVG VVpHYeMccL4l9Ef3kKkAhiV0/xJnjQ2WmHGJHDX5hmZZlbC8ofD+Bzu74Y26TO/7mGLH66NU 56BeF2aoQx9ZrdCLQVtPEmbRK/Gi+c4mREBcTqEDvEUrNAykHmg+OwN+68G69elc4ziv+TOL y5IHa5uTlW5v7Sx6CYx7Az9wKfV5fLznB8dnnVYK3ec2MOaxJHmzkbK0SqftYRP6JaWNEaUR rRU3nKA2MWpCLEhtc6O8CzxIbWO9vJtFdJRoC0gZphQjltqZ3MwEjgfjCTxvrzWbtVtgdQaw uPTm4TOEhrU4NmWgewbrg959rGpEEZ43+iRRiqZBHsAqjFlRHA/CYvqEjxIS20TRAnB+Rgw5 x2akhNGTGdl1zZsJJh6WswG4gTYlHBi+HVDeyGbCC87GmxbLIme1OIcLjx93/q1/h1SkjPKd K8Bk+CO6C7rBW+Bcu4MHtk4EtEK8ICDu9bXX88iKDQ33gpFoS6J1xCJsSAL2YJ/NJ+mFARQB /3/GMWGp92saCM0hhBHgCIE+RBAUueuOz68VFsrnPdVRs5R4q8tCg1xRsdrLv9Y5Pmr6c72+ u8sx9Eg5t1F+TETETFj/ti6ELF7f0NiZyLtq4Dt95zPHmVW0ppTnIi6uMkwZ7Q7HmDIa5b2+ UlrRvVJDnmX1UQ6HFEBLjdUTWSaVwFvnwS6ap4dnJ/aFlBKfdY7W6mhIKwcbWAVhPw13aN8f 2hhTokAj5wISb6vk3VIrxC/tHRLxrSsOOxyUaqsRbMEKfvdK97UWAzxsdpuvcBXE13DcJYNG irtUzVJBRUaoxxu29Pt4h9Bid6Nc34ijxWzkoV9NAiOe5s0tbZAVHIA5BiAA7g49K8hZUcBo VHe3NKQKpSMW4VIkq3wD8SiaUB6lKLtbetRhYma73Yv268tuyz6/vGilmPDyaIppbgzJ5rAu 6NX+oAlfhZquSzwnpexEk3J0Vzj1hXs26k39sSesq3VLi2grOvQJXt2d9qqk8EvAYKkdiYbq G1uCl8Cce84kIA0E6/PgVHhDIB9CHM5X2oXwjUcaw94tguDIWpbVmkxkglV8jkVd4C0dhZvd s+PjV7F3BvH7ztQfDMqW8tIpRx1aOex19rOjtCzElKdnyn/JHV6gXcpww1OXfPmYjRuBJB88 1BY+ccRyEgI0thqLstY3+KIYT1N56zfo8nneTWOupwG7HK+I9vJ5PofDFrXntDPisiWA1Pd8 Coe90VinW3B9B1/36Qx2Sb9RaLXss/PW6Xn3lR5kBy7vo0OLXhVC2Dx0AlJ6w9OLff3GgTvr +xW8tD0M3GxZRwPnRnKx7E8saO2ZfXH47oI5w6EUl4YfT88Out2fNe20PF6x4SXPxNgPvHsb h4kL7qGjCqX9vcaRFIt6AK8kYs5vnERIvU0yQk4SB0vqeac1FJOMPfK0uaa92yKDXdH/TMdL o1ecDiUFydKc9iPo0+2ghIaJrxbKbuxMb/HsSNIaQxUrGJC+Pgj8nkcxpFG1QEdCw7SjQ7Jz YZkZuYgTyYE7xiX6HF4FG+vM/G3XyutmaM/jJo4EX2nu9BHDLuUMmzBehpPjaLXQFye/DT8R iJE/qqCvUXyCpajITR/60rK0UihLE1TOnkRMMlQpSdWidbTzFBWtqWqRw9SXUi94YJYt1stY A3eUOGBLA9EC2WqkQ1unFLqxTC85lGSpQSehCRojoS1GYPRNSlIXuRxppCUc/Uq48csTFQVi GYoC/MjpT6/EVR1ifVi8JMoTnQDWgWxM6rvlnfUsQhElFfzgiL1cVGESs/itVJacDgXImnMP ZTVJYgbXXAgtuEkqTvAsUhBCDmiFf0mTK5oggmhthgWPWvRAjhjXDpZwNhIvAE5f7s7dAjMA yQ0JltiRIGdLOpl7oka4Evy77Ao+7jBOj6v0HmmPjORap5FN+N3GX1PfN8lXSaM4b8d/l8Gl I4nqaiE0Ua1SEaV92u5icKV0iq5NbkX9/m9wjN3Ylkg9mTPhoFBuzoM573TPh5txvN0lNk42 Sj/grZxtC8e5In/9YzYtS8xYSW5cKMVLyumehiMVossoQyoLiR+N1MhkR2UtyZMlJaPiFIts jdYLjoNiIkJJwcKy1Shm8LRLjySTu9XEoFksyDITtx4z8cpzzfQ7Uxr02LVIwtVZI+KZzQVD CpGIO9zeKdfXrdJWbavc2BQSJsEU/pnOR5B6QILICQnMjkgQ3Q3TGzBtz/APQUsXuqKTp+X3 GdRyRyk+FutpFsgyXyCzU/X7jHPOkQuWOnNB9NDtbpbrm6h32iw3dv+8h05xUbFjp5XTwYvX yzx6WsXF8Dyb/UwF8USHtWxtZJ3XP8tMljvhydFbjx+9tcQ+WAvtgxlZ+LNMbg4h0Ya5ECnR DxupsOsbfINv7fy5b3A3lZaExXyHu2aUJKyXc/xi750nusPzmN7fZVhL3uKuwSlYeIV+D+74 dxnpvGvcXerwaeiZbVk1uaYcJpHI67JM2FWtV9brVm1jr7GRFtVHr7x0WIT67i7ZOdXJzmm9 Es1DukSEhHyAhjZUp2fd1h4ZQvSckc/+d4E/m/SE/kkLgjB0PHIrFionZR91YB1zWgk2bXiN IeaFRR7nEkDHXzTtu6mQ38qrMRRXHa+KcQfd/oxdQzbIuY/+RZLp3k/dyUhcAdN/oiz/w6/7 MRPNQ5/j2109TNEL2cc8SGh7CLijytmCQkXYK4vopLSeJu0BZXs+uuhkAaJc8ap24P7vjIL8 cm20KfTIFH7oTFGXdpJek6BwbdL6Pcg4qMKV24o14RgHvv+J7U0ZPgGBBjKwYiQ7fcABBVIn RoaTVw8UDpqMHHbYiWRnN7TDEtdD9+z47F3rYvXgtmwdF2FfBxSgEv4uJvUYuEfvXKvvjwpT Mpj86AV978abFsiMRpiFIh4NfEA8NMYZQ0sKYhlvWjBuKoJ7uhPAM/Y+l2qkO+F9T2FihSHP O5ejGLB/uk/ZtMZTpQZ2Js6V17Oo60AG9W52DtptpHQ3COEMlqXv0OqxedbYndw6Y9hXxg20 TJ4AQSPZ2R1WlL3IiAEuuzlzJ7pGmWxN+Ac7nrHL/ClQz8uLi9ZpV/iiv3MlvgydT7wsYdhJ si8KtJCWvHZ3iAsBGhYNnAdB4rGhi/UdaUY1pUSjAsRsNPUGMBeKEjFinzYGhlk/hOeKHopz SMRKxPPlBCKwhC45DATelLsRiPlRpiUaFsQtvSykggaJ58Wtr9AwG205p4zuFCl6jKR9tQjr NxiIAKtoDgY9/NPti+aEII517d7Brc+xO6GrQ4zOwSG9WVHvE9aJqBh8jvWTqSJVBzIOQhfz 2opIGp8QLTDpimypwLGTOs05xI2dXfKk4x9hJAf878YHSH3fHs0w+LV95fcf9gW152gP6lMw dgANnf6e7nSECWl8pP8f7QJZoch4zmSU7fX7HFznY62AlgQfK1wpdKeIgynkgikwmEIEjDYZ zKQBI7S+e2kd26tQm0xYtZJKoRjjgvAjf7MLyEzM5wxuUzgDaXFdr6zXrMb63vpGmnu0XnkB g2u2lBWRMa4pfbDkMbKcpEUcpPIjw2kmwPz7pqNP39Gp7w2d+xizJwvFnm5UGnXcpjqGcUzu qV57gU09oJt3arEtIfI+cNRlABS2VuNzh7eTL4IcQ0fwriX6mmlwv5swkjfiG9Mt7vOA5eDC MxGy5EnxIXcbB4k9HOgb2LBq23vrcC630zZw8MfsHsW3yN+8egX+gVMH/25U1PpzSM7N/EdA +gYuAjC2obRzv+NDII2RD23dV6rVNWbWxA9vdO1Xb1diTP2pPyILNKD8GM9lIk20YVM+0t7O BnzziD8GhbLIsUAhbkbsUJENpKADKWQBoYxqmkgKdzp0lueQQpenHPIFJynYY1lkCSSr1yiq A/3IdjVrX1v/fdk85Exn9OYtZ8x9kJg7YZ0+dOujMnLGgRekBZ9hPwW9H215OMyY3k8htR/J pGJH2sIcn52+Ca2vtQ+d7gW8KWz8jq4E1rH8jV8iDTa3bkgWmP6vop3X0/MuxdOHA/lRbZga FC1W+Bc+pDCE2utmpyWf1AkwhXQwhSwwRBmv6Q9c2RonunPYrRHN9tFwUz2wLKYrPWG/PHAd CuKGQDjIuweI0ROL3JvCKcSY27KetVK7X8GSldr7lUjdW/feEa4GiSH9YDWwzY/WOhB76Q2L NqAw4XpNxMjbqbF3e02tNEUJCpGceLqDW7f3ieOAC8cFmZQASYF4H9HLCPOqMFsZ7gthAS4h B5HzZ1Oy5NbbWB9VJZ2nLCwEoxCDIRhJZD2vMa4aXDs1yTQCO+nB0qyO3BvywopLu/5mVVZX E70XrdU45paserGI/woyuMl0cFMx6PxQo0cXe4viCwTf6LDJFNmPov9H0KeG+1bfkmkkxNiu vQnmdbjzST7i9NQzAblprFq4F6sz5cQqU+FGItpruBI+OulG9zixAFr+0pD4gSxthxG22NPW 6SGeGHqkBNI6/+P9R33PUuvA0CJ7AnRwPJ0gN4/CSsHKf3mmsf8B2jtXrBFW+1H4HnXPLs/P Wxf88UOl/msR9xR5/veF4hy+IoWxCDkLCpBaw1BIexu7qZzFYKFMjEiqjoQ/Ly7BWDgHxYg0 Jw+auvepWRnRURKv+u2yxsEZ8oAZ/Rey+y8t2r8Z25gVUzVNjJi/g7PkDs4G5sz9bPAEklxa icfLb+NgjELcmi/jH8OpzwZpG7LQjjzJoUpwAI84XuabmjqQgsFASuYDMUKLJ+HgEZBEIBNZ voixlXtmH4YYGSCCIrJIJVWA9xxs+nptr5Z4z+l1F0lbMp1dsWyFAawWvyW8jUlQEslKMYut O8CkQrFABNEPJglLYy2MUpY2dndkztJY0hlOwcvwZLjixG5sf8tW+i1b6b9LtlJO8BwJQVjK CEEYGkvLCgdnx5cnp51XItfe2YijMMQDjzuUmwlLSEj9YzQaRew4dXDDMJ71AB9CKryjihYu oorroci1cAEimMLPHbvTOm4dYCDtSIRu2w+uOSLqqkHU7jfHEVD2ReuwfYG/Hl2cnejtipFO YBHsztnlxUGLV1hPXmIELjs6uD4xzuI1eMys2yetZSZNzZ5szgTNfMqMaO2L9ntMKVsOMQvf sJE49xEsVKE+xNcwQvxV0LezasVR1LKaU3Ho8DkpYqjDoYu4eP+ATJczIHgivrXU6UmwpFSD Omtc1e4BtQj7J2g3QBko8tYDMEn34jUswSVmzcn4phziXgb+HjBNFzYFFLXhEefLDNeCGy+J aa87hxK5F8U2rWlxUdzS2i6KYDKs1CZmhfxhPL3FOPvLoJcB8sxFHB27AuHdAnulRiW1ma4c Rh7uELC1WTBZExDXQjgZWJSHQXp+1KfDIrH8cap13n1LERZjREsWn1x2W+/JH6zdPG7/o3Uh MMaYmFLChVJmAjetRYgpFEtXxUoqx3ZdhILHW9qjUOiw5AHrckIc0VKANAeBX8YQ5jd3YjnQ UuImcKf2lG07yjLingSBIY0U4ojY8hTOH/mEIJlVWA+tW8q8N2OXurVBByE6N0CLzxh+UJkm +JM7DHavKZZZYH8dWkMAzfrsoKID2YKRH4uXQ+hCmaU5Cy2txonTO+tY78uYLrnMaZTLdAOU gUuFjrwAmWogqN69ClXFg1wthisUMiAM+zWmr6AkJmjWRUYIcDAHgxmPZSSCIYsoyVoAApHI 4c1x+/WBbbPxZWRxuRc9V4PM0wKX1jZNXIzbqucsKsUdsQGLz2JpLASjDhcKGvTQ8mOOccCR 1SILXCUbHEZ2/oE1ipHZeyNi07V0LguuhHYytROrh/zCGUdCgAWzUbSAeZNI0evWWQejhIkU K/FoYekLL6cXX/YuhTOiWvbIvZ+G5i8o9h7AQeFs4JXwaN7MAInVNE2Jh9YnBuCO4nVBnuHC UshHbQ5FDD/KcCPCNGnzorCIRIXR+Ar61K6wImGFlu6H6uXMPglNYGxR47Z1y2+xKdHb3b48 4OJoYDdFrGLOsgZEV2VHmkOan2uh1aJbRYEGJbkOszSlsHpCXflGRESJUzBWcVz30Ti9IBKB yDzbcG5fwMWAKSmYAI44Cba6JsJDlEo5mFyIhPH1cvT59LsTCO2Ah1t5O57dzz9yPPCsoM57 /HCWC6qvXTXyiSKqrhb1i0SmpwGuSXI7WpBbS11i79qnnbODvzc4hxLbxevsJp/m9ukbrWY0 BU9uJTV7TFjt9z41xPylP0Nuay0dUDzIYdIR+dGR4dJgSBC6r3VaZLqSaH0EVypaVUaGQdJj fQGqesbtlG2QXu/ChF5sh42eHYADHjCWU9HfhVsR2wCY3e50Wl1ShxOldKx3nSZbSAKXO3Cl 0QAyrLNA5iAbudM7f/LJwrG50o61hOb5Xg+WfSBSXT0r6b1bqzhY6AwD1TBaWi/QIhYI1xcE O7ORY/f28XfSBkKFl1JZWGKrStZO7rOsB8nnqme9hALLs35AWJUfAXLPn42mUFQqiXYCGn1E GdXDB+9XBH3dV44nAnRdgNZ6+sprK1E3Z305i1RIbQW6ylXW3lWyaBXXApfA0uGo0sSl9xZP JOGKjBwcMzBcFGueR89ujOJfnrY73UNxsB7thsQBp3UywEGd6V8bLdNtQTJtRTJtjppp3/LZ HoinVTKYNoeZznClX5G0jszfU+iyis25Eg299BTTvnEx6vAUeZDI5LVy/ffHLoQGKnM5tDpL LYr6JQ95iCegE/9UCMTkJurDRkUx50Aqy1pHUldwjdsIdvqjEbAlUfzksgh0UbYoeOFsoEMX ngGR/7hsUeBXwAREQGNBfNexbFHAgChjF4VoSdyV5aExeli2RDdYnNaNLNe7kWVLduPH9iEs tuK9+IvvxQAOjTuKdMBF0d3gskWBT9ze52icEiiIbzSWLQo4cGMYhAUJr1t3cQzCweCtlBg1 XVWxUWPZMiOf+omxA0eTGPvUXxx4KsYEKRgTLI0xwe1sCjx8FGdkYWQOosy4g5xrgutl3hD8 OedyoIccVZIXRPq1zNQy+2Lm74/viAlnZj/8+fHdIBHN7AQ/Pr4LjY7mXeCyzpN0KClqXoey zpN16OfsV1jl8d0xqc3sij8/vhskYJmd4MfHd4FELPvIuk+BfZIM584EKzzNbKZ+7nym/lN0 MxfbgifENkmkszsTFRbqKo37DsOpRYMNsyAuEVRCL3+COL4sxYtG8eUyjuGrfc+O4MuVcgI2 UNAuKSxA8+aJ1zMryQvpIpW6nLBWB8MFShmkvmRFD/73mkB65GKFFylxi//d5pcTM/nfbqsy 4zXzTBaL1hwex2SsZkaAtEjNcs1W5NFePkqzALBEWM8Mevak5CyFmmnEzISWLYZe6b9FtR/W i8xQN79TV5I+pAWK+f26zMLzOJqnii/j2xfdPP4RfS+hbhJOGj6YGEVtRtFwl80jr2aeqcwj pU5U9ECJfIZpmTiNjtdip0vPZ56n5YulPl+gKtsz5CUsx7fq1Ek1P5bFJmnL4/UXMBs/Zx2f 5bAdqTTFsYj7ApjSwgYHnWFQvrm8Qfnmv3cO8wZ5uza+5TD/I3KYozshTGLKgTRawCRYrwfO J7dsnTuzgdW6uXEnU7b2+S9vaJ24D+6EE6dSe3L6pCAi65vCOzl0bU491N0mCu3Z/Rb1xajS +2RPowp7Wfi7ZyXHzmLcVBgeZauB7v2YaWErnnGt702EvQ8AIXOvrQ3YtM5PB9Yu97pQZr7Z 0Ak+/asS8+EIj53JDeAs0tAOB6fKWk/mnwDs4dm7jr21Yb9ud2FX7U77H61X+jWJZI4IqLe1 EcuRQdjRsdtH7aMzzo9B6KKVKMduLgq/EcKtU9yF9Y26yJeWZCquseN4ChOx0TQyjAiZne6L uQQCojEJmZNGo5Qr/7NLjvD6/AFJ5RIoUwfx/ZoX6Fqu0AI51rFJagawIzxdjLr1OuYJBOTd KG+qa4kjPIlYWEiy/Kv/ATTmpJ3P9YETa0pLKA1Z/etn2tODLkZxewxdZySCiclm7PYhAi2R KELEI4LfOQlq33cDDJkNC7zqlK/QLunsFpZvMBCZ4VUqaZotJ9smLDluXrxp2Uft41ZHMugR ezWNL6eh6IapelsZYOgd0lH9SxjWAMGtonFkMTTmFNuKP+HIPws1g7j3dNfA14kLZ7znilp0 sKXNJ5WtwnzFJCP4wvXpAGizlyVaTQDKGd0CoeCn5mEZZw4Hjhtn+F1kdoyF1hyUFotjjtbR jUBf9jfvkChF1j8kB2w7wdcEcK/2egP7J2+CruRLhfkLW9EJlilQdj4ClhpMZCzKnkesnyjU 285dQm4TquutyAG1TzoH9k+ti9z5PeH01hte9gzpY9ok6YPZPJVC58+48NK6Q4ceTjk2MhPw WgTTwXzEJRokkDxvT3MXLnJ0EtuZsZtLbaa2l+YjyhxO6lget8opZ+f3WOLM9U1d3N9xZb3M sdC31PX1DEekLbEg96vCbltHZuAX1bIX1Ui0GzZ+w8zp25ICq9QLhpip1vtu6+LUPuBg3NRe z5YqYcV4smynYjKgTb7pVbGhQ3FY38yduLYp3YnzXvVs3Ss9Rb95FX/zKv739SqOygQ0OUDE 5NPU7TjH6/i5fiekCAukcyk78xu5PpbVbgMJQY0n4ByGlLpJmpqHPbCkP9NTRKsUahGUt5mV 49MQTuCx/SrlmnzFZ7spxcz3CSdQMlFG07N0X4i4y5afDiUUuEBDG+Vf5K0mDLmFXT8uujwO qR3xONAOPGJgjE8jvkulATL0eusL/CanE0pdL4JZBwng6Z5NktWACzDU73QvLg+Yr/ipefyK 5CYJFUDC0zXTL8DE8yDT8WC+38Ef41KgB/vPcCl4jDuCEvKEGrRnJRGffeVgxfoSs2/XHICi m5W3kcKcPqLKi9fQ2BypLkL+RvyuK+KU+i9ml89oF7aIoqHwOOATYk0/24HbI4MOGb4Hy2Zc +HU/Mp7cftgDQB9bZLUSa/s1uaBS6/mm1cX1ODs6bP78KrFiya+P0YGG9rE4D/+67zxEuV39 C+1EsmqmYlSvmqNAjGsHQz05OaaE2nHDVCFZeUKeejjS7kC9fsNDEdukpHnFv3RptE1D6bcI it9zAl2eGHOSLCOvATgB3AbUopvdBVIPbNDkZoaucUBZDNIZ5tlK/NMHfHshSFJcZmwfNDtd 03VbciOz1NF6p1JZPk9PnHWwEkJhHVVStMbRCa9EjuOSGTsjMNL1xgmTs8f6IFkZ4gUDr8I8 z6QnIH2ab9Kyzkm62GEx96Ql/JN0wduTEP6oi9JT+CjlroeBl9LSbkqJxEfzkCnhqfQES6r7 Kj2ls1Kat9KTuiul+Cs9pcNSwmPp6VyWsnyWntxpKctr6cndljL8lp7acSnFc+kpXZcSvktP 57yU8F56OvelVP+lp3VgSvFgekoXpgwfpqd2Ykr1YnpSN6bcmyTfkWlpT6aFXZmW92Va1Jlp aW+mxdyZlvRnWsqh6XEeTUu5ND3Op2kZp6ZHeTUt6ta0tF/TYo5NS3o2LebatKRv0+LOTY/w blrUvWlp/6ZlHJwe5eG0uIvT8j5Oy7HuYeSip2HdNV8AA3vy2MXFNUwuLrYEz9mygcFtImMp 5a2gpg/JM+VmTUae0XaKcjeiqK2joraxi8bam42ksbapUjeesKlJKrlKMHVGfYyb9YOKMZeR QW17ebPs7X9vs+x1Mste/2aW/UeYZScVrFaGgjXvQNkTPV6+LFE5CTFJydbe5nYyXL5edYHT dOG6oylq1EkmqunxyMCU8nUJyFnHizOQbakMZLDSS5+3dFjfDuCjDiBjOW3en+4A/h4eEQnr ByvdQEl6D1TgQ/zQheUGJkqxBkY2Stt1aaLU7PcppVPcQ5Rz72aZJ9XrT2WetPfnN0+SnQiI aK1EUOIWS9+slf5wa6UqJZx7enMlupoo6h7pFWdDGiYck9j5gDVDR6fXlI/bkoneyiJknzBh w6zyExeznnHOToEPMlB0zfrhJar4YZA9/HVX/qcZT0lbkJ4/uvZECE6V4DIMC78Sqb3ijaaw TuNAfIgd8Wcl+ZsNlCOinKQZOuUEUbiS4RHjHyb7mgnDJLCA3FU1Swbx4Qo/XOkf0LphpKrT CpS4xihaBXMrQ8WKVa/J/9TXCUEYBSJcIhrz0JpCK6GF/qIiK4qqffmepNo44JcWBo63T5rv 2yeXJ9YqD7moqbG/6K8j1clVENN0Ux7sW6CVtkSHfb3CVVAqaQVf5a+6NT2MM6z1NZxV+7Rr Nw8P7bOfWhdHx2fvcORlHEF8mmJSP1i1rPHTHvGM26eRGUdGy+tVmz9gDXhk7nsZncaWOaVT dQySndOPsH8AW8KNkOEyBYIBjEmwr0pGomgkyvh4TyioZv4FHcyuUi9oKl/kguYGZhd0Q0tJ NMVki99u6W+39LdbOueWBgS8dieU4/bKnd5hRot5NzbH6o7d2gvf2ARl0Vv797rKgcb8aa7y SspVnnJZj/SbKnFVY2rb6J2fdm3HLrG8axuGDttXS7u2AQuybu1KxeTWVrVit3bn8nX3onnQ ffzVrQ9x7w+60X/Pm7vyO97ccdkwly1wY5u6/Oyo21odI+i2w8bpJNmi/E/XTs/N8vepkeyp Qf9uoARqk37NTtJKYL7d5d/u8n+Hu5zScyiVFyp3OuetA1aTCa2WXhiJPqH8VvQLX6ZNL4v0 9WM/8Mj9BDpqAvV8XYYfQBro54/4Y0LnEusMHuRKHcEKuk7vls9oMHWGY6tbFjmsfHTcEzc+ oQlj6Z5oC1Ozuoo8YRJzPQt9rVoNyaBEX9UkoBBsExySP+oHHJoEWA2vbw1cZywNmeEoOBZa HXL/AcfZCI2atboBR1zJHlB4h1ar9TlDw5RM0HDojbzhbCivfGKFkr1U6hoQKwnEuTcA0ghH F0IilmswQGciSqgrctanv4F4iZCwDNwg0Ed0M3EdTqADJA+diABXAg/tk3nFw71XJ6jNFWH8 aHXrAC6XkUjAeALnmsTUgf4qkxMRI8F09SU2dwSqxA5UsNWzATn44k0AXKyiIXeABw/kd3aF f8q73fJHygNSZa+Bk0sXiRtMpawcTzEczf+hQF6Bh9wvDj2YiayCYegYogXrDXLHQk7MxzEA bZeTvqAQFDiSFQyAUgRqm8bJFVeYKKDVNfnJka6GIKyEDX4IG1h/Axyx9jS+8MfwIwAjQhVm quOM0Vp2a8ruAbhMZt60GcKLDKfvYLgJPqZ0JUib/8+ej/dCn7PfcM49WhgGsOpWb6plxdm+ fFkvh+N7+bLSEDeA+g7X81X4XZ2fIqEy4unkZuZcDR6oKxgxZ7cmIPiWcCieB+ItareALF4G tOUKj3DomIyP5tT/DHeIc+PKWwToO1IuaEBr4I0YcXkq0DDcYzoEXF0iWuSNE16PrsWbjD4W nG8FE2Td9GCv3zHi0lUMF9oo9IVMzauinh49oJ4LPT0EJ7cqt0FijUQanbXcU5sl0YdrxSrl Ym5RZlAJ75EKbDzsLfzbd8dokQCL7Aupr3dD/mqoL2oqeMNZgDFqOPUMGtnxPZSddiZ8mSG8 5PrEFkNbi1rk5GDZb7+FWCrnEgeYK9RNbAYuSSaEtLekEYT+1Fe/r3LCseJ+dOGRFo+BcMHt 4MiT3iwTb4KxuQrcqpC6rvwtXNqp319gYUsaJVqz6u6uXEnywRGuKEl4L3AGFJggq4YIqsoz FV7MWcr22daG/jqhP4WafavSgIfJDjw09tZ3Yw8TVW8BHfsMBr21YYugTcD0SucYIhZEXYmP RQoEvEZA6dHwHMiGWar3rfIj89hvlf8PZLNP21z2AokaJ2mFBrEkY7UXiCQZS2GP99PdBI4a zNWZ4KpqXioZkSTXH2FC8S2S5DeTpSc3WcK92dkoA2KVdtbLdY7hpwImWiYBE3u3fW9CgQR6 d8AVTobwJ9wntD4c4FAiVhiqsSwZR+3EqJVYpJHkuVRYSh4Tms4HAaZo7N0COtMv7HwH7Mhs LH408KcXONPpA/xGoAawyp+wGNM4488Zxb/E3wgtkoEhabFXV6VD98Hbw/YFe8aHLt4H7w4j RRcnVOkXGbJOiyCZcDAtqmqPjz1ZjATO5GUW8ZMocOZ6oywjaPLUzKNsisCM4Tocn3VakUkf Xp7H/25ECtqdZrf78yuVrNbSPx53Wq2/RxcRUDhScHl63D6N1nl30e62YhBzV7r0VEudEuYz eq4wLhReIRxDebNaV8gLJ6nvDx1vRK5liG4jKLnKOgFEXoGcIH2tbYswnFrnsrHWPwZ8pa2T oRQ5jqtK7hwm0abIiKGvu3TIZZGsCYgnCBtbShsA7XIsZOLZ0ZHdfaWCyVIv8pBaGaFnxZrg Im5ubpXrNau0uaUoIT3eOUck0mF4+yNdQTmm5aPI6s6D6wpeEriR7mQy8pGHrVI7IWrkYN97 cIHvsJzl2utxZlmsJOk53JdBFRjI0Q0wEmMi6z5x5PhhbXcLHsT13e3d3TVlx7l2DTzyCEC5 1dvpcKD2SgtMcNS9uDw9aHZbiaD60S+Pj6uvxhKJoaFKOe1lpE5mHAlVLR4xlnFmAEs0vc0I +mDeNjVFhrYqVjKKgzHwyvOEdX5aVNxFxpoZFVcCoei5xkFr1U4g1u+ub+KzZnezXm5sx67/ aIYGQZ/jyKQVPx6T+DaOoBEXEQ5pXzMRiOtEVzUDXzKrZmdIyGuSFVKC2yyUyCOcaCKGBC93 SvQIObQVsWAo9NKiPSBDCW/7YZASUco4nIQAbZqAwNLR5/jg7dm7UybPB7ckOqe4x3fAqSPr jhEL8U64bB/CZK7pp8ibUKkXVUJwopCyPhFRaPNGtHkTaVOlTO/4x7WP0m4reBhe+fgeQJ4u EFdnY2uH3vXrtc3y+nruCei0um/POl1EXWFCJKJ4kSqBrmvxBhk6vVvYZMWfajWGcBniA8d5 kFGZ4T4ZPFj/O3MG9N6VosTz2dQ6bp3CE2pK96uF/SLm+dE+q0LIPOeeomTD4pbCxZxIOZ3q T7H29ArBagJ1pnSvqV5pGqo5AaO80yiSJfAvrdbpGZwXPQyYDCGlLSHe4aJYpNPQlzdJggMt nIQ4gSlRLL1/ukxAi2YxanJC5xgEzun4wLMBysGrnmQP9RpwxU7vrGO9t+q16ia8yy+A09uq bgqlQ5+elK87h1C2oQfXGTvw3HNRn0Iapilbvobwqb3qAxteexOYfKQdYhStSX5onUVXMk4/ ZeoWBWUh6hZEA5GkpFVReJCaW0Ub+4r217IxcnQQS1G2znGrdS6yjTgynrt77/ZmMjIbFvRm kwnGTpre4tuSejqVOsaqxmqyqmI0G14xXRRVYB+uOdz5wHXH1XT7jBmKTEeBblSpigysM8K6 RsYZm0wuJSGkYfDLm/Cc5Xc9IYRGWW5mTNb1P9icEgoI1qOFW0oX9SgTDNRFsvjhm8XF/w3r SUArGiaFD3FCrSvulz/r3VZ7ebaMun2iPJMxu8UfnCDAPqOmj3T9xsque6PpIFYWTPtXvp8o FSmRUorDEKeqWIkgouNFABWuvpJrgCmo/qUMzKo90Wdhd3pMsg7qaEWMOmuVEJbUtqyb9RlD VOMiFGGCDSlWwZ3n+KWkXcL4pXDs7rTQmDIdih7rEof3+vJIaeIQ+tXsWmjACK9QyTx0w8CS QGJEAQWV1GfQJE0YIPFMKIERJel1LLYZTxX+Lf50JFI9F083Ua4KVD21RMwu7FpD2B3nkzsC zpLYQbdP2v2RdePhwjmoY62wVM+fPIigsmwnMIETSDrxgRPcVsmYp+fKnCF45FQUctKDAOG/ j62gEjQA/8Z5hohbD22S0itYtXh2wBBFTuHdgwwjP9VFEc35AHhtNDmZeHjvs0kLzJSoLg1a rhHiTg9NFVA1F+yzyz3G5EESQTuDX0XQXFUZRnHnWp9G8H6QxPV/UFV9DavEy8bMblkxeCjY InAzDBUD16GDCyyMLYZwcJ0b6gRPBFnHiJQsjJ1yjJ4YKCztyWww9cYDfZKI0SPYVDTEgP7w TgCYM7iXmN5LO21kE+nxQxsKxAwg+PQGPPZGs3s2dA1XCHPB4KFx7z1kdH3BjIr4kHiLfHIn I3dgNapb1foOLUKgrwLB0+o0GiwccyZwqQBuu2hPE1hNDKt8gvJa4LuPzo6Pz94lWm6mtLSY XJyevVvj385O2l35XhlV0GRNBHqNg1tvhCEWrPtrOmmj6XVQWb/hrUTnIn8EpSHg2OLIKPMD 3s0gaunWi6DhHrzEXgICIN4A/1KHPx7Q2KmCvwGNjmnfp2E3NsG2gUmEV+F+pM4gs1IY82HO iQmvqJ/Q1IWid5MVFaVLdPsaVlajj8rQ2ApQiQmF0s8DvyWzC+HpC5ds1blGjkYYhj0I9gtx EYW+fPToZAgN6tXshvBNQSiGo3BCW0Q2dtNOjRrKiAjd9WxCx9/p41GlkKVXDo4O8J6TKtFE gj3YGIAi2S+tOr6l6HiFExKWgA3RIrU2gcEWdLosnYxrdjGEg0pejJjXap/+1DyGt9h1dDoA mGzXrtnYMIE2z0qfxTbaoV1IltnJh8av0nSDHAbYck7arCsktP2hN7V7sB/hR+Y22DZd2qaw Sb0q+lD7VVl/fPcyPKjqEfb991ZuXXXipAYmrTYa7wBOh0aX5DGSrBg6KkDtEFJ9zhhjw6zP G2Z8pHXTkda1kcY9FZQQhZBC2foricu+ZvKP3Kh2fhjtolQUzpQMDx8ezJBwC/DcGZ0pZWaK 0oQacw2zQN6L1wPnRhpk+tfSRFNalx7hVyc5DiC/2jiAXgzJ1AcAJFaVhwaH4mo2HFvEXCnl MGJcGlq8TNlMWPzcqthlfOljDdg/oqZtgTgy9Yi/jGk3lrxOtCOmu6PGoNXN51dfdH71peZX f+z8pIsJ91OyVpMUBzrXzQlP/ckQSNw/iVsPF8GKXNQSH+HmeNHtlAW2ch4jev2iA5uFfCbw 8oha/hUmLojKZUJ2TLwqKSUsvhEZiD9lc3ZmvtRIWK4K3SJcliCSuSlauqMtHnGC+E5hq2F3 Apx5QGZi8BMGXeRnaCp4nJvyngOqzjBW4VySfbC85q7cB1+Ix8fA3k2AUxlgxCghfZLzFu8f xZMW9zUtpujk2hkEsWsGX4rPSrNx+i1D16kw0MPfYa2ThqkvpoF2+SS/yt9eYs19o4Ouk+EM kp2Gotpa7i9KUOZ1A1Xj5w2mA5NCrIiTcVropE+bKSnR6kEHN+6UHmS2Iw0oaSP4lqZkVCbz FKCVoeb3WoPifsoY64ZjrEfGODQaY33RMdbVGGMrLCmJVNbkiSitkAIcHaK186eqUyVVU5Fu JD6A0qMGF588LuTf9V8T7jB4Jx5K42YpDJTGzejMBmTo7tajB0TgCmcI7wYeIsB7VipsZM6v 7AGKx4LexBvDk12I+wK0OyUTUxwk99emwdP9PQrdeaZ4jdMrW7DriJVl0TclDuXnDgyC37fM 9Fqr+MD535kHJNZFE3Atf2Z6jfAhTO8q2FWfrJL9QV+mlZFCx4w+1DTkwtJkZoNBWemh9M0S CjGdkMd0Ysj2s06MXmCrZGkMBJQ4rSJ+xqHOtCQpxFtf96VYRqnnSUEiyB3uSJLW8ccUnjth R03vB7dva3X30+kjEhH159+SLa29kMbgSMOniS1eMfKW16l2MNUPdRCnXcnxEa3R/trPrlqP VK3Hq0aHlvKGgeHE+aJky9CXV+eNBVt8gQg1EdJBB/VY6JDhk/kRng+SX8NpwNt27E8BrIeP aR5MWQlxxLglSwtMrOBhlchuFaVXhwfvDsu0CUXEEXirBdZKdQWebXjgBRBylLpm6VqEpb2m uZAxGSJV5oPgdfPwKO89IKZOglIab4WfvadHHas38GCOzF3ALG4e+DkL3AiMqj+IHCnRBSwU Dof4KgRBJEgKYCOOQzCbdyLn7sgXrVmgDYeKxMHWFH2rrolweQF7D41xT1ABJ72jpQgexQDV Gxiu75MYPrj172worPZuvL95/Zf19cbW9vqPBG7iiuAEgRQoWDwwwcUpuwd6dfMukvRqixkv 4tQcYBBRLvXgz8pq+MMxzpeaVQ5JivL68s2bn21YCg6jCYzVyXlnn0HA/09c1B2GQkXLunUH 4+hKwaoPrlyPUBKVGAEZzQFbiKp3B6YBo3o9I29cAYOFPFINMhvfTJy+y9664oFFlnTX3j30 LHRH0mNNykcsuQxqpkMSYYzHA3H9BRGX0uzZRlFWYGrwMIIzG17lXHrNxdf9YkQOTihKemGL zOJYiYnufsqXO5AmB4RxGmeuPVhHzsgXqnO4cv3BjNVtI/fOleIXVGW5Q8J6Yq/DKIifPUcd bHwrDJS8lzF5rPJLAhcxuHJ6nwjXWMYJU8L76t5B8FF0Id+zG8yJNtVQDR7hYqdkblI8eSxT bVS36TDIzZ6NRsJVSkPVHdG+qFlEzhWNa7GU0uWGiQgJSii0L/Tytj3AQdi2lo64GZAWbjQF nISHTtpLf/UQSDg6oBTxwv5MajncSU1sotQ499dwJIQgtsgUhISAIsud2BztOaQBuZoJNxsv 8X4SjJZ7jwju4ViF9SUKAScaDMVZ4sZrkhSS9dMQxnCsMe8Nqkk+XP9KVyc9szQoZBrCugN5 L6ypRd9H3JnORg6KjokRm7hSvDKU7qTqfU7C0eEYXWD7M+WHwL6OUjkg3Yp0gqxB4QtKF5CH GlRcL7ePWp32+5PWHudyRJU4E7GRBgZ18mUW/2gd8faQ/sEnhZeLDNFw6I9CE34r68YGVr6R F0JEXIR/E0lqmcP6HjPf7gE54bI+l8TMe+K3oSa9CEzkMrT6QfpzCruLgA2fK4GJTETATn0G JWCTzGMq+JaAWPwb3++jnQ4/EUIhHqrygqitlZazJb748fBoz8Osweqch/ZaUfKi72qE8icD mkgRkqYECBkk3tApHPmaCGUt8+XFCI1YCf1EOpLKAALuxUx7Qr7hn95g4FTh8QTLVwW8XNvY aKxvNhapv7tbr8Xqt6d4V7rORDj3aUohlGWGulaBho2dWpT1U2iALCA8QWZjOL7iOpFvj1hV cUAn7hA9sWH3MW6uxcrNEVJVtp+E+5y9a3l14pnZogcVcYjOKr7zEigj7guxhzEEjpr2aanD kggUhSgx4iULxBnOdxJQrJcvcZut9KsrIqKMkQB1henfvmahfuwajeK/fplGghNe9+fif/g+ QIrF75mF8J2U0GiUhm8OuGnJI//bnsk9i2g0VfXMrsXFMMivsKgeVeWeV5Ek0McX+buQmV2W lwXeyUezFsSDK3w83eETAor7HnABE5lSWWpNRLADYLWAW5nK14/qT7H3WVcz6skyzDLgXSqI flpQrSSo7ygNdVRFtsjNruFX8lrnaxdhJkTS36PNwvfTIAVALfpI/qLx0Lyl+ia/O7v4Oyb/ 5Q/iiRPNMCl+SpFN4vsLicwR2UrkrEgQuqpJ8Soyslta1VmsrnS418O4hW3qUfD1HPD1GPh6 Hngh34F2qlQcWD3c2TQUf4frEeMgviRJrsZyhPJcFhamMhQRO93MwWiLD8e2fa2BhGtVCiNZ /4gsdFmYkE0nbAM/JitwVL1Eb9nZGE0BeZh4Ktm21blzHuDU8TOvRxSBQhP18DWirIcigAS9 JjrbOu3ioqzBUxSVsTiOIWrIiHnn3OAn8IycAOOBluZRjgXueYwWi8bDswma8A8x6JK07qHY PzBlICFomgQbPqEXNxomR8BQ55h+5JqIEU8lPo1At2fAsTcPDlqdKDcDax1+b5+VrdZ56+KE DIxaF2dHHYwCVCDDzCsK9iKjASH8CKBwaVmEpEUSIlZnQo+/kT+7uWVODSo8FIgHmkYAcSgZ DHc29P4Jm8bSsLtbn0y90FYOsYIekYAUgduvwC4nn1rMYPk8kon7N8vq+HgZoIkxz4IF4WiS i1IEEQIFY2BFoFy5GEQmkkN1NUadUDqo/rLxUKGEphi7mjqR1LPzWke8+Bj/oz58XMYsTFE/ gljCGoRpUffIirzmpHhfNH8Zjw75RQ425EVgnLb95rj9+iDKHKU8B5CnpXQxeOakhdoNSuTR dg6e7QGqA5xkrmK4GykHRb1RaWyLCOODvhIbCUaa8QfvcxIuJKCEbwDcYmkiROMoBIqa0GAD TWuSgCPc8XAS/NYWggSJLzNhAdHV+MHklHpoU4rnPtwjIb9AxYnV4PTNCfZRXFAJX5kvSd8J 1AOjS9ANkPTN0KJFu5T2MxoNk43qeY3Iroh6+o3akpt1jElIIlPO0EOKz/SCIj6HAaICLVQt 0YvBINN3CNt84peXaEObi8JCYtRQss5IkLLW+oVro5rGu76GhQmm1UAKGypqRdPXRms+jDQf qub6FZ8OIMGsTONa6tz60oGU9T0RNshKR26tKiuRdO3RvBasS9KVSEl0IWwBLBFLCk8N/Csq yLHxMZaPOzn4Q2Mjric+wP28BlGerZZZ92v23IZibsP0uQ3/dXOrP3pu02nmWKO3R0xKlgn6 q34ZpYoIo+P8msY4Pk97ama/ENTLiuek6/DUU+M7IGmGF7r6L4xbQa+ztJ4Bhg5Vf/kkH/+x Kzr5tvoa0f+kPYNEG7U1GvsdctoKy6JOE/LnfsbnF7Np7JWXJWQRLarsepH9bgprCqeM7DcQ VoWv38fHmBnGeZZ42kRXRy7ObKppskPE+i4Lj6jesjYrwod6YTsVvqrI6EGJrR5h6iBfbKH9 BJo9C2TRTIj/4GmWleEJMHtCbSyN2YOHIXuFW9ZRzLNDWr8rGQ++o0h7IwLHclBS1PqT2SFD 0kQ9/FShUd+hIE9W0Zd98BTr/s3E5A81MeneulH9Z9/r63iRggrw1pqqJ616QZByR3qIstsM PbjvXCGBGAn/8yG8VntS4idPV4FD3Yo4t8yBahYfwqCAYLEOUJknRNr5N7NAzlKkP0mYBEQU QkoaPvimX34i/fIg1C6Hu0TmBeJRaKxUFqpkDcQySmVWJSems6hSmVXJUQ31H6dUHsRFzt9U x7+X6ngxHXCKF2BRkIZUJZmhQngRZfAiiuAnUQIbKoAfr/w1VfxmKhBTlIeRB8RCesIE+26g HxwY1svSIeqpUZbV+/1fVPOla/nMVXv46Myjqb+Tzg624ExYxZXFfpLVpUMqmXgsXo23Cnx1 PcqN8K2xj+zIlDMEKGjXMRc56TAcjWckuaHj8BH+XZI9+vJIxaHOLX3TJCY1ieqWGaRIIxYk UEkSkpQCZe+2TiXO2F13MBMmo/JdyW/AO1doJ4TN9cS9mQ3guUdm1hGT8O8WOrt5RzJ6HAl2 x253jk//jk44JDr2+26sdvrTXbyYEjdDtJOv+cGJbpPBiW4XCE4kg3xvU92tvfr6Xm03GZyI I3hq8UpUTBF25dA9O6JuHVnvbXxni0j1qW91g3aDZRoywRGxpo4ONRqjhUzRorxY6QFdYhNH VJFOLfiTgjjroxJBwLJGVk6RxpJcYIoOwiopwaXwG9ZTjwyBTQp023NOCRQMULdLQQJQkes6 fQykkJ3/YRCbSWIGc4UnSYmVBpLAaSKrTHb169ycBMCuwWNIR3xZojIT1Det+s7eZkrAer3q AskJDth9gX0v2H2f8xQMnd7Ep5jqqSHqNytPkYAgDuXfMgsBLmsDKMm6VcIfdRFZWajGMTDd T62L9tHP9lsKFYlRlQ/Db3RFEIluH9jNTqd10UUWkQJO2B1CZ1uEVSCOlLrnEfPO1N9b/Ylz PbVO65sbO2jKQWdlq7pdrddk5kzMnMTCJo5H9ubgwNqoblVrlCypImOK0RPwgKxA2NDBA3YM Xf2IL7qh9cAok64TeO6kMvUrFKSu7zk3wLLCUAOCRc92Rkhr9aLI5h9VOuhPMPODer0aRjzL nVn+rAiI8cyyZsUHJD6v9GkFBvtZKtXUjq43NhpqR7erqxvC5/HRvUEvuIrqMFEYITz3QFev 3OiKXs8oChYurJA9BryiQHlwTeWpvAw4epbl4+OW+GFow95TwNDc4UJjP0TpMUChf2cVlPdX gcnTzk55GwjUzlaYAkIFmirsFxjaBR169Nsts4WUiLojCVkZhWXXsKNXAz7nQoQW7qZwi+Ub kEMpIqUY3QDxm9KhP2w33wDfAssqt/hyFBGlYch/oJNw/kTCOuVGxJcV+fKyIIDMctllIgtI 3RQIWXFIkywOWiYIJGI2kD2U7IkWwuBAXG1frGq1an0N0z9I+Un6WWS6VtvE/WjU1sV+aEY/ 0TO6elHW1qyo0T0r9omAiNC5Ihi0igWdjtDISssqEaTGKNpqPFF0j1EQJD10ppBeTtjnU4Rf eM7tVRRaY4Cwa3mgItOUoYLT7v7hxlqtxsFGq8MNvv2jZeL+h//fwYQ1cK9vbGj3f7Kyab6a 55bWECjNBBP8NZ5V+qNB8rY2vOiz286/3rEtESRamWROmrxcK9yaJZZ4roYeErAwkgZ5X2E0 SMEHRJiDMrcmQuGHyQF19SL6ZAYilp/YbzhrwBRYxI24sHqfMSxzxhajNWXP0TdYlYRPlS2r voXbu74T3d5IVcPNhbOhmsmtra9n7G0DObEN4sS2KtG8tzk7jscl2cdGBg7k9JGDGbwx/3L0 oNQP65g+g/7Fw4PHx24e2PDgOnv9X3YTOP2DJhZW4v/hXqDyejbmmK7UAP2AB06PqD2ynR95 JQvkWopBDJCSu/cOWtAiANWTcNq9Q0X4dMZev0IzDjg7nk1VeDnrIw+qUMWdmjuCQt4ISsuN oKBGAAtziiJpqDWgEAso92jOpj4+9MoCeOfs8uKg1YElhwbDDZsJ6uqHxDrDy9L68JykrZ2f LtbxDXT+ju5A+HMD/5z1rlgdBzwGhfFBi+ThGJABx6WcfGlnt9bLu1aJ/mWyiEyvg8o11n71 phLPfQ7WCpMY6jEuNL9erofoGpnSqvxQpA+dy9ed7uoHORnrwy9/+cITPGxffBV1/+L0bP/q f2AIvxYBe59VoOFh66h92lo9EOtAuRM/CIZQcn4c2Oij7LFQxQfsQm0LkbYW9XzQPHjbsilK 96qMnBn2IWLqHUycB+vW91GUBaPvfbb9wO5BYZlGkAajsAAM6wMAab25aJ3bB+fnq3fulSs/ PNfCih9cNH+OJt3BksYzSzagXd/epkwu/IO5TQpV2rMRO5DHtW/c6dXWtvWm1X0NP/ivfavv c7IlnBBOheRsq38RDcvPUszUPqjlty9P//vyrNs6XMUxIatz8PdO643dOj0sWyGMimX0n7Z9 ImjFRzHoQtn6yOMuGEOzPoq2tBC4DxWOzEm//nxybhYsP21YhXBYBTUsQ2hWYd6wDOFIhXVV XCMq4HIgOTmK5Gi+XCHqSmMOMt33A6Ubp7NnOk0zcGx1AA/UT/xHH5b4GdyJWaxHrwJX2dTv 68yHVqZLlxqNvcb23maMu4xVNpUvPbe0hhp7YOF1lmAPNhYWKRkAmc9yPn8ER/H8Eezm86dj NnUROu4W4NAn0p1FNlwvnSNIT1Q3CvS/XmdZuhVpq/a9lscWLrJlpUexgaVHsYGlp3olkPvO wa0r9D+8ZDJeGT3lqUQkuy3L9CmWyJoHdw4QUZTx0zk4othfUiSKMvl+2QoczMHjl0kgKuLC YFJixyLpOEkeIpGfWSsgPI8maBLps9nACXBoFOYQgOPPPawJoO3jw+bhofXS+ssq/VbEX+ID LOJc+fa7PF39cDMQn/Eb6gc+IHnEZT13J8EMg9awkw7xciJQuVTLUBBrFakdfTQUH0eSMejm ovXfl+2LFnV02WnJVJat993Waad9dtr5tchauOcKeqOKifWY96gMMHzw/Qb2dCN42ujmyB6r USDbQujE0iSYwQQlNJQupDKYqHzx/lXgA/uLlmvyI3dYVaNCUylOvRNMUceBPCRqpzlnOgIr C08/ERPHR3bZss7CHD4v4CJ5weAEUgRyZ8dO7xPmNme7LBd14GPKdCSV2CQa00JdVYJbWO4+ QxPzQgFgf0bJ6vXo5ZPZiDUJ6PSCQWxojRIY8VJsleCBE9/5xoT9C2Ap+jb0Gbz8C64CX6TY stW8OHhL3PXqh8j2ICs9mVq8pr+mcxgfKMjUyl+YtwxcZ9K7tSNQVgCnV0bIuUi2YMX67bf0 ezw5vRzAkhmIcI7xOUTPPjfBqb78S2RNnpXgU8aVj3lLdeov/p6T+Tha0VjOICn8VpZwgYj7 Jv27vdAFLyHvZN0d6ZD/MwRNuBEbm+UGvFzhx/qGFJgzjgOqAA4isbJxT9me6eWDG+AJSf84 8n/V3i4fyBZw5S+Y9QgeYCsY9UfHe0rv+qIIRIF4VC/M+stpc+ElfOc8SFvhwKqxoQMHWIxx 2Fnj2Y9786RXXLmZAUykRiN/xYJGepPeww1cbnKg/JdVB5J/L9L71sv1YjjKP3BkZLdIAzsb 8R8qIwOGPEOJYGObo8kjYsNpRD0BrS08qJzUR89zTmHcx1AMmDzuwXOBzFcoJqAusKjUrTW2 0HhJ36p/4LzxrF0FfbklYaazergjHAy9KC1QT9B+hQVSf/hwbx3v00wO9i3+Aag9vnWshhqu RRgEBDuwjg7xNmi9bx0sMEa9IvSUeXaXnU7JBH7YCnqKrYIbOD358rQs+K0iTKfEVZoKcYWS WBAxHckpSsskzOv8ss6l8HItsfU6EZwMWGHQsRcwvqI2rRfaCzsGX5XL2jiRZ9ynxWznBQtB RapvQaTo8S1j2bOGpCJFSdeUyxyrCk6wLEEB4f/kumNRo4DxBP1PWEKM0hjVymjXSIrX4YZN +jdiVMlO64iygiN5fib3ttvqdEX5M0tf8b+wOx99IZeavEUOzSu1tviNbGS55ZwF5OWSPxET snkP9x54R9IT6xxIpFRpPBobKHKoA3uxHeVDEtVzuRHUGbOGsvI8fHBaVuVFhUTMqGbGP/Dd Ij/XUz7DGW+NSG4d9k9hgYWfA/HGI4o1P3jAi53qojC4miHVWFf6juUEGlr7/+uyDOJnUNFc 2lhX6n/FKL9tNQ9bF6sfgO3w7tdkGjQ8LSft0/Z7ydnwH0yqQvJEpSucXUcgvBTgCpn4B85B abO0HiHVf1Vi07iMHB/U0tcKmAl/gjZESDg+os64QFe2r1v0GwMoxAGEDgEYTwbrU7YnSYuT E6hrU2iE/Jw2gob0VBRONcpPUYYzJUDwIr52HTT9CLIOOv5CFiDaMdfK5ssVY5XNtdZaQ3me d/IfHwsLFxcA9h+t14Y368B3+s7nGx0NIqXzX52J6uYi5lCGpgFJI8b13d1GBf6BjYN/ceNq tbISQAo6W2bOO4khSeK8ILwYkuDQ08wbH0HCaXFgDHgZ0g+ppAZG4vyiddH6b5RQHJ81D5s/ vUnVUydV1aHKN66tDlc7oV3ObFSINLIiQsHECEnDS8tEBmIUPYnDLc0iey2yeeUhqD+expCT S+azIZGq5oYXqpmkTus7eYYX2WiXyiQkoe/Ol63v/GcJRhqbaKsB/24JRkJxv5LBBUw7O+9q LDDdkziG5oTSqEmigmt9y4EErN7ExbgnVcWhMxQWZba7l92WYFSYdYhDk9lQ+d5n+3vZg3gu Cgv+y9N2p3tovxUdACcuuG9Sx6epfYTwMIboxgofra6Rtqe+LrQ9YcPwKs67PTf+U/U9EXIn Rd0RBcjEJXFz4E05axoa9svl7aUpODRNSjHlswxxoT5qMmf77PQAazF4/7rvPJDnoRQ5y/dd OpZR/RRUk+XG+KYamCFdQ/jrWJpkOPXdVA8v4cXFw6VH3MKlRzykSs+fCtcQnY7QUOm/vKF1 4j64aNycxEKSOwhUPDs6bP6s8FHHJEQc+KvTvWgfdFMRjWke6to4CcRbs1o4kublcbdjiKBS dQew9GJSNf/TH7kvZSoWRexZE0OypAimf6c/BemRRkIRfSle1qJ5KtKWCw/g69dA7ZVSR7Nv +iDuj7BX2lzOaRF4NyN6XYU6Kl0qH5keKbPstBbY49nJefu4ZbePWsed1qom6sOvx83TN8Ba nb25aJ6sRmWHHz5kJO/ODeqWDDaHTlWRWa7GfVVRkTnxetOyRVnu1N/xWF2/xvV1Hz6svRDa 4BmG7tQA43ZbL4TjPLvL47HkxeVu0lzP0Nz99FI8kfHYCKFeFRDAv0PzRC0nCnsyoCQQxTwp 4ESi68jsaaCU4M8RjgXsyo3BO4YuuaOgz00SWNgtz5hG5knzJGVoSW5v04exi2FDy5wJLAUa vuc5eCl5PCv3OqHWdjhNsefA5inESg1FiNu7+uK6uMC2JofzMrJGqSh0j8HQrdXveyLof2oA 8O9W763frJ50MBa/ogNxEpeKUWwyPV0sSIq0zD1l8w9azlFb5OwkkD/rGKVMfoHpO4OhH0yX bj7yoe+iVHMrOmzYHHCA+49KpTPpfSG2KAXpEL5wx8kLIRSFR24FIRKXOgsyTicHJ7R5mKD4 rBDdw0KZDKUHgQqrFFaNMEGxJZO9w7V7edClGxNT7yZE9iajTCobuv/otLry+iKdQ7jWyQoJ FYK2rNN/Bu4UrRyuroASpyxj/hDDd1R4q8r6aKR8jMVhVU3gSR2Tvcd4YIs/Iuc2FHmqGlL0 KcNAKAtQYR8l8pNHjDa1LiOL0gnHJ+XFKb1jh9SzWCFk4HrOALe9EFgyeSqlntV6lRvHJfxX igXxh8iy4W//ODul0fwl68zIUarVEbdCAYl4wWIZdPRQUUgxZ4rRopTUuCAvHc0HTTrPihvP mdzMSPLDd06I6OJ5UZKMaselZYoQQrVa7JunrZIIuCwXkS5choP8Fvp26tHJRETkCGy16WTK f+L0rLOO9Z7Co1eF88qqV3WrZevQmbC1wHp1G8OCCa5bZEnjpyk3ABoAVzGK0kUOTUc8+2Hy yCZEBkCuqWoCxGVQqjHSIaZgp1A83cXSfoTDmMfWhwed2XsT9p2rRRhaabGfvlPhjHijGNMy bw7RTtTCEV2exu7XnIs1cqWS62aMd53L3KbEfEhtPe2je5z+OcKnfvigtxMxl6eJQLfyTA2t F7EMJuEXYdqV/lkGhvkcDX5EkU3Uwq9+H+MGJEjMmRwDHOU7vp9+Fokp04ImDd1hbzi2VgcY hUfCRE75n9A+ZFqGxSJepPrMdVZkHiqwAZJhXZ1Nw3PzDg8dxiwIlC8OPpcDIEEiXe7VxP/k jqqLdFAUB2EuO5F1/eXcfGaXnnb5pB3ozDtIu36y6Wr8xPIFhLfNr8UsiVXGYCULoY33ZqgM MuH6lX/Fbh++m/mjvJx1rUH+Ba31puYiO9QKUvsMJ79gt7w2z3PFdXzRoSgpQ8mhSVzUwumK 7s7qB0m3gPikyUdWP9jXcWFdivZjUMHzEBHVqSIhdNuoNOpWfRv1H7X1mJQuXpcEdI3aXr22 t7mVraA9PLNOz7pW67Dd/c560zptXTSBX7Gal92zE3Ttbh4f//xdqsFEY2lTiYahkcQ8JZth /JDnTxc+ZAMlm1YJf0grTpwfXD/EoUCPs4ErPAsr/ni6l1tj6k+yKvQcDGuB1t7OdI8tupN1 0PiYzLgzoUwexlN/bdjfnFMjuHXq86s0NrfmV9qsN7Iq9f0ALekzP099B7Yxa7rwWQb9yYQw G2d2HtoJ7QlzFRMHBPImRt1UaXNbeBOnQmfdUOVmNNvLr0HP2Zw6Uxhn5TZrDQTRmvOZaFpW H5yLvkI8d2Yd5qnsEQwmu84U2NoxrCb55QoPzXrooZnSZjgDOo629llAR35v4gSZn8fO9Hbo 3GdNfxy4A7eXOeLx9BYPFcoShk7wKauaPHhZ30kUMcA9qmR9xzRLeV0EIw+eDdM1+9Rnvm1e RXihVUb+CFO/zKvaK5X67rXYlu0dRN2dRh7qBkBFBm72EJB3tDMXFV98WfuB3yp5+AosuzOA 5cwG3oeZ70mrTcqDLuLHAGO0yn42zfZ7a7O6bvV6RWWqdUUxVnu7uxT4RrbnbOXIQ3mAh/ju tEnHI221LOsdyv2VoWGjukUxWjk4ES3o7iYGjirVa4Do2zlris6UeZtF3wmVMypwmMHMhXsI 7Hxkpxp5ewPf866Oed/sTDodEun87xWn359bJ5hdZY1itrWR+Ym091nARVC4rMYcOSrrK3Ae mBMOW4vrod5okKHT+oayhUTvH3826bn2lRO4LzFoXOGZEtjJ+BOpWrTw2kd2MaI5Jggnh5v0 s/O2WZe/wL3MI9kA7MShbO6U12uhXSbb+JCGDq4gtkhMFNe5PML7np13pcrb3DiipEwj3hyn WUfgqyX0KcusisPB+Z4dXqI4//QQeNHu2YV9BP9Da+uOHDheuqKyFKegoQcpmJ6ZWZM8do0q LPd70nUqma9TKXz00e8JqdKzUtSkXP9miVCqiVXSa2iS7OiiRDS+sZXRuse5IK5KuVV8VxOw kmrt9ukxPB/FRrdPu92fz1sd+AUVPsetbosWS2fpjpsXb1rojaIjxzEGrErBCirPRAoKxSqP +xbdqXW+CfCMobGPsOFImdjwk3j7ETZfwhscPSLDfTrvtI5bB934Foni9N0JP6ZvjGCEcE+0 ledGKUMMq6t1Ou++vYDnrd1pvzlpdv7+LOaTEPucMcpEpfTVjfFlcp131nGdG/VNEesFZ9F+ c9o8xviMuN6AAHYHiONx69SGPb2ZiqJO+x8tKKBpY0RddS7or9fti+5breiweQxQBUz88+IN /tE8wT9en50dh58OW0fwBw1ul1wZGg0Z/o4r4Al9q1EiVGB3L44U8RZRfi+6Z+2T5vtnlTTr B2INPGANdJ+cGHIoEOkLr39OX3LVSZyghYNDtObIcttkoLfRwKdv4k4RjArCEedA0KckmoVV S1FRtjwBABblx/bJ3w/bF/Y5QdOr4fa9JdIQqVZKE4znQhNV1Km9iOO3kpbZF+lLHK0gF5kj jG5xiFF4NiohQbjAsr98osEcllgpaRw2jyjKi4EayUznmvv2u+bFqX1wdNx801Hbzh5Ttku+ NH1bvNBfUszG9CpX7sbmes/tbbpu73pze73uNLY3rht9dxv+uVrfymsr3m+iSiWtivZ6yoOE BDn/OyD4YDC3ykzVob3b2CmjxXtjZ0eZo1q5M5lOZq7ucPUVZ8VSZ9VmuIHxkPWZWavkl/dF Oed9RwLr7KWQXmOKBr5GrrB9+kajIUyY2TcmUifqdqaf3bADdhTU6ED7DRyeA6L9yN2EPacd 7Dic9DXTt5bWTfoUVnDdrMx1ozDohLBflG9d+oJNnal2EtcbNfK5XoddbWxmWRen3Px5I3mm hvykN2Ilp9dw2Qi5vGcJF0EEinGs03vVvi4/yXk3VM4E+EElxm4EEyOC6VXQispGc0r+B41x YvobgPll+Rvy64Id5i4fER6DFZzF7/j4ri53y8/ZBSuBQZnjSl2U2QjlX6hWXHp1Zmp5Sost z5ypleTUhhtIn6fuZGRTavTVD/8fvpD4BdU6bb4+bh3a4ol3Yh+cASXrts+AtrH6LFpPXInK VCP1wjQFNu/yzOhlbjPD7sWtldGL/EokfD4wneqnA4zeC0YjpIdWBjR+gxmCoVOYCYm/LgJs lg9tRuBIRbS7S+qCRugai+pGXaFTvZWlAn20AtaBVCkpoCiQwrBqT9XC2C/qL+VjmSy5ZQVG vUZDWt9UcmChAUWZRtiMC/A8hwMSKonqrRyQcnOIFQhFqmynqxlCaFJpECkhG9mqN1Kj5QXc 2IosIL+jK5SfaeQMQgj8IexZoHE4YvG81WpEH5zhB7lFYQkqxuAvGldjh6LKbm6JB6mqsVlv RFrg32p4rC7g6VVUkTwX4TIqYbnWFHN9aBVYWM6grLBwchMvwizt8bK+e62tMYajqaFSayOU FHJFRmZtPpIYa0Ui3Wk4NCWOjvYqZNBcqNWlaeo1Uwts7RjoQuOU0mB2lSwNoc22NrQ/WCqn j0nmounFC1QjmbWDrxc9ircoUdGVxd9aQEUEGg/UJ2qJIE7ir0goBVGmOVCLkogLbljGjoai r9DVK1ognXhkM46XITIzqmJd/aeXipMKJYRD2zV6LG3VdsuNusAhqCfOo2qnlH5hkVDzhcPz r69trSt5hNV3eYTDGrEjrD6oI6xK6AjrfzU2tyJ/43EN/6bjatPYKlrJFe4eGq+FNVlvphWw pkwrmNr9oS13ryTK5DHXqjlTvYI45tp3OuP633TA9QI43Txm2pndDdJSba1v4Q6pnVGHW2sp D3dYJA53OCB1uO3bWCmsgCtKrbAUU1rGatJx1uql/j0J26gjHNYYou0R4ElYxAdZ70plB9cL XD5OWoF2vFCdU/FHFcyiGClEHY9WgnmIeGuzzHdiRyk04ol9YFfmeq1S26YUAZtJh7uUFgt4 NMdaK9fjeoZj87axN3MW5EaGG+n2f5Ync32djIP4Bx46ocfQ4mmenZycndqvzw5/ltGDmm8x +8brZrd9svpB2QNgRJMPIkelKrQ+uQ93/oSigvVljgx2Bao8965HlCNEVn5Wym2PuXnC7Idh Xg9VF95+mGfk8ACHh9Ywtm39gFlL6/UGpySxVtcxWbSN7PIBfIUH6qr6A3P4IowdrcpJ+/Ts wraL1i9SrgZNaveb9XqNa3UuT88vzmyReURmL1FDsm141PHmQQ+r0NlIfAKgRcR9ciepA+YR vJMODZ4SnQ60mOPyA44vUTmjZzSe5wSXsk8aJDkdpjVhcWJjg7UEGyopS4XNX6Vs+uCA1tii rMqffQztOb0D7CJ3MWB12PrzYHfXotcGOofBPU/R8CnDC2D3wQE34YIfRALcAeB5UIUTW/Un N2t4+8IRWbudDgeYG7fCR3lNhPtYGwY3tdrGer2KFX6s4lJW0sYoEg/hmbolLSelWsJMLR4l T213ztDoA87mpE8kwwzKyL9ju3lM1JIGKR6AguHBsojQE6x6PWBoBEkmXx/NhmjtK2K6Ykii 4WwYWnjIapxhmYOJBXNI/JTv3jiBF8XzM8Ak65uH04m2nZcHhhz4Nx8dSycO5j86ik6MN1ZY ECufH0knpYH5JR9rrBAhCxOMw5plAV7PwI2t/7ArnsOe1TfCNFvuZyCBwjBd2qaFkbpkdoDI urJdM1IqnPLK2traCqX3homMnR6mrevMMBHeZnWnDCTW691yjDEMGS3CQQcOGTavCFZ1L/SD gct9bRZMJH6tYS4xjC96hXR2VJFO0itE5TEV3MeVlQIH7Pz4w48FkV7Z4YDaMDSZqgxjqgDJ RON6maYN7yXkBt3RlJAHoRUUtMJjoGEOGn/q7jHWUI5L4SMShPAwcLU7UThFSXCG4ylgwvUU I7JhTG0XJS0cLRMu1apbld5fVJ08usTdHdZF23HKqkk5ftEhlGFR0LUApjRkx+41F64Xzf07 QBSTDglrKrOO5ngXiJg39V1iFenndiQccDRkaN+bBO7Ynrg37v3Lwoe1X375tZBaNxYJVYXb rJjAXSukBsxO1Ptlzbhzit4ZB0r2URZuuXuPByu8ejmkryNy+6FtMWy3deUEXk/mVE6FFsLh LEXowIfo5I3gWAHmr61UE+1gWpjIyBYJBHly8MLtvywE5Q+//uX/++WX6ou1D7+Wf/nl+/IN zJi5lP+dAT6ufij/mlxUgOhcUf53eNQSTjK4X34rrPzlS2wZv64UfuV8SSPdpe+0iaFhPvz2 JXXLgt+qL1Z+Wa2+WBjgL8WV6ovffqn/lrYOYrCRlXj50e3d+lYezAJw8KaZUqzfaMMrIl5s +sqvfEwbXdqarqwl508laVP5urZS+JI60mAtZz2z4a0UaDnXfqmvRdGiTFmfUvPY/Pb/rX34 /9Z+/W1t7fvfkriEzTI5DSVv07gMVSY4jM0KMBa12t56Y6++FecwIpUX4S5UQ8UAbDyes0gC 3frGVbDZSbmBt8GGMDpJ8U9RhoOc5IupX2sUzCbiwYPur6S4+VHcZzK9BUxM3GYyYAo/IgqB BPOD2hpoPIGnshtwpHh3KNMS8wUsU8aK9PX0+HMkFMwyq/gfes8iNd7H6xbdsUe+5V5fu70p Z+4C7kZWrkoITYy8cMW+T9ezAacQ4Wc1SyKO2yftrn3SPLg464jktTiE3PnASG58kck2DAvH aVrwkqGIKBNXi+EipX8SnODt0saAb9UBSpwflHABeDp/dsMO+Afn52RtVRV2N8o/9NjuXrTf vEGDtTjMSEBbzRESCWdiR3GRtY3/7AWYMq8qNLgRyVKyJ/sf//iHlDM9ASbNQSMhpAqFMHZv PJgF+L9I2ti0ZYbveUuGJCsHUerwnbO6VnBhQmmBDEeq82cUr3/0QEF8KRmyw2ERxr4X+JLP lyCiuXd4MZR7FDOYfAqqwgKNLPDOTsnb7Pyidd7E0635x2srKGyNyQa2vrGtVKEcErx1cGyj 6cdh+6eX9X1LT9KSqMBq7rBY2Y1gy7R2qkJqy8t5LS+5ZSn0qQ57rEXHmqjAPbZPu+sN2L73 9nEXTb3xN9Gr1jijlgKxtUEfW/9tH5+dviEABYVlx+dbG4U4uGQLBnZ+0ZZn5vXF2d9bp/F5 JCpku/kCpt1wiibtWtcLleSgtg7P7r3aDlzt0Xs9Xts8BK8ImU4AaEiRmOl3lGJ9KpK1I/bi uYclc2aDaSJSbzSq7s7izsApAP4TAqfXa43yOnqQNcobO0JNQBlb0XZZ+SwgE4DlwIQLGaU9 Ji92dErbZbf2RXZTpSvnVPFviFbxOx3+RJqGoRo5zDizvoEKFoyrKh+zgfWufXp49q5jw2F5 DUT27OjI7pbjpR34//Y/WkgvuSuEJYMpBZarXTek+tWj2aAWtRpMbfxZILnI1kblCnYBE3eM gYOATRw8xB32Q2+PrMCIzdOzU/Rnt9+edURwxJTEOSUtY458OiCtP3WwX+udN+r7d0FV/0S1 tzbUbckzohcsj5yEBZJTKMOi6K1tHDQuIwYsgrXrvNzakFIfTy4VbVocR9Qg0sIZip5pLGEi ITLhozLYqUhwlDmh0xaPnCbvscTzC80F2ZxCjAQ3+oOMUEJFRevHl9aO9Terbu3Bifk1JW5a OTmAZDC1tFlHMytFP2FMNC0iSjEjmlakUcJGEf9LOyRhHK0wVGVm3Vo8vhQjy2uSRw2sUQQb VT6nwFrlTUB+RKBlkYOZOdZ6AzFChyYOGQaNQSUJ8CrqDGJyA4Vf6Yc7nI9M2RI7MT5zUcjG Y3JZxS3CCe+7kRPUjKCrFicRP1pWRXHZ2oWEEE+cHgaEKsvMRGXr1J3Sz7OxO6Jf2hft9+Uo OMs66xyt1cvWAaWYKsc7E4Z9eOTSDqe1mnMmi5Y/ivdGUSLL1tvzyiUMVaQhzO2VwFHfnZf1 uf2hB3QCHBB8P6DnAFGi3q3nfnZpzTAth7VerVd3sjY4hoIZ21+Lbj9L/HIYH7gd8X8Rvics E2wPcgRWbXuvsbOHpvsRtida2VycoTW0cjPgyewAi6W+S4W/nSbZSIH/nyPk2CSPuc16WZd3 X3vRBDALmN9r72nhsgW3E/0DnPyctDBaTpVbEfyVruiPNBX6B/osaGH+TCEUkhD0cPAimfk2 5TLXFiJvHUwt7uMLcnmKDjutw6dZGTkK6/FLlAMqETo/hY4Ic7mQiIiCMIvNFj6c6rW9eixH hF7T8NEUZqlCFWj4x2ZG4hI0earV6XyvLxcfKQXIE4RK+t1eRiymKAOtRr/HejwZlB7aYBBa 8Kd5fdDnVLTWBaGhF7d9dHZ8jPdS57jZeQt43vn5BN2c4jnv9FBw1IcNrxtMAOyOem5gBwMH IzzZwu4xJxMe9To/Fd78PiIp8kZ+SlI82VVmVjxXuDUK8QzXr4nzI8gtGXivh65v8bDD6UGD 5w9fRPRbujkFDwy1XB+eayEBK1pMwCsX0BBwEBARg4oGPgnkPGB/RTLkWSAS/+k6s+eR8HDS wAeDvhF+0Zuzh7K/gOPBTBzqzuJRBhTzOwKuBwx3IFo7MmQqhaMj6bNKqhzJIrnoiujR4LNe pckMom8wDyQeGGKvKRi5eP7H1J4v0OIrmk/SYFjJPJMZ4+C4yn0fU11/Gvl3Kp4jxUj1J8E0 Pp7iMsuUly1THozw7aa9tSIjxTEVBiOrEhTI3gA1AdeABKgVoICwdxywFdjxBzEntPHQgPCD aiRwIkwzXnns5j9iOZ5F0z9ak6FVuSYbCySCVWgT/oF3xDMtP+hyZBLR7vvvedJpEY/ziXQ+ G/JxwOn19CHg4ROdoxiI2AK15MKGJHqaqxEpz5IkmnKYapKW5eZZSol1TTMtmM40xPW8ucbe YznJP4f9TZ2L4j/nZwIM65lbLXIb9TZqPFmGrW+ptOaZKypnnHCjP2nZo+bs9SezRFOx7ZY8 cj1vn9fDBI1mz+283U4HlrPxvO7/8t3P2jTNYyrcN61QGRk3Gmj7UW/s1WM+JPHaCxxWraXc yq2MnXzMMf12NkMvOLXJYZFSA8L61rf2Nht7mzED4mhd8w0O2ykHnoztfbzp+H+m1XgsE5t0 blS7LAvm515TNc2Srm2LnGvKnTJ1V/5zEvmFdh4yIYKe04UeArRUBZJMJdMzUDwxkoYrrWIk QYumdJR5WXKC0MH3sF62yF2FEJdhm1Jq5ocSD91nFcqFRQKVGoR0W3u1jb312LWfqGtIWMJ2 YWZ3QxZg6ylZgK1/OxYgRjBCb+dw/1TRfKKh1TUiG+t1QTY0L+t0wlH/z00DqsdqTDUxSAtp l0yumJ6hMSkr1SI4ZkXJEVWSiZyyksGEObT8a7nXJBQgzTGsKwUPCx+r/GCGVrKrSDpDfN0u nsswaSggcC7NUiBVy89p7sZFVHVPy9Y1PNndqfUi7TeVki3PWl1L20IOnrAggXFb7wZTak3j jYqwKWLNUmRmMkXeeD9usfAhseSJJHcpVTiTm0w/NR9dRn4YTCoBLWHOEIs5ykJpkXkk6/5J BGcI6Vji03x7t/Q2ufcSxegWmY8rz60khHnCCCPFTQ7Y9UdR0P8TrLAVc9tNiyvL/rtJSioD vUbyzmYqlpIBZKEmRnCK9fYyW6uohQ1RuKqVzZeVxCqbWydoDRX2ZElO1uMJkk2wNK2DrIgN 6wtnYP4/Y5+wjVpfqZRPIq4Moqg8zuMJRGRU7kSm5DwjRJWWQFd+uUEmpsu9zNaiyho6HQ/1 hHIWL2siQmYZELq0vl5usInwr/hA+YDBTjDR1IdG7Vfl2iduLQV/dUXpEwajT421lTI2UanG 4HdKMVap7+dpGyU4GxMwBFHbvLQKcd1hds2IdkQ36/ujFGyZ4/kDlGl5a5GmOCslFWdxDRJt emTL44r2iIolOoKVaNrWSiJfp0RMu3vRbMMv///2nrSrkSPJ7/4VZTxrpEbIOjibae+jQdCM AfEQTI+X9dMWUgn0LFRaValpxtP/fSMi76MOgXd6xt3tZyRVRURekZmRkXEcs4uU/tvrY36F 4tyciBIUO+AtHgmy82gQ303RtNF3TWJd68s5wW/2VU5a0SB0ECnVoCyS2cYCNlXNMEC/d3I7 ubhO2hh76iXfKgPTQOOMV/60qi8ZJq0+JQdqrUz9bcuIIvshHg5M7vL8d/EOrwEucRfCkMop RL7eff2u+nUZ6k0fa/ZEjnarGcCJY2PzdXvXGW0FutR4MzQx4pu5uvWdF+vWvw6zjOCnDzN7 UmqYFehSw8zQim7INn+feb35dV5rA65CNKohV8+KQ+9YwEsMu0KUK/rOy8LqfemB87LGWAbX VEMsH/ERRttYvBtFXwFLZWTCLjHAEq9wx95c2lOgFJkve9RlBFU16vIRH/UNfnEFo75hz2sD dolRl3hy1w4qIhdno97cqbeqGVzQVHdPtDw3Gy/gBT+xL5sj9BC6iin0p9JzCFeDxuvN5utN 60LMAS/vMS23d7+5/w46MO/SiDWX08qVJPVH94j2XX/qIZK1IVcPi69ADehSl6A7m/wS9EDZ hhOVeYTpP7nFt7D1TerMBbt4FEuZpiEpl0nw6fOvUV8wtmvf/Z4GGEeYPfMiXEyCzt1dNE95 y2BSArWHevqhP02iQbAenI6ni4/KQZK7Z2qwLCS0QnC8PikxkIzxwHMhda8vDzo6lRzsIlz0 S++btb6ejj++x86vhGkwicIkDVr1Zr0lI8Fs15tV2eTb8Ty9l3eNTiWCyv0YJsMU1Y3chTVo 13cxXM3TY/hUtagAAdZJQbO+XW+sObfWMv9dple8SiG2Vjoptn5pze68hX6aPL8ph4G4uZaA Z52ztwBIueeEi3HdYgJx03mTeYXt4lJUohFzLbPucrWL0xvlUBeP+gyORSrnZPrjRDz2obvu 8bkX3Tc3poq2jG+8dS2OTXRBRkyPr+e5M7XHZkE0FDYRFgwno2wvin1HniZ7XgDyh0jMO2/r Et/umUQN5BubruPQ/5xRdG7Qn0dFXbL73TRLUwp8OlpNxYo2Z90jDIlzfXDFJnDvqo9RnPon PfFYpAR03Au8Xpg0N2Lukck7m/v8Y7gjY/SU771n4JVSdjQ25mrhDDeWbqy1PbmKKXgwSyPb 6zajY9MiZ7RSUSy8c9Xh1hK0igkVUikgkY+fgUzWHWtSHOLSkNq9YEMKRhEzJqLs2NdHvVZQ yQ7DEKWDOu1e6G11fnXUA4GJdq5qnYk5GKzmMUTXF+ValzLhJ5oM6RVmShpiNVgQN4KrtJrB XxZTkqBQ/018vwWPJk/0u0ohM8jp75GCZeB28SGaPwXJAwbSwOqEs9kEDx0YUQ7pUNy5D9Ek npELIaYYozi2IrJOkqIPonA+DJkN1fhuwUKIBVye06L/gjAUBD0Q1OYRhmjDMGPNerNBhcOX Js5C3nWrCW3x8wGmzfhhMWL/D8dTyuaEfeXb4WVO28+yzZfY5A2xx7cM3JQn4a4D5ZFz53+J +fqvPF0zT9Cmu7zjLZ953/UCZ/kdzVe+2fAdnp9/Vl7iaPxZveJbbcqb3JbZwtQ/Hl9Kv7Fn HonjOXNENG/s7fjKJTHRzsBExTtSEmNExM2Tv+HxRJ65gt0Ana3DXyMMrpksBoOI1kWaR5UV 7MUfViQ2X7KAQsuDlig8vP5dT+N1gb+WVXpNxtIqUY26oFM5woDdiFiT8c6GCxb3Jridx0CG YVaV7T8cmSbjW0KKPtbDuqzUcxtV/ybP8hYlq3tgFQyg5nicA0mK3qaMZG7s4cX3bHw1oDRe DO6VSUb6MGMJCDFv3trGNjd/tM13ksUkNfkpzz7HKt1joGND5Fjo2KCf3UQnu0L/BBud3N4o a6RjW+kAExhGOgySevNPmWsG9q4MRqFF7aQQFH4NncxRpu0r8lkZ/ZwCLqWe22zq6jkuj3Ia 90oKE5bsmN5IOgDJ3eOL82D4LriYRzOsHnXY4hZE13SRIo/9WXXfj3hOHKci6KcSWj3qpMP9 05Pj8/47XdB0Yg+iNRItcLIIKd0wHuTB1TlcX8D17w1xMCMcYYHiRRORVAszNS0sLyYCmCCY OwtP+MRZRAVk9Cc8iuARha2iZPUPg4eHBDZgo1ESpfHIzTlAvATDN8D1/vjgILhd3AWbrQYG FbJARQanu8FA5m8C6L/DmSP8IbmPH/vwqz64G//nePiGSPzIM3lZmiJKB6aiLDsFwRKJcQOh FwawCAAn/SiO+7y9MEwTYNvgt4AMQkNg++B2L/i0Z+ucePDlMK6guFqV/RBUTEp/xtc/1oLb qq2RMgIiFhHltdSqhfoNrJmPtKvsIjRcIPvDeHE7iW7COKiwr9XgP4L+Ph9u+ewN5t/OCkap qOGUJFoipJVJTT0tSY933k3oqY9bSZ2en5cZTsiDuMNCpMJGsmCxPIL1IJwGOGB+tvLlfqjo SeD6/ZO3Z8b3iwv45UsZkZH/DZ8322ZitqqNjn5AIW9QZacqvvPYaE1n67b6NUxuVB9quNS7 2aFHXX4ylZRFC5yljSwEF2pHw6unAMnVMKp1+80q5XpRE05/pRbMVd2bSLmiaus/O/dbubOP T/vHnfPO5f5Vx9grQFbFiq9PQaRTz1eKDq487akhYszv9NwXIDM0tjHJWqvpChjzu+UtAQRa kV3Xy026vlpzyWG+tTLqqUfK5mMLB7qx4ZMkb0tm0jMu9g05kij4xMjdXYp7XmRru/v7mOx+ NQDSMhnr3CCelWIHHbgsP7AgxBQ27j6eUFIxaCBdAtMs1SRFlmhKbZ3ENBQRDHoQTnB1vo6I aoiVJCuBzkt45yvD8FwlJruwJyXsQHXQ8h57Ek0ObTPHOqyUhtMl2c6xEfuCvPK2dlGJCn+3 NF1WptQEfUgy0zea64p9ba8puuyD5M0NDG9eJhkUpUUuHjgwY8mUHhDViZj/CE3MWKYbkwoI Sb2r/fPlCQWSEIhWf7nuYaKTg9PrQ3lhA+RPgO47RpLojNH5bjwZQm+iemowiUCeJ1r6sZdl +PkGsQ7n4R1sejITYhK8P3i3f4n5mmvi6/7f2KkBEw5RMnRAZucDkc8Qdd3NbWOcRDxyYsRh lEaDFE/PePYFLqJ46EGzWW+1fxiHWxt1HQ2vqK7PfYP2ddxo3H7JWxFjZwflj8qtifGypvF8 UYzNDa/x0oTzHprNrxbz1Pk7lIZ2R043OH6jw/tx5+rgTdN6ABPYeHYED3vMNVFB9UwQ9LRj T2SXMY0S1kpEvFUJ1IBTo/kcGrZCnQFNoA7GHOM0iOvoBVgfrAiCK9FHzOSC1/nxYj5g6Wsw wcv/LsZzLYsaxRl5y8zweixdzQgHZKUenJCtCnlut2oY/m67iR8if94/O8UXyygn07bAC3FN dreAkqdpxBI4HOzsyosr881tDLwBr4kQKbDLJQ2jDsY1YZ2bWwU3w9kc1olRMJotKDdQEkW/ xsEojSaTOLiL0mEE7ItfJpT4djCJE/iIZxFeEKGZRZgyasmUU0ofZjSiHwTpD+KVuLd5RsHw mRilM0qiCiVLZ96ega2oPun2z7qH17jznx+eHOxfdS9/4eHKmyyJc7Plmz44Wyi9l7nhcA2I CchuV9Szww7sOza2D5kAbWw00ChVNLfksOavjZmB3DOK7cLb/YOfgLFgOzpSNBxMEzCHBjOd RUoFNBigQeni4LTbc/vApcQAc3VHMFGdXVA8Uy4Dm3iObG+9bm8726AOvNQ+KBBleMXt32Ej tIl+3Qn5TrhLiz9+sOQD0kb2cv/8sHvWf/eNbhUL6+0wfiAJSiSFlItXv/MRZLowjScT1IHH U6jOBD2D6JIW1yRaueJwGH64o8VrcRvP0uAOF3H4fPh1iHcqjOLDrzFeQs/klwS+iSf8wSxN iCqrVB8zMI1TupqdB4l4yBfiiF5E8Aa20gmG2gvmswe8UcJ30fQDXt6k8ZB9TCbsc4GGatNJ PPh1xlf0xZSBG8v2C1vOKInKR+ob1JZ3Spn+YGRmcTL+2MfdAAoQPcQ/sfXULarL7N5gRESX 8F7Tu493rNbBa9zSNbf39I7L2HFwYcrYcjYbeD7abKoMGXwhO/upi+eBC7l8O0udhDBWyrOf 6GHOgs0hfFhqr8jC4uZ/YrUlZ4juRef84opQ3fVYgzBX9KseJg3PqSeHMAtkz/qXmb0iIczS rq8653/V9g8XjyCMwtg6kYfEIIyS+OJymd2TAsJE6+yfnnYPcvZIA8LBvdi/epdTJIcANJKL yRBopyHEYh4DSLFcc8+3xZpAWg5YwXPNPf/erAO5aGZxGWic7+iRwXXNPT+ey3jsMWe73Koa nKc/gWHN6Rqd9QQi56FmluSnAWm1FDtUbs8IIBfvsgzepY4nOCgXz2Si3U2SlRstacYo7IPO iFENYc3N7MuAWB3ks7dX3feFiARkIdqLnhdRMqCWgdhZUHyY1poiH9uLihdXW1dktBp7jfAh msOkBbqxO9eD2vF0rrNKZGHyMdZQe50SDWVAeZL3fOT6bspnZcyODeClXXXb7Qxf3S10zdyu PTfL3zL0/pVNk7PHLY3HVtRo/WFxnE4beplDk8IsDIJIF6Ybyku+/BB6i2nn3cs6xXxBB6sN lnq+tiWUJCoEGXN7w0tPFodMdqwVgkwFHrQyz4tMZZnRaiVF15iFOUCqJPbsKTa9S6lQg020 KZcEKlUebgz1gB/CyQIthRdpIiPAY+5BPE/ciZy0z4zZmB97WbaHQrU5NtT8renTot2A+CIs M7Uo3n6sKW1gNJ9PSRu4pmsI5+PpnfUQmq2cS9Bo6iEcT4MK7GC/8UGpiJzM8BbqRmmZA+1Z lR8hfxOVY1GQydDqVQIDt7LR2t3Y3dpu7W6uSDsq9nomfwviaFQpH1IrgEJDPoG38Ft1YwV4 +fsZrL6N6p6WprkyQw5MgjUEnUTQoKSqmY5xK/imgcIKA7SGC9kyILESAKd1yNbmZnszeGU/ 2nYptTmlT6b9VXbntZob2xs77a2N7T9U56lmFfQRf4atgN8ZobLN6ZMVLduCIheF5Z0NhK/B NOZJl2GlMQHD8cdN28NAFJpn3u93Z8CF43GcRH5XgoJCPA4MrhPBmvnNDU+pLexmykrNS0Au xGYoRoPLrTW7wc0LuSKFzNTp7ieBDY8uaNjNkdiuB/VcsWUycYSWiWY9tg1SC6VJ2nm9sesR WSaTZ9gJCjwhR2TpeFskO+hyxIviO/qpfeEmQExV5/DAQmeC/BOHDrwkFyy+ssG/EBv4DjCL pQ4wi+ekvtEx/98OMF+PKSU5geXONPhAPiqxHBiwuTyAmjEWMV65Pm9qrs9byBvo+D8mf8Ep 3vSjpcE8/oDHD5HkU0tYnG1u/NVOtPzRlWmGmpnB/GVy1s8Zy5+PPtPBsa6Pgls8CAOroA/O kORM8lFmjWRcEwbDxcPDk3BNewyfEnbCxSAVghY3ZccqsKgUSBAokCc19fMoeoRzKRn1JPUA z86a63NNOmezPAEbdMna3qw1XWf2Z7sWs/ZnRv433+e5FRuAn9+pOKM6/wyX4uyeeGbU/+cn ADDqkh8un0/H4mj5Fk0rWH5G+Hq3lKLY8V6X56ekzzIkWVYl5vMSrs8WQin3510RndDClrl2 G1leRl9uxjY3G1tmcBwnIZuRi0gS8O0IXm2fmdgM6wk/RrAlTNMQ4wv63aH1scUvIxdesC6N F0658A4A0E/5MUa76uS1DtGs47L+EE6flL9Kza4cW2WwJ8fxnBnK0KjFI50UOibr8Wjq+ssW ldPtHf3QDDbqDacIvnNxx9MQN0ngoaFulWmVFY+CVS322IdwssoMLKcxM1Ifp6yOjB949s5M m3/XYDwjB50n41zOv5sbs47BrZ3RrewA24qr0njoH5rJFOGUdEjIGAZftGm8RNSVZs6AgdBw dNj/r85lNxg/zCYkovrGi8SNeTQZsx3zATbKKK1UMSVQKic163IefIBrpOuahtDj3Jrdcm8Y vSAnbIAvcsCz+YClIWTN3CNX5Nu/R/MYh9/wDXZC1WVkTVy6dk4cRS5GwKIcjXjFvADcL4FB wHSaRh9ZCIN+NlL0MY3mXlmpRJgB+LdysOJF9vjms39kU/6K17HCftUCyve4mGIQfhh/3BCq ezmdQCOS1wcEYHRBJsrn6QFWQdn+Ek3nmS9Hw8T7WszlyvcA4aNg8a/Dwsim7pPnLFamBlqI fL/IOEzuFsqPOjyE0zAC4eU2GoSLhGJb6oZotBvTygI1Ywev887frkQQOxa/TtBmRVp3kJ62 ZF1EatIBEy1trbcOIBTfa47ZjQ7GqgR1v7jsgCRC797135+c97oHP7XYpelL/RvWlvRvEN3p 90b4Zu2HV7ChPEQySCJ35UABTWr2A9atCQ8skRXpDi14v63IUMz9YxhYjCfx/ffBt+rp9QF7 XMXnTlDcrEC4Ysbl5qCl9VXkQ1WJeFkcBtPqU42ax/KTSZvYzdfApEqsDDDaBoWUpH0ThWto V4ghZWD2YnieBKNIwqozA5mHQp+BtIvCU305+RTe2tVCA57+X/cvT/bfngL+n5pqyvHIsWgJ jC5tFIzzAMTHwTxmTs8pKSimAJaKcLILkMRo5iT1rAKP4P8rELB7orT8ftTaIHpQzG2egdZn NnmhJ1zmz3LAdWjy/WZHbZB7MOANAEE778MPKBHDkQZ1AUKW4nMjoaXIuKFjxoEiS+6eYzao l2kn1TXqaL00MfIQFHzeITYe/Br5DrHqeclDrIZQ6hDb3N7WT7EKXZ5iWzlJUr6cU6wMmt8b P0DBf4mTaJTA0p1/xIWtoZOZmVxBLKvVLAgmKyaQOP/VqJNlmgRM8PcBzwEJrLv4ib8xYLB4 lsaVKkVPEITiyXA9SZ8mkbmnVahvuaaR4j0xux0858Cmwg6MLI3LqpzVfOpyI+GLkxPeBxQg km0kNHOz9IJxMlKKJC1Et0PQCcNtRuGGg+ocY0qk5ANHPcRCS6CCFhp4a7VWk5GgXWyiaKkn lNjE9FdMl1esjyA6y+oj+Cwt0Ec858wtqsNOM8UHZ29NShyc/XhKFrUEwJIEXHEQOe6EB1m/ X6TD+HEqBy2gI4ZUvsiRSGCdmAw5MyoyvXfXV/3Lwxr78v6yJp68v1Q2atqNAki0vETRKK9N naiV5+hcknNEgABsJFXpFZMPSo8BVMEA1Y8D+Yf3MgdkjaWcsw07soc3v0Dzf8vr4eDTnpN4 oLBRbpaBYhTzOKS+l2FFwNczPEsq+kL/ZlXvlFX7rMU+2d/vgvfqenIgjxWPSSsdzMaz+j0U 9Vj3nUpYYUYQcMxgoIXghvJBDIEGpPE8vEO5N+yPwofx5KkPvFCrEQ/A8UE7BIijB9YI6hQO 4JhCBxSoHa2cTLHEzzHovaU1FNfbcXtna30xxXuU6TpKAbfJcIOHXOcos/gxms8G6xj9PVof hiDITTfrm8oHfZzWi44pePJXpzfe7c7hQnClfvpQqO97rauDi5MLE1H1vIbmPapihWTqCauv HRYRdliUWgLqu394COIDSOn7xx39cOotQw1bBt39/tH+2cnpz/2rQloZ9f3WJpwd2d1CrScJ r55mQ6t9zWt5v9fjNX/T0FAKIrlnj78/0rtiA7/2J4spHGoGb3hpMUaxuj+vB9BaFKMu6pBq NOmtiN9oQRX1KNmh6qEI8xcoVucvWPWRwzIkKHFpEOSQKWonYGmMZmlwO54OUbacRdFcuOsi pP49Fo66E9J2kihOMrgUyrlETt6yDEFJMqygjYzzu2dLMPQfbLhmtpUnihGWhGHYwrgHGbYY CAZi+jyp68hU9XHqhao+vr3mqfoE6za1F2q2snXPpwEUeA2vfCZCWfGZ7auCWxavgh4811sd c6v36R155eRpTwdQ1Iy0MPEDnk2XHFG6wov5LPzO1vGaQ4+GUxguCjBk4Goog9WJrwf9d/U8 RhRgkhUfNvq0yGZY+dSY10W+JRDrJIMSlnbSPbg6zSfmBasWJlpZmnu/9R5N3pNREa5qC6aM dMvjekmhVWdZc+iAggGvFCkcZCUkpvcYv4Wvb3DmHuCKistxONmDisBaxVLUwfDG8zTRyXDl p8AN2aKZIKegfMfrextxSyYQyirJmOlCFRlGvhZgOh++Oo4phCczfOJHrAGu0GyR0/q0ah+n 5LoBJBGoJfrd3ExXrHnLgfv3Kxlrh+JYMW0la2W817nFC2KtMtrr7FsGBZSniGXLwedVaPuV Vf9eCm2nDZZCmwFk+/PzjVTXaR90z8+5/teLwt8bOPsHB52LnGLYewPlLbQ2LyICvjcQjjtX F53OpYj14As8JN7beNjKPDzx3ofXzQpIod4baKcw5zrn2V3B3pvhIToHuREl8L117ZDfd/je KeHoUoag8JaA751Srro5vEPvLZT8Puv5+wwVI4fd9+dZ1RPvPTy3kcmn/L0WQiHrVOrepGRA FtPSznnNvWz7jnLFKWJ6wdoRmIIs2LTUew1LdFZWkAuts3Ic71EEwNhB7s2OeFoi+qMNvoQP t44qb3S2oDXrr9aD/UUao+0o/sgKqV7ajdtb0ravpJcYRf5hzOFbGOduDf5K422k3pkmmL1R 5gfF0KX9lMXkk5cjrjc0KvdwS+wQBwdiq33P9cXQLJlja1VLwrdad6Tm0/3L487RyWkHRWXX 89qAoLmi4ECMgRWn19/agJ2I8qP2Tv6LK7DsQ4wf1hKm/UCUR8JURskroOPTfgZl8y7Izsd6 zPQMopMSs5fQeO495alMhDQl1ykrpSFedqGoHqPx5tbG+u04rStRVYyyKB01DNxjAAadUvwk TNt7G8ms1xjcV9dHAPMJOnq+wbrh0oAMUbmZkl12ynMqZt09oxmGuz7Jp+XunRV4uVvnxpZI HcXTdEaUwUcdSlES1K1E6poHz44vz/uSwT7+/dO4fxe8n49TVBrdPump3Ol0fhbOQcIPTkNM KJzkXlIz65zlDhLCuAEkOkTvHh3u//ymQdOAhk8Quo0mLLure8jAIy0MckRHRC+9pqAiyfLZ Eg8Giznd4DLrD7rs8h1anFb233YPf844HWQAP88+3SXmGqmXyOGaoz8zM7pnayDYzPToHyzz LHVA1cwHpsCUHyK5+hHnnvX+elBzLMG163sWj1we1X+UVgR4tIQJJa3AWJYGqiriIGOhGrSe r232pzczq6O8lphcIpN907vfIZ1ZQcp3O7f875TyXZarVAaZqeatAcjPlmRlg8cJNx5YfRp8 3As+Yq7ehPKl09cFfN/zJlty+92fZckDV2AF4GJkMrfKy/7X/VNbDZzD4iHfu4NVmj3pai6/ K3IVuVmz0aOlWB8J2tZ4OtWaPU94rmtBDEFxrlVFnXjXs9zbqBkhixvcK1aDSruFFf62WpPh rhUlyqqNcuB9yGaZaBYXMkPc2Fi8a7rIrfvD5pAbJd7PkMCj94bgCpa/XpOzskaszxCsbNGZ dga507HchCw1JbOMvwumZYmJWW5q+st3DCeyJ6hNDseXAsSDRAXC7Xj0xHuebnxvRNwgMa0p z5p4yHikmpl1LSP4S+ZgZ8WByUbQbTEcG5oCZM+aEOjxUfSFoWlfyPwrXmh6Wby8RbXBuHRp eYdK4AcY6mH4lKMwpaI+m9q5SI76t9E95zTEUkCbMvVeZsx4CeRYTDM7xmcaS5sieIbyyy3e t+E293JUdxxIx1ayaHMvU/GnTiyGCban11xbbLfaGSuCqYr1A+Vr/txTtXFEztf4lT1N2+nz tLP0Axyt1mGbgK19PnRP1vJU7QnLCWfoBgYwadJxuv3isJz59IpVfloc0S34RdozCoBLf5ny zGuRQGoxbdB6F50DGSl8XVsQbL5EQFzH/0fbYJNZNOBSH24FKPaVoLCaS4EmLZ58aDRqgVrD a6ggmKX3lKLlvu5ENs9pYC2XJecOS85LBWAxQJfJ4HcZAdPNaYscP2hW6K+DSTwIJ4xuLbh7 4CVkxlpp15ZQSBdR+IJi8VgqP8GJNh/wZ8XqPh24nLKPx0kQIZg2MtR3L1kk1v4ACj3pYvKX 8UNwFj1F6I7tCBLaPFcimDdUnxyo+3qBw0jONvbQh5kZj0YGu2gP+crRXG83MIBXe8PdzCzo 8gG8dEwZSTo3ltvui+O3fY3UBQJvkg5N2UV7Viy9WMDlbys1RLnhN196Mekjuvn1DpKkKIom DX/zriBn42HZG8iLk8PiC0jSP8GcFuon36mPqHWPjtiF/OfIHJef5416b4NS261tbMgkR+zQ HcgT9uB+OJ4Hg3s01R0uZvh/C/+0g2j6YTxHD6TFeIhGvAlGC6NPODKPGN6IEMP0Gx5EIEzD 5Gk6CEbsL8iV0wGm0YGhGTySofEwxnDRwrx4mIa3cPDDG0n4dTePF7OExXKCn+hWp1II3UGj xZf+nGyWwzuJCt0xT+4jtOTTfjBS0GT1msroMyVgMGHtpgBV+AcaNsHMc8BQxFWzqIX8GALz P85hEjB6+ICH32NfMITJA3ZHMomimYzOxz9RwZA+8SxEC7rv5B8iWd6C8IT2aImWSwR/842W c1i9+WMYyfRp+V5YK+gFrQGFPcKIWd2iesSXMYkbQGZkTNoho4WdLXns0gzJ9o877L5/Lz/V nQC0E+3BDLvsveucnvrza3gATQqX3esL7pCST0EDNKyjTnr7V1c/l8hzxwCN0k8P3iljrDxc BmjiYvyzMnkCKTqijbl/VaZUAhTJY2jBWtvddfJeYX5RX218OY0OndqIh3aNMrH3zaxUl2eH J5eejnDxEdA2okPHaDOpld8ATwIaZfdOO52LMmUToInKI9gV5ogU8S09yM4gZiFbXQZsaGfQ 8aNLQCNDpbR2hlnVzTNGtQCNOsh3593zt6fdg59Ozo+9VqM+QD+l3snxxclFJ1P5aQNaVPwT ykOFDwdJom2muGirtY0FiHh/eXLVyc08RRBmQic2i5p72dmctOljPNpXWbUykPZ1I0Wd8TO0 rTbHs6fE73kZpzRG53rXM6tRrmb2zGqU4u4sPbLO1iy/SZslONk1h4EylWCS1e7xyTnLsWVR siC0Wog3cofKRjb3JuOV2p6y0fWdac3IsWIOkw/dP070Ss3y5l7gRdant0Dt9vrvMpcFCWGM Vq8P8u3+mcLz6N45hBgvlj1xrbm5U2u2rVxkh9cXBXmrAMLMdgUPWvn5tRDCxDmiLXXfY35v Q5gq/6Ory+tzkG46mdcFEsIsEPMMvz/MS1rGIBysw+7Z/sm5a1bvBXGwBe839rLKNHhfe04i Ty/vVoRBOIiGUOdF1GaM1rW2KOWi6jKUeGYLUS6WLj3JZ9Zq78GSq5L+RN9z/TjEMD4V6iId P9wuDJWYelSsQNVgS+lP27siQg9TX+z69KfN3d0dS3/KAtCX06IiQa4x+SNrUjNubK6vTs7e Xh/pFzZ8kIz7mmCdG68vkkU4mTyRAc9CGahSlBDd6Rhj6AQcgJznWCRpTo9FJWHFhdOnR7w4 dy013ZseXlvdMjHfllBUwR8fV7Oe4432Ws/Jd//O1nPSl/+6oNxFyUILTOd4pzHTuXBAN2Bo Ogd8jd8LTec4fqHpnIBDixnHJDQL2vWK1GzpPdMjw4geyrFaa06ZrNkigqO8cMJocRVyluto mtjLNXtUbrnmsKWW601K7JtxA/nFxUyTKXjsdY1m4Hmv+BpL9P/ApymmzBFEque1w841BCgD Lnj/Jckm1jKSTYyoaTC67BNVv7yxAf9EdSF7mWHoTTGkJBYGasHImxkQSM7rhi6STOzUG+vz QSsAVrkH9pjodauMhjU4OJ/W8He1HgQnKVeZa4am3N5k/PdoyKIBiXjWMlA1xfABvp4nzFFh kUAhaJCl2auOUx6V/CEKoVUs+EUwGjI7ifycjqqlogVYaZpIjl2q2TV9ngRSAqXxYnCvZV0A EnLVMhNBeoJgmakeYUEaeWKJUMnW89Fgmk7oGYvBxjMKYvPfBPEMEwCuGHVaqQVdipFlxg7G 7H6A8+egUXWTBEoA2Vs4vNRV7G+16uYLdEw+c7oxIwScF9TM/Lds4r/ifCCedCB2FcolBFk+ H4gnHUh20U5CEDMfiLKFtdOBIG9nZgu0yiuboEMTBY7Y+rp/1UfO6L+9PnZCK7oudYqztMUk VJMxwCuKuh5rzU5UWLSjuxv6Evt5+e282RauaodRSqbvKLBgWgcUaIjtVhMrED9uXbwY7dzW FnuiVyxobC5j7vIHkRB8ibiQTYNwjtUt7ma64ee7KB74qDMb2+vQhUCK/dpdb27TOBzhrkPB UOd4T4z8CAXYIVUEPdxzyCgNUXGrCkl8B7IsArxitKoZYIUsmfEMjdHQVWGDeEjYrGXzkN2M k0sGv8r1osF7q9WVZBbOB+hAcjqeLj6ut+ob9dZOjXUS/GrX21WkRO0ajoe4WN3HU27ejDNw nTbWdWjhehqvDxbzORBfp+Yl0UM4hcFKeI9Re4z6kOU0ehMkBqez4jDnFdl009XlOvNo+Y64 NCHXlAnvXxpmmtOwaFQmvCHwX0M1pFXfrAqNhHOcrzEeTBZ3d7AIkiUAcYDmCekepnVxUT8+ +yQJMv4WAhqPGGqJCIE/iRZCQQ37XHIjcOlD6JEavDmjc2OQMZ9fv9iQcXj2HI614y4ZyTgZ qocwEO7DsZ3KWh2Wv1nj598x+oCOpyzELnclCcJawL/dym8Dkduaixth8Oc3wS0Ksbf4bcAS DVMy7G/WrGzY05TnN5N5lSkVM0va/IpWxjeBEpbYcLC8zX4HGv5506J4pL/tYjLmT7Xgt136 VwvY56dPe0wW/+EVS+0iOIYVUKnCFobhksZ06iWW4RHmZGZpzW08SODIzLc+dKuHikPhIybp YRtqwcrjipDtSGhDLx0S0rRU0tgL/3gjRTx0c2PAgwlGgqqMqmY+6BwUzvS8cN4nmegtG31C reLY32Pryhf9bQXh0ZOeLbbQUDEmjV+4k5Iz+YBXBNaDjdUUWFVP8Rtap3IrCap2QX0/FYw+ d9cjUSec3y3I6h7D97Ew3FAA7GQEnIYPM15KGrMIXmwtZiedgFxrVkcsCgGsvY9oeAKf5L+3 CjgceQiSCezeUyaHrnAiK0SlhqQxWOsD7NFoL3R+1GNSAxeWOQ1mKDWnTTpkttrJr9FjcBul j1HE/AZRJqetkDYSoENb+dzmbuu4wjih239/2T0//fkf3f7BZWf/qhY0tjY2DL5mp5V8NhFv f1NswFeSFHaOVD+tGJMM3yZpE//oMGPu6BZUvk8b5P4m/d7Wm0ZeFLc65jzjXD9EnkdSVvb1 QgJlZp1/5uWQoVUij8ZOcVuay7eFTJkYgZX/nsIBldF4QYe2lq+EGNbWM4dVh/rNXHQoz1Q/ /pXFnAdGVzsdYzO5FiFL2jl9JDbOIA0X2EbDM6lAD8hfDj1cOBG9aSycOoGqnUFIb/eWn57W wH/8Q1Y4j1K7ZVD6ZE4zsRENSw7lp3/e4kx7tCG0Mon1uQvbxjMWttw+Kr1beya8wt162YZn pZRdowHy3mB4pGD/FYYP0FAH5cNl3XV4wIsvO953L9EkSR4PSMWh33JwQoxZWFYaDGjh3j+4 NvWPKJj2U11joR5JF4rGLuyJrze3Xze2TZWFCVvegULhCR3ERlBBv9/oY7reqDd36q1qXj70 tkpj/5JM6BqZL8O4/v8AIRcmnKdABQA= --------------000801010703000000030508-- From debbugs-submit-bounces@debbugs.gnu.org Sat May 26 23:10:04 2012 Received: (at 9000) by debbugs.gnu.org; 27 May 2012 03:10:04 +0000 Received: from localhost ([127.0.0.1]:45169 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SYTrn-000770-Qe for submit@debbugs.gnu.org; Sat, 26 May 2012 23:10:04 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:52169) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SYTrR-00075u-LU for 9000@debbugs.gnu.org; Sat, 26 May 2012 23:10:02 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 87A6CA6000B for <9000@debbugs.gnu.org>; Sat, 26 May 2012 20:08:26 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id nqNYpOnAaE94 for <9000@debbugs.gnu.org>; Sat, 26 May 2012 20:08:26 -0700 (PDT) Received: from [192.168.1.10] (pool-71-189-109-235.lsanca.fios.verizon.net [71.189.109.235]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id D2CA139E800D for <9000@debbugs.gnu.org>; Sat, 26 May 2012 20:08:25 -0700 (PDT) Message-ID: <4FC19A9F.5090907@cs.ucla.edu> Date: Sat, 26 May 2012 20:08:15 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:12.0) Gecko/20120430 Thunderbird/12.0.1 MIME-Version: 1.0 To: 9000@debbugs.gnu.org Subject: Re: 2012-05-04 version of patch References: <4FA441A0.2030501@cs.ucla.edu> In-Reply-To: <4FA441A0.2030501@cs.ucla.edu> Content-Type: multipart/mixed; boundary="------------030309010703050808000508" X-Debbugs-Envelope-To: 9000 X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org This is a multi-part message in MIME format. --------------030309010703050808000508 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit Attached is a revised update, which contains the entire patch. Since recent gnulib changes have been merged, the new patch is smaller. --------------030309010703050808000508 Content-Type: application/x-gzip; name="emacs-ns-diff.txt.gz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="emacs-ns-diff.txt.gz" H4sICGd0wU8CA2VtYWNzLW5zLWRpZmYudHh0ANxb+XPbuJL+Oaz9I1BJ3rMViYokn3HGU3Zs xfHGV1lyMjN5WQ1FQhLLvIqHbU3K//t+3QAPXZ5kZvfV1qYqFgkCDXSj++sD5P7+vvBDxx25 0hEj15Ni7WhiBWN5Fo7XDNM0RXH7rNNqd8zWltnZFp2Nvfbm3sa2qLfwz6jX68v67YhWa6+z ube1o/sdHAiz3dgS9XYDRA4ODFGhKa6szBPd8VjGqRA/Sb44sJNmZntWUzrZz4Yw6s96WRSF 6DFxxxMZm7FMQi9L3TAQqetLkaSWHyVi/V02fvEGc9aaGPNK2GEwcsdZLJtuINbH3uCw1+te 9wcXl4OTi5uz03eDq8ve6S9HH7pHH2sYsbRLv9vr9xoCj04vTvu1PXEe3kmRTmQiRRYJacWe K+OGSEJQSCdWSs9EIO+F7YX2LdaWjUbCCWUSrKVos5KJuHfTibjufToZYIYeLXb98GjA6xh8 6B4ed697mOg45BETCSqjMBbJNHmdSE/aaXPS4Dtinq4zfQFCViLGQea5Q55S8IJocJaIILzn qaRv2cnAvhskaZzZ6YBGD7NRQ3w4/NQd9PrXN0f9wU3/9PzdzXvdiJvup8MzFtJJt0+3l++P D38dXF50B4fXJzfn3QuSzbX0IZ23c0sgUeWTF3y+v7k46hVDFAvJW/QTXgidiiFC6UhH7SSI vXbSkPtE0m7aDW4ay5Q5n70NR441zdsiLTF7ryAEbUnNXHTcME0GupsbVBu5EzWVg/MlmJbj 5HMUbUk2nG+rjmUegyTvkt9iQn/zNWuLmtHf5JacO39TkSibFIe6W86hvi25q4wrORxMio7U hjnlXBuN5ZZidMGL7qUVpnpLfFRvEz3+AnZACJM0YI0R4Y2VpaFvpa5ted5UjOLQ19pS7rS+ 92+VGDzTDv2ICIpzGY/l3CCj/mN4UjfEs0U6QqFHu73V2akBc8SzPsx4mLmeI6I4tDE0Zi0W diytFHr9U5I6lueOoR4/Cytw0EAmOY3APFpgdIaxv4i0luO7weujqyvzuPv+9KLbU4i70Fwi ake0t/c6ANWdCvI+0X85Am9vNNptgDB+3zAKK2v/tcfG/W7wYa6laOgfHfb714ZZBYL80fng NyBAfvdbr9vX1zcXp73+MWioYYQm3V7+bIb859OL48vPNG2/e563XV5/PL04GXx6j4unpDjr teYav0+C3+3BNsiDtXdJdqXGbX2fxv1VD+aTnpoaTde1Rzq/PL456xJ2HjqOqMAivJTCB3IE VahoCA0SDVHAA3uQgboq/+bQRhSqsKZ9DKycXYB2jZeXZ4P3Z4cn+VpM07oLXWdfTVbeumMy Id9Kbml4f+LCK8Sun8BB3AfsLzWLrk9CaijLpPY7GU+FR/aWVmCiSx5MeRc3TQQRwUhPYoFg j4QajsSaWsUa2+ZaZQ1roIAun90A0wOY6LmbCitJMjD8xDiBUUEYmHokyEzCJE3I9xOB3MeT 49JeD1qbAfxozT3Xdz0EC9gMloqQcRyEYNUOUk//mHAFI9ohtSjeIMIT3CYcXRBNLSpNWliA pTAgKIWX1ysTJEU3GDMVJSxqYRph0QlBkSVgVSMZQ27iHi6FwLFiNd8VnYln2oUnsf3af/2q +YTBVvW5arPV9tIQ26L9Zq+1uUe4NWe2ywcstdzObqONmBU/nRYD36wZ7a8ZQgg4o9C2zDBK 6c6GUC3Hc4NbRE92PI3S8LXvbOWXycRqV647W9uVu612xzAFmaWF+Eo4WcT3JAWIRJKJeqHl WHdjusSExIWAGwljad5ZXiaxMSl0DnDgkS7QaN8KpvdWHGBPE+HfMmRE6YRWOYCGknaKfMnU n/y6JwNBLioe048b4m880mATp6HrWw/qKuOrqU+DWed41nqFhxJiFD/1P+VHo4+oohANe4rP +go+NZqs5Lde5Vej29/kPIdGUfzJgVFUUTEHRdKZfNmGWCOjWIBI6BkI55DIxl/csfHP3pmT 8p5XJcrBfnJnm24AIc42BSFEFN6TAuTtseUCMvI7JUGYTHUps11WQ3fZlsNSlUpJmheK1Mtx CYktz3RkJANHBrYLuDJNhfG4CELTZu/rhWN1Cx44WFQ0fOtW0q0ZWL7cL4JCEvAyhKlmewpb qi3PKi67vbsHYOlsVlBledflkUBrp9UAoPBve4MhRSaWTbtu1F+Io5xUjtRDCWgmbb8LbwmU rz6e6BxIQxDBO3s7OLoUmY+PGCElUgTp8sEi1yZI90wPggOCF6ljQ9xPXBsJZZh57HMCYFdW Ook0JDJuYIdxjG2FlwCjtpc5UmWGTNCl1DDV+RaRZ3NQ+Uiegxj1p9Pn5c85d+ZHlDuTc3EC T7D/H2WBzZ7awR4HroqEsOGB8v0nQQjD6zRbasiCyNZPev2b90hPx+lt3UQ/8fO+aDc3kKeD bb5sIh2xeA7THRWX4LSmaPLE0EhFSYtT3xyxycKxS+DP7dhU6kHwJCJrLJUetHfeNKAY7fbu doPDQigiKQER56w94Q2cwC6wqUqxzfk8f72a1VeSepEFLsCLLnTDvyiOXBhedPsXGQ12Lnt4 jaApAa+aHv6nEj5zFOa9GBQH8oFmZLDBrx2ORviJ0qke5oPZYgDu7zwEMPkaKXzNYpuWRX7T k7p94A8JrOQg5aEspk6bCz91XLxpbBdyAieKB844Ph9CP4Rhkux6tPVq1YmYWHlxABSHGUVZ FGM5EhFIzHUYocoYiHWmkWdhTUrIh5CTktU6F09Up6LWsaoIogZfnl+dnnUHp++7Z73u+hc0 nR0iH7m6vjy5Pjxf//LlhTuC/gjOZD6f9j8UaZNhvnC1hf1U7ubP1eaySXqJpCdMaz77Wkko H7WEHkB3VPmtEL5ZpJrNDfz6tSG+fKH9c+05eYmHt+KhSSaErdnHJbCXrt9+/Vr72iCHs0Ke +1OKXlc9DMJazYB1Co7vX67ohgmnVBoieKOpsBsq511fWrBqg4tjtm3CsrYA+d9nuVkjyNMa 5IjhtBRF8yvWA+00lRUflbW3COg4APjC70GmTdbfBR1Tnar86hYyoi/fqVjFtsrYd0OqJeiN 0Ut4IHjTglcGttlqdCg77SDGVQYmxDOacUEMisQi/+VcJAGFY09YEUkL0cfixuYP/v9Y0TKj 0Fwqo0jBPOLifXUJ32uvNgo9cLlR5A+VUVSrLfsvV/R9wnbyNT5tO3qCJ41GU1pUmoo8K3az Wmvkgy0jcsKLvJePFIEfMBPfSifKRoyFjSrIavyKx23eKFx0+CKWKVijZxRjoun5c95TWPmc lXW232ySt+9sb2/hl4wMWTMNQqCUSMdF2HZLf2Of/kI25HEp/4mzBCEDXQ3sLKZUe4AeAx4L 7xojR0fA49Hv5i7c6XiIEEg+RGIEkBUxkiRhDxGmJTJNXIeGgDvkDxDsKALzFJsIHbbLzHUs 25ZJQvNRqJK4f2BL/8BgIqCcNWiYqkrL62PHTk/Lq2iMmfDMvucf/E0mWcrVGtwiFI2ZO4Qk f5eAGAxGlB5QYAy+kG8gZSAKLi0wZnbxGEqJAPZOVWwhCMSmLEDiUso4F+bYcgeFdPxbCiEi zlBJsfHrSKxQjJJpAB2hPypG2Wi1dxobgNDOm90cQglAF2yC5cdO0LYQ4iWi/1sFMHNjfP7w smpdz0nV5q2wcgiyXk2Sa/S8sGrLJiOhWHlQ7TRv1WLe6u4nEs/imfQbSw4EKUcEm74PBYwg o4JZAqh6RtwWRlkdNUDXQbWr+G5XVmDy/3F8VzwJRo8ZfOcIJ386K8v1f6qaaatWor34Phky +v9IfziErzU1YBHuV4+DkgRhVUeq6L/yEI9cAenDvObPcK+0KFF1xxC98kmb+ULJF6i/yiuE t4MkHIysmLg3Zg1gXZ1CNUSj0g1MGyW7RfuM5rPpbnQ6fLCxAWTWpgvqvZt3vf761TUYOzu7 PBpcvvvPWvXBZa8/8wTqsJi4w4KwxXTmw8nyvRS3dKPObM0/SYjN1QmxmSfEEIxtIVt//jKM oL3PkalzMdJ92DQ7NXF2POjBbI4+6NMRDD8/POrtPzc/ew1zGISAMxsBR/pcvH0LHpZVRZzQ fu25SRTL0fxxydJHRfGj3aHix9bOHpxSWSd5eszTRyet2aOT7f/doxNEs6l8cMV6nzqFI3FM 5yB8c2XBzwTjhriig70kga+4zgJ+1hCnDsRGl3FSUyegkeolc4I9Tk3zwVJ16xdLEZUFcmnl XkSujRiBamINLrX4rh3rhpmSO2QuTjwZBOI8jGMMFj/FY/8A6tgM47Eqtr8S57ouxm81nH88 Pr0eXNX2xIW8p4JFSrFZWc76U6XQclpUCf2g2NzWpmht0Rsg7c0VCjE/YoU6tLd3VN0Ev+oo 8g9gSJO4O7DdwJEPQkahPSEEOQ9h/tg8dfSRF40SyBgzJnRswTpgJcISWAb3lS77PqpISipR /g0aozCLjTpCMAnVRMx+YMPmvq0f3FnxN+yfSSr5KIpbL7zXd/kOPxp1vtca8Fh7BMjFajW0 PPF3aBfEDHboP0Sq9tgUgo6481GGmOtOZ0ezs49d9eYLWyI/R7MY8hHcCPd6e3cByB2ui202 2lu8wTf9oxq5Ei7XRNJWysguWa0inbixo6Qv1TneHK8NOAND6A1r8FJUzTTI/KFkiVasKilP EGGTsd5+qqKr5yvWYtQrp3T0nPY/nSxZV76ftKy5VRn12WWVxr9qVdWV65UZ9fmlCfIMJCrk LFkcCHWEAgpqs3VqwYcfj6VqJ0q3M8I7rXJmqSf3E4IDWg9nAwpIXXUiOzeNYap5uCBvpWns DjP45kdB1eaq9on1g+gBaPDtuCzsYnjFiCw6uv3OWesrZl0+iZjvV4N6nQZlsbkMZIVsjpsH ezwp7yitRZ1LPRpm3o92Y1G+JuJEyBObPwyhHeDeZGtg+ebiNerfS4TGN/RgdfBLalfQYe1T 57wq7pIOuPo1zDigh87ckftU6VyhXzTGKNVAHYqDIp2FYQYLxjbJfCsw6dTGGnpcReVTN1YV Y5lWMdiAQqihMfaTQrGkHuBI+lH98/IvoTwVpxgWCA0OEHlT+T0LGPP5SlSnMszZMwKlFcre dT/9zkLBIb1ZVAXwOV3/S+gKMV8ids5L0fzWXh7ymrm5knmVHp/Ad4YKhQAtAMvfZmjWFf0F fsScI+JFkUcsaHKtPY0t16NN/UNiHL3ykPPPUKUNlNkmgRh1TAV1qIiAxUYn6gVrSFYmfNYy swQSjWXU/QwZNZ1wgck2goQGl/lTkpdPWStHmSSLxfiPz6gAuEPsBXnwOyydlLm5QsdGXpif D/8zjNTxpCgNXyvsdovDk872ri70HFCkrULHIzY3Ol1BM4XetIyFJxS59OeijaqhKnwDVCrT JnUFgoY6ZikdOUUvP04HJkrKUiFD0pMPkWdhE5wcaqFnd26YJUKzUVP4QAWiwInp/TxBNZrY V+AB1DDEnWvzOzmJRQ6JxbXZbjeQIeA3P91hVWeYUQdg7A6toHCC6638n/km/0dA3Q8FHTPT i3NiJEmpHHfsElaTjzlI4Ce+/WPj4pGJwk2DaUWxkT/cVg+NmVAAUJ/aIH8YTLkgmCSaLkOq 4yY20FAiMid1DqF6cZhxPQo53pFSYJi8eoummnAwICPapgS16sAr+pkoX256VpLqvdVTj2Ug YytVlVTemJwHsMCUvXtrmrARkja7lHH8I1oUrhp1eP4oipur80d2slZEb1fELqYpScRq17a2 N+ldtnp7a6elg/DCSpDqM27GdHgfZ4GCZLEawaIijULvPOBQrCmxFUBmmDk0F9q5NwNlFRhb Bcn9yQyul6OKgJVHAhGGuoBRxK1FUGaYhXKoA3Q3QYDjjpCcIYPBZUn1lei8ekUvEJW0oRgM L5X+/PcljXjV+a9v7e1HgsWXeUd+Sk4tD3R1LNlYCHLLuHYmml2HbFus2uaTaKxjqEIBIe2i RqNoUXasvclf2oIl+UwZAyRUhlWQQXu+JIYw6nnkVknLEaaR+l2EqX4tIY8NNX9KldIZ/YMl U10vKfuyqhni3lKvM5SrKtRTv+rHmWD+Wpx6BtdHOAhkszxlILvtXapY1HGxNW8gOUeu40lt HKcjTRBrpObG3HKr5gJ8HVMkMaqsmxZgmEMpAz18MZhZsV2F89da+0SueE8FrdUWo8/TDXMx vStgvMhqcs0sSMxEPEzGcvJXgFYlaSt0ob5KDk9obSmG+o8EQau1N089ZhOr1dr7mV6+KXSA NFAxMEulUJnHQiVUh8D1gCsKZCkuUn4+cPWbmZwWkqfJK/sz2vbnVZ7ZGtZisWf2eVnz6Yj2 xh4Vcd6sqPmsGLii9LOzo2Ir9cuxFbulTLsYdq8R8cwGX9huHrPArcQkGcxFbwkrjxPoDTTI 43kIXEjp1ihScvLyAr//lEShOmdiHVCpHkswUPp6cP/tR1zRo9aVRqE8UJkfITGvi0sI5uqY u9MyDPxO5UTsN9Onpgz26aT6PanPYTWLzoO93VZb1Xb0hYZF3kMuaRiqmsP+iAyiuoeEzNyJ gi29oczlX5V8Lpb/IbkX5JYKd7XcmqUMZB4qaRlIz4qIKDDGljPCmBfEMg40oj8pg6bGux/g s7LeOzoeVuu9c+M0A1T70g/jqeBzY1U0zdfcwDMryWKVQty6XjicpvRy+zLwQcw9f94w01RC zI7odPa2Nvba1Y8zlvd98nxh9996vHDR/dyj75EClRxpVzdf7yPULg8Gih0rK/7g/jsq/lxr ec1/TafTlF5jpimykgSN+tNEdvJcCGo2GaZXbxAxUe4N3VW/92y/2dva2mvNb8tst6U7stWm F2TxV78e+x8Gwmi1nQy3ynl1NpsdemX21StWwCJW+r1qeGt8gJL7SsA+vUrsmNpiKzuEyPLD 6ckHcXb5Wdz0ukfiCn9qKp6k/LHclkqAzAeJ3NOo00dmiJMD9UKsvIfroAcczkwj/b2aJebL FVQh0Qs26nmhg0ogqkpWAHaxEBUYaqRPMiQfFGzMgYouA1KnarWwoWo0HB+pwohDRcEwJr/m 0fcbl94y4XBsl6TImcsaIqkhRM9f6BWr/F2lFyY52mStUdyPkRRHyVqecJT1Bu2UDUGvYCB/ oX58nfBhaVBU2tWh2bqKQaMwSdyhJ9mzLNNOzx2a9D3JHIQsNM98n9zZ26A3uyv6+kT/J48q N/6tWDJzoEfHxEdnl0cfB/qMXh3tUQ2NSgH1Z+uAY+r98lv3l273l/4jOtxQGS9t5seVTMze E6f65QeEzOlURvypaf7RRXPCxPhrT6VcoNMj1IeNYEfvEEbdSW/6lor1FM6OM/Zb6MED6X0m GkzLoyNOelEpqdZ58l7lqy3Fx76x5Dd1uTie617x0TDZu/5w2E1mv0ja/uHj0dOLXv/w7Gxw fNg/rHyfnAXk65tPql6FzqzyVR58p/otHbHiM02GTvpRr5RDHa67vcuzT/sHxSWaX7wQJn2y dMtrdvV7MehBmvP+9KxL5SDT8y3Xqz49Pzw9Y5q9AV0yTXUJdQdN6UfpVA2l4yn6ham6D5sF kRnVNOoL2ir2xcFCI0eJIN99SGPK5oaxFdPHIMAGQkSOFOmjAwrOaYNo2c18nZefiOjL9WKp Ndx8vH63iQa6PP5v9v68r63kShyH/4bP90VU04ktocWS2I1xGrO4mWBwELS74/inXKQrUCzp KrqSMenu57U/Z6vtLpLA7sxkpnsmBurWXqfOVmc5aspvULghvx5c/PT28pz+EBOvtTWUPNbW NmRjlxSA4U34uRph3+f7h1D5qFlUlUi1JwH68Syr5E17rv7wM5xnpzf+9Zm5Zkhm8ZD5zb16 u1xZgvGB9PzhZ4Q8diX4NbNlcmD5Ahdn0R7+BnWV388fMlCI2zmsCz1rKiDF5S7OrZCxQjVn fonm3vT+NvPSmZX5V84Uy/WpV+Ce1baeN+rPGxsZFy5ZP9c3cIfEGfzB4ihSRBWNUDeL9PA5 8gqA6O6CSfuW3GtbzOGr1WcA0ca4TO8MUQFbTHiX/cHd2uR/kVVZELNfGQinmK6pZSX2rWQH RCZw6vKHehn+aeyajz1SGcCEW4C2WyJokDmrega8ZD+4wdlXpDawEWPlUIH3a7UPu8ulvK8n Z5docX96dNZ6dX51dqgKUxhvEHxuTYqqROQB2IKV6goA5tJSCdix1/Vay863RSjs6vLk/OwD 2izhlC5wj+VZPBrR1BE1kO6bd5oOa32zvMZsZYPZyl+lPSlNkD/z1GxMcY3gRTp45zSpgbY+ oDdHtK+LrcqRNE+8aqtbFdYKjoWJ3MvqC5K3tD75JT7ZPKobh3K+xKd+VCm609V6TZw2dHuP BnPhZyD6skPKPbHVZQOrqoD+ecVl9TNOzRyWinfJHxNgZQi/sm1hIQU2xWU2U4SBVOHox5PL 1jFg4KuLo+Kuwq2XXbfT7PbGsM/f0JyUwClgIYbVAsBpcdd+aF69sh8IivGfepGMLmNiKWBS DviV1cof+9PqH2ub/elKGWBviAbDYYdihhSl06ODJo+UU+HK1ijSJqCpZLItfRjaL2eJT3mz W3l7cTJ9s//jCkxytQNzBLF5xh0owxi8I44qX7rbRQivkOUrbCi7q3UUG+679ptF9eRJ4rOJ 1wLN4ZT2L143YdWHdO99O9bJqKwm/xqJ2WbSw2F1MtpNf0FzLfj0L/z2M/k5fMbXItpjvnYF PEL8MhlVXhoPCf5UoGqrxRofs9SYcpXartg/F6B79Q0UyMzgT6j3r9agN0T56A51oXvAL0F9 3iS26kVRE84FSRyyfwz6RHBARHepjR9OxlAbv3ipvrNVQ2pTqyP1oP/3qU2i/mxqUyvjg0J5 k54TSnAuB/KW24mmaIIh2gLqC2kDLPsgGt2P0R1UFYDeQvf1Co6hjvFBoBl1J3co2R3ji2XA rhXA8+vGhBeBptyMgwHipC42iqXRc3UvJiTjsNOLRfCkQAjDzjN8YUUKfc/4DCTXYSfkNwD0 FTKy3+uzK/Wa3jL76i0sAhDQaa8dggCBiG+EJfGtKOnwFKFJ3tR3tdGdPKOrNT2I9Ij2J9RL AVDnPT4F8Bs+6jQ5SIRpm7cDdqHmGfwWqD0L57DKO5SQr0mk7U779P5O1ghovH5+dan2z35S 7/YvLvbPLn/aNQ/G4SfRdGIQCuRpYGXjYIicdJe6eHN0cfA9tNl/dXJ6cvkTMtbHJ5dnR82m Oj6/UPvq7f7F5cnB1en+hXp7dfH2vHkEaL0Z8nsM9jBjn+k1HB2MO+EE+OZYrx0thOJbcgwm pcE4bIcg0XXobWF0P/8EqZeAbqsQLruZVaJPQCjYR/bF7WQyev7s2d3dXVXEsWd97iV+9pJJ VIlA/m7cm0xgu67vPZHafNdXAqcm14KNwVAVAxckcBER3RSlLhCG4CNse4cmjTILSq9owIDm YfdskgKSxbjbj+7KGtkG+I44GYO80edRzEznsXYrNr7Tiv/BsnH0ITHb5ZIbTKEgKwTcV1wu EYEOh9OB+lkBoJwCeUCuDXVMq96PX4kCSVtAiC1r54Ule+ryp7dHrTcnZydvrt4IhZoUvUbA AiQa0cYBdua2+z96bWFkmWvRTK2kCvrXiqoXi9yBeqYrCJ3016/GuwyeiOK/UYX07F/Qbkhv P0unamz97PIXZyoODTGh0l9pY/txqEfFzy/SmzB/1MS2ZI7qbEpy/ET33AuxH+g2qIvljLrj wO1uladdUbEdlu4mMSlY2RRDSWkP/33hl+tic0Ruiz/uOaW6HPeL+qnp43XnT31WKrvu3zx2 sn/ag4xdjTN3cBjbjcNf5LYi6PyaTcxNIDhLyE3RAkTc1l2IgK9vawKuw5zAmDdahGFFJ5mm 5RDxGrC58O86kPLaFv268ztV/52q/wdT9XeZVP3Lqann08dDvfbvGV0/MlxcvWyaAZHvJ99U FjmSRGh1EjO9/VarNc/2z85Zo6lIh83tJoRr2ZWwRJFUukbQYgXbxdH+KUmwIIJl6UcZhXqx VAAJeE1B/oqLam/P4FhGdziwYqGGTl6wbtJF8ZOgyqR34qeyOrs6PdW0YhK7ctgnwcD+x6H7 leQx5jeoFqFiEbLmYGGJv5lCxVK+OD7WDRZCyvWNdY2V346jT72OH3xKR1C1tnMcSIQuUY90 3VhDrAEnT2N1PY4+hsM8QayGglhtjbD3xm+AyHf/5yNy8gdIYm1GL79j7n8z5t5FPPNl4th/ 9QbqTXgfkqZyJt6Gdk32TmJbK+kwF2unnbBLDup1Q5BysCq/k2tq8K1BhdjQc18GdPrq1dFF swVoVbDxL78oikaa8U1TrGj8UQVjlhwp0usNQmDsxh6it2rYGd+Lvh9dX6O/nL4wone9nmIg RYZcGyYAAJetJ9GK0nVuEkPmUhJ1GysIsuB4AyLAeVP9CHi4Wquuq0KvGlbL6jAY38FkMcjV VpFMR3kyDA8gPAy0YpsCP7jPrWTbgNY8wZhxIk43DGIKewf3vh/gw2qjulHGf6p1tpltVDcN 1CRioQAJHrRQVd/iHdjNqLFqNkQqtTACBNCaJ6m2CAKIzJxYC8sl0S9mdahlMXq1nqjVotfH zSCvA/6S3Vo/KZAd5t04GI3Y38lOCRkl2ksyGRMTawM3hpCkj1dDTwbkUFfeKE8RZOJpf6JR yDmjNdaxo+odNRlo/UHFuKf4RC+IJA2X1EcubNJA9pDNTi2XxqN+K3fD8a+R1l44zeB/eyrR alR0pP8cmEgBhXBFeSA0Gex6UiL9/atGU4E49l5HnzDiLb0GydGzgbOzGdYImEeQzUhtRTbo zNwHt8m/dxMYb+JTzRfgTEMOujPRqr51hHXMpaNgt4yIWB8/+45RzbLHrsHVYr6MexnYe5SD hGddJT5UFhDwNN2ZyekR4HxiCIFWk0gCzZHh8dAaPs0YTdQaPKZLZ+jBDBX9OKxMxoWXGAfe y8GYxInLhJmzz8Ws2A/DgKWcuXvu8duzUJvsN9KMoP3R93EgdvDuNorDjGDMXk3qheJUGnoV G8yDrzclX5pJPkrhmYx7WAJSDoGXU/QvkeyEAHjxZw3P4d4FkevmXI9/F1wkjuKh4OGIjJ60 qvcOlvA0GdcL1eLjHshyxAayFdafhKVT+kpLwLFSSgKNRATFl2RZ1l5SGo3woAqpF8Qintau RoW6sRWEraL0kyO9Rknx1XyfehWmtsavtDGigJ0x0dnTTO7tAhAz73p6Er5Wc9LcmI3xNA8E ua1jjW3NSdAz/zVNGAahJbc43DFHKYJC3mVvG+VLlYMclZKbqD+TnyXSMa0KsFtJ4IFv0xrI zv/cujzH5/VWvcmKEKqiOBzXyjnikrp2nB5Ggx66BnGWFMdSsot3ArGQyOno74M2v39aQWsn q2leOekCu455JQYjVEEY44rKYXoiIp6iWcq3Sm96xo6ogtWa+Bti1p46MPni60bS9k02rYWj GdFFc/Ls5NTNtmmqU5y6ujjYfGvZGiNtk0Eq6Qkk8DBiMxONQisDoS02f+26qvIkKpMo6lcx ZtJFCLU7U+Cqru+fu1/dQM+d3nivCj/h2x78D+ODVyocQLZyHcQhFmK853X+a7CObaI2/wW/ wJ/o+xRzAf2Kcaenn6lnytGBfy0aH3tecOz80NOzA1sPI1yhLJ7MdSvoItX7vHfT9+NbO+Hm vzTWvBdo/guizD8oxPxXiC9v46WX/odC0YNDtH8h/D0k8vr/GqBNZBZ4TFqBh0P1nIQCXzWb wENTCTh5BPD/3pw3L09/Ojg92j9Dq+4mPq62ke9crULv7Y+d6WAkYSvWyHAcfhi/vG+JWqEK wk0ZojefotV/q67Dm94wXcMaLCyX+La1glbz/OrigCfh2T0R/csdzOlK5Q2IWSWU8TJcp6Xs 1MqNOofXZ9uunCEQGEDWrNzOWJEATN5qzAPwjJU4XcweRIQN/L+jHy8v9luHJ81LZxR51rDf Z8zIqTt7WnrQvB12L4nZ6cYmxuwoNWCnJVBX7iZjpFmA7xlbLNcqa+EmCdvsNXvV8uZhRslb aeJam8WusZV3aW1DByrJXSxHoSWAquSM4qBnND/ECJl9HeXx6Gz/1enRYStRR+KO+lvj5kZq Y6387UlVzZ+9M2zeNsXDHsj/k2ets4j5WNoP9SrkBBIksGu/FV3Z5EwI1Kdg3CN7He2aTFGh 2E57rYFQtW79//I3mjKb5IKUQcBZQOWk8ZsBL24XuVshidxwoq+uTk4v3V3/Q6F5ebh/evL6 rPV9kda3vUU+Ots7W+X12pz1MTWYtUSTmQ8XkRrdzQ7B8se70CSYAlEJSPIdvtdAv9GYngAj SVDHDyi67Uvrjs2qHOxKJ6yi5ygUdTnMaTT+GFtpCiOSDLWQNa4ul9xun6tE7kTYLiDWLeKm gK0qap8RPIZpjI45P/54eHTchL2EP97tX5y1zs9IUvu+SG4v+29aP7SCSfEPJrIlDmE/vT46 K44HqtJVf/iuMoF/8OUdvWB+VmH7NlJPn62qw3N1dn6pjg5PLr8BKf3s6GL/8uhQ7V9dnr/Z vzwB+fz0J7RQf7or/jMIwhWQ0uJfvnv69PXV/sVh6+3F0fHJj0+ffvfL69Nfbp5KRfzPVDw5 Ozi9OjxqnQFcYsU/FNySYk6rtxf7r9/s64iunAIDW3+X9eG72Z0cnJ9evTlrus2lKK8hzoxe 3JpHp0cHl63veeKp4rzZmxc7v32qOKv9M9xciZPL9aDxsz8U/LLis5ktMxrmtzMzfndy1jw/ +HPDm68tnLlaO1fdUM80p9XF0dvT/YNEw0ThvLZZTXNbPrM5dEgH2Xp9SoGVD48OTlsXb0+f jb2LN6O5bu1cTGrsX1S3gxfwld2+isk8qny7flUv+arKPR180jd3uZTF3aby4eg/KhOvASAH XT+DNvgzmUUfXPyrZiFpJlUqG0XDRxgGqcPO2lp5raZKOzvwc2ceeTD9VmYMzcm2gOBnji0e ZsQQPJA6mGSlaeIwYzZCj7MnY+nxQ+fCpgGpqahH0qmKs8DndhsXoFJM4ng+z5WXB/hh5G3/ 4nXr7PwMNYqZ9E7l0zs1h96pR9M79Sh698zF/Rx6n3FwolCwsHoUrVRfg1aqx9LKSi6tRNvv ZopUSmkxpzXntW22Ntdbr04uW+fHxy1ZedaXRC9JrGpBd3cmVTcn402UT2Y2RXYfMzzq6nma fWUaa6AqPXray+3ZLKjkHFDi9uZCpvchrw9NYdPTyPoyr5esyWR/y+jp69NyBwtRYx8r/abM gMGbjHh8VkC5rEAljxUQDO7+DoxAJSVGe5dklnBsk1fmDsnJ5uyvlUk2h2GWN4e/YJfxXO5C PnNuydqO5JbcLjfmqGToWXGWGs/V4SXnby2uZ0ze7WDOGKjQzNOuuXVmKneSnc0bM55ezx0T 6iw2JneWd0jTzXWroKxTqpFSvbGxXq6vzz4lTtA445R0Dtmchei82+30GepPs47Q9p63sk/h GA2JFaVbSSux5HOmwbdR2NkXTVO0gJm3rbuQhffWpjbw1hr8CiVxuh1HQ4xjfPLs3ERn+oxB zJOW249xn+X4KrEaSbx+k4T8dxPu3024H2zCzebb1NdvYcKd9qidG6LEUxL6n+gBlI2vbXXS jFs78KPPwYCiLKPA1vtXWDk7PmzypemEcXvcG03QkC+cUNy3C/hYVu/oXzSi+hF+Y6iNaNE6 uClZYfNm9sZORxzHDLX7bLuMv2HcBerDFuOOUDgGzL6L52TyAMJmc6452MB3AUCnWEAPIjGA JiYPoNKEh8Zpoj5cEtPRQ2HzBKSH5p8lfcZdQKNhhHEFyKEvHsgUQRvRRjAI8TcnZvcwcteE Y2hHZSZHcAF4STi5ISCGoNuFA6I4kmYWvsGcxogFCujRxZl3Oy00FLSmcWMsdixoUhXustt9 TrRLelOJAaw1wXOXIE16NxgiZJKqK4802vISZ88raRkzKKd1NObquxl2aGi7tTr5NHKMa2Ui SWsycQKuqRd7eq7W/wlY01TZC7J94v+KeY6wbC6wp45OzoCz93xixU6oUs/2hzX2bMqfj2/h VrWmSIXUDEsKY+irZ9ZfixuNyMb+U7YfMn9GOUD2DO0bHTAfTIc3lJaRMd41hruPBr22k6CB Qz1zDPw7NGIcytidiIkBVAiBJrtuInwA9uCxevIpvgBXrNU8usRrVtZAUlZPNABoE2oPVsiN mm8B3wACeIFqAmJcsmt97U/CAoiFQn2q9NNs7Ozpmln6LngWRNy+Mz2dk1cgx9/OeQGzDJhT uAAL5tZezM1u20QvobbjsE+2YWTdYOJI5nrNbZCX3O9Oz787Pf8fcHrukul083L/UmcrLX3L L+huoapncGT0nvAyx3UO8bRu33x7dAD457IMRa0foaSokbL8jQGdr8XOfxXkRtyr+xHvSIKS UzIzm0TH7gtm2/SHbJ01aVT2GkuMbEOZKRtUV84oe1bcT2J0XRUv9jW+0rfgcg3K+Etb/zKg XyjHdOu6N57cwt/UFzF2bQ5bLdp5DphbVnBHA7HPbQfGc4FaqwI9SRgpSGd3GmGKHIyGam8j ZuUhezlmSkfj3id8y+AMWxqnGs9Ia4nvqiVpSzETKSyzdfkDBRljY29Km/vT26Pz48y6J01X k4gHQnbNSeDCD4V4Qjv1GWZUVAX4s1h5qf+2xtw5rWFKszrQQTuKjmX0t2F/geVy786aHzr3 b7+lYykuPOCsgeYsE8bSq1xoLPzZSpzpY3YXfrYSu+w681yIs9eMKwd362ksF0HnW2SnNgkV SZmxCTFqxxt6kaSrFsKoxh+CjBmFfY8n4mTjuph4K3OYmQSqkvVi/0W9MPaE6Od1BtuU1x/h IbfLXdfVwzHQN+D560M3z8MeD9rD9m+8h+2vv4ft32YPUyj3Qfs4+I33cfD193Hw2+wjE6mH 7J0mig/bvyzE9urk4vL7NOaes7d6/Bn7O3OwWYO4G27G8TYdY1+Sg2CgVqwqhqN/r2hTayOX shMo9La74IEthl1TIeB8JDv7VJgVeARutYFr0hobXuDEicM1IaITWGcwJxxXJk0ouns02XX9 nzK2aEEcmr9T7d9mp9qP3an27J1qP3qnHoAp83dr8Nvs1uCxuzWYvVuDR++WxYe+7LLL5sh3 6F+jYz1y3A1H986TpMS9MidK5xv+E9PgAB9fqT9w2w2unbn12dvGQkLhwQjY+ET+8stCCFW3 I/kGVWZz0PbuIjxvClunQcDsTQoMkhU0kaBRzYagJclaw11li4taLYp//I1TfvDTa/jUagkF OKNMFupdb9iJ7mLMtjnh5MUF1IdgTO2D+5u73rCoRlOOLbZCOjYtCsoG49xWKEaMQUffFFm3 ITW06mAQd4aNKudhirqTKhDyZ52w0gmfceqD+2f19duNj1vdbuGHZnW7VqwG8ejzS0OHFkU3 NfcuwkJfmdugU9DFnI+EMkan+hZ9tNujFD2ebPphev594PzQdkfmDsBaUY33qnlIqOAsnOCv +ALFKbXlyYUCrFzHIQYQAXYMc9v0w85NqNWBShIJStD6/ckEc2kgGrnzIg15IXr2+0EsmSKt 6nwcksNjF1DZdByyRg61GYC+eh03jwx1gB7QPGdpbmeug+H/Yzr8qFWEFmGqbi/sd+Ld1Pyk HwqI1EVNIiobAQDaLhjJG4qBJriB/J5SdR9SqrNeUKx3fwokTekwUeyFs/DIhBufLltZ7psE Owpz/8MiSvNEi4UU540dEzW0Ob2OJ70J6qjxYP032Gq24nzr98Byv1sl/KcEliNZsoWWRAet lnq5p9aWS9k2u45slbTKFX7vfKjOm8fP6uWEyToia89wPNukga9TEw/sHjauH96IltaamAMf eRsGCOb6ybIdxKGjuv0u5d7ynZtyodWK4i6sE4osu+JYCNMXEyQDLSrdrloXR4cnF/jr8cX5 G8+y2BsENkHMwniHRZ+4eHfY6DvX6vo79V3K7+c7CTvyJaumV42HL5qtlL/WmvV7y4JLZkA7 uTj5UW1i7DsDWWwjaaAr9qHQpA+XrwRsVOM67rTyaiVBFNkFuXQRJe+hl3S4dIyEU7Y3ZcBc 2kuTAqTobnXW9mdctYWe4nZ8jkZHCcYDNJybBJ8lNIvuLrXqW0k6wwkHIwzrNAn7jNN15l9k Cr7gfi0Ga/FNLw1pwPRo4H4otDlNiw+FLaftQwHsfBQOkb3cqNYAxsSM4DHgtQDwzAUcF7pi MWyEszKz0oGhQj2NWbBDnT2bxuNn0uMz208OFM2CIG0V9nWhSLY/ibXeXn5/AeQoibR08Zur y6MfWydnJ5cn+6cnfz26EIhZGJlKsCR5D25953rcfOe1sJCCgSusqFpOevMGcTwdUPi0HgZw xC2P2WTfwoiGIiMnDEBAuTM+3MaqCpkv1J8MYZuDju4CdtkCjqSO7+EZIp8QZ4d81bnOSrl0 M0HU1TpdBH9tIw7fHHPwuQD5HszsARNv94OxFcmBr0nGMmN7PbKvc70YCFxwdswN8G68CdoY WrWs9k/gn+/fVq7gB1KAsg6Dikw1INTeZxk6FMOcQtHukGVAuO9XwCZSaBZOgjoK2pjttC+x reD/b+CWtXU8Pb2NSsMGoJ+TVweouvhWqex4uk4IKt5JmL/aooXr8K31GZsKjP/xYQug+DwR ps/G9hvDbaLtx1d6gJFCkU2+NBvM80Jp9wVnqvJW3xsSm46383E74dxM58a6mh9csacJiqdD v4B5E6/o1dF5E5VFWlOQUBplb7xeXnLbMbiu1GoNw8+4Z/+c9saMHkE20DmdKvZq3kwBiM0y F0UezpivdQAGA9dP9R1++ijgozaHEV+PoDsRQc9bV4FiclIEsY+k+XBIWJGg4jqEKqGNxDlj 9eneBGKLDrf9TSF1KD51b10dcHHRjxdtTZM9LdQCSFdb5cxDzTS9TKyGGjODrm2EzAxWD5fp pDFIRWPEe/yUbXCfKg72FEiMSLi3q2JzwghwSIbLlkzYS5SJORhdEKZT9XrZF59+cwThXHB7 lLej6ef5V44nPszR4z5nwVlvqLt3Ve9Tux/FYaHoEhKBXuSaNLejdE5Fnut3CT/G71JhD5Fl 5Nt8cvbaqcnBDx2+Mr+SWf0dUOGo/bEh69fhN2e21nY3TjeSXtSxyUngrjlehpjovUp2Te1o hIoOJP+u7ZvfR4anICphstpS62MgqWTj706DAp67G+Ba0mUdgxzQN+KwJMfRwqC+AAO9mIIQ y5tRRY4BIPuk2Ty6pFRiouJ+19zn8Ktizx/SwpFhJZUugdAwnJCeFOcWTuLMhyF6eHdHVwWc LAzW7VizenSG0A9B0xZy7D0TAhUr7LFJtpcLREJMslVboUeqf9WjVFmTykvouR1NhxMoKpWk nfRGH1FHdf++9wG77naM/bp0Xd9NBbP8VWJ7yp7N2F+0XfTCojK46l125CpdVMC9wC1Qbj+m NEX0vscbSbBiIuM71/cRUPOtf3cTGP/q7KR5eSgXK0GM2iOgZfg/V6iQzTnbx3eM/YOjontt CeF4aIBK+F+05u+0BGW2DMpsscNg65bvtrHWT96vAnXiOlm4/61oXEfhmTLwMo8C+7XCFhMu FvnSZd+EMFw8QR7EW7xT7v7+pRvhdJW7HU6dR22K+WUW8BBPQDf+awEQoxtvE7nIXx6X5e0j PVdwjVsPOqPhkOKeuPDJZV7vUvbQ7tEsZuT3zkX+3LnsoZ1fAxPgdY0FyVPHsod2DIAyClGJ loZdXW76d8oeMQwWZw2jy91hdNkjh4kS52CLVXKU6OFn0YdLEw69AbjIPw0ue2jn47D9yesa C5IHjWUP7TgOExAUh2kIwrLHzBipUmrWRKoSs8ayx8x8EqXmDhxNau6T6OGdZ0JMnAEx8aMh Jr6dToCH92FGF3prkLKFB5hBJrheLoXgzzOIAwlyVEkTiGyyzNgynzDz9y8fiBFn7jj8+cuH QSSaOwh+/PIhHDw6i4DrOl9lQI1RZw2o63y1AaMZ52WrfPlwjGpzh+LPXz4MIrDcQfDjlw+B SCz/yoZfA/o0Gp65EqzwdVYziWauZxJ9jWHmQlv8FaFNI+n8waTCg4bK4r6NYCjSnR85Ugt3 3yViLX73dXhxE3nYoVna7R5lWfe7TDSlVilIJXxtyT4cdOBP++AvVJK5/XOc9ctSYB6DzJci HgIu4ODHH/dPT/ab/5ELcNzbrO7WwoV3QCC+/Qeuz4U1c1T/mUvJWAkiGrOStDGyRgDnzZMf D74/4oQzqeuqc+dc7L9r0UkLAPBQHi4ze7air7ZY0qJNJsW7rqiVjMWv4KN6ZqRy0tlx616/ N7lf8dbq28t+50W0TeGzr4rOMrCZg8wWwWUPA6/s35KpvXKwzm82lMYP6dvzWw6ZB+dJMM9U XyaPzz88CR3hyUv4Ngk3DQUmBtEWg6g95UUv1Yw7lXulzI3yL1TQvwvuY0WjsFFILxhOFr9e D7tdbiLEWa98Yk3yiKpszwBludbHJlygb3tsihe0PLb1F7M7rm0k82IHbEaqLXGcSIe5cTt+ Nz/+3fz4Pymv9fzYHAvbJ88wT3bjOmShCm2Fylb/C9lIls1pAwpB0QhgDjbEuNs4b9J2BGYJ ck1KnEqW3bA5/GYYP9gFfOm4hgtPxTNJ2TMl3vkJJt40fzgoo44622giadsVZfcSqM31ynWP G7YmZTFrkxdfMQDATdfXIXMgngc+GHsvkQDnfJY2DBKnQ+VQK2idMpmOOVto0IOPyc6zTaDe NA9aPxxdoC3Td9lRhL8jo+kUr5Ayic01IFjERCHXQmG+gcK/x/bACWucZ3vwJXYLOiiLw2qb DMcrByvq53R+UG0p5B/WrIO0OTXzazj8uuYrKY2xTtBqOXYjJyQe8BnsbAsfDMU0QZJbO2Ho dHABZXOr/rrrzWfmOGwq4M7N263U3v6a3tDvMkKSf5fasfTXLxGWVGYeYeW9pdlUdJQePFU1 V4Jyq86QNPLyHyeTHxezWifvRqFQL+ZIWV97OlpBoXG/cykSh5TWw/y3bo1zaOg/TEksIrRo nVgL+qQ1ZRl5DYAJ4DY4YpbEEAVMdjNFGzplXCsf9F8qHbGgpKTE2jrYb14uum+PPMg8udUd tJgO8JEpUOZdrJRg6efqznpacRa84meGjGGUh2tuvD6yBcyUbvpLjZU8s0hN87PIetr8cJYJ 01dAfY4R02OtmJxn2QfaMT3CkMmxZPo6iN+3Zfoaxkwz92MBc6ZH2zM5e+Pbey1s0vQVttQ1 avqaVk1ZZk1f1a4pw7Dpa1o2pUybvp5tU55x01e3bsozb/rq9k05Bk5f28Ipw8Tpa9o4pYyc vp6VU8rM6evZOWUaOn1dS6cMU6evaeuUY+z0ta2dMs2dvqq900xKMtvi6dEmTw+2eXq80dND rZ4ebfb0MLunRxo+Pcry6ctMnx5l+/Rlxk+PsX76IvOnh9o/PdoA6mEWUI80gXqYDdQjjaAe bgX1BWZQD7WDerQh1GMsob7IFOrhtlCPN4Z6HOtuXRy/DuvuGA0s8PCcIFxcYxHCxU/GM46s vwA10U6Xs3bQeQ+Z9eYrkdrzXnf9BGf2edcvX+B9N9FgsbRYdf2+u9/pqMldlLLDocCHuTkZ Hp4T6/c8DL8/9f7n5GHw4yvH0wFNE65J4n7AnqGj9StoeD6kx8BuP7ori2OkvP+r8PNkHA5g YdSoKvCgw3FwDDwd9G4Ps/Lwf87Lc0ZCLlO4YoPvrHi1V3rDCezTKJYPqSCk+rcWYA5Ps0sr DMoppHCdF410vOu8/4xjBeiu6jwDyYdr/HDtfqDMU6a6pCW6dsI+6yodqAMVK05MQPN1TD0M YydJD+0ptEqGDdRVO7tuYiec8B6lTmi92f/x5M3VG06X1JrkZm4yg1zHiWeCmwgEzVvAlS0N Dl5ep+u4VPJTOkmeH0vacJ621q92VSdnl639w8PW+Q9HF8en5+9w5mWcQVa2KljUC1XLmz+d Ea/45MxbsZ+FivarNn/CTufe2p/nDJrY5oxBzTVID57ISQXdlvAgtFOyDQ05jndNiYSFHA9j N1rwOD9Tkp8NNINAU/lDCDQ3WIxAN5zAj5NxgJftdyr9O5X+nUrnUmkAwG44pmC71+HkDuOG zaPYHBElQbUfTLGpl4dS7d+KlAOO+R9DyisZpDyDWA9dSpUi1cAQJGh+FtlOELFZZBumDsdX yyLbAAV5VLtSWYRqm1oJqt28enV5sQ9S9ReTbneKz/9NFP23pNyV35Byu1bTtuwBFHtRe+lt Q63NNYJhm2zZx7HVMShcN2iHecbSNUpv2KB/1ysLZD2kbn6n5b/T8v8EWk5B0Iy+0ATw/94x JXYLvXBkfhJDIfhDtIeGRZUpeH5ZjaK4R7a7MNA+YM9XZfgBqIF+vsQfWRn5jmEHw6B960TI V5c6uH6EXg9C8QlMGEqfmyS8q+rSoKderMFqTOlqatWqRYMafE2TmBzdxjglzBhNgaUkVn8/ DEbaCizCDCRossHjS2IGaxHm1JWs0/kTsjS0Wq3PmZqkZBz0hr3BdKBJPrFC6VEqdacTle4k +LxAJw07O9sTsVz9PlpiI6jj8fUAVrNlIN4iRCx9TKzkzOgGU3IQCgOUhxbYACtxD4270tkR 5GxPuOKEEjZiUErYXk5qEAddztfoSmV6ITKTAF/P2VbkE2ZVp0PgbMOTiCgBcLEGh9wBHNyT 0f41/qlpu4qGxn3ExAiEm0uEBFMniysA3mK4mv8gd6m4h9wvTj2eSuxmm7mEcMFag2zZkRPD pOc9wO160Rch1G3jTFbQT60I2DaLkyuuMFKgnBHoZAAU8yOjjJXASd5gGqg/AYyo5w5f+NJ+ hM4IUdl4wHT5jCmczoWBKVTQRo4OQ0zwOb0GbBhfUyIJ2mDyUy+iHMMcY5AjG9PGcAeFsHpT LRvOdm+vXrbz29urNIQCmO9Anq/td3N/igTKCKfjm2lw3b+noWDGhDV5QShLBBQpF+GWMh0r dUWJPwIDRzh1DHlMa+p8AhoS3ISainAmDUqrHREvwYDLS4GG9ozpEnB1DWiejOOkIlV8yGig ylHtMAzpTRvO+h0DLpFiP29LZvQ6I3q0AXs+SPQQTq6gj0FDjQYal7V8bg5Lgw/XSlSaCbnF 3VRKqAocPJwt/NsJR/icA5scida3d0PG/vsYC9n0N5jGGL6UA/yhhQLTofzgflYyw/7S+5PY DGcvat7NwbJffrFQqteSSgw1S6mbOgzcktwesmTJhXroTCLze4HDunIKdbvxiItHgLiAOgT6 pu+XdaZh9ZRbPc3cV/5mt3YSdR6wsSUHEz1T9XBH7yQZMIsdb7q/VVwBZ3nPqSGu67zSWWll ppyyylUqmqIFpBNbdyHhZGNtzegSwwlPQ9IPIvJK5Y3LT8S+9m9WJ0IB9fXFIojBxV8kgiAt pl5+lzj+l2gPAaxommR7GFiuA88rAg6q2p6ly3P1c/pOJvR2L4AzwTF91V84Hg+jRFm3PZz0 E2XxpHMdRanS7Fzvfrx3U2zMuf35OvnGV2YqIMWz4somR7Fd2+Fch4Ym8iji4AKMFgIssS3M m0QMIaZxEYqGTycmWr7JJsbYFZ0f4drdOX51Ojy36yiH03t1dWwoEfZ+Pe0KBSC4Cmw+PPob UIwU/LqbWAHnsQMgngoThCBJoWflmPFW4d/yZ2CCP7PFi65mCkw9s0Ucc38HZCw4iY8hJi0A lr0dhh3iboeUNwPFP+AxKp3eGInc+F48UplPHsMNJJ6wH8SYNB6E2TYzxeRq1OWYHJhMkvLa A+L/nNhB7f2GXlSc7e745PTIkcmzK6haMgaJBZGz5v4lsilUcixFtOYDkLNR5Br30LGGRTpY KWFdmrTeI4QdDq0MjH+8y/Y6aNCLKIJOBr+Kx62pDLO4CynFnkGu/0BWDVPi8bYdnZ03f2qW Rarq2GjOU7QzBXIY4AaLsDGAixvc0CB4I0g6xDE0kjRz7MlEYWvfgITXG/XdRVJQaDhUFERg PKQJ0OcU6BLje/1OcYu4FUVdOlBAZtBDRLz9aW84/cyKXrtDnSiM8dKEn3voXobZPEjcZ+cy pCIfw/Ew7KtGdbNa36ZNiN1doP6cOo0GbUkYjIGoAGyHKE/GCvMf/vTm9OTsz62z8+Pz09Pz d6mWGxktFaOLs/N3z/i38zcnlzw+wjOqbMRLNNndWsPaZ6nPXbppw0k3rqzd8FHi43o0hFLb cWJznGQxBEG+pqftgeFzYLL3AAAQboB/qcMf9yjsV/C3YZTkPid2mBb13RqHAAX3u16dfm4l azA258ZYEvUDinrk+k9aBArKEnYcqKwqzVLXBEBF2aDDkFv+NBgKw9Gh22e3rMCJHEQxci/s F8Ii+r3z1XNTPl5PbwjeTA9FO4vA6uJY2ePcGjOVISG67nRM1z/o4FUlf8frAGcXDTkLLi8k fg4Hg5l6hf1yqmNcGLpedkGiCWtIi8za1A22oNulXDTuyIUEg0SrkedHyDs6Ofth/xTTBvvL gY5Jd9NlZVsKbEC2kGNsWbkoT+x63/igRRd6MGPNkX6zMUDYiga9CQdxNx+Z2+C3GS2b8ZOS KXpf+2Ckn2/27EU1YjTm4JxV19w4qZzZMwqvANNW6UgvpumK9qEOatue6nPmmJhmfd40kzOt LzrTujPT5EsdQ8aeAMVuIkS+m36UEsa+c+4Pg52PReFO6dgS9mJaxC3d82B0p4yaFVVONeYa OJ8skZN+cKMVklFXqyi1dvUYvwbpeQD6deYB+IKzgkMHqV3lqcGluJ4ORqrtZBxniMsCi72M w4TNn1kVh0xlf/Ub2MzG+gjkytS99+JFh1GanDhXzDXHSvRWX3x99Yeur/6o9dW/dH36iZXH KalCGuPA4K467SwaDwDF/Yu4dbsJyiPUGh6BcqxeNssCrYgmRfpFAw5KLg68PIJWdI1RTzgP y3Q8RhzusGMiVaJCg2RE7iSSXMXMfJmZUKoIHBb7Zc99UrdyGmXhBFFOYa15OAbOPCYHbPgJ ky6yGJrZPa7NWI8AVuc+CnAvST+uydx1eB9JVh5OwdYGli9s66Aiet0i/xietJiRmL4b9OME mUFJcbk0HWVTGT+pfDCBvU4rZlcnsUN80l/1b3tYc3ehi+6i4RyUnQWizl7uPhShzBsGqibv GyxHcQqVJBqnjU7bdCyKSpx6MMBNOCGBrBVoBSIdBFNptIpYaJ3StVFUPnEaFHcz5lhfcI51 b46DheZYf+gc62aOiR3WmKQp8ZpmqSiVxQDHh6jt/1gNqgpl0yJRJL6A+kUZN59eHPXf9Q+p 52CkiYdaua+VgVq5j8YcgIY4oSXlqOPHwN4NCCLAe1Yq/MjCUnYf1WNxe9wbTShxWUB1o1FI 2dRwkjzeCU2e6PfQPmdPkIyTlC3sOkKlTqY5CIMhYwcU8Vm+ZaZXFVDA+ee0Byg2xCcQm5lR ZdewgjDJVXCqEWnlo35Hx6TSSsecMcwy9MbSYqb9PuNa0tc6hyUPli4ir8rDo4gvyPZP6dhJ AiuQph0QKHFaRfwsCe6NDo94625Hq2Xw9YcSJ7Vvg7FGd3gi5Zw4sxk8d+odgeSHsNNy6u5m 40dEIubPP6VbqucWx+BMrWjSEilGU3kXa8cT91LHSdyVnh/hGuev3fyqda9qPVnVn1qGDAPT SfJF6ZbWls3ljYUtvuAciPJ8P0GbBjgXDFrDl5v013AbkNqOogl020NhmidTNkocmbdmaYGJ FR7WqOwKqL06PHh3WOZcWQgjIKvFaqW6AmIbXnjphAwFuqxd81jaLq2FYqQhUOUKBK/2D49n yQOydFKU0nwrLPaeHTdVu9+DNTJ3Aau4uWdxFrgRmFWn710pGQI2CqdDfBV2QShIK2C9h3NY zbuQFbDDSFqzQhsuFamD1QRtCzjjIiYzRV3SCM8Effa0daBWwaMaoHoD040iUsPHt9FdCwqr 7Zven3qdvfpaY3Nr7SV1Nw7FODfWCgXFExMubjSOrvs4YZK6+RRJe7XJjJfkm+ySXuo+mpbN 9AcjysCGzSqHpEV5dfX69U8t2Ar2wQPG6s3b5i53Af8/DtGMxioVlboN+yN/p2DX+9dhj0AS HzFiMiAAthDf2QNYRpUzZ8JMpA9W8uhnkOnoZhx0QrZWEwGLrHy6vc8wsrwdaYsNrR9RehvM SimlbzAa9YX8xZ5JVf5qfZAVSI3vh3BnLSnn0i4XdztFTw9OIMqRdhu12rY8YqK5i7FlJJwe 6zdFhzN3BNZhMIzEnAlIbsRpRXeBtN6FWv1iMkbGzF7bUIifeoG52Cgr9I2+lyF5ZILTAhfR vw7aHwnWWMfJiUPDzwF274ML2V7cYEDFiQNqIITLSXFYTWY+WKfaqG7RZdCHPR0OxVTAAdVt ae9mJp2rGnd8ibL1hikLYaMU2pUYUK1WHyeBiWi5Cr5hxPQKN5xgOuQ4U9IvHAIKR+vSIhLs T/QshyfpqE3MM87nLlwJUcQWGYOQElBCZMrhOOKQ08k1Wzl9xKkm5CdhtMLPCOA9nCtZeXXx ZdMx4VKWs8SDdzQpvYmewgiuNQbNwmeS990PRDpJzHJ6oYBs/Hag6cIzs+m7CDuT6TBA1XGZ M1xr9cpAm1MZ+ZyUo4MRmoB1piYwK9v66McBevtCrsVByE4vTKBcBbl9QcX9ohznxyc/vjl6 zoFg8UmckdjQ6Qbf5Mus/nEG4uPhpJT04BUiQzQYREND0rTeIIPW76nGLBN6IYR/YgalwBzW kxjYzueATriswyUJM/skNXS0F/Eiehna/ThbnMLhvG6tuBIvohORvjPFoFTfpPOYCN8SE4t/ E0UdDJ/HIoJV4uFTXixIydv8TEYr6R4o/ubkZa7vuY356qMX91Q9zJ826NcqJOcRwDJIfKAT uPI18YPXwTYTiEZ2wr2RgcYyAIDPE974lm/4V6/fD6ogPMH2VQEun62vN9Y2Gg+pv7NTryXq n0yQVobBWCzhnEch1GXat1YBw8Z2zWf9DBggCwgiyHQE11fIiZY9ElXlgo7DAVoiwunDfawp ftwcIlYlxBABPWfrMt6dZFhH/6IiDNFdRTkvBTJCL+QMEwBsmFCatBN3MA1Afo8aIvZYIc79 fKM7SozyczLMQjbp8lSUCRRgSJj77dc80E+QUR/+XWLqOec6mWvz4N/KB4ixWJ55ELxzZvIB 0UOktGSR+vuZ6TPzXjRN9dyhhTD0Z1d46DsqHRravBpLak60HgwtM/tYXhZ4pwjNWhAOrlF4 ukMRAoo7PeACxjoeu341EWNfYLWAW5lo6ceMZ9j7PNKM72Q5ZhkglwrSz3IqS3f1DcWw95/I HkLZHfhKk3Umu9hnSiX9BG0WnkzijA5qvpD8s8ND85G6h/zu/OLPGDmcP4iI44enlZ9aZZP6 vqqB2dOteHdFd+E+NRleRXs2ZlWdJupqg1PXjdG2qfvd12d0X090X5/Vveh3oJ0plQvruvtN rPrb7keCg/g5jXIdlsPqc1lZmMlQeIlWcifjbD5c25Ou0yWQVa2M5PdHZKHLYkI2Ac4fL/GI Yi/j04tPZacjNAXkaeKtZNvW4C64h1vHYl6bMAK55rRRGjHWQ15Hgq8Jzx6dXeKmPANRFB9j cR4DfCEj5p0TC7wBMXIMjAecTdXnWIDOY7QE9OGZjnsTMrwIjXUP+b7AkgGFoGkSHPiYJG7A hR2vGxocYxd1CRnxUpLLiF17Bpz7/sHBUdPnZmCv7feT87I6ent08YYMjI4uzo+b6AXzlAwz r8nZQXvDYP9eR3ZrWYXkeNIQqzMm4W8YTW9umVODCvdPiQeaeB2xKwW6+w16/4JDY23Y3W1E pl5oK4dQQUIkAEUcdipwymlRixmsiGcyDv+kVDNCYoAmxrwKVoSjSS5qEcQFAH3AvF6uQ3Si 8AIwFxLYCbWD5q8WXirU0BQTpKnpxa2e19rNwSXw7wXRlzJmYYruFcQSfkGYFN0oVp40p9X7 0nwv6R39s56s5UVgnq3W69OTVwc+c5QhDiBPC5SDuV9toXaDGnm0nQOxPcbngCAd6BxoI/LS lXqj0tiSCDv9jlEbCSPN8IP0nJQLqV6sDIBHrE2EaB5PY4NNaLKx82qS6gcIxxB1cMMbkbVF kaDhZSoWEJcOP5heUhttSvHe2zMS/QU+nKgGx35PsY9CoFIR6X9OhzvDd2BgQns3gNI3rEWL Q5R2cxoN0o3qsxqRXRGN9Au1pZQiCSYhDUwzpm4xPuMLinhiHaRiJ1QD4Yt+PzdOPbb5yJKX tKHDRWUhMWqoWWcgyNhrl+C28Jmm1+3CxsSTaqyVDRWzo9l74zQfeM0HprlL4rM7SDErk+Qr 9cz6ArHy3uOxQSobuJ2q/Ijkvh7Na8FvSe4jUhpcCFoASmRLQdTAv3xFTguFsdmwMwN+aG7E 9SQnuDurgc+z1XLr/pq/toGsbZC9tsF/39rqX7y2ySR3rj71SGjJcrv+1U/skiFr+vP8NYtx /DZL1MyXEIxkxWty3/CMqPENoLQFCbr57292oiidZY0Mfbi9upJPWvhPkOi0bPWr9/6TJQZJ G3M0DvttOW0DZb7ThP65m/N5dTpJSHl5ShZpUWXXi3y5ydYUp4x8GQirwtcnyTnmhjGZpkQb f3f05kwnzku2Baxv8uCI6j3WZgWl9cfYqTCpIqMHo7b6AlMHLbFZ+wk0exZgcUyI/83LtOns gNmTZ2NtzB7fD4Dr+ojPoMcJzw5t/W50PChH0euNBE5gp3x89SezQ+7JUfWwqEKzvkNFnq7i bnv/a+z77yYm/1YTk8vb0H//7PQ6LlxkgALIWhMj0hoJgh53tIcou82QwH0XigZiKFmfBiCt trXGT9+upxzqQeI8MAfqWHyIQQH1xW+AxjzBaxfdTGO9Sgn/lzIJ8B6EjDa8//v78ld6X+7b 12V7SmReIELhwo/K8pTsdPGYR2V+Sk4t56GPyvyU7L9Q//selftJlfPvT8e/1dPxw96AM7wA i7tuBsY0dljkQfghj8EPeQj+Ko/ACz4Af/nj76IPv7kPiBmPh54A8aB3whT7vsD7YH/Benlv iG5owMe++/1vfObLfuVb/GkPhc5ZOPU3erPjfMzED5TlPMnqMqAnGXU3xss51sjB4a3iyJBH fRCRGkWUPZYjZJneugkXOe0w7CFKww2dWiH8mzR79PMXPhy63NLvL4npl0RDZfoZ2ogHIqg0 CklrgfJP28US5+yu25+KyaiWK1kGvAvldUJsrsfhzbQP4h6ZWXsm4d886O7OupL+daS+m62T 5unZn9EJh1THUSdM1M4W3UViSlEGf5BfZwcnuk0HJ7p9QHCiBSOn1ncoNtG36WiP7Mrhenb4 bh158jbK2RKpKVNWX6Bd/zENGeFIKpzjQwfHOCFTnCgvKjugS2LhCCraqQV/dnpjfxsoJ1f+ zLLy4ZBeYIIOwiYo15X4Dbuh9wbAJsWu7TmHxIz7+LZLQQLwITcMOhhIIT/+WT+xktQK5ipP 0horp0vqzlFZ5bKrv/oxuVhx5UB+PHp2QB4hp9GNBn23zMLzpmrUn29sP4dL4MJ+duVM4K+X 1xD4oScEfqdjN1CRUi9C+uW7dlydtoHrDTtTgpClpigu0HggHFcsl+Kp4Aqvpjff7sCYRYrT tLSK4ilsQTCmQEEVJPFV4MsLSDsrnRCPt0NeIBVSLBSfq7PwDt8jofHbk4PzCuzrq/NT5FJ/ 2L84PWleom8GWgRwPN6gXyZkik+id8ATkbU9AARnQYZJLBXCIY6SHkR3gKMpHAt6xnIKBrdG TanNJKpIwNOiev9Ntx9JGKMPIM3KpiCjNYSmo15b2DjgJ5ZwKtGQokB02YoB42BQx1IJ+8au GJAq+uFR/gQ0WXzubP0oztv2AJjJsN/Xex4OgnZcIfDAWmPacfpNlm5nNoKZxGQ20sfZxeKi 1DHLH4+gzSX+oj5RRCBUJNyxcA8newMs0E6ZdAvbtk2FVlW0GwSbU4kn9wD2hfUKsqfFRAxU 3XAYfp5UKIzkOOhXBhLephJ1dY+XzrL1RKC53fkkA42iF3CCGIKU0EcbxR9WbBE/iB5Xdvxx 2CevSOdYxjCfth4+BTi8gbYDYPQZ1AjCkc+JcR9C2WqUBWruRiHT/gluBVQ6uA2BNeBq5oTQ 3yzSB4tGN3A2eJz8Kw+F4WdHzm77gGLjzCr32r+G0xuqN9EYo0KpF+ObwXcS2+zlslpWMNrd WqPSBbpK9xV+7w17eDbdCIa6IPGzmo/YMu+9g+QyvwsOq1eARte2ngPOa2wkEd6shnnIr7FW rkNH/APwH6xvd3dXHYDcC1scjO+fQ1EFSgi6JGRAmwOfwuXGCH7khEUqU5T20CiEndYG7Gsb EPVYLuX0YXSRC/UCk1NtuM8m3ADKlYXvT15/r6oKaYvODmFbRtdw3uEkZGaSOElakOibSQWH Q6J9A9suyVRUIGFtMdlkLKPgGBRTGLswRerNycHFeVF66vbGMcci1j2xnvNeUf1V1fj/6puq hA15Jozydlkqve2NO3r6Wj8ap1vCvzSoekZ9SMgU3Rd7ZLlRAEnpzC1emNr48kMf9FRe0Aja yU/8Gzly0DgU66CYogoh99BjXCt+0jRFEBexHz8Ya7ozFkHxb5soxO0GhHnq5zq0ft8alfMm AyIfR+rvOdTyKQcVQ0++jKNe7JjL9nfq5ap5dFBkkzd78Fio3uIX7jsOU4eul06d8PLDf04D ckHMOlbqchXO6P+rYOFb+2e9wcvRQcbZZ4liYwDDaBCjLIkibXdw2zDEF0xP7yy9AeIhGT93 0cxfhxT5mWY865wiU5X64cji7VvKJSlh0e2xeV7nt6QjoFib3WgcmhMKR1H79oEni7jA8Md/ T/EyT4lnxjeDMIgxGhqGfAuDvo5pCUdFXSSRGEbf/LvHdDzlmH1D7b6IyOcWCCx0ODWdhIMq IdT19XId+En8wQj10mym4Kx+IJgN78+r88Of2A0WeWnkLgADH2FstJDdME0rgE7N6PGxUImD B5crfyO41IwhQJP+le69/uM9pg6RPz7Qw2/lh/3TqyNkTBfsweU/ve4S/TFitdfefqSgrHy4 +kC1cqKH72rkzBEtS1TBwXXUZxwoA5XduWF7d36wDrrlmhnxuOXYdM7v05YvJeUg7b/X2lle qjUxxFESu+G68UNNh91H0sVkyyVVZW5e17XoPKnCcoW/08ZgnUa6jkt2VpZLToezKzu9rklF EAszatK2Yd8YPUcHBAWhsYNAWS8CH8Qf0NOmUHhCYfALfFQjlfz5BC7Qe/0HAusH+reI3SyR yWPnHn0Y8AZt7JQB723Wy9t0f5ZITC6QaXZhFI3gYkyKRVOOVtkZxYMeIhHnQ0k+4IGrwnRI iQkKQPoKwqtjNXoTW9I1dVvbK22baRz+029c16vJaWxQkyoAqy3zwhVvbpYb26q0VSuvr/Oa /w4dT1ZVuYD6WTivvxcK5RsQsu8HquyIazge9F4o292RakX9rYwbVKbtoLUtFegdkbbh74Uy /pS6/IGWCB/wp5l9ATVgCMW2f70sRQz3zZCWjkFC/slDpidDvUjJckU2ylkht5WDww2yrStL Ul2lJwlnVnRPjSaj/1RqVre2VrlAAhJBB+2SlP+dV96xrejrUubUGbTaQScxhu4uY+5rxaLp Mbu/mtNFzuKlC2Vh1F8C9WZrC5Dm7HzNdpaGFPJmUt5nbzb1YtGB+NQIBIoajN3h3LPNGi/3 7Gt2vDzFiSp/wnCogJ3K32k0IxtDsOIWL1cwu/YUKH2SmxAEhCvgidP9WK4otXJEdYk6EVkq W4KESrdIc1CWCcCZI1kBQrXweLQdTwxV4uFLmcPT0DwLxOFzJ/GF1Io/L1ceQK1stXnkKZso odB/nKvbKnP8JHS1wYAfmA1kYNhiCuVcXi5x0ChOKdRhxpQ2C43NMLTeRBgTkaGu0ww1U0bE GwRPBaQHApSMLJU+QoE4W6MONWhznBoVr0YjWYPBoKgd/Raomai3ll1PCQXgyuT3QLCl0trB ZMuatKWbowrBdBL1o6CjngIjFUtDDLuPSWxs0UrRq4tF/wKxpYLcOiktKsF4FFTISQWPdkXX WGFiWW9sELWsr2+U15nFdv4rANM+HmlGpGLkg6dWO2kQALEvePsSykwm1UXb78qBTh7ks7IS RAZ7xkWyUDycDq7DMUBHxcwpDzMVUkiFpmdfCRZvSeiBzln6cPekpAogQFZrfICbGxtrm14F zmRoJ8ytnknXoiyoEq51OKln0rHUCjeLDA/wa70hdVmd9O233+oDX9Z7ntDzKq34pYmZDQfZ 9/zssAkAk73NRZVAbbzvDOgFaIKviXKqsu7KkpQXBlEn8dH9uqoKFfO50PX6Khb1rugLyfxa oUDPt7jbomHxBqnL9hXwPYCf3JNVqX1d7zN0p1cxlQC9S8jyqhlL4Dq3vezla+givgZQA8xE rwRVr5p70nwTfK4Vnb9xPvUS/BA40N1MvW5UghUzbZna85+4CuiqHzH7onuCYjko4QuSHJ1p 7bEOVIiLhi5ve8WihlWWERjtYSOYxCieDZlGcVwBPDKpq0mDYVInu4uGlSHH6HPRARFGHXid DJbcrw2By9n3uY7XsM4XCsatW8aXPjfwc4M/N3BaDHkP6RMvaJ3wBPdfyu8fqzaoqozFG41Q 90Jxz9QI2a8CKcX2ksVuC5oF9i+ygLRwiivmMF/o6fJUzGGaCtylX0nWojvO/Ki7522gFRYN rORDRCe4dxAV/iWkaGutvAayaqNuJDcXhkxaOheKvAziFkTiMoLQoDcEAAVoWc7JpdwbGnVP QMqfDNy3OLUhcjEHyuz5lx5Jjx4FZnKfUaqt8E8Hqki+rNAPDVFKxoVi/sUevOLJwBf6yadO TVicHwSfZaY4CYM0SNgQWHG8w3hmMlhdRtNIjwcq8U9LIZaV16ORfJSP0e6oQ+QG5e7IKCWf EKc7xKbJ7njv6rx5ukMao0Q/DDkgqj+f2dP6gNJi1c35L4BrKTeac0X2O53k7cDLQW4qDXI9 Nk8b5lEirab+X3obStm3oZR9G0q5t6H0mNvwcs8H7exLUcq6FJWZl+LlXgLGs+5GKeNuVGbf jZd7DrBnXpBS+oJU/gddEBKIgPQA0UHKMwGxJPdhOcO4wXlWzvhq3oZr66q28by+Dv+ffFSe 1SznSXm7DH/Sv0gR+Tm5Ez7nVarT4F7Sc/CV1dYTz+nB7z3Ii2hnAxdqRFtmhDLYOvM7GQ/g 5QeJHC5gP7inV6SHNB6lu8DZ2RelYIxpVTr9kL9+4HceZwB0HBE+UNT/lPmHzBbgIt0FPRJX yOfONiyWeRwxfeFcQbrNStBHG657W32lLDQ/Gt8z07HeKMO+l+DHWkr6VYXndHd5R4vJb7D+ dgVt1MR6o8K3pWBGw7gUAO4P2Pfc/aKL8OAzmNGd8ogGyvjRNaY38phz2tXzV/91dHBp3y5F GGfOkLdmpKQxsopaia+LtrVMt2iDHXOH1ds4nHYiuJUhUCd6Rnxa9SdeETaSrY6WjXyizV68 PbOVlH1EgEruXkqdSrIO7zF/Je4564NTPPLry34Druy6E+cJB4PrTiAjKUdbQpy5nA/3BKhw PIbSlZOhzfA8XnFJW3fW2vkhQZQalXSTrJ1Y8l4sqC2r/vnX/M7cneG1EAj4/dAf9CagOyL9 PCv+3SLovuZKoSEcMr1XSU88GmoLR/KbJaiJ6bOwbaVzjzA6GyTfRDYludoRn7UcjoP5rZb8 Ri6d5LnZ7XMl6/mHwSQ7s7K32WwOll3RBUyejpbXEjdLW5i5gOnozAGRTAJGoltbSKO2N4RG pXohxON2RVOwXTHOEolOh9dnLEpIS+lMPagmvEAa0Dw6aAImwB9qAIjuOtSeMNCmnK3dIksL yi+KDjMw7jLPScQ/3wqlWTRGBOr6vqw4qfbfJcK/XRHgo5Lby6KN0IrHPj+QlZLWrKOF/dH+ paRPQO1ImY0vDGFcRqOokJO+0eBHyFYQ8cPd6urcDBRhW9swsYLd3gQGETy+nXp5va5KOzvl 9U2hgSs/Ecple9PPJrc9pVJjXa3kftC7jkZn2oqSMr7wAb1BsxQQKtq9WDuJOh2WnR7LM7tc 1n0aBZyJLm6sXTxgMG5KWoVJ6IIYSAxIjxlyblVd1S1PijZJaG/kgU4ZzTrJHIiMgCIyQO1H sV4UJcmtaISEKkurGZeBqECZgiJjVHxT7/eRNFuFsHygqqz5FI0wVbSSFJWmxhkCCa25GFMT MPxQ19iGv1BZwyljLAGsqda46tkxftBTjjpSATWldp6mpalJ5rVmDRWnru6jmNHKrKaih89Y qHwy55bQT9uRU73JMJ66d1Z1tVA7O5+E8howmJwwavBJj8yKLNkV51wcKrHKolK15p+oKKIJ 6VbMEeidNfsp1Wh2Mo4dU7Tupo9iojaRBlMNZmJWQIPZsa1GPZ5e89GM9KqwJU58TeiyfQFH 5Xy4mYA9rcGH0Sm2EL4SeH16k/MV7sRNvNgzVZy9KGCkT9Mr82tEfxNrLfmjeYpN2WDbi7cl mnDqCXm9Y8f2dwcwzci6n5wOZHoG0jLaudr4xBBW558BtPa7V8Efxnt+yOrCr1b03/szTNwZ 9pOEX/iUCqmpPmHuCaYu1/c+sseT1o3690ygWfLX1G254qJ/scC0LIEkMMp5Wyw9at7CPJHZ wMNnbz1x4+USGRdQsWNBlyBp2WtaLuUtyjLJdHH5ylBlTfvZFCTpI+J8TD786Wcv81Jm38GM BIAOrPgF3/4IpGV0o5uUv6nrGvzf1LCg9mbLC53d4gX7sg1rLHEYUcCqskxj1nASF1tMCcSV St7DVROOwyR3Tj5ZkSlb5nuVGdp06YivEzRh8AoaWTdK+4fksNHObToZtsds8GpTVYVkYs4s dBaIzr1VDlNFVujcoGcsPISFo0xeoowR047Sg5fhXq4HLqacvmHlxa5Y9gIBjLhhgHFInLWG 95mm4XzWnszFZ5qtWchAN34L3h99TRxzhoe3N/JerrDnuBN5ct80cUgi/WVJbClhjZDiqD+N eUPZsru+toGGqfV1rdkkkYYlwbDTv09LMCogk+LZ22vVJwuJxzNE41pGL55yTSs2iA1htDuS fVGFl4KbAA8JilkW53RUQBXIPEf70rDZTuYZ8FZtrNNWbeqtYiNSpgKjWeqeYl7dtGoht6qn +GKVSLqSp+2SnuST0UGar5prNyLZOCa0b0T9MYvKhNb5b/zVmEKiyT9Lrmvbm6h5WK/VZWcA HN9yIisklIEMrIXOHFnZRR5iZS8te7HOq6PQ3f3y5PxMYiYZK7j9i9ezNBHBf4guwuyKVIAL iFXYgPAWUNt1GA7tlp1ZW54z9YJWj6p4cjmiuFKwY/62AbamPao4bbvjaIDOlegmkPsOY3wR ndcXU7aII1+ycq7ncn2rVsYnG/5l09Vlpbwgs2xZJplWLHksgTFK+Dv5Lz3FxtCC/oj5aVbb yPT6Nk3u/xrTFzYRT1i/+JZ28rHBVYq4EakK1uQl6xPNJKdlwiom87MsQvdA0lDS4sUr5eVm jThRT+lsHesY1YzGiBrS0SoG68/a/aj9kcLUVAfrDPvJ0jkxK1LVFwpbsVbnsBXKawt3dtwD uo/hqDrDvjqIRvccCb9wUMRIeI0K/LNZpqB4FRxIHaMnWDPqTu6QSzpGA72AvaWBoatyN+xd ikvGn9gglgbsCJfXB7fmEGLTYb8HTBnsnU1tTWgbpojo6xnqPHpoOns9naALW5lbEyLHeFYS kdON94lJEmOKXKV0Ku1hNOm1aZ5kJDH+RM7ruFHsT41okbdMpwZG1MklMZcwNkXeFQNpHJye H/y59froEvmjKnZ0TFIqPjGMA0CMwQD5zBjf8aKojPkWtaEGii/osjZEq3DRDHcjzKlAAfe+ 1ZZNlCYhHkUcoesNMB2UURw6x5/PsSZ03To93D88VHvqDwX6rYi/JCdYxLXuH7QOjwClF97f 9OUzfsNQHO8RheC2Av2Np5gfkuPh44qbUT9A728dAYWdB9kHisOhm7yIFIEMhrk4+svVycUR DQQ0sNX8qXl59KZ19OPl0VkT6EnzQ5ED3nxrem9UN6p1ilMZq0p/FMW9z+s40o3wp/7h6BGr fidbeLpdykZBJvfXY8xPQa+8lT7aLLOrGrNuMQaJ1B95wKqZFboJBxwmYIJacNjRJsYJYEKM nZUlqYakn4wANNEeR2P6sloFCrrK3QlQxPpkR0H7Y3ATSghEdAuZjhAgPup4UcQ+O1llK/Et bHeHe5N14Wt4Z9qmqI5Dk5QdM0AyN4Lx5TFfJO1RCiL25KiaV6+al4X3qe8fiKrA+cWwFZ0W jBnv/QF3gUUYbHm0f3HwfQvLCu+94/lQVu8xwADtaWakF6XeUz7XlT8E7VYbo0AF4/Zty+tl BWB6ZYgJd8ecirezon75JTvad3p5Mzr+UDRrOPj+CNogm5Ncg3/3uQkude8P3p4slz4UMwmA dONif1s0H/U7dRcLV7QmeN821Eh/Ow/nE7pf/7+K+T1sqIHeQ4XjkAAvhjlS2GiMIqW3t52F 6hycWsz4rONKm48O9LXOzw6wFncfddHGCVUgGvhmQxnVzwA1Xb4wvJkGiwHdek2gTkCtUROa moS1OkLZGkHZBv279RCI+/YL4O3bL4C2b78WrCE4HaO49F+9gXoT3odjjieTgEIKyiageH58 uP+TgUcXkhBw4K/m5cXJwWUmoH1/tH94dIFUlzMvf79YLZzJ/tXpZXNBANVEHPpyi1vaSWlP 5z9HwQqxveBkJN5eCwyodx9y0A9JIEsB8tyt2Kv5yaGztgsv4KtXRxcWve/DCngVhffI4nmj 0uFyIum4dzMMQFwLLbXCLcqabIvIWiurBY54/ubtyelR6+T46LR5VHCoFX493T973Xp7cf76 Yv9Nwadk799/68VdM+HmZmZSSWd4QS2Ft8pCMkAksjTjHsaPwvOxfycTZHxIUu7375+tCl9I QaCcjvG41apEqxV5Ga4lby4PkxXvratar8+uWs3zq4sDCYOAaaMwNsn30R1Gw3ESkbMbI0bU wLhuGd1huA5A097qaaIY9pHvaCjaC4xvAIzfhJQ8w05GZ3ZYXjHNrKf1SkF7MqXnIAoWhdIx 5uoqs948ozc0POCMYRRm1MS0EwY3IKfNfi+AwzOAlZn/B4+3sIqvmQsfa3o6e94eZYLQZ8xA qgpP2pJpNzPr5jeFz+oX1dZRPeVXMgpIwVLRh6ZFb9ce4IVEy5m3bP5Fm3HVHnJ3UsCfd40y Fv+A5Qf9QRRPHt18GMHYRc3wGjy8YHOAAR7fxcwz8P3TxKY81VFYHzxwmiAoE7rUowp1/trt 8U8ktCddDJOK0s8Ys2o99c/waRm/Bv3Y5DKwVT0mKLFlenQgu1cHl0Qxf9g/pVjSD57lYL1F Ecot0b/8a/PoUpMvFJ+cvU5X0B8pJvuKu6mTf4HAgtLO9XU4XvHSsa/Chnq4YNZMzeAeedUt gM3dP8VitzJzMidnwCTQLEgIHPVb8kcCgA85PyAmjdR1tPW4DsRsnh6s2zlFRvxQzBnW26Om nSXOpJ43AxyURpdNQ46uHfRJuR4rCRt6PUVPmsTIu+aiA/KXpBpcg8/ZzKx1dfaXq/PLo8PC e2878be/np/R/P6Qd6n0vM2OCdl4ilj+KfKmqVtHiT6CSftWIgZhgoSnmiqx5obDpkq0HiGJ xoKRiZK9CSJ/lDQni1Ghegk6a3aPOnR3TdIg6k0lisz9IEPWm/g5QyTulde3AQR6cXgTtNV5 U/1ISUur69xVoVcNq2V1GIzvekNVr65Vt4r08EHbhWlB+xiUCutygxNyOMBEPBJqLRiPMaSl BLLyJ4CKILsAYkM+9QLuKAtiJbjXXSIZt53GPL7fYgLm/xfi75Mywv7Z+dkJXIHW9+dNkBOU 3nK0EIgryHBg0Ghi4ZOssraQyD5iuxV8wgyiuTRJ2kktnOXVWYJyzyDZHrGmAAoJrngu25wR wjmz9aQDjJ732eOA379320kKxUkqb52+jAO1mkhIbr+I+ij7s47z/snPZUCBys3GF54k+Azd JdRKjutzNE8mnzjxajErB8IgHLQHI1XoY1B93Sfy4P+C9pYdGhSLSKLdlbtMzjxQQLZk4bou A/j+W/UOL6sLwgARzxME8RZYllYU+/TPnLh6PaUkYf0+KRMQqQJuYS5f0tY4mTRWKzfD6WpR zZvmyg32ioz9MFpxaIM7MHMmnJEJswSXJeYKI5FoHE/cgYuGCC84MOzUSiZVUswCwh9pjiGr T7NxLs8wk11YlFNwqHUWvptBtB16nU94kpjJUmzaFt6RD8U89V/O3DU/5kz+ZmD03MC+6L8S lJp5G/6omZtxOOoHbbaHms3gOKOZZekBnYLMMe0+PHBY3ptvZ+o+mSlAvZy3h28vjoD8JNRX ZuNYk8SEq1l4r1E14NssZVPhfaub1HwmrAtQZzmcwrQIDXi6T6/Yi46+hn6dGKXAU33m1M/U fK7Xy/WGKuGPdbFZ+ZZcOpk5gUlO+yElSG8HlWg0eT6zBrl6ZldAl4Wgg29CweQ5v/uk6+AT BT325PYyvh9NomeDzsacGvFtUJ9fpbGxOb/SRr2RV6kTxfjelvt5EgVAYvKWC591FP7cHqaj 3MHDz5NwiGrfmGos+ExJURjJ2G1jS6IwZvYOlwOOG4nF89k1SNSdUWeCNtq3eXsgd3DOZ7qi eWOAkB2NxToktw5zRS00vMqvMwGOdgS7SXEbt8r1mipt1fFH7i6RRxC+yOV1Ooza4yDO/TwK JreD4HPe8kdx2A/buTMeYXzboIN6hkEQf8yrpi9e3ndSU/TxjCp539HiaNYQ8bAHEsPkWess Ys5rXkUQzioYSHra78+r2i6V0FeVj2VrG0F3u2Es7LIaAhbph/lTQO6vlbupKOzlnQd+m4mf gOkO+rCds76Pb+grSZ4YKF0kFzQ75Nf4/ZMf1UZ1TbXbRZPo8priw7R3drCnkB3lNgl112sA orN2YzKeRLO2mb4TEOZU4Iw9uXtyH7dmgynVoF2t5H4nlfOsIWbt+rxvrVwUbPHv7O9ooj+3 Tjy9zpvFdHM999OwB1CR17kkYMlr/Ckc97q5mPEuGA+BkcbWH3SAPTbeXVs3Fwif/6PpuB22 0N1sD1MTPV02err9U2Qbl7MfzyxFR8bGezCmHt4cbtDP5vf7df0LkFyeyWadZrLVkLd+mIrk 9Hl92ro6O2leHra+R/br/O0l8OWohHLsO3KrykyEbaPfU+qI5ZJRg6be5ZRkxvK1pIkajo4U Jf2TV+ev/iv9lkh7m8FGLpdQoYbboRUeb84Pr1D9f3Z4crB/eX6R6iv9YHpydgq8NH6Cjk7O LjHcZxN+waeE06PLo+UkQ3C6f/H6CJNjaVDY2qID2Nko1+ti806d5cxo8FE4WDrZK5Ak0FzG bvDb5tHp0cFlcm+lOHtb7cfsHRX6h5vpbBk3ypiirW7g9+3l9xfApLeaJ6/f7Df/vKwSs/M/ 58wyVUnPVvmz9cmx3uedRpniiG0Iu4WrOHl9hoos3m84uVYTLs7p0VnrEoomUtQ8+esRFNCy MbOZAWj669XJxeX35qrBFdg/hV6lT/zz4jX+sf8G/3h1fo7DUQiX+lZ5B+az3tDn7i1CsD3u ocCDXLD0dtuqJV+JpyEBukUFWOvNnw9PLlpvqTe3Gi7jewJUr1pFXw0C6e+TvbOKMN3M6V1X 0dB8wStvbBPFbAD/a3COvaJSc841YHoia9YWMPPup8ZR1EgSlsngLK21wiE+AndaIlHsdQO0 DMisch2ub6y1w/ZGGLa7G1tr9aCxtd5tdMIt+Od6bXNWW+E3pUolq4rD7c3qCQn67O/AVvT7 c6tMTR06oo2dcn0bIwwhcrIRcPJXMhlPQ66F54Z5Cisc6Kdl2wzW0YrcXZkqkOvTz+z/BDjh G3rLy98KufAVc3lfIak7OXu9XElgFDQRSNQhpap04F82O8CHohyHQCP0ANB9QEirAkuzI2fd xGQ/2XvmHi3tW0X2rYL7pnL3jfIokv34z8tq5oZNAv22Sg4xa3VENWvr9jBT74+niAV8lDpr Hstmwl8VkVdmjGo3jUCr5y2DBsdOMQ1e9qjO14ctkrZwYw19itY2N80WAkbHwLkn6Miyf8r6 PuaGjs72X50eHWokYt7hMlHMh+Jinc1DNzmjzG224PByz3NG0V8J6Od35t6T7A79m7TQDPHE 8nqbEGu8YDeEMHN74q8P6Ww6u7cpdUf6oHqNFEINK1ajftRV2VVvdamAj1PAWq4qKeelQMtE UKhrTUcN+xfqPFGQzSi55Sk1SDzYAEFl25kS65zqthkXtHpDZ4aidKre6gkZI9dEgWh+dTtX kWR702ohr4TE1WpvqGe7xhu4vuFtILPMFe1VZ3vgD3ZkAWM7Y+FknRo+b2k/6COyJaj6hL94 XjuIPTY2/HmxUtNrgX+b6bFCiJdXMUX6XthtNOoQpymmV7UdizqEu3IKxzfO5m1slRt11Eeu lddq7jQFSt3+RFfhFDET6kzK6CP8UUUJ4a9Kax641OmBVuW2zyxoOVDvqgoySuPpdbrU9jbd XHf+IJWANyed7bedLDCNWBXAfw/Wn9VqfOerg3UpYRW9/btdoe3sYElJpfyzpBbdW/OX1Tnb MnNzTQlcLwx0GXy68crgotqxrF2/X6AttnUz85gxiIa22NXnuqVyMaGEIGt7Az0nS5uA34yK DOqJUtY2jLrdltOPvo5mbvo62hqJ62g+mOtoSug6un81Nja9v/Hq2b/p6rVobhWn5BqPBo0F bE3WcjoFrNd0CiatzqClj6YkZfrKOtUCr5FcWa9kfKP3dLO2Q0LU5toGcupmT81lddrpy2qL 5LLa6ZjLykt2SmF5oZQqWwpz9TZHX+Bkc7qdTuPMv8e2jbmRtsYAnzoBMmwR30t3KLyF19Ou XxDy7XAKnNuCOrlKNERHdr8QFXVOCSZu5sPM8pOwAGmeCW3RfO8Ip+7DvDCdi5DphFOv/9/1 uXG1YJmODllKkrQnQ7Y7RFr56ujG8nwSpIpKGZ/m2UdZg9Woq88acwahCz9Z6ZF0a60Y2O4C WumhPN8Bygz+YMeBtD2zwFzaeSDDph9bs035qCi57Lsd9HrDtPLp34z9c7YbXsqSycmYvmDb 3g1asE6SjYpwKLJnGaY12h59tJu0tX6f2vKURXlGFTab1qac88FlGFkxNtUbfXehKaHNZSMa HCjHyculQQZ9uYXzEZhXeyEUtr0hKIz8oymJMD/nUcSaUAIwuZ6/acev+s7OdgX+2SFnrzr9 K05glZk+YOxOnUSC/5scwd4G0746wog7E1kZcB/Q2wA9KIboTVFRp73h9HNZOzeX1cH9zV1v 6NRlCmwb4OJfNQ/L6iyc0E/SO4lPjdKqNnK2cXuZ0Xpe2yr8bPmzvhr2Pr+j/Jho9htigtdG tV5tYHLZaHpzq7aq9aJZ8nVvPLk1mCI1CYxIAZdhiBZ656NwiEVr1R102rm/o8DaXi/QAW+S qle3qrVSiuaYd4F8zzqjiH6AK3vaxEmIjjVJ1XTHVHxz9OYV20IxuiS2MgEExrwrlwCl21JI L8lpl8DErjkd4zGsFXVbXI+5Remm1Yt1cVbztBPOTDLlG8+mjHZJCEnSqwRRwyWmq3TZU9B5 5/ArqPlOdd+GQ7jLeWNnNklSuEm8m1mBNMGxT7ESJDi5M7E9yL1kv2kvqkecYoZH1WN6sSRS pajjg3pSGa4+nlfHT2+Pzo+13w1d4OZlax9Ou3XSdN1xyLU65erhWEbWTX4CJ1Wx3uxBiJGd OBWDe3q+O1/i4K19abfn3dW5N9xD3Tjr5OWa30NGy4UbJ/E295PsiyyuF7ipOXc1Ba0L9DW/ o7m9zOlidvucxtYy1oaLcakXhQoLWRQgi5Kr42ZDFVIkVWhYWYWTdpWoF/qWnF0eN4FhIspV FH93zGaP+Tcllw+ne2XmB2N74ycKMYPTaFMMQ3YMaNTVf02HxEFhjAeC+00o6t/T30X1ajoR 95TesBPdIbn4FI7vVTxAi3icTjAa9dHQFh1dsB+K9/Ip7Ecjsh/GZ5cyxkIRY3mYAQYMm8bs 1RqwBNS7mYqXkfBz6AIbT0fov0sOvuhFNA4/URTuGOh1vUaDwy91vIWydei3BCR+3EYtxbNp l//X6Q1J9Y17lUXhzVv/fwuZX4DIe2xPFhp4v3gXaTyweOOZ93+B+/o/+bpmilK+/sxKU375 AgJVosFCMtWOlqkSrd3wGZmhWjb/72qJ0hqgx8XEcAyhsgJdZDHXvjIF5wl/dCuA3SYBSkUG RFnkx1hL4bjlni3+0k3X18BP54V8U3ADFWLOg3g9vYmfuzXqVXU+5FiqIxC9SbdUTk6OHYlw J3voVYm3ImYXT7cr+M+7RVX3Y4PGOW8eP6ur9WotNcRoHH3qddAdBB0gA6SBlG/a8ShNjAVo PO19jUh+GLnxFIgTQ69WmJWZ0QICRq7e68OHmTqmZCSq9wnXu+ukFmnRA06y1gu3Q2Y6Fygw ChCCIwCGBxdrdF469Fl9xoEFQ3V82PrrESZhH4z65AaUdV5EvMchEH88ZGSJ43BSKJZh6Im5 1LzlSOutP6Y5tYSj/9yVZzL/anaEh68HB6z65GXuUtiLa4wBjcfviV0pBjtHU/vg2aWkPyGJ gJTDrkwsswLrZaQGJpoJPwM+hmNt5TfCt8jxMLM7ikagWq02xnnG/2XVWjlYyWycIT7zfxyH ROZY4L8waN2kDBQGVedhhwhCcXfGJtCJzNoDquBtQW6T/54d4Ama9S+wdNG2dztx5md9lwtP oEZWDwn4TYEwgmm65DHIysY8cONbcAkilTQJDfp3wX2sY250QmBersN2ILF7xCyHtI1Ejati Fs7s7Bnw474Toe6bh0zoITLWorIjTbncAevjbaSpdIWaF+RBLOxT1ZIm7fjt+9a7kzO0XW6w NpC4PSNROpSUdHhA8oEwAqa9Q1mQIzOMol6MMYhIe6G78COFsg2AcdMiRgu9YfAJVab0bv/i DGQXEnVgem/3kUsCXPRslX1stGgnkReRQTP+oIq3NZb4RHn8OermvikYBXLrNRzsQaulnjxR 39jSqwMuLmJ5SpWXp77TN27muxfhV/0GYx//Mtx/ZxjJexEBMcOUZSsVyugkCBPdpOzUYTeY 9nG0CUYGjinDQPh5BDwPydNtjh5RfRh/iv4DiWm1MNLJD/sXJ2i+Vnj/h7q9ctpPesJBbkiF cADsY3sclSW5GCDNcAjVJloJNgVOjG5OXM0b8Bj+dwkMdlOPNnsfnTXoHdR3W169artp95S3 7iOvlM2o7tbGpe+zNz2anwG/BJVgnbfBJ+SIQaQhp3/hpbSjFKEiE5wb+3GdMPbqu8kL7s0w +ZDnzTHx0W8xq4GtP0uIteYevhBryxcUYp0GiwV93NpypVjb3EixjRwpduP/lBRrnvqavQEM /F9RHHbjmEIWzxBxgTQc5VpD2BpZMuys4C9zVGD6Amn5j1P92XA247D9CeWAGPAu/sS/Uc2p yyZRoUjhtHRHUb9TiSf36JHt0jQKUq9f60kL/xTYwacK5RwgKiwwslnWU3Or5erKE+TbkxPZ AzdeINbNC/4Rxd3VoiNW6oeFVIepxwP/7QAE1XEH4xnZoNQc3xAdUmGB14nVOjwSrIsvivNg btkmDtnBwSnm6yOon4fqI+SWztFHPEbm1tNhaWa+4Jw5kwUE5+x2lhdNMIALdpBmByU4FD0N 3U4nnehuaCNmkIhhlC/mJCSQBgOj7ab5/dVl6+KwzL+8uyjrkncX1ewI1HrEVMA+x+rEzCpD dF4QcniiHDKFprTK/MHCZwBT8KomArI9LDzjLJBKyTYssgfvP8Dyf561w+rX3fy4i3mLSr+N zm/ii0P290VAEdqnrIPwPxfR7z11N+VpUtbin/zvt+pdaDzg20asuIsbk/aoN6recrqWDKmE B/OeLsib0D4cwPjAhsACJtE4uEG+N2h1g0Gvf98CWCiXCQZAfHCEAC164Iwww1YbxJSOpIEn zMmKJZFj8HXVWSji297a9mZlOsRQScMKcgHXcWddHoqkySi6C8ejdgXfrMJKh+K/bVQ3TMh4 iso/R0xByd9Kb7LtKeFCQ6Urfdim75qNy4O3J2/9hnbnnWaZoipOyDyYJ/Y6BSI8WXkQh/nu Hx4C+wBc+v7rI1c4zRzDHltOv/ut4/03J6c/tS7n9pUz32+SHee/RyWaVuNYpue8Zjm/zlp5 q9mUme/VnCZz3p/yzz/7fcqCQbb2Jw8oUr15sJHZlxtM0negy9kB358ueZr09W/SeaLWvB11 PDJLCyAonvP/YdXHDJAhRkm4QeBDhqidANQYjibqujfsIG85CtH/aUDhfLCm+3s0EuVun7Sd xIoTD26YcuHIUQkhDSwnwwOt58jvGSTB03/wcY2SscGQjUhwGE68scxECYQMNACxPs/oOnJV fdL7XFWfkNdZqj4NunXng72tyVjz6Xa1TP5MJqFvdtYU0mPVdZDkOMyrUkuT+iy9o0zOSHtu BdubZ8xCbkIPPVFOiSu38Nukjtc/+m9VE8CQMydNr+NJbzLFMXhOgg9a31dnAaKuZkDRC59s wplYfRMHGXUNOlJ1xHTN6wlHOzk/uDyd3VlmteJc85AHQ+83maLJO4wMN0SsNmVlZHo80Utq rbqEokUBBfNW2q4oq5JBwBOQmw1+A5kbQwL3OF3oLkwEcBUb1sLxRuNJ7HYjyk/dNmCkGSOk IH8n8702kZs6qsDR9SNnYdx9mcJyCnbsDTkVohOrsI0YmpGcs6fFpDhl8AZ0iZUaet99YrqS uLdSuXW7koM7LMTqa2tAK+e7Cy2ZVRJYxvmc/8pgK81SxDI6+O9VaGcrq/6zFNqpNSQU2lwB dbla/k1oqZmQujrtg/OzM9H/ZjaR716b/YODo7czhuHvXpNXsFrTIKMJfvcavD66fHt0dHG2 /+YoU+HufE+2w1XOaqe/Z7U7l3XltTtPrOsU7tzRWf5W8HevycXRwQ+ztgK/J54dZu8dfk+N cHxx/kYaZY6A31OjXJ7PgB36nmgye8+a2XuGipHD83dnedPT3zNgbj0XTuU7t5kplaZfUnJq zu/LkfPqu/n2HYsNZztzB3ZE4PpuRl/2u9NKb1Z9N3sGzmbNeNgxjrfes44pXexRx1Zf7Emn tqmdvcRyF7OpezGDo7H3BFt1kn5t5+T8+r+V4utb9W6MueWHmNDe8e4i1vdNgJli1WmAPgbx zBcgCej/ICqdGZq7Rsa+dHy6o+uwzwbfaQqO/GIXcxkh/5Uf6ht7Md1KmoOo3Z6O6XmEn1ZJ k1xdKOHYq/PDn3JIb07lr5QQLS/V2Wyz7hnCqe/klc/e883MS3hmJ2i5P+dtbghA+SlU78hw P2bIfdP84aCcMrN03sbwZF5YPvileaJDvg0ulDGxoMPkqeo8pahjqM5W5WTnWfOng1KUuMXe e/4/9M0xeM95N5jjWjbXC0x9+5t4gZlxLT+e632WOIBZ46YcxCSdSsJK9fOu+qwzb+3xr5h5 K/HqkbvviaeO/HpzntjSLXKB28uclNSxzADxQG2uV66BoX/KWTeezoR3210BId85cELF7kkQ WRuAXHO3uV5O3hNxf9GdYVW8a0U9J9l6dsfRDpdPkVY8VYW1Bk74m2JZ3d322rfGi4zwJzra uFny9LK4i0GAhA3uLdIRfCWp5qczJOUnuXW4u6Ghgl3aUhkN0yfW4gZfMZPhvAu50JXMs6yc cy0XuJiLXc3s8TPSIuZd0GR3eL74OIBPmBx+SHaenlPe6ywr+loXFbCIupBhpKj+pOrquarU P8zJsDfvsHPDIOQ2cB86czLK5TaemdAtgRjqSW3n/8TXgkwQX9xc0QNcehFIBkPO0UZkRln9 t+l05vFR/zGKnRkLSWh3fJ46Rw72kp4kzRHZSOiRlog+C54jWaaHzyK49d0ZcrFUcltbXtSM m/nu4KYYzpZEEhqHrEoJ88gEq7Cb1Tw98xyx2olVZYRqp2y+SO1WXkygFkc/kZDr6zkicq1i 46JUHioy/2/Ni526rNa5f152dhsnsDrH4jEHVGx8MgMptmg+oDh1F4sTtuPnT9/JjaLjw8n6 A3KoY4eiY/nfDDEOQXHxGgYPf3V1jGyAlhnkkERmQEYCllKpcBfTmPM6ozAwtcouk3xEWwdQ 7lipQK9cnNVN+pPIEjQcRqpBIpzW+lg7q8RsXS3HbL2EnkK2I6sjicuiMyVx8+0/WRI3RjdX c8adLjjoHDFcNo3F8KBNwRdQDAe4xt/niuHSfq4YruvpeCuzRXA9q6wIdtruOeN6JCyfnVx7 idX6Vybvtmgrxi+8MI4B1Ax0zdEjPXTNRYuha6m7ELreoGi72c4Na//nnBuEZm2l8JokbJhP rk2Q3ixZg8JDUlfNTJ1uGnsaPmGx6hr2F/GfyE2emxNsssthTJX8DCbyG4ir8hODo/HHWREp TSuKMfjkSV4N7C7TXkTCqKjtaq0ybjcUgMotgEffnVuh2yljRtgy/l2sKnUyEWHYUVpNUC01 7vT+FXbYbFc7nhuPcjK2Bbgex/zogYmeSbhzdF+Y7pnCBwzCYEgRMtnRlZQm1dnBNu1K9Qpw 0nSRUjouf2tamInZQbPvJ9G0fUthanA/q9iFG3rKSVCcYa3u2fdNACF1M4z+OIqtX95tDyd9 KmNnCVKgDGn5eyoahUNVWPHmtFJW52TM7jv5AqDAkakXqlbUvjT1dAWzW3i8tFWS99c0auSk 7529jTm+GplVnTy/WHOR9LxOht57DkOQl5k3Ozlvcgq56XG/JDdvdnre/KFTKYGd3Lye08B4 oCpdHzD1x3Tq3sR47n5S4l5nyNWiF11BswLHjF/3L1sIGa1XV6/TAdRSEdQsZDnIJLCXkeJS VV2nCD0Pvep5FD1N0B9Azxcn5/U1/ex9GE5IjR5R5uCbGBkaAruncSJiBpIuGcaR29Y0Tcxk C2obDxHr/5dwCN9SgK8e3SrtkoJgqoIxTnf+NmMXmoqiwEebWduq1CmmGf+1U6lv0TkcI9Uh r0UTNg0GSNo+6v6Q5lBWZh2AjeLpYbccqsECWtG3hCStKEVnG7qDYUQ0Sr1MKxsHRK74eWcM 7YNJmNkMvidWXYhHwbiNj1EU+7XSqK5XG9tl3iT4a626RkHjaF2dXgeR1W00FFUp3sAKEdYK rLAyiSrt6XgMnVPkX1j1IBjCYcWyY7Qebz6khcWXidiDdB6uG5DpZjSk/KgVHRwOoTSmZy6d fZGOme40II1CXxYC/1ezC2lUN4paI5ES58sMg/H05gaQIOn4u1kxc9PRxIVddMXnLE6CFMma QRPXvgSLkHYAI5SLtWCGLeHcqLqxR8jgGjhgbpJpmOUsoMOcZrENOcJzhnDsiLucGyPRfNLB VBepwl6UbG16XC6J/NtDe5LekH1h5VlKBWUlv12b39oAqj/j3gi7EagXe+oamdhr/K0NROFX 7Jc6HASACwq6BXJFgE3wlQIdT8i79zYY66DghBn3lGWW+DhWqGL2Y5z8fN8gx8Gfd8qqXvu1 rH7eof/Kin/++usu8+LPVjkGk4YYHqBQBBKGds09knoJZMQVBFN9lVKRX0FkFtKHiSRh4jB4 lzk9XENZrdytaN6OmDZ88SMmzTAEvAu/7BkWD5/MuXK7jybbhW4RX9dqizQRoJfBZU9ymzeS zfuc2YxbP8HVLT70NwWsb4KX4kL1mdQ+yINn6vIBrOhWg2Srum5VzBh+3dlUJITDjzztOfP9 dc7py9M/sTrB+GZKtnHoZ8P+8jAAUDKqPAkGIxllErGpPeNilnQUPdM97eKGPkVaehdi8M2Y bQGeQhtp3AHOBKj3kPnQFelkRXHQUegavSoHQKOByKiz4yZzDcIsO9F5Ccn3TDjR+GN4p67D yV0Ysg0C8uREComQQD9EysdJ6E6IKwwJ5613F+dnpz/9ct46uDjavyyr2ub6ugfXLK3MBhP9 9WcLBoJJJkA5Jq604odXhq/xpI7/uHV68miuCk8mNXpKN2/olboXwCg9Hf+eCdR3EOaxKw+E FuhgkVuXffNmdENYYlYf2/PXUn/4Wu7G6AZHHaz8bQgCKvfxBRvaePgk9LE2Hnmsbq2ffaRD AeFa0UcODgGAbikdg5nBRQiSyeBbpjXeIKctgI3Tzu8FdsD8leoPESc2r3uI0+2gmAz15a57 M7s/Z4G//GImPKuntYbX06/+NdOEqLPgUf7670PORKM9ppU51scitvVHILaZe7Qwtc648Lbt 5pcRPOHQ+CvzZUmVUD4XnP2EkVXRUwfNrpf31pFRff5jx7vzC0wra8QDUnG4rxzSEQMLh49C 49j0+wMLw0ZhgXGpD0DOuwlPoxvWWHhFVg+xqRqN542t55i4z6gscupm6izq5Q2OvrROOcSc jj1rc/UipF++AzFv2u4H1bAzfbmslktLTY69rW57N3BtKnDWESqgUSlAHAFyLABsr6Y33+7A oCieLV1isHznK2ob6A4NgyGAM0rGbkdiYHSg+hguHI56if38UH58Gos5TyzhxzGeLVzKfgV2 HeRzZll0hPBYIlUscbTy8J69Cnvt/FFPe/FIBmblBI4JPYRBfM9RZ/thgIqRcQSyJOryu1OK 137eRDF8HH1io3YSLZdW1ZvgY4inXEXBhJyyMDuxNlopPldnwEKRsRLOE2scNaEU+breRHdC OQSrbVU4vgnG18FN2GpHffSUhZpv8TSAg7MH4u41dnpI2kgMNuQyj9qCqId7yrE1zHD4fVxt P0ddUkpSTOoygPbQ8bAZHHQAe26DxvYmeDNokOA6Zm/eJSBFwVgo0XihNVijPfuBoj92+3DC SuWscRBh1PilqDshBhVVJcnFgmDQhcXeIn0kdpALYFav6BclT7EISuoWQAInqSzg4Oz0NiH0 0SaVyQaQf6cFn52fHf1I/mTkS0mPy2fNo4NmWV2d/fns/N2ZX+wChoGlDoYicY/FyQRKoxwj pFWCiWjjYujlGDEM4yVewKdQttlfgwwQjzi6KeyHcRI9PH8ngew/OEPrpcp50tb1BgCbMOil ll28TcsdchjeIXC/Pbo4OT88wfzyR0dv3mKaXVa5ANKFTi/CARw43coj2BcdAxR6wQFMlqBB D7eMrjdff0DklFcA7yx10aEpT0co7LS64wDZJ/kL1ez9sMU5DUxp4k9q0kIuEXY87ofhqAWA iddggr9kwnMGktQ7EMJV6uLzpbCgGqoRBGD35DxoMIHtFrN8xwDuLZ3ltjWeDqUcdZTyax92 l51FNCtDs4buBXCgF/aO5locihkK3ZGktJiaQutf0RCPe5/jTgQUdmIYjlGITC0dWifudMFM tDUJen2ZuJlyGWEjDuI4HFz3nXKaRyektN3UGJ9RYSJDDKlFteT07Zr5MrlZxpzBZZ9Z4UOf MnaN6zCDA/D3Zv+ALVMAurBrqKdGIxgX21+QbzvqZcPxGMOoS7oYXD2+dA5BbuuB1OJqeNGq k/JeoGM+2vVDPx22ttVwgne7F/lY2d7/l3w60ei+RQzbc3pEmAuBS2/HYZej0cUSjc5BsJ96 AUZo71FIurg97o0mej2BMMUMmJhsD6txOp4yqoVB8pcyDJPGp3NMcl9rHN7ATBiexID9Ez3p d7iBYFwEQ7jT48yP0jq7GU4ns9HzRTkYs+l8MY/HANzRQAizZVtiRvQuzmGb4zi0FOZm8hH6 72M/n29ag+D+GgCr02ktTP2oF8Kt2MdoHI6AjWlRASKcFuLQfgCEmLeLP7SD9i3vUj+KPk5H LY2cneHmLv9jeH8dBeMOjss0ewSMB6EIjDKj/2oBp9uLOrS9syk1zodS+KIitqw+XndaTG9b iMyA7cKw3rQxLR6v1+nzKnRhNKIyXQuFDbiobhFFo2g1vD995IW1Bcdg9oCWXiaGoZy07oIe WrTT1vaGo+mE1rUYTkdOhEBCP/uy6gmDLFK47moCeY0TuAk6QOIp8S+Qen4CNi8as7FLOLwB 4XSnTEzWRG2nVHd4fy17qwxmrNodlN1J8ZgYO3M8qA7goDnINfkRTCdG1dSKp9eTcUBMJ9Ni 6nUY65rSJRFnYPe6QbvXh50M4yQ0BIAFbgchoFtcCXHZ4f1T8hZG/6wBOZCiOyguCakKPw8b KEKVI0xWD8/zRYxHQhDynpOInKBgdyReiATWJOFeZ9P1msNFhoXADpjIiM5VGcYzMKjZOmAh 3dnsd/4xBX7EzEZv9CDuRIRULBWhQOyt84vW2dHr1luf1+lpWEJOZzprIgUboVyOAsEBmCuH XrWaJ6/PmK3U4VL1vPp4L3FedD8BbcKiAH/SnVxwL7gfwEa4FylmBiaCdno0VbxjLRyIsMc4 aoMo0gIYotvG77BEVHvMtgKXMwg+tyZl8a3BV+alBOz3oT5QMuzZzEV6drh7lO9ab6WYVsqj tjohoFC66Ujp29EUPZNnYvqqNwRs3P7hPnCtwDRfHO0ftl5dHR8DR0u8K4snQDDHIIJew4jQ lA/l+/0megUdNGlbqOH51eXbq8vW4dHp/k+tk7ODi6M3IDYAWeOwW8ntmrudDvKaCciF7AHK al7v84WzuShRcM7dOBiNCCnyDdild384DwxB5N7bYz0NT9jBk9McaDwfUuG+dMKRy1FpU8Jb I1L23C/VWxQmx+5BJkxbd7U3WCcyL97orWM0EQXXQ8tZpzSzyVacQFc+v4pa/wTR4B10WTDN 1OKj0sxD19zr8eEuOe2TnNQmRNoxVKOFD+etf/S63R5yd/2MMiTfU4dBZ0VMK+uY5IppZjpv eq7g5kxoHn+hT1aHEtOXD04aw9vBEKkUC7tWd5G5/3J2umeGBAs01l3EY+kd83p6EWPFgNFm AV6/mQbAV05CtCVJZITELbRY24goXiXrj3dH4by01gu5g5n33CEHF0fN89MrFLXL6vT8db3W yvyYVEfoPgz2ciDZFc5J9oeNrAhD4moB9YXgnvxenA/o+Kc/XpLrXgfVqiQtWQDQegaKMq4X TpsdqcEUAHbUvydyiLB+fa/qtVpNx6rAoKHYXW/iDCvKGT0H+AfjvdiCy2SNS64l2hu5WakN e33EBsa6HXTq/d28eiUnvjDWdg7MZx92dewVdAKvwn+J2sgKpBSQdjknZz/sn57406N2XPy2 mOgOoxK1Ds+vXp361S/PpTQNREmxcbbmwrBUSDcoSWYKMWboEDIVBQ47ktrEgzfuFg4jMlTD F6KYEk6+7U9hpnB70dbpenpzc18mi8kluok9x5yxo0mdQwp/iqZ4VZ9OmCsF6ANg1Iw1AOE3 ickc/cXbyzN/a19f+n8eJc/k1K9AZ3AR8usrBucAtpUjNQpKabUB7wqmI542RwdsKAP5Zket S9GjOESJ5WBJomE4dyTwbLrHXSDDPYhga0GUjHvczils93sguyVFFWgdMaOKoaBbZCveYhIB dReS76EfCU6CnWklsHAWaPDY+xS28JPlpAecPRX6E3yRwVHcrTVwYn2GvavNdYT+05PmW7lF mhwKvIeIKltAfCb9uDWa9vvMzK01WpmqvTlyKCPeJHroOzou5u+Q8UI1p46HgeMAgDvvHSyC AcYG3r9HkX+WyGuBNFNmsZ9R72A1A7fRdHzTBybvIcLC5xuh00DNzO+3pChxBKkOXvlBEH80 L7JlPSWR7VDSvPfFO2UgYf4soMsp6Wda+BtpAEj818LP4j3p5aiC6YTvwOReQBQWSseLtAcQ mawTFWJzeemyREBddDL6CvusrL3Hc7nVlNxi3suJiRKnaZoVc1XEUZHuAnC7hyVS2gMXt5on maXCj5ddAKLbsvrxEm9Z6zrs93HLkmeyEH3UXHy+6LFcetgbaGlZLR33PqOxLswOxu1TlJU2 XpjOFPkaAsKbdltVurDg0acqtEDGhcx72c53AJITYpB9VVGv0OoVzar2aRtf8RNlRJc/LktZ L4ZOWAep5AkQNUVoOY2MXx+znpBRtpkFxuPVaT7pZHNfnp0XSvv27BTaF+WGqm8+b9SeN7YS r8+ZtbPfn9e3ypuqhD+26QX6TX3rrHV8etk6OD7df43mLt8litxKpyev/CpY8B0+TKeeVve+ SxV9h6d3+Oqq6Qzm/PmdfNSDmD/gw7ffqs71NEalZzVS2j8Va5TZ0iIcjCb3VVrj2tZ2Gda8 tl0rU44jajwd9dH6HTNt3w+uoz7Cpk4QIk5R6Mw2DsaoMLsLxzbOLXVAUPX64KCMzP6AfAPI Hp7iRhwccJpPFXQnbJg8AKijt2RYyB/wVblZ5J8/tl7tN4/MH+eX3x9dyF/N86uzw6L623JF KSi5aP7wuqVbnrzZfw2MxOsT2E1dZvanKPHgF2iTfgFPdqSoI5zcm9OG2+712zfyG8klP+hZ y9uk1xb4naOLNwf7b7ESjHR6vn+470ytiYOfvW66/QPuOjm7+jExkeOLoyNy99M1j8/PLg/O z45PXruNzy+PzZ8ecGJPeTdPnvXtrZMCe4c2VH37eX0HrlHixqVqZt62jbXNjXK9oUr8C9t8 sOmUwl+ereLb3RQEJFSg0QtYTKb9ZNYEYOALLapAtmqmXAsrUL6Gdmzwvzp8F/uhY9j0y7eq 8MNNuwVYEshyp1gk2FJOEcAnsez0JKkKP1Kr1uH+5b7fUpWWK0tLS2z0Y6UyHDrr25X9uKrq 1VpY2dQGV8ZUL3Nx3recBUqdR6wCiBb8V8oUj2i2une0qEK3MGAPOyCylEq7fGJiYnWMIfUw /jVFdZpEk6CvnukgT6v0d5mLocNc8BMzDwf+pETAql6p76gaWhs9B0hMAKBfNQ8CG5vlek2V 4IegQs2ErFwDAH+k55Xq7Yr7QXr2Ch3/g8pyJZlsQ1z1c6ICVMQpH/YP4B19niq0exjwiYYS vQrIkwL4iqa+s45YfKcuhIpuywW55hBITEfaJHsYfkbHXIw4zlqOnuMESOnMxMaRRtNjwCKG dhVHlyfY6wXeD7w8PhRrcwrHDM9WOsuspIH0yRP/tthaLxThtTf7P568uXpj7F+Ly2LQqvy7 dpmaTRmmspuulqqVM35J4V0iIIGtrm8DlOw0yo067bbuFvb80Niux8+mKN/0+3bb+QCBDRr3 RqHsbPbtBo6WcVfm9bazZZiIKy/Dz6PeWHzquLFKgJ45NGeydOj6KZ2YOPIbiTjxCQY+6MXB dV/SZjGou9O25yoSuyrkzgiOagnOaWnm7tMZLc0+R9SGUTVjkcv2zUuP26cSee5l75Rep87n /KQ3gTmWNe7qTewhgcAPLD9s3xTddMzQBv/63101kAtnBkJhOL6BqsCTwWea07LiGWC9b4mT g1PE1wp/4s4JBf1gPFCFQfBZFbJBG83ZBbTX1uvleh2YwfUGIkIEbbpZ9ohxzwi0ckEW67Nj nAYFPFC42AXUaKOMJMVkKw4QN56OJvxy3SIsi+RzD3FCZcnig0XAq8TDZM0LBXDnKi3QWxKx 6DgdfCark13Bu2uba4ByS/iDHGsReCeVl3Td98iNVa+XAdstQThhOK74Vz25qS4XxObs0kO+ ha7oiBxyqUtcfg3Eo7UasGwJcpmumkkut2o7SHT4B1OdVz/sX6jCdZlmgj7RcJbqL8Nefzf1 tQU7OqMKmg+iLcE9fi5oWwgxd1R/kop+udfquXQKO3tdeantIrVrXZYiHMY1FemaZxs70jxt zRYiA+i3UqcPP0Kfx/tNYNgvVcGsJgbC2mKLiKKhRNBHP4gnYrHHJiSKrNSJHd7a2SrDychP 3F/yCC0E1zHF16OnDhbM9J/kkkyqSXyPJ7mcvVwZw0P74WRZhxWcIIxehyjad8I+0K3OLkLX MLwJctqHqAiFy78/hF8n43tAI+r7k9ffq6o6PX9XhPvcIbExtoEX+WDQT/pTL5rG/XvgMTrL lb+tTIcaav+2Qsz8FHkN6g21CNCf0jFyyIaVjJmjOxDqSQ2IOiVKOFqR1YgFlXZIcz24xXEs kDQ/gfFHO5E4man14OhIeNRb+GfWunBz7NqWS3ZVu6qQ2VWs40zHAWl+MF8sdFJw3ZYBl+Fy e/GXrixdWR/+AH3f4K6QMx+a2RKxxzWxURMSf94T1OZE13GEEIKnPwfj3KYwzq2gkfVKbQc9 AjYAjeRgnNt5Cpkd0sdofBOQVz4rG86uWKXMiweaiOZRwFzfTiaj58+e3d3dVW+G02o0vnnW 78Gy4zB+9lJz0CrbURmpK6oYo263NTE+vl4WtBXzxLqiazvUkjtnwVXCYpDRU4BGuagy08eh 7cBlHxzGfmOzTkLJxibQ5DVBs+QYDMQy6IMQF9zE74Evbr0FJoHNODD2aPPDrhGbm+FEs/8a D2bcGv1igDmJAbI5sn9VKFOlLuFr/Bb4iAkS32fKyzbRlWtZdfXIkttyF+/BMOIQH6g86ge9 obRn5S06Swx68SCYtG9RQ0g0lWA1gJkNRhMj+MvB6DBkwnJ5Aoe2qSRn4zzzdp62NJ+50Pze pXUm6VhkW7T/anpzHrYtpW85NviM1RbIeVDXy55xodIoWnpJQG22WYALyZ+AkwUjvSzcOFSu i/4X/h9fJhEaOxx/hNCUMsFeWLts+roZh3fCTmKYY/wmpj0YvINNCsweaskVDRS03EVYtqCN GJ7GHK8CZsASsRhHFSm6011IZn0gXKOnSC6iE8cGi+ekwKC5RgNx18ba87VGAs35NfOwHNx0 wHLwr2ghSCOAW81q3JMLPMrvU5gLZwjTDVMhDhyza2pAos6b5uF5E/6S0+deL35qIbi8eXv5 UwGE3gL8U3nZaSGX9r72QeR5nOL2DrG92yALi8KhUWXvjWmvw1GN2Q4fUUmghlOMys6o2Xxh WchkSsPTQ+NfOpsyNwrHvTbXK6uwR0856BXDT4DcNSmxyiRUk7YJ30mUWpPZ3KDper/3MeQI wxW1DqwKOl4EhJAt/QyUVrNM7iI9QkwIje379KDaP6TCbq71TbQCNc/SZa1VuaWYMXf6O8ZR mj+0HjaHdRjqqN6zWAdcvSpgHJoAqWAoCVAEd9ihEXUc719WroNYoFtHm0LRZ0PmmsFsmN20 V9oY4gsaQK5WyBSauArpEf5FG9jz88PO1g4yuTvbNeFxRZpnFIwnH79f+2A0lr3PABWtaKx1 lzH6BMMhF0UolRbrH1wZW6oF4m1sq21kVRukqm1mVWtb3+XUoMaiQ6EBHTL22pG58CQueo02 ZjYaZDfanNmo7TbSLMCJg6BJYKG4COuV63s0xAZ+x4n9hQ+rCA94nFgXWVbBrdhHo7KuXvde qTEdLtpI6PhG+Lop0oNMtWxiJuF4M1CqdeVy8aotXeCVIbt6NobdJgy7rbUcOknBjyfodvB2 Mra/IbAdHuxqNIyvd166Y9fjzI2G7zCGNhh+QpHqN/ZSJRxMx3E03rUI+ixqcZkqCA5ubG1u oPwNPzVD/LOctvFhBZyhvcvQ8o7ycpCuD1dHxBnvqhKfDDIZAmZRE1LKkprtvpHkvXyFl8Mt OB80LL7tfR4EI8P7sq+IVivyRzWiH2ghFX/cnQk35I/nAw0VLQgxibrZYsfaVhkb4886q3wl 4s6nCMkdGXqJp91N/350G9NWcQFQfN4yY9VN5WqVb+f/W66Q2pgOeZZTIcWiK6OETmbdrpHi OCbGmQwZ2NwCA1YCcySmljbjKenZVGdKBNjOLJhQB+PwZtoPxkYTrJ/WBOATVpRQ3llg2nV8 00CUvlj1mnkC4beTmbVR3YgPHWYhAK/IAmtqZd4vzIE5kGnrikfQ7pxayGmzRwpr1/U0cQpn 0ZDiqE1HkVYmYHA0MzHm/DuebbnJ4MFG9sQDixyoiSS9+xBDqvhdAX4h8Nll9ylSi8Ao4+AO NcyO3LjWADG5DkC71qht4rOqfqhABaKZF77XTVojTJorGk+AknbYGrEeav4BuLEbzk5O8QXV dp7a4WLWIF7EJP3lyRN1dvXm1dHFgj0mXoAY9QyMOr0TTdGjBkfk505Sz83s2Gr2Kd5Ru6wo 1ZR9FMD5shAj6mut4O7dDCPAmfE/p2H4L34+KcjzB5/M2rqcDB5RTauNbyKUiiI+DdYLKz0H TnhVgKkU1cjMbCrFI1VRlDtnlR5H4D9RxGc+HA9SL0taCypvLam9KNv12wflVC2YSbaBLfSY fHrTlsTeYPZ+leHsyirrTEQV7jyTyvv9xf4bQ1DfYoAwAxi052uNDeQz19Zqm55YZXXri8C6 Pp3ndgL80hpSSF9UxWhlIet6MOaDYv2uTud8HYprdsfQPPLjYyWw9tqmrgrjKJoYh27SGstq gF1urOFyNgCCtrxHyBn3e+nhl1s9/IIvJW+3+uIb7j0c2ru99NiLvZS61RUqTF6zpdl3TDmz Sl6wpcferqVHXK2lL79XS4lLJU/EVwSP6p337CtAeh3eYJyQrn493ORnw9LaZn1DpLn5ILZk YjQJYBSlDK9uZWnJO3N84MHogolinP5SzjGkXoWhh7LK3R1uk3jXJk8FaknPjMnPp5cztpvA d4kIFBv9fPFBLT2G+OABrW+tk8RTWt9q1B5yQFnH8zOBeIrimhPKpsZLs2jSUra5wwIHlmmN kDi1bIuF+UcnB/c1ju0xh7axA1Le+rYqbeysbWqrOLIfa2IwD/Juf8c+4HA9V7/Of8hEolhy gEb1GB3CvCqK1u7w6mKfHhzRrdWImOSHqlZRXaVG/SlK/MhoeEFOdB3EhmXWxiKpnKIH3fnQ +l6I7RhqvKiP4DPIiX0eXsQSFL6WK50pP9yjZwemFSSEXRC6oD+WCd+vjgjT8q+Eb5crP5MR E5S8OTk9xRXtOTyUIRNQeoL68/0fy5oi6PoVoqXaFEoPqF7oBmg6VK2JLeHPHlMJvej6hiWT iU9j+WXP6RMoENIfGdljUKcx7BoIeHumZeJzO+z16SvXK6mC/vWFaVLctZYIFFSNW73QI8Ii ln52CGXskUiujUW/6k4M1ccaZkdS3eAWeV3VnF7EOoLODisTtVZygDQslWA1RaGRVWGF4txU AGOtYHwNG/Sm6fyOqaXwlV8TNdj59nNSTyC3VDaxwInY0SO5DlyBgjRA7/nZYVMZ72pTMgBp 7zrUmmk0u+d3dFFjoyBoeMN7drAin2XqNsBH/qCto67rq4V3Y8QhrLSCGV0D6VjMTEZhG/Uj GGN7uRJ0dMwr7lyzGkCwB71+vyfzFjMvmTOsuzvt44HBxMbLFfbRYdexXn9itkSvTCwEROdQ XS49bNQex1q4Dtof74JxJ/b9Y2BL/1Y4Q2m538cIhWMeUufW0X4lEv+Cdy9784qILkgcKJBD /fn1PyjyvXaVdwvdaRaX1c8ODjACoLmk5mLuYeAjHNropaWHXcdoh7lnbwBG8Zs14JeAiwcU v9HQorrApB6hBPwtsbZee/WMkFW15tgIVUzIyxpcOd2BNmYWtCqmMViWgz8N4nxCS38i7Ckr ZYaZ6iBlrjrabyGDP5U0qBr9cYihwsobuwj1d3NZn5JyxGiw8IXijzHcYNaPUh4bnIFVD6lZ zv40Ez4zMuaB/8dV67QgNZZkccbePmWaXTMDM4MLN82NeDxzZgPkmz1zvGIZsSM+4yOCLLPp dfIRG2vlrsRYiHlHDIUMYutkILyxs7UpL3YO1C/raGD+BTExVTg0OS2F/wA5WLBhzh3heOYU BUM5BWpoVSjxHboF3LGHVIwU2/Sp5dzN2sZGubGJ097elsSBmvc1tdXLPdUQYd8T+yiacyts 30atAGavCg39SkRM4F/YCJIW+JdJ0dgpwzEcvSapVEeKScIE0x2+jrqOtfO0d0/idC/pA5mY SkND5komNqyhldoVIW94QT6aodKCrxjwz5mQoJ2sSYkV7c/EKy8I9xbPlQw5nwfcXFe2IAHf +O3XrE1JH1fCPtPwDZ5qrJax5RpTyop9vmwuZrf767FKGejW3WJT94HY1okcfDeOAJPgG5Fx MleFv/DL+qisnHN3XvmbJ69Pzsk3I7rGuHSs/y+IAbFI+w/Ao9r44k9oEPQceSh7ESnM7fyO hgt0pIyDTArTuSguS5YCwQk6xVZoATrJfzsykQzt25Ep8t6Odug9KPl2lFE320h2DfWOW2uC dfmB0mM5cj2oVQElHP+o3HcnL2aRVFZn562Lo8urCxQPpLI7WDp+oiq4aSZAep2M0RAQDd6c hmVyWlqyMb+tOVzZhPoY0KNW6UuHtcjG0kEzqj+Wsgk6oKiFPZhnNqySV5/2T6uxOKSbOD4j A11wJmN+NVSpji6TdX4O3NI2eZ7bjsRUFPUvHSWLzcDxIv8MzCk/npO5oFgtokTrzG65RP9m HrI89Gpuqimcf8dEbUQ+ahwSDRxOUJ+AGTeYO6TpadEatgADHozQ8DhyAj8CYQOyPJbnqeup 2LxGk0k00CYtwKSwYP6R2PLpWEwHehM2xnFGF4u0rze0aCO91zqgMMvqtic3Rz9L016xL299 rbyOObDW6/Xy2prozLXE6NrQrCRCigIH6v9Zk/9PiY7O8tzIvmIFEYodFNlVCPVmy7SMLF/V 5cqlE4dTGzclbJVuMSmWsVZS9PDP2QhvecjlCln6ogc5GfLAjFyTpdvQikFsZmeLbBccqzaj DxkRzmrcMRZSnIqL7PKs4me5QoqfKlLCS/+TqIRgkfSCGg2NjMcpn/jNVGIdLbvO8/iaLPGL HEkZZb3S/L2baWwFsiyVyhao1CbO2EHsSW9dadbW0XD4gEsKM23t7u4MfFwueSESMdBb1cqz LjpwWTahkyk9K/MUQj5xJ9YUh6QRyCyYC+QzcMUiEQCvaj9auKrvIFgUayaZRtKQaaJxlbmc QB0rmjpWgDqaW5oTU7iZXW6u60PuL7SWCOQxhSYSfP2/9HbOuzdZdwV5Q23ZjpaJyADkmSYu o47Xu94cX8hP+aP3vKz+nnn0wLFJDBAx8BUzilj93R3wqWxALq5ZrsxGNmoxXLPoXNKX1rUk g1t6cdXcf320bN3NxtMY7bToXxJchKzB+DG7rpNul/4qZWIAlE1gD6WjAo+AkU+OScrAILuc zUM/+JFNJz9Vs0cwkGkM9PqOmBlWrqEt3wj5pXEPGKg/ETFmGrtZowem+vqG9UTW4lisKo5u 3cptMfmLO6reRdATtpuJlPIqTPlDlhOYxk/0IBuzyBPPR1XGEfObxEEa12k8YzZNaCKTYrqb wfnLm2p9fWsddnQNt3RzzWTC+BXtxpiZw2gmAJGcCaKnE00Y9ssxzr0UJtNV/JQe1gP72hgl 6+X+yanwdmmeH/PbuRHTLU/ma1zxWyJr3jFKBXknPymyeiyrkjl9rMQ9F3XKvUVXKkk53C3L Wp1rEOwxmz4AN2YuIxd6M2mku5WsAnzw4pyoW7i2S/NawVlkJNq7IF9JLhT3MYALJkDRtr2T Ty1Sp7BQE2NeaUl4nelEssum64Ts8WXFZi7BaaKpW9Ab4mMh9tCOAGnGo4iEeXfQJBskR5OG OOd+ugjRzbNIycXTqqfc7U5os0gqzTxe6JhV8lqFm/z6Rw7myEYkdMjM6pANKAVdco8QM7uf HJ8cyaNz8kQDSSGOcthJN1kb5UDUnUwltrKXjI/aoF/Y6sVR8+r00nGGUTqBDYDLKGrfmv6J 5It0OZxioCu0elqlYu1e5j/12oDeerS3yECU4SfwEGXzDLz69q10gqwPyoTxrqbFbLwKnffG YlROLg6aVxuK4SUQOgBEVDd1p33BdJhls5KOzZh4BtLSszCPWq3BiaHktZgfi710oBgaIZXu YXbX7rfVEXqREJQIKfS/UgA1v4hUcLkNRjRF0cYbYy1/CsXUM3SXKWJRFzjfVEqmqKQ/pWQL kyt86ip4r+wtc+uYfKf+BfMq2WzvFZuKzXlftsXaZIDOgbum8CKVutGkVjKVvu5G0qmg607C SBK1/bc9U0g+yXtAqYJxapNNJTKiabGVG6L+m1v7DbU52L6T1V6eIg7Oz5pZZ+i/B7iz515/ PDi8yO41WV8OycNSteyqo5yqjtmhzLdP4RiyASoD4FJ1sibZ6pvd6ruxUVR6eK5eLCarKLej YGwqZvbFtye/q9Vp8sXBS7aYqv9zuigJH3Y62laIHxX0U5N8x3dVv+CF5qrp1WHJuQrp2blz 93rJqPmrX+T9qcE3SB9I2vojceDpvfM3wuvvtmdmqi+Q/oQGSsazwUadvA37I5OehqPSjZWE 3xwA14pMSIzWJuxrOoxQ3iSkwaTGJN3ieIYTVnC2OcUFOlJj27ZYRhn2hK9EjDRsOuSAjTpk MwfPlSkNjOeM83RUoOBGGOL46NDENjJ2bX9SBQ6+1XpzcqZevkT5HqDizXnzEo3c9imK//HJ j7B/dP6//KKy6t/2bJfPVS1RhKFTqEeOJWF6xGq6t/0fuTc9CpxNxtei+/hVc87LovsCtnyB ddEQiU8XT109UbXPXfiPHgL5JTKB3pgj0ziOQQWracy375X6WKnFEoEYA/5sjAL1fdCNuZ61 YswaNlknb6Sl0czOf6Wf1jqa8U5qrjJDXS7PpBpNMy9hBslD/MRUcC9OmWdGZUpl1iNt8eJT Yp3R1GGZa44oQtntjdRoA1krZv6I9fOVn3DJwiHHN2H+l2aCPHDZZuniC+2IBy57wrKIcLNl 1pzysXBR622Ce6VI6qSei3QzriNOthh8Z6ivd9EEx2iTU50VRmIvpTS/r9Ky9QxIoaU1aRKe Yz7vyhnis+OB+0wmMyyJW1JOEVCWR5IEvexFq/BYXv6jxWwli04uJ4Q8EsoWZeiH4Maqpgz/ 8o1rTUHYG9GMLcJ7KmGbbCERC7+I5qD5HgfesqhDCa+rKRRMgBfII3hcOLKFIymUbLtn+F7Z p8gG00kl6lb4vQ66C8fi+e2cx/U9kocxhvmXGxQGGJxBv9oRjJkocBILO9GLSc4LMy3hxRNB EqXFCs5PREf8+4W2+YGVlvDq+nWnmXVhq0p49xlJ2/V7PZfMb6t5Y9JOTnMbTfMm+gTQfl1j fTKa1ZudJuI6Rg5tVTzJ3atZ5BPIZjYVdIkfA18eHUsBHDnfE2JEUSA3jJS5SGz3qgkdXxiR /eFvc8aW4/cvnUM0WwYhy/a66oq6g3sfr0UoPUKLgG04zKRB95iNygabDDACfQpPe/j57UzM /Fbj5Fn4mLpaDCdn4GNeBW9lrg6ENBiYyqHv5UoEXi+Jue1il0sPVT6waXoa52oJvDRTti/l yeUlNwd8puBoxF5t6TNy+QG5Zzkqj+QinnBnT6i3J9zdE1mTYTbzSFvmRKA9mmIYOrCkTR9O HIWl3kyOVrFSdI3rtGrAuSinvY9hRuKOsgo/U4JQniCnfnZe4kg7xRm9EZqSSipKxOPWpFqS X4ajJOAF8fXKjLEEWpL5QGcBjNFpzoEJTzNCSdW/HCZSgPnfBygJnYSoXpeSxQREtQcDkNm+ pJJKG916b9U2Wy0+UNNf+lXa/aNGDggPNCERn4JcMxKK0cfoysPkFY3J8fF3WBYTHYOxKRY/ i7PwKw2xrPPtJQOUCQN7ycmJGEDFsZWyNVOQEWCelivmqbiIgXr8h+NiFXpA3lE7QBB1obzP 0TW+BqClHggDyxX/EZUuE0kJf08kj8b31cR6sd+gH4O47s1MpsIhC8tiYcTeCPii1OtgIkEn 4l1p5kLSRWJAoniFy6X0EnkBCy9suZSzMLXgupZLmQsDoH23f3F2cvb6OVA2DT8io6Nvhufl QVCDr0UcrQmwZIDZ7RDOgJNo9+LQy5cVUKSuf04x4BUzDxK/yV83wD9uIHuccI4AJtQ2glQR toSsB6lFhQvd5/RZ6JH1bq5oUrGP5o7b1jcqi1Kn8JVjnJvwaJiNR9xnbTf0OvGHwA+Gm8AO suDzDP8qGoN5g3ITBtkLTXdkJB3tJo28e8F5gdI/Xuw5FtrClRrVBnDSibcyZPS1fX/RsrNh 27Z5ntGmHq5JvfRrm+yIj2MNkxzWG+5T2TvJCcWAQSYJyCxKUM6mDlykYDHNk78elSn15phU BsyZ8uP6ZoMC6NQ3tzfKWwmDwDTMreSkH29mFQJyX8vE75if6fj84s3+ZaV5eSFxXbgH56Gd 8i8BYFE60a6KBhiMsYNWR4LJzVmTmY1BQFUFQtD5xdFhkQiG4XOv75dLc5q6Bj2JpklkBRPL wr9IFDR6SaOkZTIbQbTF0fk4vROFazNWSrBmcXMrW/JydXbyw9FFE6NfY3jaaFghgUQiqlCm 72veMjnVrZ3yeh2OdWttp7zGUZnJ0uW5KqRPNXEYT/QEOG6+GTvHh0yOXp960nuGkrx5mpgh UOBxHPQTqGmy6B03vcrTizVvJv/qZaNMl/UUvBlyG68IxiH+SjgAKW2hPzJemUQHbJoP//1A 0UexGVn6s9FEWUlGDbnYWVbfzSb7qfjzglv06qfLo2aq3ObKMCv/RsnjjNlL5uyekDN4ydTP qzkwmCTLrGOepTp/d+zCpUUfGCv9+pIJBkR1HLP5CZU65umTwaioX3ddSLBNk5XZ7pNmx6jv /Tqg4g+7pnQViuGA+SMV22lL2GoJZe9UwRL4DguiP93FQC3ekyQd1WYVu7MtLDyAXZX4PIB4 Ws3946PW/unp+cH+ruvDOPMK8A4+hhwrnt9UyK8NmCOR6+tJ96JXlAXo5Ozt1aUTASi+H7Zv x9EQN0xSyNJc+W6QEZeJ4AMLhgEnQEtvJKofTh/DlFNtp8iIHekmiQSfZCfk95BVw3uj/QYD G5iIKldn3soIf25tbJM3an27vqbdGw4xHDewqH89PzvK9aedxXvxfRoJM5Ms1MguLfum3jI8 EKKw6gJGDmCxyMhNUjCMKjEcIH6/82EurKVYKjNl9kl6KBuYAiWl3MnS44w5SzsYw6w18mpH I0rkyTFzA84x2pfM82Pt7RSry78irea0Xbg7JooLR6KwAwu8y37CNNJ7mAUqOxJjDP0XdGS8 eQLVI4CHdIYu4Og0Go8CGo13NN58Lyhw5Q3wkfujsVqrqXrj+frOc7gFK8CCYtgCIKenR2et V5h1TAIElVT9gzHCBWypTjCrFj4m7Imn2sNASzSjjwQrJ1oHx+Rg2oUwQq003RLtlnblJ5Zz HPT6HD+EPCXDO/iLdbRevfVKp3cDUuA9Bp7rY95Rk7IQBbwgbjtRmPG93fV9uZc8cJjwj1P/ 9VizQL2xYxTCiuXOdzDRDsa3rGFcIebPsUEnmAQojLLleLdnDLEfCVNJ5bQ506jbjcNJCnoS BXxhByk8869oGLa4izL/gWGUhXo4H032i4qy1TB3SAYjsvLHv66Y7DP4Bz6klJNaZO2qV7NA 9URmWZzxaiFVF7tTxu38kVOWwWre1JLYEU8LutXUjxfDw7rlKZrH9Wxyt4mgN7PhxlVQDw7M RDELy+U5j+Jvvcj1HdUlC4QdTVfN9hzdxCC1W8l4dW72MS/G7LyI39+/vfrRjRc+DAGBYBW+ bWt1koV31homm4sY2RwNybuPVg8XFTMDoFefMEtosWl2SLuOcMh3Jw2RERRh91+HEwzOvW/L CiZdjOFVmvmVym53T9T/7/jkFJjHSxB4Xl1dYiL4/cPzs9OfnAiOFJbCzd7tdjZEFbKkEMqv X6nbpDZeG81KcRhAermKxoAn6aXIzFN2Y2nhhelsY7WNdYo926BYCHU3KaLrwI3ovx8ZPxzx uG73o2u2StKxn0XJOlRxNNC27jaDIi6c0zxDS0DphajbEf8QiR6Cjq28L4Y2PTtnOkVuk2ST DxSEl0M26ppCYefsqk3tEUoRjCikmMdsO4YwHzFcj7xkKAka5ODrgCnMgJmU/Jh7Ui+emDjg jL/yWwzcFgO/RRZ4aLE2HDLbJFvgCrDebMWyJ7kWxGqpiOETsRZyczAkKw+SlbMmCacJgnbe TJPz42Btn5m3bKjCX6grcpmm8y7rWHSKwgN1LMo/4Jj+FBMTgQ7brMAAeigJbqpjlpRmAl7p SwCP8lJ6HQMu5CgCXh4Eil9YA9RH6c9qazU3oLZL1YPrmEfQ2ycFKfIvvPjul+ifnQR2j1Y9 L65WclPwLVMWlljo+nH4eQTL4e2nMgdlzUvEZaOW1tZ3KL8r/LJmaExiH1FrcHZwfojmh5Sh jYv1nMSMNtMsPZVWkPy4NBVIZxQ0ITel/SLXWk+njGoZE5olj17MbW2MgzU0Aiy22EXMSzuH Vxz+YZKw3qjh9pXW6zuNcjr2KyNOAT8Hbfon5GZEc5Ac4478qtn4RuW30dnReAz8g6tnQ42b NQ6JaEsXMMag1WOqPVz92obLqPyaCrRFWXaM1fGTJ/mrQg+BYioFqXDFOa1mJxJKUjROwEAz QgzpZBKiJZe1whSwlsc2wRUfojEbyeX0h4DAdo24tfWtnZrLrZF9maQBIo8eaOfJ/HoKZoKy PYsCx7zaOfAxs1kmiOgzpRCYtS3K17BR29wyq03ejDz0myi3AFVKE1QKXtotKxRpWAJyvGgZ qmDu+t5eo+rcW5Ik7qttU0p1mnY2hLJy/q2TINBAfrGo3LhB3ODag9aaVyUrve61D6fZeQzd TrLShBA6Ri9zoinAzZIGHHedctj1JmWTuEmSLfnGudSJnEPV+Ahv1HZ2yg1MaFbbhl82DP7S O5CkABlb5OhW6Pzto4KuggRzYhmI+TX39gyvMYe3chPUJC642Tr0CEflBN1yesQjW6Fexxay bwDyUJilIQ7unegpWEuLVGXtjM6Wa2J4RlZ7AWXxCVMOBYI1cB/PATWhpb4t2j84OGr6RWfn l4cnF2i071x25fhNaaeWxHcbXMto/B85Nj57/CkfneLn57nZOEuZsezPPD6+hnGnnPDxvFEF bz17TlJP46zCB3sdoScsSHY2uSY/X5JHh2iy7qlG1O2iPXA0DN0oAaY/WLw36ksOlOhc8Jec +pY9MtyqFVVPTnLJ9pq7FGxXtOHt3OjHGFRNNsjBGHpD3bUTzD540SVn0c6wP+yfnhxiaGaW NBJZfs1Xb0p6Q5LBm7Omj7CUEUS661bTYg6DVnbtdN82kXAevFnSwQZe6RYm+XCS1hSLliO0 Z8/EcS+ZcHbZccyC7U2mo0XEZ2IiGixP+LfORg/wU7MOZxlcg7rDN/p2OEZrrD5b/ZhEhBRc tdOL25gdaNi+z4ptUZnFJszKwZvTal5C3jnMhWTnzYqNuVFfWyvXN2lLtvEXevASMxDJ1Vgh cwfpE+VNKWeWX0/RHEoz8/OD4s7wOjBhIb3DA/pPpo30E7NJRBoTZ8wNQ+NZY7B5GGZxs/Ym 7FdNFIhDwCzUjWcykt9h2lZEjiE2iWoTqyauA/3y9NKxg+WsZHT00NSdDjkehXSrarZjd9OW fbpc5ly/BOjXgCbrGMQ5DNXJsItGvZ1Q/b0QorBcfOMOfEkmMOitMEBdXydEh6w45wqwbJ8n Q2TybrkChw3T4tpNua64lXQAg/z+ZsU1yW/jG7uC0FvJuyEoEGffEr50HOoYLt36lo55zCb1 hovqTeKw3yVguEZjfk4n2KG9J/UlZUyFb8PeDSWujaMhnOH+0DFNNUGxJU9oIhsywzn6bCJL 97eCZ/UaTLLS5BbL2juFbgPhQrwjy5W/ueZOnmFoUYcK+ltmZkff3Co/cFDSrgSPbKLNQBzR 135Lynnoodi6PG+Jb5VTVRumlNVMgJkt/uWplmSE2sKyYKWeitPKULO1w8Rraz1D9TGbxX+5 Zy6QTWDxW2pF7H8PlXzNyvFH7huUH7w0Hbg05/VpgaCl28galLZd3UJmgq3d5fnBIOIQEMAY 5B/MXQ87Nep1MEbr/5cwpzcFNkrcrg24/LAuzpwukrL32f7l2dUbdD7EB2z2pj/eb3LeICnj iOV5+34z+Tid9Pru3puiBfY/o2520sHNeoPYEv2L0UeL6uPzTasDYnl006IX8dUOpgkq5Hws 0rP5biJOIGUuESCmfHmcxoQslyrotYeRPTFylx+hwzRzqk29elfpinQCnU7lJQ3U60gwZids fExXVMeNt3/RHy+A97+ZouFFpV58Rl5zPvn0hQc7chIF+lO4aUng5FYA+8ezMA56NA0aq5wV RyH1H2z6ILi/DrEv6ne8WLtOxzH6kreCGVvuCN0jOLJB7Afovjhqnp9eUXaWZ9ZVULeg2j7H YftGe2vuEYVGaM5/ee49MRqL67PA6M0V6FNnIkB5avYG290dxOWsHePdsChQxwTbP20eEf+R dy85j6hzK6VA7lkD72Rt8/l6/TmGgfXupF8z90bWNuv0QES/cHg7DtKbmyY1mfOza4w4OQPr am9wo3nF5KMGS+DvOCk5pW/G/IDS78mb15ThE9/Y8AXePOBgpb8DX/TU6B1ycDOMzOfEzfay 3JuSTf02fnphmJHhr8kxJZAkruoeLWD6EbBVvQm/nNuAkbQNOrnw/Qj5aQzkjZwDtsDIHcLd WxViHSQ2zD4OP2telEETRsG6jv/AR9IOALG1wk896qrVCTHNgPd2f4yxOqma4pTYwiLSSmUv l1KHZDPQRX2Q+Knf1GMtfZpwsY4vzxVxbGuRO6S5xhox4kfKydCjEtUDHNiuvMQ4pLuqVOoV ZTMa/KoGv5g8nzgQjkDxej6jqR8lrqkXc3PWydM2TDUFCXDBU+uyqhJeXDk/MwZv9WIL0qnF dJ6w1F1BlXvlJe/T+94HP/cXfgdykQDsF7goPwGYVEyokvx2ZWrmZgDrAoTwDQfesozD6Lxe pdIQP3a0AW1ti0xptmrr5TTZtotxqPEVBVUI4tvdBCYYYqwOfcuO1WBKqmOTVLIi0QoJvbDF HjqLOfX4bdi9Zt4TsXOr8E0Jb9XWzlb62cJgIr66X4B+hjq6z0wENNSBGxZGQT9olYXNb92z KTaFilDrXiffsOtjeH8dBeOOS0ds2QLsXVblTGrSqDXqdHH5lzUHjyGMjqJ+nykivTRenZ7S rfjlF2+bbC1YlmRtJv4VP1AKBk5AR5gOr4CwFyatJKGHepmTdviNyorCKrzZ//HkzdUbE1eh 6CWcZKciGVlfcn/++lq3g2E77LNZy9irQGxgrimO7r2skvOreYYxM9o59QnlOnuLL4jjiZnV Pi7oogVyMkgEV+dXzbJZnfi+cPJb7AHpPBk0idGufaRu1HYo3Q781J5l13BfW/4CaIpq6IUC fnt+eto6Pr9gA0TjWBFi3B6/9a4fkSW7ihF7huolVhFmmCsPxcSs0eDJNhp6skjRKWoCOdIN b/ohWUsH7Qkak5GfqoZzP722q6H4eN3RuRVQQKY8P6rw51fn+xeHanX14/XIBlfstAYR/GgN wuFU7FeXjI0t+3uoVeALDAvMNdzgNc5XL8sDKxFbZO3taVDajDwyZo4RxPB0By1UhXd0bt52 NOz2bmK9a2SZCbu2pdGl50eECU5k0B4l9B4MADtjXl/Xd2gI/FEiA9kqFfGd8cL1jMNPvIll pnqZe5e/aUwBsxtl7qOQrU9RHzaoH3qTaSecif4xGFFQVskEu7VNEAU/NURluVotACDLORJT DtxkV56xJdkNZm2HuwvR9T+McdP2xjZST/i5I6lVl/RLcYKpST02meQ/ZrCychKKaRZnZmod lyiYtuYmKV8sdyqUFuk8ldHJ64D+SycvS2UvcxopXQGtpOrpdGZKYqMZo5/GBgEU/Nw0vElS GzqOPXnkLqSnyaCPq7rXOttep08+6hPcY4rdgeHaPQPYb1Q6iSwrR7DxEDeGaYaNsJGnhZjV zNHk52VryG2tDcE2t3lXtmoJbagmbhwQjnfH9Uajdf5wdHB5rhOdjYvIW+yju7QpAD5i2zOK XqjJDhJ8jOrcG06tQvNHbqorVl5iDYzk8b72wbhACMfJi2NV73pju+7jEJsXZwx7Eo1oh/xn l5zA7nn7WSY4rNST3hEnZ3yS84/DeKZfhPF0IGDGh0DUso8pGjTsjU0YDWG9YY1bstad/LWO qeuM1f63Am1ubaNSxLVnVRAgXgOxYxPt+WpraOguXHC1WsVHkyOMoxb2Q3pK0MlY+BUSX6Cq av/idVOnA/KopWRWRu1B0O8TaigxYiAOj982reHs2NrgSVA+lKVG/aDNHg7yIDqcRHQfJGAg 5mXFqBZ3GP5C2mNjP7xPMpRfRprFcVYgPh3dx+MOPpFZrcQik3A7yVsJsq1/K/fwVmbFz+Pe EFHkXU8nmJ/YVVITuLU58dFMbrbssD3SvP6hLIO/b9hf1+yv6x908i8dTK1mot0v26hxd7ch hRUJ5LYhjHQx6AjGI4iIaSJdUjDG5CdA2K77mOwDTa56g1H/noCt04vH4Q0yswJqkg1Eh3zl 1GBCZMjnjYoH4ozZG7enMMCyRbz0Zt4V10u6DNchkhmB+Do72K6vrW17iv2EZt64Xib1Ab6K wFwttDNzfBB/rv2asv926+5mE9EyVWrpP9q3URxyVoqx6/l204Zd4X8Bd9LPhvxcE0KTNMjW axJUW8kwyk5UmYGNdU1HA7DPUba00yk7wmDUj2B8bw+P9QH8JwD+D4KkemJEyn6UtgOLyWOO BQZ3gbMooItrpx/+t/EOzjHZdVChWYy1VPQrM7VlYFzHhLAAi5sbmLrFZliVYLbCOyCllxKn q1Qazlxlj3U/f/AG6aYP3qSlJKftQr/4cM0i6n5e1GxrJb/LmvPGLYoziSiw4G7ykQCTW6+v 4aGAbLm97miGUtdVDtO9tD435ausabUSatA0sD7eieo2xmIiGL7TmROHMYV70m2cQWc2dEJ8 Nz/2RmpE/JPj6DKOOZij/CpMPlsbd1IWsf7u2/zzOWyydvJalEOuLFmDAuUiF44W7fVLmjDD HFdE0MGfi9Diip2bfeMwJJUmmP7Q+GADf2dWWEtUyKD0X2OJv2YciQ/+2efi1vnyw/ExIU8/ PcL/kmP6ssX+6l/EcMK8c5l/iNsi3EL+8/Dk+Pjo4ujs4CgrRGTizpezUYH3VD3ujUKNofF3 fDXy2unCXRsKfbbwZgfKshv3W2TOr+gM5W5J9jaoJectUYd/9jmSKlZKNtSvGMCXTgKJOM5B HFCWPDt/h68swPkO8azIBJIvzDXw3Oh8RvtSMKkJAA57k6cWS+JnkZlKj2/vKM8ejaJVPorW T7MzUPRCN3EpwzHQUkHxzpUUBM4NlaDNvyQ+wR0tpvyGr1LdKq8R3Fu/jWFI0rfC7WTopTH4 RvkipIiNT2yLjMwGeWi6lLr1Jh2BeSYy9ytht54/RdtKz2T+gh0uzOj2Dc+1WBfpCZF7cQJ1 nRyeHrUEf9nfLRJzytKYTOIFk5yPcp2tPKNt5vW38kTeFUjw13IPPP4ujy6mb4StM/daJBjC r3o3kn0vekEykXCKdy17cu2MO2PbwcVJdJJxe+ZTz3n3KE2sEpdp0ZUkOsq7X9n7ZYLi+dJK cgPmXr0Fep+1Fr6V1rnoMGxjwB+QkNq3gueF8NFN0QZ0S3TF0NLg4Pvz5tGZvsQC4vjRIZ0m 0mf/vorLyG5rG7DRxMXJ20RTuHP7HKwyHElM+9uQFTucN+gOMQFHvg8m3o3OlzxQMzeT8XU5 pnAwyqEaIZqnLMhRORxzhuQNPWVwja7OR6txdxdm/R3Bbk+lGTyXlxa3wpmj21XtPoKt9SaT w3JmSCjGkizJliykj3B2n24SenN9k+njln1kBq0Al5/EIC8c2uzWK6RQzZ5fU+aRLHPj+1pT qPyLvuS+MCUmveSH/jXdze4pew/YG06IXzZAGvYwAxjJBG42IOLmCVK2m+KEJjHPt5lzcMHS p895IJmaUp4EZOeVOFOenIBomta7M/SovUq4KWtUywIWZttGt2Pk8lF/jgac5G8DH1KalDQO cUGgsuQ6e8qzr/1OXtbmahoLvKvsiv5tY6qnzZgesvgl13/fFZaTD/PWnIGzhO+RLd3bw1OQ DA+PfjRJmdc3avw0uVGrW0u5OZp/5SQt9WPv49O7wgx0/QTto4eM2KRfHUb25DAB8ycbNwJ9 10pzawVDI5/Rc5ae1H7MJvwYdH14nwSPu1AgRFM33oJGo7yGKsqN+nq5sZN2E9H6ed+zoNXg qKjGDVvUo0lTdxO6oJYCE/8zy/EP6OUspxflWAk6jy+eu5v2y8JraVI8aN8ec1fLqplR9hDf T+Cabia3aHwlLw3CR3FI8F7f8/VEPYD/IpH020TLZjRiu+EHkEvyrxvHdNmXK+wYF08oiCjZ hcIM6pvqGp89xf9NwgGWZaNtkXmT7YcBusBl9CEjUnxvPQ1KRBEnMwZLXmfXA3Xe4oADG5u1 ZXqmYiY1nnBA2Qnu+5RdoOD62BXpJuSNik99emTafMXbn5o5VqCnYwyvxpHVmDmUJDESyGG5 Arc66k/JC7HbG9JDE6Z0cH3nYd5nkhYpUINpf9IboZF5101R3u5H7Y/KdjbTB/Xf9y6V5Slm 5A3n8XH2m5HKNpZ64BOO4cWdlOxriZzdHtrwRBbJA2azUpoI3w/ooFZU8zrw8JvXQTGVhCbp qpuUsZynJ8/ZnR1YttbIaBF+aWgHSqj8/8SPpYI+u0iOyHJCW7caHxZjQMeWwFGrDbd+jGmx s5u5Fg2JJuKyStEAg09Br0+RAOmjazxiWmgzu3p9bYNoL/yybs3U/zntTdjYck8dTPqq8PTm KW/GD9MhW2Ky/SUbGcbuE1migvQisU/+/YZEwEhEk6Df+hjea08QPMk2khMsg83thJ/NF7Sh 7IaT9m0LuBcotTaV+TbuCD3VW2vfzn8vYNuerJhp175Wr9fQoId+8gEd/Uj08/gOsN9Qnkh1 2TTG1/fopjdscTy5uvtVoqrzFyL2QJpDAGoy7SUQMTkDGemps/PWxdHl1cWZ042mxzaOo/mE lqdk4T2ETQdGx60jY7mPrnT9xGhVxzs0fKNj2UumzcIvrq3XyJ8WftaTO+LcGtoJvhKj/An8 RYwzR/Yz7cXHXr+vJyZVQj9TKErF0gJfV2ZafHLCH+8fs/WLNKbMMKke1KL/ObN+QCtBU9T4 Lc9JrT6gPZ9Y7q3B5bpuIVJgr8Omqm0/X6s9X99J3ptkzcyLswnQgWZB+FMz1GSNMoBdZXEB dtgL58YZs9+S3yoyaClnVwcF05FJoFT7xkZhJadull/toSbWuoBT4NzR9F+n6NFjOc/0OBfM 9mlMfIHM6d8Rh2OKcUq24Bg7uxEtU3GmTEpiSROe8aJo1uMrVX3nM2tFncNsOF4Dlcy4PoLy zWhlu2XJXvcPDxO9YphQ/ZvpwaXSecA2iDuR590vBQJC65XajqqvPa9tPF/fTgCbXzMP2NaB AyiTjQn+wjZo3/a6QwoUvf/DESz+FCTrRLDpOOzDlcRw08BY6erO5v/16OK8dX7BHCbUgM/A 3+bWIEpYXPobbn2hgDJokYuqk08tSp2qakv8mdQK/kcU3PRXHTMp0QdB0AvWJVQkXHKFrAcv 8dXzvhf2O7FOezbJynWn4n6vHep8ppMg/ggkYBjc0MstStwm/d11SIHwOIQHytGUPpKV2xio JDYB3ji6DRmeL0ty7+60T969kY7PT5ZlfFISIKUEv9S0g6f2Wn2HkopOAng3DkYqoCSTJLYH Mdki07DDiMPVoKShFR519PpC1DLCZI0dSSJIpsp/B7Joo4/M0CC3+0jv5O0kUQUT8poaEr5m KStSK1cpe55tullJbdY8jzMrC6wKSiwr+5s027Vb1JxEI5bopJIIeSi8IYm09roZq/TA1Y44 a72mDgOeLNkayZIusU+7vAe/sCxEnsFxiwBS4ucT3BVmECQMVTMeuIycLpG7X6/Ud1Rt63mj /hx4Oh9LJKrmBgJh1zD8sS2Apy8PiNXSyYAoksMdDIGpJUwhHm5dVB10Oy18h1lFWugVYDz5 EEvy/Hd0Rb4a1DZLIsE9381z6cnoIymeIPxYJXbcu0GxBprAbwO49w4/Nh2ingMOg9RmsFpk Isc31yBE9NG/OenzvzALwhQWA+HSLzf6l2v9S+DM4qz5NqLUI2hfL25QEVFcjlIYDefCziAF OwOXnUHAWXve2M6GncG8cAnbFKgXf2y6Pg1nzUvSMK7CmQCaHaOXOgtjyQox3FHgasfhKAwm 2XXlXBncWga2zK9A1qVmAmSkhRy87ZCZIvo2pPZ2VvtTjO6Pmq7wbRQB1EHDcDyCX20t7eRN bDzbnq9y/HH+g115RS7Yrpc3US7YrpXXaq7HNVkvmJmj/0BF5t2Kp9fEjaWlcm0nnyj/nCq5 B2IIt7jy1f6ji9vUE0NC+Xd/yKc6INyP9Nr6U5lSfOsYEDrl6FCJVwX1J3rRug4J5ib8Bvop xkllFRkHjBo3/HrrIqLws6RXeAtiJjqeEIcQjAEUtZq/HwAYKH0wyDMDBzAddTh76n1V8Nql JEWKgy7bWgWYNSeRikHqErPBbM4gJCURNNRox7M4/2z5HBhKfpew1z+7nP6QuemCqaQqyjTW 8Vs4MouN++pU3jMVVqkvvw5WKe25H35Nz7Di9PdSd/clc82YZ2n+PCvJeeoEGlrS0o8zY7i5 vaFkDUX+HXZej4PZrUx0TB0W1pwMg3TlpWZVefbOHujxnYpTp2Zyu3bNJOVa9ICXlUB2wLVq LxjnNjlcqU3CpW+NM0/q7bNluJ3Z4c74jmhA6jQTVdBZDOIi8QRfEZtIyj3UbtPeEzHAmFm9 yT0OSRw2TIUSVV6H/T61+LrXnuExgTjvgo/hdJT0qeFSE/wl05WT6xR307CWegSkgM+j4Iax h2AatPukzTYnxz26YE/fd/1v8qmQqG0uUHE3o68/7tn7VcoTiCWkTK0sQOBUtXKw3hpvixyP nT+H4UiJDkyeQMmM1NxAmZnWeaTSM1YyPbwNUc+2Q2Z6nxu6zrCSrvHzyVCFQH/aEicRb8Ce zA7uqdbNoAjxCjiPj4j45CLe6XuYunxac5Im7U+MPKN3zhE8Mh/jT53dtnXV0jXOJmnr7NlS Zg7j2wxcorWywChJk8j3ViqY6e8ulLxu2AMQPSBm0VBbQpkIgCwL1LSLt/vvkxTrPlqovo25 4fBMrG3dqrO2dW3NeEUjC/VVxJIHyCKeKLKg/JEhdvw22PUiJN9W8quleKq0MejuFzLWxUJ+ LPkNsKuck6SDWV+vYxZJcT1Dw3+6OZwdk7WRxkPprHkkTPUnAhhn8ymRaJKtZ19RFCku9g/w cVHDQHFXIpeIJrW5PxqhSgmkCzK7Gp7FTQYWKKxjJ6iBes/1evE+mVZ84Cwg6smTPBFPGqBF AU38TTBpo+LnDRztc/g2vJfi+CMjwENgJp/DJJZxK95EnRBqHYbdADbkYjo8jaIRFgIm/ec0 nMLH8w8y6yI9/lYcZYMGdgZ0A+AGsJUDjIlbKD2MHtEFwbAWmAXPNzEeHGdGoHzdowmB3KQs +jGQn2OFDznY8SQccmrTfj+mcOQyBx279Sya6MjPyISxzo0opDxEVNts1EnumjJnrArgTKNa CNzZopgd65tW465c6c+EYnMQIVnRAMUyMiRdFfE35+SUlI8en0JwybFgQh8yjRIzo9zRe2sG 0dRb7Cie+J3yqS4+gaGZQMmZwEOAQetREhPxYEPsusTV3X3jNvefj2mD46kBwvDzHcGB4GkG hiLjoaOtEtmVYKB6uHp/BpolPuARKQIRCsVc2+Y8xVdXNYjgXEWmc09OHhkKBUZGRT2eZu9R SZn9kcSVZ8JMVWsmha3/ZHF5bh4sHEWWmJRZHcn791oxEgOW7kwB7OnPd73JLf5yInGqnisn Deti/03QPX7yXBGyekBLPt1o/Fx9p381TEVLUr88L8op1jf4FL2wwov9xxqg+Ln66aj5Ac+d SBbI0SiiRUR1nz1owcnuUY7T2aANWHEQLRB+SO2PTwDIB5Htk2AkBWw6gBmnupjfbpTRkHmD h59xrVp/8Iofe8y5Rw0zT57yBt9VtA/0TzlhVeuE4baDkHzbDoGyAscctD8yWre7Bltmh9yl NNiOzBu7OUdyexs9qDv3eZiwFSG9or95g3DQhqYFgxKfJPWRkv+2wGxg0Y8OLlhPp3fbWNui gCgbNWcLv7p0m2C1FmCleEcNJ2V3LsFKefSTnkB4WevrQGTRYLRm3hLs1j1xNmuR3fuaFNWZ MMoXdtwCP4K2MA6iWi3WMkqy3ix+W+qbO1tPSkrSXSsspYiusdczZ5Hc/yczzyLvjcFwY/aR wRSZd+xGQ9XWn69vP8e3aO+VIVk3N44mJm1Zw0B82zoFvZsquau+4VfojirsH+6/vTz5gVME t15doQ/Qydlrcsuxtc7OW3kV6dHbvnl/vy/qEBhInrpzWpo5Vby5YVd5LczrOZWfX12+vbps HR6d7v/UOjk7uDh6g+m16rxli1QtzAgRXrQLSHfxZv9HAZDCrP5X1ca8bqSrOd1sFTXj19hh u6nGtk6kZ+M1Xw0p4wxZLtMTAGrQWWYA7m4I8AsIvs2JaM3TvH75JupbhZlcojaDNTSChY/2 T3F6P1WLbLcssX/uMEFbpH0XSBOCPAilRApJDUtZr/s0blVcq2dUHXl1yUcBH57a/BYcR+2P ffRmQFNwLnIRD1zEUIdabOxw3MHGjo6MB5WPD+nlGq4yVZX3cyhtHgEg4I12y/9ydXLJXlBx 20WL+BKQhQS5cSYyNE49nvFnUQdqpf5HiQEEY0mnSY1P0XpwxG2dqzPpueFnvTs5u7wQdmRn kyFoZ2NLiM6FifJVQVG/R4ECx5pNQLsNMWPjBH1GFYnyRfh5JKGltJ31OLzBPJ7jRKROwlx+ WE9jQu9ZE/b6/R7ZE7ml/5jGgLlBvm1Fw9BYcbOxVky2qWWTboGphLa4U6wCLtlXlNiJAasD Rsj8tLHYwfdHB39uvb04PzhqNu1Xga8d1NLQFm5tldf4ITeRvNmbytBMUrIvO3lp8qzUHmJy 9mUGZ7FYnMVFL6eBDbVhp1gSVyM9FHssu999Z2FZt1/NeggPnV3SLsKwj6WEv+Hx6fn+5ex5 UJUW57jJn04i6XOehVx2b7vJVaUigE6KZeXE/EyvM5GJJXfV8PfdOBretDD6v5M26C9sHD8q K7uX1m3I7Nc3SZCuOLOumXSdOfBfSpyMYzbPHRVmGroyQE35B3v3lBZtNXRbSWBpiuSk/0is TP1J/Zi6o+o5Y0rdhpv4+AMa1tRziTO5ViuvrWOgSbQp29GR58jcAGlqTJHlx8EISR5bkmly gPr/aPxRlwbqenqDAtRN51ptVNf4kfssGg+A0N6XCW3qjoDcRSPAocA5QkOkpNcYj7VPT6tV eWY56XKedqKjkwgaorcQPlwa3TT2icOhLIfoweRZpQ7i2+iOVTc6HRzrFkVBqDuJI86xClga H+vx6z217w1GURz3SNssbt+TW1jsze0sa2d56LDWkDyOY7vRR3aITDiErdbbwo8QzgtEt+O8 Prh/fMY/Us8Mg6go1glJfW9ZUV/UB7XFuvygq/kzqetPKWEjeYGZ0DhxbQx7Q+5H8fRaNkDT Sdao6Uc8sokQcgn8Et/yYISANew8g48mbjhrSGGrMU2BdgHRLon8pnXy5uQSjuq5NoqQfntD S02jsXwkxyscHZgASuPkfKvUQbYJhrG6ia6J0KCStjcYhJ1eMAn793Z8hW9anQhdYA3jBjyB DnaTnoF8QMdLY5Hy+FHYXenNycHFOSFOu3b0D+t0yKoLDt9QSnmVK+P64umY7ozrmBZr4xNK h9gTfzYb4FSSsw34StTojg1dnkeakw1BzA6BdnqoYOetOTPTLT14usNgGKV20wMAOlye23Oj 4IFKPOrenkx8zJZBcv7VdM2XUtGco7sscrezK/IavsCGOcdaRnfCnjfjO5yKee7Vrr8o9Pz5 1aFxYByxUdRzEb9ruDu9myEynf4lIUiWOMESBnvbhsG2EWiNoy9gijDJ2cqDBGrAkMnV0rX4 9DKCmufV4YALh+7XkBaXRZkUdFofrztABhdyEEn1N8zqS+lQAVjciXRqJeeDyzzTwOhO0w77 fadOpnMIVcbZ8ZhEOE2ZjsZY4z1fq9k9t/LVvr7TzJ7YD+/wVST66OYqdy6b9kk2G2hKzPCk lGCC/kNveNu7hnL0czPOmRndDR/alTWd/0aHujCtKi+Rhk05agmmiuaoQ+nvZfWX8HNvYtIX D2BvKUvOirHh4RTxkSSQrghAVDQJ6U1uyYdPyezCzjffrBT1A9D6Wn2TLeAxcm6DLSXxXD0n yjxXKlG25n0Gxk+D2i6LM4m9fWESw//s5WiTnXeyoHuijzC7DvuZmU1F4nlwbzKO131mKxGt 8GWVbPbRCgPYqmGIWeLFUCPG504xhom1CXLbMXELrslx2Nog6TABE8/A0JnNL79YgM0CQ/hO e1CkZEUnP1Ic4x4rZ26TZjDovfsno2L/+UsddIym08UpdrZz0sRnth5Kywc4+XjPd8rYpKyv rW8wEtnYSETqT9qCEYbGSM4TzEts/BaUIdLTkfMuAa2PPnPwDhOdbzpE1izDxsgiC9ShOOLv UDIs1ryMaMA16fS5HY+vI15K616EKspNtiwOLEFHs12Ty7u55rmvzDlHHUs3IyjPLJCcUXEo 1oqyxHzDrwzfjlPvwH03EKXEykotzTCxygKSGZGZzAgVf4R0cBra5XWgUo067PI6xuMwWeAE uY/ZWkS7P7d0dPyRKpg4KHoEG7o0N2YAm/Fhx84Gf8NglYzmlBdOOC8ZSiqunxga+pu2UDga nAzF1VpSjtGe0+uu9w3Ylc60jdmqo7GN5FOnSr96YatsGB3LO6NSTlKOoMr5JnLMhhV6bvT7 1ssoC0Bz9s+428QougZ8TCNy/GgHmPxa4b1D5td2PyehS6tOfkWlnJVYBL3Qehzd1J6+YqlA erPDZUk2xtISqboyLt+lV9W/f2YoJzxZxkknv+eetlRERRVqqpY8VZWe4ENPhRotciR4v53k N0I+1lFdg3qb9Y1tbSoHtQ4wfhvaoSKv2UK7mt0H4VZ90wtac0DZ4JA117NDc60yJokTdgn/ LpLa3tH1P9mniHQGEgqjx/SHIcF0T/pt7Oz8rPXq9PzgzydnrzEn2xm6pDqPDMD7GVwmrz4x SnnqT+oJb87z1CuF5CdaqC09QOB0xC/ZDJx6+cAuRRWndSj5ta3Rq22XNGw16Fv7rybfPPDq YlTe6GPArijTWFxISdAn6R65Bx2akrhseYrf2uKn+O1tm6sKg2XoYwo6wQhRAEGrRBXA+y8R cJR5s+oaXaQG5BhjAQNl4HBPnIX0pfWDdEJTa/+BZNLoWZjer0HHBYRd0kVnPzoSFdADZdaw ymsjg6YU2B5vsMichrPnBOc+nD0nfc6UMbV9GwCE9jlvamJrebf5+wvK6Ohdt139sVRys5mS XLhH33T191LxgzZE2VmndMfrm7UN/bQO4OqkdtIgDmLvwemFmSYAsycX62q+ArtYeUng5QIO 22gsOXs8sw3vwQvth4IBa/VJz2/n0ISFBzL0zR7fIgOpJYPTDSuxCJI2T1VLCwkvNUdm0THt Mm7nnnZDphkJuqIT36yJq/kmpqhpiDFFH7bHWEdQcICzJt9nsZE1RtUWU5pv8qFkS0a2LptC uP89iGQkzG4MzCW/FPjGEJlE9C66mWzi4Bv0zMDdSV/jPP8EQ81o616fXV2eNt0JAiJ/PZxC oWJEG4uKUYLS9O8B354MVT+6A7ZrgMbfPbQLCD6FsZwapX+DQ9uuezZ3aPjOifDuInbO6ExJ 0G+evH53cnbwfRkjBE5xCMIDNyFZ96Do5sWm7kSGUOpMmFy7UEvmlHM4SVRHaRMwUjDN4Lw8 aTRbo/Cw7tQSJSwGlgt2sSPPQiBPW4FWYnlENu2XXrT2mXHM/mjkF8aUbZuMG0vr28bDxMEj xOUZfL2nsa+Le/0qHGtKCyJG8VPRvKirVqLmNxFc5AhTwZFOl7hWZTnHRXD7xmaNpfKNzbp2 7V9aSkjPzUs0RAI2PeL4QbSEpajbxUepPYRWVVHNJr8dRzrGkMo1kjJ4faZyGK5YA62adMjE ZG7ISoIZm9lZ3QZezOpIHrtKi09MrZLNlfww6S9Rf585iHJJDBt3JTcU93GPaOcYMIyCSq1X P10eoabpgujKj9zONNP5M6FrPgyx1djc2iATy82tzXq5vqExwTv9xGTf5R71JudJif933uQ4 38eQfX7//e9bCz9v/fe+bmkdOr9uOQ8yD3je2tzaoogRm1vu89bF729aX/tNCzZ4jTj7za2d TW0H4psYYgshGfGuNhb/TDZ2/4nPJO84DGsYu63gOJD1QTT0p6/24vFc3VGYJ4t8/q88cgD7 ydd3e239/9gjx+Z2o07s1Ob2euP3R47f6JFjE3OrE9ra3q55iqt/8xtHxtZlqrSxtasWV/+T 3kZydPMzdO1WgMnRsatFXlP4JHd20Gp9c6e+nWW17lKfYhogKkuecoHYfK/Ngq47VoPtXgtf TZHV+ex4BHqqn8UiXRmqSUvfobC4sPTG9u/SelJa7z1eWqfd3WoADQKGprTVWKtrUxE1CP7R 7U/QiU6JtQhwxFCIfttoqELe9TE9J8BHtGJpD3pDbAIt2tPBtM+J8JzGveGsxjxebuP8kSsY 5wYIIc0VzVSYLuqgNxN2SGHvAolr7we9L1J29ADt9mLbkwSMf3xf0hX1NR3gInielF1Jkj3N 6aItK5u3MOoTcw+0b3v9zhgDRif6xM5i09mctS3WnbNVvLy2XV97oQWWHnZyfv4B6aScjF7I FsxexoM5yQ4ecOqJOUDbuaecbvLoU83o6vFnmtHZ/BNNNkK9WU/J+uHXaIzxpiQmrNkze82H GKCTa9OvHFY0v/7klrNEUO/8FXNzBDp7hIMEKCQ8d83GWU6P9C3szIfHBTpJb8EnoinU6FNv jOQG3UKj8T0Tm8TqYAp/fvXUW+UYimVXxiGa75Pf0mSx5hUV2nNjHVUnPXlMTTMdovMAX6W8 DfjivvhS6Q4BPtqjqYaPcNymTAKwpIO3VzMuGbkwQf8VNg+wOzWCjc3ojcL/q9HtfYzOCXr3 ddfSLWyau7tJX/68Qee56t6mXXVvH+CqOy+abL2GuuYS/3BiA5z7MRBBjKjeVNXrs6tnp73h 9HPZ5mKJMS9VEJuWFIxlEo4505EKRiMQEWNOjqtEVaN8hwVSzg290B8osCe8GsSKg65nD4cE BDyZcO6YOhwESLJoBGNei/D8gSP5gXAATJTktYqOzIzv8vSCqKcko6AcbLu4Ja8UrcO6IKYN rfJVtao2KIKIciMcJId09IyzBywtNqCv6nZ4TKPKSjxy6mSrbOp5F+ZPwR/aHMQJx9UhPyGq 9vd5FglPq7kwDcDUCUeu97kuWSDTRbpqdq6LBmW60HEaTKz0F8ClR+1gEo2rty/d8naA8+/3 hh+DSeIT60YrnJkLPpXsJ6Jcw5gauBHZOR/HSm6Qdr5zO8gHlzgrB+sl/OowcNBPd0PgBaUV 9/XyimTE77HQmxxOzb6nVLxI8tSmmShsXl5cgTCG315dHZP3mTzXIexiYFQm1+NAAlvCfZyy KbOSuHNtBDPU13d7bOvCbmCkE52OEfra/YAV8wC878KnIFFgx6QiHwdGex8Ntemc6FNxHHyU Id8qzozWNokT6G8ANyn41XlHsq79TixhDv6LAaInwE1wYg0Zhz9h8WpxN6NRPKeRm2OkUdvc wiDCpUZtY13H86f54JX8/u0VR95FUz7a/7dHFxfnF6Iof7YKK1tdes0x36NuJ8A352aPZBdC eYMp8KHwU7vIVRFp4/NJu41vHyG1h4MbhgFF0jeZrBhzi58eb/+/RuSEx08B8tKC8hz1Qb2i HTvcZULi1uEsjMkaUSwRqPqzFLC9PrpEcDs/Ptz/yQddLP5h/xRb0MPAjbPajBRHI8/j7l8A JFD4r5F2uZMY3AQNzExS6gEJGjkZOaFf+TN9F1d4W8MLTEIiOezONxQ0hcgC/An1/tXiQP3x XRhPbHIiG1OeQrUm4BDP/ZvUnqAw7m6H7CFAAFyBJbJptP6TqJy9idhlM4gptCMlCexzpsJ4 Mr2G6r3P6BJf6A67yNWYFIGNemOTME+jtr1TXl9LgiRO4vDk4ujssvW9wOH/Wy7ZCLdBKqon 6dWB8UGfTICS8J/THpSHjDIu+WHrSi445aMzTRHs+8xwAx6RqhcmKyJ6m8O96gsLLwGnvfid OsuQkGB/assl8kTRo7mxD/Cx4udEdB1aDIcvnHyykWAmJvKu+TB1vgxt4NZdfpQkeDGf/sjU moHHf4ihip+cQNE79B/qAG1xqbSbVi1/soGBM19YrHu6qUr9LCVWQF7vv5rnHo5sw+96uBFU JHnayTWlbcQ8puwS6pgzckyCwYhY5eNDVQiqH6tBVR2fnB4V+eWaRtk3ed3f4G/oGofaJGQh 9BsotB5MY4oOIk4q+sUGWfKe9R+OQ3EZZpzVgc/UAb4Qp6IaaiiNRoC8YMo4MZOc8/hQHDDt wzTZaGIlzXKiGlGYLfEanrRwEAIvFNqjIUyarQWwnHNjOSAXsLrCKRmIVJzsCkkNugdndomm DYv0imQyxSI0M6InTz69b3xg5Pfpfe0DQEVgqCqU1LFkYEoEPKYyVbvSySdjBIJ4xFA0HlcH W/Qp+XRyTZ3CzyrTcmPgyQ8ygX19wzpC3xOVBraSOzt3ck+gtTUtyZlfRqwt/QvtkAQJpL/d fXLL3d2yl6nbEVYR4zOVlbNp0q64qxP+wdQGHzu9MQdNHOBvGvFjENxobFJY8jVg04hbDOQJ IDtgCCU8v7GzUd5EPL+xXS9vNxJ43sZVendydnj+rnl2WRR0L1ADcl7r9OTs6kfjNM/JCAnF oBjQ+kevC8w9LMpPvMHEF0CrzL/e/kvr9Bk7qVVO1aQbrXJo/JKMYkF5ufSIsXRglox6035f 4/GMr/i4gD0BMr/9V16lLoi0ut4fdT02J0jGH5+IVn9ViIXtGmdHU4HiVR1xnr5X9vSXVV0T 32iBv+pO+88R93//VwzRzxFqMHoK4SmdvrXT+9SLJdEBoEbJo+Rk0mGac/svfPzy4/yvTp1p rppY/WYvZpkAxO7Lv837VzQNT8/PXlOQqQpMHYYGVKpLnqnM+Fea5P3yC2/5Qo1M4BBYB7Va VXnBtXBV5tkqtf5ntEduNHafcDtuJiA3AoKmV2hkkUX5N6UoWPgiFMSS6QkODrirvyINxnis IRyMXVGVMla1g36bWPuYDJlGwGB/7g2ExDL9wuY3UxCf4MTZqfQao1iAPDa8CT09hFyH1igc t2hHeEk5u720tFSiGn/M2TLiX4qOsYje42d2kF2PkcgxdgD+Ha0bii5+nOiMzoICHCObZdX/ AiQgCEffMdPMyd2Q0Tt3BWgrmQzPITGZGWspgUZWblqvGtaa8ZkGK6awiU69mj1VbzuTuWgn Ql4SiByF36mp81DU7LU2eY2Rf0OmabWbTsiAJS5GXJ26ERWzwQWD32tjDOycvI5aJ2dvry7p AsMwCIjE1RVWSOP5bDqSHOAr45WiE2cL6uZEuOIWnAnZ0G5KAZdBREa8RSOEfm5CBfgLFtkA VuhIQ7U4laxu0woxD5yurr+Zv+Gr8xxMmEY/UpJm3l0jCe4HFdRpEbfb7qG0RLplUseg3QE6 C4p1Dur7o+k4DvuU5Ztz5x0oaQ5wGaq/g9gIp8pFT7E9DEm6jWq7mMqQ0EC83I2BQ+bthS3/ Y7+r4H8reGtkV5/obfWzJCTb9afVPw7xxx+HyvtrRcJWP5Gtf+Lv6hN9FE+c/ZUW5nSeJPfb FLjfoCUbYOztqXU21kHLDYFXXg8bc2jYLchBVKhS0VJOa8iTRzVpNWmfTCqeYTlnqgkrko2u K+wyqT0mjaNkwv/TgCgwpLRCvQ3QgbvLdlxye9p1Wr1Qp+ev67VW5jyciujmBIci815F/iPV 64yeaMOkK6fXSsXt9Znfq9kjCpOmwSR3w4r+juUjJA8F+HYw3XYfIzIRrrF2eEpdnXmYy5W0 CS0S9dNBoN7s/9f5RaFTBIpiKF0R/wbasm1IC9uMNrbW0Vmw1NjasMa5WWhLZ0mVn/zsWjav 6HLMmnHQ76xlekMd0vP4OI53072zRUZZjDnK2kSjrM0tyvx2ubsAOfYJHieRl+s6uY4i/CEP hinqOKsy+mu1TKYKQfn4Zlimtz4qdc16g8lk7KUidz+2Bx1MMI05czCRaKcFBTjUQPS921tr 5bUNOI9tDNC4rW2odJ/HKNNj5mv68Rfc3LIfL0Xvd7FY5lbiNZbTg7xeSyeAvdF/NhrrCI3y uRWiSjrRY8oGkVPVI3rziHuCCVpKJwq1O51V5ypZSXoibZR+Ad7zx8xJLapPlo9b2sqAGdyR wEMbw93ExKTyUuYvSFrOWo4m6s5i+Gl/b+GpeKu0xr1JOKY/ZR45YMAtyNNyKc2acrl+hPb9 Y7nzbLbVtMntK6urx/XhbWsR/uPWBmJL8xafZnulq4XuESGpvFtEH5/Va431BXsbI77M7mt9 dZy+3Ck4N3fFxWyzQYBYrEeBgL5HXwUITGdfBga6mzQg5Nx1JnCqZCnc3FtPdiN7LJCVlJ+B rVrDfIY5Syup7Ml6zWeCLB9WGmTNssse4AsBy0Ytc1YuXejFZic4kQEkcMeznDQodno2+jP1 C3BTNbEEZKR6tTbzjjAF5kvCV6NOVg1Y7q6fHvRr241yA8Md17bqGFaeHSP/wtwL/rrPMaEd zzH275h1Y/SFUSrzysDagJWJqiO2iNVPLnxJTLs0WOe08+7D4k2HpA4wjew1mLWy9uJLaz92 be0vWFx7/upKc84tdXe8nUteoJn7lN9VO9nXLHge98o5y+3fjfAH1Fiwrwy+MNkZVvk6PKLp eQhde10uxHHMBzGq+hgQ8xo+EMRM2zwQezhD4ff9NRgL2yNU+nLewnQHdZIdzjLI0qZJnk2W Llwga326dq6p4SblHt8UU5ifoqkOQUhPWDbgP2f9EcPU12dX6jVIRRg38S2Ib6QiBjEJnZAC kkIpVCVWI8OWKnsZR8TBh+rF7WQyev7s2d3dXfVmOK1G45tnfW4fP3up/VK919LmT0j1yTHl e05XYt7LDvcv3p2ctc4x1sa3UzJxwcRz2vPUi9zRoBilDZ1pPb8fkfzdjsSkKLNvx6ZJNIR3 aw11Pe3BRnJXsQklPZl2u/Rsvtao3pat7bpYinWW2aIdvYexkyE9TfRYgUjPpPzNOWO3dVXp 4TmAQaO8rkobtfKaWfA3fowS3lVnzXqe9260ErFYmwGzbN7mQSwXLQavXt1caAURfhPAdccY ErJJk3CFPzXF7M6sJfXBQBUVvDu5/J5Ai1TojrEeTOiZtdczxY4JHz1UJSE0bfXnd6RbZfTn gVHJr4Iv0saokUYkUIS/lDOBH1vycizBN8o7dUxHUd5c95L96J//j4wJHZ1NL2aTv/tRqG0L KdjpaBzGZDwUDkYR3vieJFeLVcUxJTT2C1HSShm1mph/G21HYv2yxsHfghh1DQGnc3d98k2C A9GKC1BqjweMk6sj4rsiAS6kSI4gQzVmKyWdfV6b/GJo12iIXUcMBVUyqbl82NIzlkG69CCe uYyRvVxmGfxI6EMsHUjC+EFsfy5CCkcrGc0TKZu10U8B8Mt0iK4fI8rliUsvcrbPfnRDM73G l9B6TaP0selWMAjUM3Y/gcncrp+2c2ft6HCXlkT48nIvzdApL+3IGr/CkXqAQTFCWGlf1HAe dDpjMmTvZvfF5tZJRRQbScHv52eHzSK+4MT8FIwOiFyqw9MnwrrguBrz9ryDu0VbQQnO5gxv +7iauxNuKPus7cC+2GqRldxshJCYh7Y+Jcof5PRZ9e7cpTu3sgl5n7E57ifM/02ToUgDQNJu KWjeoyaTmI7rPW7OqlkmNxU9pWsY0PYRO7vkdGbVsLzt8SQahww54gvkeV/BfePhiJzD+mwg ZzitPlurewNY9eLhUfMS5nlxUKd/G0WEzZgKCKygSFzL9BSgf7G6hHGxOZohXxxo1k1yednY I94uGaVWelydWT3mQcm3gKYBw+Oa7B48bHjPh1t7WRtw1iFLNBXy5m1sl7MMlH3040RQSn5K 4lMyRjWzOpt7v1yfkTnY5tLtrqzO9s9yboTzRUfPyX7icuH4bAE4Zv45wQJBM8Z/LKaxP3JR y3KqRKbUfpurGY2mrKNDE1q/0dmMRsO8RgZHew2feHMsppd0aZdl0x9lLm/PTQFVSfdz5XTk oppias3Qk1ehyGbh6JvV/OFinSML4aEAbzymaPOU0A6z2AKI3wBYD9mrh1J3qVfNQ2QS5CVf W/o5huit87Oj1v7F6yvM+pecukZSQtl8U33ZvmLCCDS3c5oBVHqLd3sQXPfvHcKIk3RMe/V8 HzwbHbU1Yfk5e1LJgTTqLHTCGEXKcbtO/zYAcv6G2KYTqZ8l9NffJEEVVvXhAVq58F+gDrRt ebqdPn3TTq6AbTd1G5LPv9/4pbFfs/NKjVAxhoBlf9KlkvT9q6QSKtSK6a3R2P0rbk3lkVtT ecDWYLiZpRm7UsrblUplkV2xZEcjGD0W+5sUfXQBs3E26JdfkugEozUsedNFd5FkT2ZhPCF9 B79JxAgVclbMhHQmiWjePged82PBPARey8J9c3Dog3AnB2LVY+UjCMKrxZTTD2/WopddQ5EB PXMbi4tfi3QnlbxOXCiSBVCYpIrnSjTzeEvp7Ttztm+YJl+S5bgwpDx82afn9cHWnAydJeyK bAHty9mlE4gZahfLac7FTAaHJIHsIBoC4ephSBygaUj+iDWK+p0QM7Z2xKaW1Nqxn1grS1BM g03RzjRnOgWsxOZcxVxewOvVSTtYVLgd7ttoYhuwTjnDqMCBaky3WxF/Ns4ymu9w4lo1ub+j mlv8d1hmj9g1G7jNXseR4HN37eSMIyhZOruUF8hMJg8Yk2IxpQbOEWUyh/ZJOyMToe8Oo8Fj vKUgkzAASgausAD8KQaDhJvuijYY1lAy5pHsgR7nyAv7Egg5UhrvsjLLQmmftMzJL4RBtJal BVNkTCB10rduEVxiuoNlJbtzvfeIwwKmSqshkoAgUqU4XlU4TitsWD1fAdM8eX2mz8lOA8cQ KuFNoO5KXoFaCBDdSF4yEqe18NGWhzzG7LEm1l6HGgBvxiHa109cekd5NKhcHJoPWcLyAGCc 45VYVe7WDnrD3mA6cIQrXmpXiYfZBNbMT1X5K3USwRY6xaXOJDL+SIVO1iLZmZc28VKuuHUe MHvAEuZh/rjmoR8ojT3KSdRBC3IZ1miUhkr74lN3M/AUGSMviqykn4SKN8+Nk627/WnpIKY8 Me0QjKieZubmG+M4pX5KbLY3qK/Xy40dDImxYaJVKXWL2TiHEheRXHJhmeQFQmFAoumE8qLS HRu3Vac3xu0b3xdZt4c+sK8P3l6c1zkOBExsQI8+XcURA9Rd4D2skFgtIhq1I3nJWWvY6U26 w7jaRmIvK/XyWOt9cwyIXZJi3jadBL9O+7Jx2GKl+qqQk6wZuFCQmoLzhpp53BRtlewpeTaO ksGfT+4fHPDZt9X0vCLdJciozte5G6HbmucMOgoMnom+7wzpl6S3UpcNN/pHjfCd/kKe8gQf wUAUVabmC1MX/nC8or3uMK9EpBNLwofCQRBzMlAAKeJqe7FokdAOedQPJhgmJ5ZHPDlP1jlp 81tufj8KWWHPNc0gOCHyOA/6d8F9jJq2m7HFlTC9osqVJVoHb94WLoGKXDaKSRnIU7ozH5wu h2Ys9JR8WyxssOe7gV4amRP/+1NCl00D+EVe/eciOKn8Y6V9Df85BZKFhtGwUvldhZO2fUVO b8LRX/QeeOZXsDfKfNjby9CIiQQwv/U3ua1fX85v/TK38QJDv8wd+nSBoV/kNl5g6Bd7Gbq9 1I4bnqT9/2/tSpvaOLboZ/wrBr8ykZBEtLEqkCJGJlRkTAwk5NM8GUmgWEjKjGSkIv7v7669 zCKw61FlS+rp7un19u3ue88B9SbR3qVn2js77XpuWre1s9Me5SZ99rVHua/tPPvan3KTPvta buXAdR5OXHPjyM+7qcdFzgX74d8vgPpJRsy8oK8jpkqp3kwB/dyiPEsg+RDeZyIM78uxsAlk H/ca3Yk9Hw/jWS+ZhQD1+IH92d+gzUIgFRMJXLCgO9U9dQpwcULI/SOhpV8xJBrtciNESVAA Kbz9+DPqTpXyfTJOo2CQtx7mwC7UoDaFs0lIWSYhVVgz2zSAGBQpDolGIXiIxVeFA3CjoQgq LSd481DxLwJIYmLNPWgMy4fOiUqcO3qLBn7VdZfIl8ATs1l5mECOimyPW8vNger1g6grCHIU iS1UaOeiF4+JZ6CLS9fUySSpvoOmCy7hhqvFbIK8p4bZxGabziJ1dkw05njySH4s3IjkJERN RUXeHKCvItu/tE9AzT/GWzF2EyrAw2LliAoYPky+kEdEVXxKdhrEC1bfae4bF58b2HyfnV9B wkU5GIESEHLaBednHy+9x0t+7J6VFzbIxFwAcPj4B3F/tJvRUccLNd462hhqQy2nJbhWO13P rqlO3NSI3GDHE3aC4hsBWn+73GEVQo7GPtv82L687lzRQgyqzW3/QR5g57I2T2DTW9JuOw3u 2t2GB+n71XHMym8JPkWAgYxSkfbGeCxmGsatrdMwXqWzssitvbqpUm0hDRqHbASnF+/D6wvx W9X8RM6SdeB8GurPVq4UBjkxcaUw/36BFE5GzJbCdWLR5Q9tZrT3EEA4JKWxvypHzg916/0D Kaxl3ssjdEPuTXDvgCccrKclDVvLAQzy9mn7I25ekSg7KHhvEsAQtP4sZadP7k/ykpNp+3PF 1EFMlnDVZrlWRVu4ZrnecEHRb3vYIjdv0URkDHsRhxaMQL9/h1d0Id/fDbh3Rbgt2yMe8YVZ cD+8uw+2kH2qiFaTk6iHwH39L0OYMYqD5nBc+om3Ar57zk1oqHfwcq4foUnEeBkMRt07Ii35 cN6+Obu8Qoyo9x9OWGsipXoSmZTX57+df/jz3I+g4NBrRnLKCNn0h4vfxC4NE1FtheqIi2Sb 0OvY+zIQoO16kW5cyyZyUUibXJwck0/JspsK2TrkUbT0QxsbgYRzp+HTFY+dSM/GcuP6kaU+ F8rvnpvKT3ZDUv+5JKIPruUe5to8C9pOeBRog1/6IisO16wXMuWh+UJ3Z22/qRvF7197xx8W niAp6rq9aiAlRA9N0xrJrm2D+r5m6XfZfomnCGx1J0jM3p/h5v1L36gJBTzUe+jObsmoiFGy CJ+3N4w/kwg2RWOwFkbseehGn0FyqKxWkmCpqGmb9YToVImUycd73nZ7K1uSaVkctkg5Ynrb Ob78NTxpX4F6gpggFPHdfIzORNqgqK3krTFoX+wsMfTTgNSCJKw1D2o7B9WkLa4bLxfPs7aH ALX4Uav62nMcfgrhq+rQaQARxg8JCteItYL/mH4G2f0Q1YxQfQkim0ye7L0EH6OAelBRxr9K NB9XWDxWDE6diwGOsNF9iwQuSidnhvrMNJp8GfYsFvGHSwfwLhNM/CVZ0CCEudjrR8MvZMiE V0v2/IYYdfgN/uWIizG9RXLZw12BjiF8TK1+CNX34D6oZxDOH/2yGg11y3I4CDYxvULFUiXC wbjIjJzlYOOWDt3hS3+B9uYbn+E9xFKK/VEsWvTkJxdIuXP88bRtxD1GDemImVPzd+rWlssZ 6VJI4U5K8BmUaAqE1Dhuua/RjLc6k8cLduvFoK3eIwScQLmv1KM8leJXWJv9JBiSmcYW2nkP B654k5PKeZdJlvs2apat3+fdnlM8ysaEldzMNdRrSWJU6rT1Dged9qy5Gh5fR6RnxAoPTbhI iCAbJzg8ne7wzYEtyEhGoQXjoZKZD+09/fhvLCLHM5lqrERlL7tjPOMjrlLcbqLGGCCLHIHd ou2etds28ytVC4JtpJfaHrN4onag+00kFyq3tl4yShLFDIJngYniLO/eYMVfErMo/r6UvvVa y0/JSBtacrmp8Lqm6Azgrz6xVbO6W0U+xVKzivTru/7CAB/hFxQCHvKRK+EqI4sQy1KAduz2 p4AfJRcQR2IoztSqttecM9ofpH8iVwtNyy+wHsVVAzUXzz+lor3xoznlaSbKkygO0dZlR1iB UWWbhzU7f6xw+bDkTOqe9RQLbNByzMbJnARf7zRRqe+cXV64Nn7SFfLLtE2nrMb2ph06znHn 6swELtMFen4VeIsWmtacn3Tawb0Q+HlHQ+JD6oWJLz6P0v1dpuuu7u2WldMPdI9L0jVQRh/H 70CLktOAwSyUhVkPBVTaYh2gKuiG/VArBxCRRbUgF0Mgy7EOTZnNWJTrZO05/arM65Q5LcKa dd3Ler4q67pmDd8bOEqxYCXKRAjMEfMcyQqgafas1pBVEioIqQmwMrAooPMhdpAbTwKIxu1Y 9D0NNI1jYqJCGOIKiDNoeocUgGhHs9sQNWYeVR1B8aJnh+Yh1/52Ve3dkxx6la/AZFWywbU0 nS4S0havkS4fhBDmTGl1XIllpSePzJWFJzas+i5ti3bqO3p09qRsk+NygMzf/ShqJdkpB724 P0sB+bBvUisLbVkf5ZFmqivkoTm29p8Xp4YEc4AnphK/cjQcD3q2Mvs1rszuvkdwQadtUUQX iX9+uO6cEEZTnt4p5kzdIH4gpG0ue2qhf4ZZsMab2pJlZLNI07VUuEXIcwpi+diovYvJh/Bu EJEI+INgszZS7s5tgTSn7t5NAuyubCeo7h80agfb+4ndWypm9gHh3j6jIZX4m5hUPCU8YsmA kZ0K6XKp/Z76wvXSYUqLiqcYnbTfHV93rsJfP1x/PIVN7CVsYjvHf4kdnTQfZgTK2i1otveT eXQ36iIJjDKv4Ug4v37/C523/GEiCF+gyIskaqChFz5k4/rbmfphp3Jouah51eAnkxYpFvU7 HglDibnTCxrKwCWxIJfEmtVXxVa150Spt6p0MMdCqRhyHZnPTcpkg2RdETCMWk5O5Rwgck0r J+IGwvxd58PxVXah16TIFCVkGvNVJWc6k8McEyoo8cqMbLmeb4f8oWY4/LKnvyR3LURp1trC EJY0nlgRtoD+LBBe+sfwI7zl6uyPdjmQDgnE3CW+nzzaAW3JDsVMJXfG34kvtzvpTZidzbWg 1jhobB80q8l5nxE5++imSfOeP5jmhBSsxV2oRI4svWMkKyx7y8lmNEDeci/oMR3UxyCm2HQN fpQ7kgdUxpMyWkISmQcoS8O7h278Wa/13PxB2IdcEPyG728lpNLsYVKGXB8mer/Daxrpee+7 w/HbyXgGEgI0B/5i1ix0NqQcIR19rB9SDxoJNw7v+ClaYc6jEN7BP0DZwQXUPDCxkOyaf0iT ChRkOr9vzULKPCwThWQZax0OxyEhUdtLTmJvXeADGOYiOPWoTvrb9DW3Kvdon/O0fJ9OwulL UkLrU4dSNzqFwahFpOu6naJbkO1N/h9xMiYQTcOLRQMM7Sy05ilrsPtVYtDYr7pnXgkW6ZQG gIMk0WY/0i37q1V7aeV6KiSSyk6n6C8t69qAzmiptVwOY6uqPKW1ljTlbYZmk817y1PAEt76 Jx+rOW8zC4tLXMWtm0QqBjLRNuCz5QLKauXRgybJnOsVjwg23EzMsQIieMqYPzTzoCSlSpDb msHojCk7oX/mYPp+IJy0dqTyAE8y2n5zjnKpsnoC0FuYX1vmFE/7MUkysnYlpqxSzbu/TRy4 VGwnYH5oh4iOSh6brPaQYWRfGZt7gLugaPdJDu/u2SA4nX0uicEGmm7Q3Thz7d7NPocPIFzD IfLMWWKcT32COej3ys+vfvcZq99L8ENSkfMVXzLc2DP7/qy/9JL3opiPL44pC2R2zKwls5Uk PF0R2bkTTC+nNAxdE2xtOYK1YU45uU5o+SZmN6cKv8PGpbl9+dAfzz01hgOkY+p087R3sL13 0NxL9qIXM1eBgc0jKjDwseN3YjFT7rNLAdTZReyLQj4+LoCevDmeTY2UY+YJ3qa4xqwmg6If de7FvU5Hzuh/ouZTtSWwW+1FiJs3UCdDhI0KNnvTJX4x0UhhsGZIzSoZSjWrzYSUCEBVH83j exDqnEPlSDJOHN660pzq8RNLgrn+8PDB14MsHndbV2efDi3q7ZKZnt5/umFS6inUDs7NZq2Z nJxoTUc+FFGE5kBdg64S30aT0QjBkSDw0xD3/mjTb1XZeEIWe05emvSOPPGj4d1d37gzm/Zw dOExrjawAGifvYgxHWto5+zK3FyKdE4V/MdVC/6P5Zi+uBSpbYsOmK/50z5j/5LekeSaNS1e uHup1Rr7tDTWjHWgS6FAzOjkSjKNJtN+NFsaUneZYxhOaPq0QG3qN7030FMM2RTSAJ7OIlSO QnFvRJPBi/bbi5NOeHZ+0r6RQwuZJIn3hlF/OlqGEzqGLkoVtnfIEAm+bONBtBnrmWnLsIDe dnGtXZV1EKMrQDzxTlbXA61e5QjmDuK4JfkWRHotZITSoYfMELUTrZjLVIpayIoruq/cH5g0 Vx+P37brQeF1EPzJbj7Bm5607xtGGY9fJ3fhkpZ6UihRzZW1UKMWnBRMR2EYwVlE4ZGIlo30 xqAAsTJKbmeHTajXe4l2cFgkxtoW2fV3o2c1wevp2WunGcZeM4ylGUovboax2wx6DpEzlniK G/YOFe3nZx1j15SZEq2aaPDWyS6nRJ96dHs8Q6ba5bQfdvHbobHamnUjIvSER8bO5ecgXj58 mpC95YIT6DJVDrgEbjKT7mBVOi9FK3MilzLGBre5QxnFU97MH7IIDjtnyAMKu4Gi1dhxF8xw 9NwqO2xbCF+cKZ3gGAheOUxFSHz7GAf/zIczdJE+HsVQDbZEwi5HWxfQrSNzmv2yifqtk5RG Z41G5yVBpT/605RMbi41p/PJbDhYykjlZv6OWfoN8zJ/Jr5wBubXz87B1XUsfd8UNCYAnMrW Lz0PvVKeTma8p4K6velBMdbdqZmTXbG4+jYh6fKxeLHPx+JFTh972zT44WMn4fVxU6v9eHnf H4k3hnHV+2bcRIGfzHb9MBZzoH6Hp1e/8U5vf79RbkKF6vt7qiownd+ZddR9GPZ60Ez/zGFs 9CN1a2DfBRwWW7VtHAhGPWT2ZSVHTmP5kR8pO0DISCujDvrYF0JANlZh0MQ5sfr+EFuAbEZJ JQpNkANlTPY3AvA9kliAfL8MYzRk/AQNKrgKDI2VBzkBqnw21mdFQIsuxeeeSvxf/zLwB3ZQ jgNmRP6Lfe7VptLgf1FlxA/A+l7X1FLOHiu5yF6uOVzV1MS576+oVb6iAqSZh7kE5eQV5iIV slQuYryp7kfofsleLaATLQ3C14hcKA0IAXP2zae9LsmLJYEiDtViCqoSd9H+UnWzBOYlGwny NeJDn+ws0ClZ/Ds97r+FAxWz1O/JCy5dnVDiLR2AHZPYsb0wx2P4t8zAFQIZOVaPERNHQHac B3La55ex4uR4lGAs/K7SZpS09HxJK1klFUfR+axvbDQDBAYYjmnQTmhKbiGxI78HeuQWBAE8 Hy3lDYpyaXrIOIzolfDCFMGUppWIOHdiJhutZYoqE2UIkk02IyB9Hu/7QuNuZpjFEUQfiWEP t6tSWoOTZ0tLeS4sjpFTRmwlf7N0czUYdfGYQCYMy73NAW2G2My3USs3mojyDzK07m7LF+GA jxgGri75RCCB3ux7BIFH1HMuSS4HlvX6GC3Kk6iLHEVw9d2uJTc87kyYUbPhqEzKbveOZ6rM asQNIc1DDbk5P2+QbcsAdJ7Jo0Iitss8mcrqzaHLMbbyuhIUBHirKCnqsGRTWUhIbSCvocT2 Hhrjt35/anQZagTEoJ3Zcc/piHl5vBRPLDzyYMcWd8Uh9w+BzlonEAQ6DIQE4RSXXXhBochM Eky+ljIaEUOZVvZTa22yljiTk3Rl74bOiWTHgmt/xS+BNvgFtKHPKJ48/nEXd1J63lh7ppaU DVMEbWd9k9LA5b5HMC59gVFay7hf6TjdabNXB6NPmLutORK+Tx75aPG/rF/8oCJAxJepU8pc pdpKPxFhVLMUeLlEoLonwkGaHqNOCa9ggukMJIdYLG6lgvDkj6hT3d3PqEFh+YRVcTI225g1 90Sr6h878f8bjv6/5h1arYxuD6zWzCWJtUtt1Pb32V1hu27OjJObM7Z2NMfd36hRsQYTpATs bHJ3N+rDfEIeYJhwIXFBoiEB7y0vrj4GA0azMHHEkL9eZzPFRm1XryuedGfKiW/Ck7PLi87x X87e9On7FELnLEBLilomjlOzSgyK/nmuwbxfe6J299sTAm5+gSwyC8tbH9o77ELf7MPmAWnz 3MMwYzilNlPuOpNiSkPjFnbbLGVecsqdY9hVDBWMjJNc5l/pVc6dqrkl9lK2/JvQ9G0q3Yv+ +69zN1mqcTWSAxgjCvaBzdC5gZSz2syUMuwlvTnj5jrRTJXdMZ8JytQQsR7SPpPwd7YGLD1e /Q+3vkbDMAsEAA== --------------030309010703050808000508-- From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 22 17:25:25 2012 Received: (at 9000-done) by debbugs.gnu.org; 22 Jun 2012 21:25:25 +0000 Received: from localhost ([127.0.0.1]:53250 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiBM4-0004P6-QR for submit@debbugs.gnu.org; Fri, 22 Jun 2012 17:25:25 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:37350) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiBM3-0004Oz-66 for 9000-done@debbugs.gnu.org; Fri, 22 Jun 2012 17:25:24 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id D3ACCA60096; Fri, 22 Jun 2012 14:21:41 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id ghjQZrP3UHMH; Fri, 22 Jun 2012 14:21:41 -0700 (PDT) Received: from [192.168.1.10] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 73EC8A60088; Fri, 22 Jun 2012 14:21:41 -0700 (PDT) Message-ID: <4FE4E1EE.7060305@cs.ucla.edu> Date: Fri, 22 Jun 2012 14:21:50 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:13.0) Gecko/20120615 Thunderbird/13.0.1 MIME-Version: 1.0 To: 9000-done@debbugs.gnu.org Subject: patch for higher-resolution time stamps Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 9000-done Cc: Eli Zaretskii X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.9 (-) No further comment and the patch seems ripe so I installed it into the trunk as bzr 108687 and am marking this bug as done. I'll CC: this to Eli as it affects the Microsoft ports. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 04:44:09 2012 Received: (at 9000) by debbugs.gnu.org; 23 Jun 2012 08:44:09 +0000 Received: from localhost ([127.0.0.1]:53510 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiLwv-0003Wj-Ct for submit@debbugs.gnu.org; Sat, 23 Jun 2012 04:44:09 -0400 Received: from mtaout20.012.net.il ([80.179.55.166]:62491) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiLwr-0003WZ-Ex for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 04:44:06 -0400 Received: from conversion-daemon.a-mtaout20.012.net.il by a-mtaout20.012.net.il (HyperSendmail v2007.08) id <0M6200K00AIR0V00@a-mtaout20.012.net.il> for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 11:39:36 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout20.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M6200KETAQ00M20@a-mtaout20.012.net.il>; Sat, 23 Jun 2012 11:39:36 +0300 (IDT) Date: Sat, 23 Jun 2012 11:39:40 +0300 From: Eli Zaretskii Subject: Re: patch for higher-resolution time stamps In-reply-to: <4FE4E1EE.7060305@cs.ucla.edu> X-012-Sender: halo1@inter.net.il To: Paul Eggert Message-id: <83vciibewj.fsf@gnu.org> References: <4FE4E1EE.7060305@cs.ucla.edu> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Eli Zaretskii List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.2 (-) > Date: Fri, 22 Jun 2012 14:21:50 -0700 > From: Paul Eggert > CC: Eli Zaretskii > > No further comment and the patch seems ripe > so I installed it into the trunk as bzr 108687 > and am marking this bug as done. I'll CC: this > to Eli as it affects the Microsoft ports. This badly broke the MS-Windows build. I'm working on fixing it. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 06:52:29 2012 Received: (at 9000) by debbugs.gnu.org; 23 Jun 2012 10:52:29 +0000 Received: from localhost ([127.0.0.1]:53564 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiNx6-0006mH-9L for submit@debbugs.gnu.org; Sat, 23 Jun 2012 06:52:28 -0400 Received: from mtaout20.012.net.il ([80.179.55.166]:54436) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiNx1-0006m7-UZ for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 06:52:25 -0400 Received: from conversion-daemon.a-mtaout20.012.net.il by a-mtaout20.012.net.il (HyperSendmail v2007.08) id <0M6200L00GFQ1Y00@a-mtaout20.012.net.il> for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 13:48:38 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout20.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M6200KNWGP1K3F0@a-mtaout20.012.net.il>; Sat, 23 Jun 2012 13:48:37 +0300 (IDT) Date: Sat, 23 Jun 2012 13:48:41 +0300 From: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps In-reply-to: <83vciibewj.fsf@gnu.org> X-012-Sender: halo1@inter.net.il To: eggert@cs.ucla.edu Message-id: <83txy2b8xi.fsf@gnu.org> References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Eli Zaretskii List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.2 (-) > Date: Sat, 23 Jun 2012 11:39:40 +0300 > From: Eli Zaretskii > Cc: 9000@debbugs.gnu.org > > > Date: Fri, 22 Jun 2012 14:21:50 -0700 > > From: Paul Eggert > > CC: Eli Zaretskii > > > > No further comment and the patch seems ripe > > so I installed it into the trunk as bzr 108687 > > and am marking this bug as done. I'll CC: this > > to Eli as it affects the Microsoft ports. > > This badly broke the MS-Windows build. I'm working on fixing it. I think I fixed this in revision 108698, MS-Windows users please see if there are any leftovers. In particular, any feature that uses system time or file time or 'select' (i.e. subprocesses) is suspect. I only did some minimal testing. Paul, please note that I needed changes in 3 gnulib headers: utimens.h, timespec.h, and stat-time.h. The change is to include sys/time.h, because that's where the Windows build defines 'struct timespec' (time.h cannot be used for that). I hope you can make these changes in upstream gnulib. I'm OK with any other solution to this conundrum, which will be compatible with the following conditions: . do not assume that 'struct timespec' is defined on time.h, or on any other MS-Windows system header . do not use gnulib's time.h (as that requires Sed to edit time.in.h) It is OK to add headers to Emacs's nt/inc/ directory in order to solve this, provided that they do not shadow system headers (since MSVC does not have include_next or its equivalent). Finally, I see compiler warnings due to the changes in revno 108687: dispnew.c: In function `Fsleep_for': dispnew.c:5960: warning: comparison is always true due to limited range of data type dispnew.c: In function `sit_for': dispnew.c:6008: warning: comparison is always true due to limited range of data type keyboard.c: In function `kbd_buffer_get_event': keyboard.c:3861: warning: comparison is always true due to limited range of data type process.c: In function `Faccept_process_output': process.c:3999: warning: comparison is always true due to limited range of data type They all come from snippets such as this one: min (EMACS_SECS (t), INTMAX_MAX) I think any host with a signed 32-bit time_t will see this warning. Can this annoyance be fixed, please? From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 14:01:19 2012 Received: (at 9000) by debbugs.gnu.org; 23 Jun 2012 18:01:19 +0000 Received: from localhost ([127.0.0.1]:54224 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiUe7-0001rj-D4 for submit@debbugs.gnu.org; Sat, 23 Jun 2012 14:01:19 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:47175) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiUe5-0001rc-Dd for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 14:01:18 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 9CA71A6010B; Sat, 23 Jun 2012 10:57:31 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id q4HcKd1rMh2W; Sat, 23 Jun 2012 10:57:30 -0700 (PDT) Received: from [192.168.1.10] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id D54BCA60002; Sat, 23 Jun 2012 10:57:30 -0700 (PDT) Message-ID: <4FE6038B.9000906@cs.ucla.edu> Date: Sat, 23 Jun 2012 10:57:31 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:13.0) Gecko/20120615 Thunderbird/13.0.1 MIME-Version: 1.0 To: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> In-Reply-To: <83txy2b8xi.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.9 (-) On 06/23/2012 03:48 AM, Eli Zaretskii wrote: > dispnew.c:5960: warning: comparison is always true due to limited range of data type > ... > I think any host with a signed 32-bit time_t will see this warning. I don't observe the problem on either Fedora 15 or Ubuntu 12.04 compiled for x86 (these used signed 32-bit time_t). I tried both gcc 4.6.3 and gcc 4.7.1 (which is the latest stable version). If memory serves, warnings like that occur only with older GCCs and are harmless, and the GCC folks fixed the bogus warnings after the gnulib folks complained about them. Maybe time to upgrade your GCC? From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 14:59:27 2012 Received: (at 9000) by debbugs.gnu.org; 23 Jun 2012 18:59:27 +0000 Received: from localhost ([127.0.0.1]:54262 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiVYN-0003A2-2W for submit@debbugs.gnu.org; Sat, 23 Jun 2012 14:59:27 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:48937) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiVYK-00039u-Et for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 14:59:26 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 754B2A60111; Sat, 23 Jun 2012 11:55:38 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id DV4RjIItIw2Y; Sat, 23 Jun 2012 11:55:37 -0700 (PDT) Received: from [192.168.1.10] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 7949BA60002; Sat, 23 Jun 2012 11:55:37 -0700 (PDT) Message-ID: <4FE61129.10004@cs.ucla.edu> Date: Sat, 23 Jun 2012 11:55:37 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:13.0) Gecko/20120615 Thunderbird/13.0.1 MIME-Version: 1.0 To: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> In-Reply-To: <83txy2b8xi.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.9 (-) On 06/23/2012 03:48 AM, Eli Zaretskii wrote: > . do not assume that 'struct timespec' is defined on time.h, or on > any other MS-Windows system header > . do not use gnulib's time.h (as that requires Sed to edit time.in.h) OK, thanks, here's a proposed patch to do that. I'd rather leave gnulib alone, since struct timeval has nothing to do with sys/time.h in POSIX. === modified file 'ChangeLog' --- ChangeLog 2012-06-23 17:25:56 +0000 +++ ChangeLog 2012-06-23 18:51:45 +0000 @@ -1,5 +1,10 @@ 2012-06-23 Paul Eggert + Improve port of struct timespec to MS-Windows. + * lib/stat-time.h, lib/timespec.h, lib/utimens.h: + Do not include sys/time.h. This reverts the most recent change, + so that these files stay in step with gnulib. + Merge from gnulib. * m4/getopt.m4: Copy new version from gnulib, incorporating: getopt-gnu: Handle suboptimal getopt_long's abbreviation handling. === modified file 'lib/stat-time.h' --- lib/stat-time.h 2012-06-23 10:22:59 +0000 +++ lib/stat-time.h 2012-06-23 18:51:45 +0000 @@ -22,7 +22,6 @@ #include #include -#include /* STAT_TIMESPEC (ST, ST_XTIM) is the ST_XTIM member for *ST of type struct timespec, if available. If not, then STAT_TIMESPEC_NS (ST, === modified file 'lib/timespec.h' --- lib/timespec.h 2012-06-23 10:22:59 +0000 +++ lib/timespec.h 2012-06-23 18:51:45 +0000 @@ -20,7 +20,6 @@ # define TIMESPEC_H # include -# include /* Return negative, zero, positive if A < B, A == B, A > B, respectively. === modified file 'lib/utimens.h' --- lib/utimens.h 2012-06-23 10:22:59 +0000 +++ lib/utimens.h 2012-06-23 18:51:45 +0000 @@ -1,5 +1,4 @@ #include -#include int fdutimens (int, char const *, struct timespec const [2]); int utimens (char const *, struct timespec const [2]); int lutimens (char const *, struct timespec const [2]); === modified file 'nt/ChangeLog' --- nt/ChangeLog 2012-06-23 10:22:59 +0000 +++ nt/ChangeLog 2012-06-23 18:51:45 +0000 @@ -1,3 +1,8 @@ +2012-06-23 Paul Eggert + + Improve port of struct timespec to MS-Windows. + * inc/sys/time.h (struct timespec): Remove, undoing previous change. + 2012-06-23 Eli Zaretskii Fix the MS-Windows build broken by revno 108687. === modified file 'nt/inc/sys/time.h' --- nt/inc/sys/time.h 2012-06-23 10:22:59 +0000 +++ nt/inc/sys/time.h 2012-06-23 18:51:45 +0000 @@ -17,15 +17,8 @@ int tz_dsttime; /* type of dst correction */ }; -struct timespec -{ - time_t tv_sec; /* seconds */ - long int tv_nsec; /* nanoseconds */ -}; - void gettimeofday (struct timeval *, struct timezone *); #endif /* SYS_TIME_H_INCLUDED */ /* end of sys/time.h */ - === modified file 'src/ChangeLog' --- src/ChangeLog 2012-06-23 16:56:47 +0000 +++ src/ChangeLog 2012-06-23 18:51:45 +0000 @@ -1,3 +1,8 @@ +2012-06-23 Paul Eggert + + Improve port of struct timespec to MS-Windows. + * s/ms-w32.h (struct timespec) [_MSC_VER]: New decl. + 2012-06-23 Juanma Barranquero * w32.c (ltime): Add return type and declare static. === modified file 'src/s/ms-w32.h' --- src/s/ms-w32.h 2012-06-23 10:22:59 +0000 +++ src/s/ms-w32.h 2012-06-23 18:54:35 +0000 @@ -296,6 +296,15 @@ #define utime _utime #endif +#ifdef _MSC_VER +/* MSVC does not define struct timespec in . */ +struct timespec +{ + time_t tv_sec; /* seconds */ + long int tv_nsec; /* nanoseconds */ +}; +#endif + /* This is hacky, but is necessary to avoid warnings about macro redefinitions using the SDK compilers. */ #ifndef __STDC__ From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 15:12:13 2012 Received: (at 9000) by debbugs.gnu.org; 23 Jun 2012 19:12:13 +0000 Received: from localhost ([127.0.0.1]:54267 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiVkj-0003Rb-Fz for submit@debbugs.gnu.org; Sat, 23 Jun 2012 15:12:13 -0400 Received: from mtaout20.012.net.il ([80.179.55.166]:61176) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiVkg-0003RS-Is for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 15:12:12 -0400 Received: from conversion-daemon.a-mtaout20.012.net.il by a-mtaout20.012.net.il (HyperSendmail v2007.08) id <0M63002003SJHI00@a-mtaout20.012.net.il> for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 22:08:23 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout20.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M63002593TZD020@a-mtaout20.012.net.il>; Sat, 23 Jun 2012 22:08:23 +0300 (IDT) Date: Sat, 23 Jun 2012 22:08:27 +0300 From: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps In-reply-to: <4FE61129.10004@cs.ucla.edu> X-012-Sender: halo1@inter.net.il To: Paul Eggert Message-id: <83k3yxc0d0.fsf@gnu.org> References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> <4FE61129.10004@cs.ucla.edu> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Eli Zaretskii List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.2 (-) > Date: Sat, 23 Jun 2012 11:55:37 -0700 > From: Paul Eggert > CC: 9000@debbugs.gnu.org > > === modified file 'src/s/ms-w32.h' > --- src/s/ms-w32.h 2012-06-23 10:22:59 +0000 > +++ src/s/ms-w32.h 2012-06-23 18:54:35 +0000 > @@ -296,6 +296,15 @@ > #define utime _utime > #endif > > +#ifdef _MSC_VER > +/* MSVC does not define struct timespec in . */ > +struct timespec > +{ > + time_t tv_sec; /* seconds */ > + long int tv_nsec; /* nanoseconds */ > +}; > +#endif I don't get it: are you trying to fix only the MSVC build? If not, where are the bits for MinGW? What did I miss? From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 15:13:11 2012 Received: (at 9000) by debbugs.gnu.org; 23 Jun 2012 19:13:11 +0000 Received: from localhost ([127.0.0.1]:54272 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiVle-0003T7-QP for submit@debbugs.gnu.org; Sat, 23 Jun 2012 15:13:11 -0400 Received: from mtaout23.012.net.il ([80.179.55.175]:37626) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiVlc-0003Sy-CT for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 15:13:09 -0400 Received: from conversion-daemon.a-mtaout23.012.net.il by a-mtaout23.012.net.il (HyperSendmail v2007.08) id <0M63002003P6RP00@a-mtaout23.012.net.il> for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 22:09:21 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout23.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M630028V3VLRT10@a-mtaout23.012.net.il>; Sat, 23 Jun 2012 22:09:21 +0300 (IDT) Date: Sat, 23 Jun 2012 22:09:26 +0300 From: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps In-reply-to: <4FE6038B.9000906@cs.ucla.edu> X-012-Sender: halo1@inter.net.il To: Paul Eggert Message-id: <83ipehc0bd.fsf@gnu.org> References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> <4FE6038B.9000906@cs.ucla.edu> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Eli Zaretskii List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.2 (-) > Date: Sat, 23 Jun 2012 10:57:31 -0700 > From: Paul Eggert > CC: 9000@debbugs.gnu.org > > On 06/23/2012 03:48 AM, Eli Zaretskii wrote: > > dispnew.c:5960: warning: comparison is always true due to limited range of data type > > ... > > I think any host with a signed 32-bit time_t will see this warning. > > I don't observe the problem on either Fedora 15 or Ubuntu 12.04 > compiled for x86 (these used signed 32-bit time_t). I tried both > gcc 4.6.3 and gcc 4.7.1 (which is the latest stable version). > > If memory serves, warnings like that occur only with older GCCs and > are harmless, and the GCC folks fixed the bogus warnings after the > gnulib folks complained about them. Maybe time to upgrade your GCC? No, I don't want to upgrade my GCC because of this. Is it possible to fix the cause of the warning instead? From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 15:46:11 2012 Received: (at 9000) by debbugs.gnu.org; 23 Jun 2012 19:46:11 +0000 Received: from localhost ([127.0.0.1]:54296 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiWHb-00050Z-7J for submit@debbugs.gnu.org; Sat, 23 Jun 2012 15:46:11 -0400 Received: from mtaout20.012.net.il ([80.179.55.166]:36133) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiWHY-00050Q-IX for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 15:46:09 -0400 Received: from conversion-daemon.a-mtaout20.012.net.il by a-mtaout20.012.net.il (HyperSendmail v2007.08) id <0M63002005BQWS00@a-mtaout20.012.net.il> for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 22:42:22 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout20.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M63002G05ELG580@a-mtaout20.012.net.il>; Sat, 23 Jun 2012 22:42:22 +0300 (IDT) Date: Sat, 23 Jun 2012 22:42:26 +0300 From: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps In-reply-to: <83ipehc0bd.fsf@gnu.org> X-012-Sender: halo1@inter.net.il To: eggert@cs.ucla.edu Message-id: <83hau1bysd.fsf@gnu.org> References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> <4FE6038B.9000906@cs.ucla.edu> <83ipehc0bd.fsf@gnu.org> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Eli Zaretskii List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.2 (-) > Date: Sat, 23 Jun 2012 22:09:26 +0300 > From: Eli Zaretskii > Cc: 9000@debbugs.gnu.org > > > Date: Sat, 23 Jun 2012 10:57:31 -0700 > > From: Paul Eggert > > CC: 9000@debbugs.gnu.org > > > > On 06/23/2012 03:48 AM, Eli Zaretskii wrote: > > > dispnew.c:5960: warning: comparison is always true due to limited range of data type > > > ... > > > I think any host with a signed 32-bit time_t will see this warning. > > > > I don't observe the problem on either Fedora 15 or Ubuntu 12.04 > > compiled for x86 (these used signed 32-bit time_t). I tried both > > gcc 4.6.3 and gcc 4.7.1 (which is the latest stable version). > > > > If memory serves, warnings like that occur only with older GCCs and > > are harmless, and the GCC folks fixed the bogus warnings after the > > gnulib folks complained about them. Maybe time to upgrade your GCC? > > No, I don't want to upgrade my GCC because of this. Is it possible to > fix the cause of the warning instead? Never mind, I fixed that myself. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 18:38:25 2012 Received: (at 9000) by debbugs.gnu.org; 23 Jun 2012 22:38:25 +0000 Received: from localhost ([127.0.0.1]:54425 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiYyH-0000KR-Lt for submit@debbugs.gnu.org; Sat, 23 Jun 2012 18:38:25 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:55141) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiYyF-0000KJ-Bc for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 18:38:24 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 62CE4A60121; Sat, 23 Jun 2012 15:34:36 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id l0SIttxMFXcr; Sat, 23 Jun 2012 15:34:36 -0700 (PDT) Received: from [192.168.1.10] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 08032A60002; Sat, 23 Jun 2012 15:34:36 -0700 (PDT) Message-ID: <4FE64473.2020600@cs.ucla.edu> Date: Sat, 23 Jun 2012 15:34:27 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:13.0) Gecko/20120615 Thunderbird/13.0.1 MIME-Version: 1.0 To: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> <4FE61129.10004@cs.ucla.edu> <83k3yxc0d0.fsf@gnu.org> In-Reply-To: <83k3yxc0d0.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.9 (-) On 06/23/2012 12:08 PM, Eli Zaretskii wrote: > I don't get it: are you trying to fix only the MSVC build? If not, > where are the bits for MinGW? Sorry, no, I assumed the problem only occurred with MSVC. If it occurs on all Windows platforms, simply remove the "#ifdef _MSC_VER" in question. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 18:49:16 2012 Received: (at 9000) by debbugs.gnu.org; 23 Jun 2012 22:49:16 +0000 Received: from localhost ([127.0.0.1]:54434 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiZ8m-0000ay-Ju for submit@debbugs.gnu.org; Sat, 23 Jun 2012 18:49:16 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:55417) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiZ8j-0000ap-H5 for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 18:49:14 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id E5368A60122; Sat, 23 Jun 2012 15:45:26 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id yrqMqGo18AKp; Sat, 23 Jun 2012 15:45:26 -0700 (PDT) Received: from [192.168.1.10] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 8145FA60002; Sat, 23 Jun 2012 15:45:26 -0700 (PDT) Message-ID: <4FE64706.4030807@cs.ucla.edu> Date: Sat, 23 Jun 2012 15:45:26 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:13.0) Gecko/20120615 Thunderbird/13.0.1 MIME-Version: 1.0 To: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> <4FE6038B.9000906@cs.ucla.edu> <83ipehc0bd.fsf@gnu.org> <83hau1bysd.fsf@gnu.org> In-Reply-To: <83hau1bysd.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.9 (-) On 06/23/2012 12:42 PM, Eli Zaretskii wrote: > Never mind, I fixed that myself. Unfortunately the patch that you installed can break Emacs on hosts where time_t is unsigned, because it assigns time_t values to intmax_t variables, and this does not always work correctly when INTMAX_MAX < TIME_T_MAX. Which version of GCC are you running? What is INTMAX_MAX defined to, on your platform? Does it work to pacify your old GCC if you replace this: intmax_t secs = EMACS_SECS (t); wait_reading_process_output (min (secs, INTMAX_MAX), EMACS_NSECS (t), 0, 0, Qnil, NULL, 0); with this? intmax_t max = INTMAX_MAX; wait_reading_process_output (min (secs, max), EMACS_NSECS (t), 0, 0, Qnil, NULL, 0); Or how about this? static intmax_t intmax_max = INTMAX_MAX; ... wait_reading_process_output (min (secs, intmax_max), EMACS_NSECS (t), 0, 0, Qnil, NULL, 0); We could make this latter rewrite conditional only for older GCC versions. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 23 23:01:45 2012 Received: (at 9000) by debbugs.gnu.org; 24 Jun 2012 03:01:45 +0000 Received: from localhost ([127.0.0.1]:54549 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sid57-00068e-1c for submit@debbugs.gnu.org; Sat, 23 Jun 2012 23:01:45 -0400 Received: from mtaout21.012.net.il ([80.179.55.169]:38674) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sid53-00068V-De for 9000@debbugs.gnu.org; Sat, 23 Jun 2012 23:01:42 -0400 Received: from conversion-daemon.a-mtaout21.012.net.il by a-mtaout21.012.net.il (HyperSendmail v2007.08) id <0M6300J00PCVME00@a-mtaout21.012.net.il> for 9000@debbugs.gnu.org; Sun, 24 Jun 2012 05:57:52 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout21.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M6300JPXPKGHM70@a-mtaout21.012.net.il>; Sun, 24 Jun 2012 05:57:52 +0300 (IDT) Date: Sun, 24 Jun 2012 05:57:57 +0300 From: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps In-reply-to: <4FE64706.4030807@cs.ucla.edu> X-012-Sender: halo1@inter.net.il To: Paul Eggert Message-id: <83fw9lbemi.fsf@gnu.org> References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> <4FE6038B.9000906@cs.ucla.edu> <83ipehc0bd.fsf@gnu.org> <83hau1bysd.fsf@gnu.org> <4FE64706.4030807@cs.ucla.edu> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Eli Zaretskii List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.2 (-) > Date: Sat, 23 Jun 2012 15:45:26 -0700 > From: Paul Eggert > CC: 9000@debbugs.gnu.org > > On 06/23/2012 12:42 PM, Eli Zaretskii wrote: > > Never mind, I fixed that myself. > > Unfortunately the patch that you installed can break > Emacs on hosts where time_t is unsigned, because > it assigns time_t values to intmax_t variables, > and this does not always work correctly when > INTMAX_MAX < TIME_T_MAX. We could use (UINTMAX_MAX / 2) instead, would that work? > Which version of GCC are you running? 3.4.2 > What is INTMAX_MAX defined to, on your platform? It is defined to INT64_MAX (i.e., 9223372036854775807LL). The problem is that EMACS_SECS returns a time_t, a 32-bit value, whereas INTMAX_MAX is a 64-bit value. > Does it work to pacify your old GCC if you > replace this: > > intmax_t secs = EMACS_SECS (t); > > wait_reading_process_output (min (secs, INTMAX_MAX), > EMACS_NSECS (t), 0, 0, Qnil, NULL, 0); > > with this? > > intmax_t max = INTMAX_MAX; > > wait_reading_process_output (min (secs, max), > EMACS_NSECS (t), 0, 0, Qnil, NULL, 0); You don't show what is 'secs' in this snippet. The key to avoiding the warning is to have both arguments of 'min' be 64-bit values. From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 24 00:35:35 2012 Received: (at 9000) by debbugs.gnu.org; 24 Jun 2012 04:35:36 +0000 Received: from localhost ([127.0.0.1]:54596 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SieXv-0000Yq-6Z for submit@debbugs.gnu.org; Sun, 24 Jun 2012 00:35:35 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:35936) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SieXr-0000Yh-Na for 9000@debbugs.gnu.org; Sun, 24 Jun 2012 00:35:33 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 62C2DA60131; Sat, 23 Jun 2012 21:31:43 -0700 (PDT) X-Virus-Scanned: amavisd-new at smtp.cs.ucla.edu Received: from smtp.cs.ucla.edu ([127.0.0.1]) by localhost (smtp.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id qxHja2mG8y49; Sat, 23 Jun 2012 21:31:42 -0700 (PDT) Received: from [192.168.1.10] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 4AE7EA6012C; Sat, 23 Jun 2012 21:31:42 -0700 (PDT) Message-ID: <4FE6982A.8090300@cs.ucla.edu> Date: Sat, 23 Jun 2012 21:31:38 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:13.0) Gecko/20120615 Thunderbird/13.0.1 MIME-Version: 1.0 To: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> <4FE6038B.9000906@cs.ucla.edu> <83ipehc0bd.fsf@gnu.org> <83hau1bysd.fsf@gnu.org> <4FE64706.4030807@cs.ucla.edu> <83fw9lbemi.fsf@gnu.org> In-Reply-To: <83fw9lbemi.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.9 (-) On 06/23/2012 07:57 PM, Eli Zaretskii wrote: > We could use (UINTMAX_MAX / 2) instead, would that work? I don't think so, as the buggy compiler would still complain. > The key to avoiding the warning is to have both arguments of 'min' > be 64-bit values. In my experience the width of the constant is irrelevant; what matters is its value. If an obsolete buggy GCC sees "E < C" where E is an integer expression and C is a positive constant that is out of E's type's range, it sometimes proudly reports that it is optimizing the comparison away. These warnings are typically bogus, and this was considered a bug in GCC that was eventually fixed; the warnings certainly are bogus for Emacs. Normally we should not worry about silencing bogus warnings from obsolete compilers, particularly when attempts to silence them are liable to make the code less reliable or readable. I suppose we can make an exception here but I hope this doesn't establish a precedent. I rummaged around our servers and found an old GCC that issues the diagnostic, and installed as trunk bzr 108714 a further patch to silence those particular warnings without introducing a signedness bug. Here's our combined patch: === modified file 'src/ChangeLog' --- src/ChangeLog 2012-06-23 19:28:01 +0000 +++ src/ChangeLog 2012-06-24 04:11:19 +0000 @@ -1,3 +1,22 @@ +2012-06-24 Paul Eggert + + Fix bug when time_t is unsigned and as wide as intmax_t (Bug#9000). + * lisp.h (WAIT_READING_MAX): New macro. + * dispnew.c (Fsleep_for, sit_for): + * keyboard.c (kbd_buffer_get_event): + * process.c (Faccept_process_output): + Use it to avoid bogus compiler warnings with obsolescent GCC versions. + This improves on the previous patch, which introduced a bug + when time_t is unsigned and as wide as intmax_t. + See . + +2012-06-23 Eli Zaretskii + + * dispnew.c (sit_for, Fsleep_for): + * keyboard.c (kbd_buffer_get_event): + * process.c (Faccept_process_output): Avoid compiler warnings when + comparing a 32-bit time_t with a 64-bit INTMAX_MAX. + 2012-06-23 Juanma Barranquero * makefile.w32-in: Update dependencies. === modified file 'src/dispnew.c' --- src/dispnew.c 2012-06-22 21:17:42 +0000 +++ src/dispnew.c 2012-06-24 04:11:19 +0000 @@ -5957,7 +5957,7 @@ if (0 < duration) { EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (duration); - wait_reading_process_output (min (EMACS_SECS (t), INTMAX_MAX), + wait_reading_process_output (min (EMACS_SECS (t), WAIT_READING_MAX), EMACS_NSECS (t), 0, 0, Qnil, NULL, 0); } @@ -6005,7 +6005,7 @@ else { EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (seconds); - sec = min (EMACS_SECS (t), INTMAX_MAX); + sec = min (EMACS_SECS (t), WAIT_READING_MAX); nsec = EMACS_NSECS (t); } } === modified file 'src/keyboard.c' --- src/keyboard.c 2012-06-23 12:39:23 +0000 +++ src/keyboard.c 2012-06-24 04:11:19 +0000 @@ -3859,7 +3859,7 @@ { EMACS_SUB_TIME (duration, *end_time, duration); wait_reading_process_output (min (EMACS_SECS (duration), - INTMAX_MAX), + WAIT_READING_MAX), EMACS_NSECS (duration), -1, 1, Qnil, NULL, 0); } === modified file 'src/lisp.h' --- src/lisp.h 2012-06-22 21:17:42 +0000 +++ src/lisp.h 2012-06-24 04:11:19 +0000 @@ -3249,6 +3249,14 @@ Lisp_Object, struct Lisp_Process *, int); +/* Max value for the first argument of wait_reading_process_output. */ +#if __GNUC__ == 3 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 5) +/* Work around a bug in GCC 3.4.2, known to be fixed in GCC 4.6.3. + The bug merely causes a bogus warning, but the warning is annoying. */ +# define WAIT_READING_MAX min (TYPE_MAXIMUM (time_t), INTMAX_MAX) +#else +# define WAIT_READING_MAX INTMAX_MAX +#endif extern void add_keyboard_wait_descriptor (int); extern void delete_keyboard_wait_descriptor (int); #ifdef HAVE_GPM === modified file 'src/process.c' --- src/process.c 2012-06-22 21:17:42 +0000 +++ src/process.c 2012-06-24 04:11:19 +0000 @@ -3996,7 +3996,7 @@ if (0 < XFLOAT_DATA (seconds)) { EMACS_TIME t = EMACS_TIME_FROM_DOUBLE (XFLOAT_DATA (seconds)); - secs = min (EMACS_SECS (t), INTMAX_MAX); + secs = min (EMACS_SECS (t), WAIT_READING_MAX); nsecs = EMACS_NSECS (t); } } From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 24 13:27:51 2012 Received: (at 9000) by debbugs.gnu.org; 24 Jun 2012 17:27:51 +0000 Received: from localhost ([127.0.0.1]:55360 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiqbH-0002ab-Hf for submit@debbugs.gnu.org; Sun, 24 Jun 2012 13:27:51 -0400 Received: from mtaout20.012.net.il ([80.179.55.166]:47088) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SiqbF-0002aS-AF for 9000@debbugs.gnu.org; Sun, 24 Jun 2012 13:27:50 -0400 Received: from conversion-daemon.a-mtaout20.012.net.il by a-mtaout20.012.net.il (HyperSendmail v2007.08) id <0M6400I00TL4TU00@a-mtaout20.012.net.il> for 9000@debbugs.gnu.org; Sun, 24 Jun 2012 20:23:41 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout20.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M6400I8PTNDLG50@a-mtaout20.012.net.il>; Sun, 24 Jun 2012 20:23:38 +0300 (IDT) Date: Sun, 24 Jun 2012 20:23:44 +0300 From: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps In-reply-to: <4FE64473.2020600@cs.ucla.edu> X-012-Sender: halo1@inter.net.il To: Paul Eggert Message-id: <831ul4bp3z.fsf@gnu.org> References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> <4FE61129.10004@cs.ucla.edu> <83k3yxc0d0.fsf@gnu.org> <4FE64473.2020600@cs.ucla.edu> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Eli Zaretskii List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.2 (-) > Date: Sat, 23 Jun 2012 15:34:27 -0700 > From: Paul Eggert > CC: 9000@debbugs.gnu.org > > On 06/23/2012 12:08 PM, Eli Zaretskii wrote: > > I don't get it: are you trying to fix only the MSVC build? If not, > > where are the bits for MinGW? > > Sorry, no, I assumed the problem only occurred with MSVC. > If it occurs on all Windows platforms, simply remove > the "#ifdef _MSC_VER" in question. OK, done as part of trunk revision 108721. From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 24 15:30:35 2012 Received: (at 9000) by debbugs.gnu.org; 24 Jun 2012 19:30:35 +0000 Received: from localhost ([127.0.0.1]:55452 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SisW3-00069w-Hu for submit@debbugs.gnu.org; Sun, 24 Jun 2012 15:30:35 -0400 Received: from mtaout21.012.net.il ([80.179.55.169]:34623) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SisW0-00069m-8y for 9000@debbugs.gnu.org; Sun, 24 Jun 2012 15:30:33 -0400 Received: from conversion-daemon.a-mtaout21.012.net.il by a-mtaout21.012.net.il (HyperSendmail v2007.08) id <0M6400300YUY1U00@a-mtaout21.012.net.il> for 9000@debbugs.gnu.org; Sun, 24 Jun 2012 22:26:06 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout21.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M6400302ZBI0D70@a-mtaout21.012.net.il>; Sun, 24 Jun 2012 22:26:06 +0300 (IDT) Date: Sun, 24 Jun 2012 22:26:13 +0300 From: Eli Zaretskii Subject: Re: bug#9000: patch for higher-resolution time stamps In-reply-to: <4FE6982A.8090300@cs.ucla.edu> X-012-Sender: halo1@inter.net.il To: Paul Eggert Message-id: <83y5nca4ve.fsf@gnu.org> References: <4FE4E1EE.7060305@cs.ucla.edu> <83vciibewj.fsf@gnu.org> <83txy2b8xi.fsf@gnu.org> <4FE6038B.9000906@cs.ucla.edu> <83ipehc0bd.fsf@gnu.org> <83hau1bysd.fsf@gnu.org> <4FE64706.4030807@cs.ucla.edu> <83fw9lbemi.fsf@gnu.org> <4FE6982A.8090300@cs.ucla.edu> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 9000 Cc: 9000@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: Eli Zaretskii List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -1.2 (-) > Date: Sat, 23 Jun 2012 21:31:38 -0700 > From: Paul Eggert > CC: 9000@debbugs.gnu.org > > I rummaged around our servers and found an old GCC that issues the > diagnostic, and installed as trunk bzr 108714 a further patch to silence > those particular warnings without introducing a signedness bug. Thank you. From unknown Mon Jun 23 20:19:29 2025 Received: (at fakecontrol) by fakecontrolmessage; To: internal_control@debbugs.gnu.org From: Debbugs Internal Request Subject: Internal Control Message-Id: bug archived. Date: Mon, 23 Jul 2012 11:24:03 +0000 User-Agent: Fakemail v42.6.9 # This is a fake control message. # # The action: # bug archived. thanks # This fakemail brought to you by your local debbugs # administrator