From unknown Fri Aug 08 22:24:15 2025 Content-Disposition: inline Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-Mailer: MIME-tools 5.509 (Entity 5.509) Content-Type: text/plain; charset=utf-8 From: bug#11935 <11935@debbugs.gnu.org> To: bug#11935 <11935@debbugs.gnu.org> Subject: Status: XINT etc. should be functions Reply-To: bug#11935 <11935@debbugs.gnu.org> Date: Sat, 09 Aug 2025 05:24:15 +0000 retitle 11935 XINT etc. should be functions reassign 11935 emacs submitter 11935 Paul Eggert severity 11935 wishlist tag 11935 patch thanks From debbugs-submit-bounces@debbugs.gnu.org Fri Jul 13 11:14:18 2012 Received: (at submit) by debbugs.gnu.org; 13 Jul 2012 15:14:18 +0000 Received: from localhost ([127.0.0.1]:39522 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SphZN-0000k2-69 for submit@debbugs.gnu.org; Fri, 13 Jul 2012 11:14:18 -0400 Received: from eggs.gnu.org ([208.118.235.92]:38631) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SphZE-0000jp-GN for submit@debbugs.gnu.org; Fri, 13 Jul 2012 11:14:11 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1SphTe-0002gp-K1 for submit@debbugs.gnu.org; Fri, 13 Jul 2012 11:08:26 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.2 (2011-06-06) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-6.9 required=5.0 tests=BAYES_00,RCVD_IN_DNSWL_HI autolearn=unavailable version=3.3.2 Received: from lists.gnu.org ([208.118.235.17]:33075) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SphTe-0002gb-Fg for submit@debbugs.gnu.org; Fri, 13 Jul 2012 11:08:18 -0400 Received: from eggs.gnu.org ([208.118.235.92]:49032) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SphTS-00069R-Ls for bug-gnu-emacs@gnu.org; Fri, 13 Jul 2012 11:08:18 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1SphTC-0002Yi-Mr for bug-gnu-emacs@gnu.org; Fri, 13 Jul 2012 11:08:06 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:47592) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SphTC-0002YV-2I for bug-gnu-emacs@gnu.org; Fri, 13 Jul 2012 11:07:50 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 28C89A60003 for ; Fri, 13 Jul 2012 08:07:49 -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 svEs-zCTyYLO for ; Fri, 13 Jul 2012 08:07:44 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 1DCB8A60001 for ; Fri, 13 Jul 2012 08:07:44 -0700 (PDT) Message-ID: <500039B7.8050106@cs.ucla.edu> Date: Fri, 13 Jul 2012 08:07:35 -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: bug-gnu-emacs@gnu.org Subject: XINT etc. should be functions 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: 208.118.235.17 X-Debbugs-Envelope-To: submit 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 Tags: patch Here's a patch I plan to install after some more testing. It changes lisp.h to prefer functions to function-like macros, and constants to object-like macros, when either will do. This makes the code easier to debug, as the symbols are visible to GDB. It also simplifies use, as there's no more need to worry about arguments' side effects being evaluated multiple times. So, for example, instead of this: #if USE_LSB_TAG #define XINT(a) (XLI (a) >> INTTYPEBITS) #else #define XINT(a) (XLI (a) << INTTYPEBITS >> INTTYPEBITS) #endif we now have this: static inline EMACS_INT XINT (Lisp_Object a) { EMACS_INT i = XLI (a); return (USE_LSB_TAG ? i : i << INTTYPEBITS) >> INTTYPEBITS; } In the old days Emacs had to use macros for this sort of thing, because C compilers generated significantly faster code with macros. Modern C compilers, however, don't have this problem. On the contrary, I would guess that this improves performance slightly, as it shrinks the size of Emacs's text segment by 0.5% on my platform (x86-64, GCC 4.7.1). === modified file 'ChangeLog' --- ChangeLog 2012-07-13 02:38:30 +0000 +++ ChangeLog 2012-07-13 03:38:40 +0000 @@ -1,3 +1,9 @@ +2012-07-13 Paul Eggert + + Use functions, not macros, for XINT etc. + * configure.ac (WARN_CFLAGS): Remove -Wbad-function-cast, + as it generates bogus warnings about reasonable casts of calls. + 2012-07-13 Glenn Morris * configure.ac (opsysfile): Set to empty on gnu, cygwin. === modified file 'configure.ac' --- configure.ac 2012-07-13 02:38:30 +0000 +++ configure.ac 2012-07-13 03:38:40 +0000 @@ -675,6 +675,7 @@ nw="$nw -Winline" # OK to ignore 'inline' nw="$nw -Wsync-nand" # irrelevant here, and provokes ObjC warning nw="$nw -Wunsafe-loop-optimizations" # OK to suppress unsafe optimizations + nw="$nw -Wbad-function-cast" # These casts are no worse than others. # Emacs doesn't care about shadowing; see # . === modified file 'src/ChangeLog' --- src/ChangeLog 2012-07-13 12:20:07 +0000 +++ src/ChangeLog 2012-07-13 14:46:11 +0000 @@ -1,3 +1,121 @@ +2012-07-13 Paul Eggert + + Use functions, not macros, for XINT etc. + In lisp.h, prefer functions to function-like macros, and + constants to object-like macros, when either will do. This: + . makes the code easier to debug, as the symbols are visible to GDB. + . simplifies use, as there's no more need to worry about + arguments' side effects being evaluated multiple times. + . shrinks the size of Emacs's text segment by 0.5% + on my platform (x86-64, GCC 4.7.1). + * buffer.c (Qoverlap): + * data.c (Qsubrp): + * fns.c (Qhash_table_p): + Now extern, so lisp.h can use these symbols. + * dispextern.h: Include character.h, for MAX_CHAR etc. + (GLYPH, GLYPH_CHAR, GLYPH_FACE, SET_GLYPH_CHAR, SET_GLYPH_FACE) + (SET_GLYPH, GLYPH_CODE_CHAR, GLYPH_CODE_FACE) + (SET_GLYPH_FROM_GLYPH_CODE, GLYPH_MODE_LINE_FACE, GLYPH_CHAR_VALID_P) + (GLYPH_CODE_P): Move here from lisp.h. + (GLYPH_CHAR, GLYPH_FACE, GLYPH_CODE_CHAR, GLYPH_CODE_FACE) + (GLYPH_CHAR_VALID_P, GLYPH_CODE_P): Now functions, not macros. + (GLYPH_MODE_LINE_FACE): Now enums, not macros. + * eval.c (Fautoload): Cast XUNTAG output to intptr_t, since + XUNTAG now returns void *. + * lisp.h (CHECK_CONS_LIST, LISP_INT_TAG_P, XLI, XIL, XHASH, XTYPE) + (XINT, XFASTINT, XUINT, make_number, XPNTR, XUNTAG, EQ, XCONS, XVECTOR) + (XSTRING, XSYMBOL, XFLOAT, XPROCESS, XWINDOW, XTERMINAL, XSUBR) + (XBUFFER, XCHAR_TABLE, XSUB_CHAR_TABLE, XBOOL_VECTOR, CHECK_TYPE) + (CHECK_STRING_OR_BUFFER, XCAR, XCDR, XSETCAR, XSETCDR, CAR, CDR) + (CAR_SAFE, CDR_SAFE, STRING_MULTIBYTE, STRING_INTERVALS) + (STRING_SET_INTERVALS, SDATA, SSDATA, SREF, SSET, SCHARS) + (STRING_BYTES, SBYTES, STRING_SET_CHARS, ASIZE, ASET) + (CHAR_TABLE_EXTRA_SLOTS, CHAR_TABLE_REF_ASCII, CHAR_TABLE_REF) + (CHAR_TABLE_TRANSLATE, CHAR_TABLE_SET, SYMBOL_VAL, SYMBOL_ALIAS) + (SYMBOL_BLV, SYMBOL_FWD, SET_SYMBOL_VAL, SET_SYMBOL_ALIAS) + (SET_SYMBOL_BLV, SET_SYMBOL_FWD, SYMBOL_NAME, SYMBOL_INTERNED_P) + (SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P, SYMBOL_CONSTANT_P) + (XHASH_TABLE, HASH_TABLE_P, CHECK_HASH_TABLE, HASH_TABLE_SIZE) + (XMISC, XMISCANY, XMARKER, XOVERLAY, XSAVE_VALUE, XSETMISCTYPE) + (BLV_FOUND, SET_BLV_FOUND, BLV_VALUE, SET_BLV_VALUE, XFWDTYPE) + (XINTFWD, XBOOLFWD, XOBJFWD, XBUFFER_OBJFWD, XKBOARD_OBJFWD) + (XFLOAT_DATA, XFLOAT_INIT, NILP, NUMBERP, NATNUMP) + (RANGED_INTEGERP, CONSP, FLOATP, MISCP, STRINGP, SYMBOLP) + (INTEGERP, VECTORLIKEP, VECTORP, OVERLAYP) + (MARKERP, SAVE_VALUEP, INTFWDP, BOOLFWDP, OBJFWDP) + (BUFFER_OBJFWDP, KBOARD_OBJFWDP, PSEUDOVECTOR_SIZE_TYPEP) + (PSEUDOVECTORP, WINDOW_CONFIGURATIONP, PROCESSP, WINDOWP) + (TERMINALP, SUBRP, COMPILEDP, BUFFERP, CHAR_TABLE_P) + (SUB_CHAR_TABLE_P, BOOL_VECTOR_P, FRAMEP, IMAGEP, ARRAYP) + (CHECK_LIST, CHECK_LIST_CONS, CHECK_LIST_END, CHECK_STRING) + (CHECK_STRING_CAR, CHECK_CONS, CHECK_SYMBOL, CHECK_CHAR_TABLE) + (CHECK_VECTOR, CHECK_VECTOR_OR_STRING, CHECK_ARRAY) + (CHECK_VECTOR_OR_CHAR_TABLE, CHECK_BUFFER, CHECK_WINDOW) + (CHECK_WINDOW_CONFIGURATION, CHECK_PROCESS, CHECK_SUBR) + (CHECK_NUMBER, CHECK_NATNUM, CHECK_MARKER, XFLOATINT) + (CHECK_FLOAT, CHECK_NUMBER_OR_FLOAT, CHECK_OVERLAY) + (CHECK_NUMBER_CAR, CHECK_NUMBER_CDR, CHECK_NATNUM_CAR) + (CHECK_NATNUM_CDR, FUNCTIONP, SPECPDL_INDEX, LOADHIST_ATTACH) + (IS_DIRECTORY_SEP, IS_DEVICE_SEP, IS_ANY_SEP): + Now static inline functions, not macros. + (check_cons_list) [!GC_CHECK_CONS_LIST]: New empty function. + (EMACS_INT, EMACS_UINT): Now typedefs, not macros. + (VALBITS, INTTYPEBITS, FIXNUM_BITS, LISP_INT_TAG) + (PSEUDOVECTOR_SIZE_BITS, PSEUDOVECTOR_SIZE_MASK, PVEC_TYPE_MASK) + (BOOL_VECTOR_BITS_PER_CHAR, CHAR_TABLE_STANDARD_SLOTS) + (CHARTAB_SIZE_BITS_0, CHARTAB_SIZE_BITS_1) + (CHARTAB_SIZE_BITS_2, CHARTAB_SIZE_BITS_3, DEFAULT_HASH_SIZE) + (COMPILED_ARGLIST, COMPILED_BYTECODE, COMPILED_CONSTANTS) + (COMPILED_STACK_DEPTH, COMPILED_DOC_STRING, COMPILED_INTERACTIVE) + (CHAR_ALT, CHAR_SUPER, CHAR_HYPER, CHAR_SHIFT, CHAR_CTL, CHAR_META) + (CHAR_MODIFIER_MASK, MANY, UNEVALLED, FLOAT_TO_STRING_BUFSIZE): + (DIRECTORY_SEP, MAX_ALLOCA): + Now constants, not macros. + (LISP_INT1_TAG, LISP_STRING_TAG, LISP_MAKE_RVALUE, TYPEMASK): + Remove; no longer needed. + (DATA_SEG_BITS): Default to 0, as this simplifies the rest of the code. + (VALMASK): Define in one place rather than in two, merging the + USE_LSB_TAG parts; this is simpler. + (MOST_POSITIVE_FIXNUM, MOST_NEGATIVE_FIXNUM, max, min) + (struct Lisp_String, UNSIGNED_CMP, ASCII_CHAR_P): + Move up, to avoid use before definition. + Also include "globals.h" earlier, for the same reason. + (make_natnum, xtag): New functions. + (XUNTAG): Now returns void *, not intptr_t, as this means fewer casts. + (union Lisp_Fwd, BOOLFWDP, BOOL_VECTOR_P, BUFFER_OBJFWDP, BUFFERP) + (CHAR_TABLE_P, CHAR_TABLE_REF_ASCII, CONSP, FLOATP, INTEGERP, INTFWDP) + (KBOARD_OBJFWDP, MARKERP, MISCP, NILP, OBJFWDP, OVERLAYP, PROCESSP) + (PSEUDOVECTORP, SAVE_VALUEP, STRINGP, SUB_CHAR_TABLE_P, SUBRP, SYMBOLP) + (VECTORLIKEP, WINDOWP, Qoverlayp, char_table_ref, char_table_set) + (char_table_translate, Qarrayp, Qbufferp, Qbuffer_or_string_p) + (Qchar_table_p, Qconsp, Qfloatp, Qintegerp, Qlambda, Qlistp, Qmarkerp) + (Qnil, Qnumberp, Qsubrp, Qstringp, Qsymbolp, Qvectorp) + (Qvector_or_char_table_p, Qwholenump, Ffboundp, wrong_type_argument) + (initialized, Qhash_table_p, extract_float, Qprocessp, Qwindowp) + (Qwindow_configuration_p, Qimage): New forward declarations. + (XSET): Simplify by rewriting in terms of xtag. + (XSETFASTINT): Simplify by rewriting in terms of make_natnum. + (STRING_COPYIN): Remove; unused. + (GLYPH, GLYPH_CHAR, GLYPH_FACE, SET_GLYPH_CHAR, SET_GLYPH_FACE) + (SET_GLYPH, GLYPH_CODE_CHAR, GLYPH_CODE_FACE) + (SET_GLYPH_FROM_GLYPH_CODE, GLYPH_MODE_LINE_FACE, GLYPH_CHAR_VALID_P) + (GLYPH_CODE_P): Move to dispextern.h, to avoid define-before-use. + (TYPE_RANGED_INTEGERP): Simplify. + (PSEUDOVECTOR_SIZE_TYPEP): Rename from PSEUDOVECTORP_TYPEP and + change the first arg to be a size rather than a pointer, + to make it usable as a function. All uses changed. + (Qsubrp, Qhash_table_p, Qoverlayp): New extern decls. + (setlocale, fixup_locale, synchronize_system_messages_locale) + (synchronize_system_time_locale) [!HAVE_SETLOCALE]: + Now empty functions, not macros. + * mem-limits.h (EXCEEDS_LISP_PTR) [!defined DATA_SEG_BITS]: + Remove, as DATA_SEG_BITS is always defined now, if only to zero. + * window.c (Qwindow_configuration_p): + Now extern, so window.h can use it. + * window.h (Qwindowp): Move decl back to lisp.h. + (CHECK_LIVE_WINDOW): Move here from lisp.h, so window.h internals + need not be moved to lisp.h. Now a function, not a macro. + 2012-07-13 Kalle Kankare (tiny change) * image.c (Fimagemagick_types): Initialize ex with GetExceptionInfo === modified file 'src/alloc.c' --- src/alloc.c 2012-07-11 06:14:27 +0000 +++ src/alloc.c 2012-07-13 03:37:42 +0000 @@ -3077,12 +3077,12 @@ + VECTOR_BLOCK_BYTES - VBLOCK_BYTES_MIN) /* Number of bytes used by vector-block-allocated object. This is the only - place where we actually use the `nbytes' field of the vector-header. - I.e. we could get rid of the `nbytes' field by computing it based on the + place where we actually use the 'size' field of the vector-header. + I.e. we could get rid of the 'size' field by computing it based on the vector-type. */ #define PSEUDOVECTOR_NBYTES(vector) \ - (PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE) \ + (PSEUDOVECTOR_SIZE_TYPEP (vector->header.size, PVEC_FREE) \ ? vector->header.size & PSEUDOVECTOR_SIZE_MASK \ : vector->header.next.nbytes) @@ -4382,7 +4382,7 @@ while (VECTOR_IN_BLOCK (vector, block) && vector <= (struct Lisp_Vector *) p) { - if (PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE)) + if (PSEUDOVECTOR_SIZE_TYPEP (vector->header.size, PVEC_FREE)) vector = ADVANCE (vector, (vector->header.size & PSEUDOVECTOR_SIZE_MASK)); else if (vector == p) === modified file 'src/buffer.c' --- src/buffer.c 2012-07-10 23:24:36 +0000 +++ src/buffer.c 2012-07-13 03:37:42 +0000 @@ -139,7 +139,7 @@ static Lisp_Object Qget_file_buffer; -static Lisp_Object Qoverlayp; +Lisp_Object Qoverlayp; Lisp_Object Qpriority, Qbefore_string, Qafter_string; @@ -612,7 +612,7 @@ eassert (NILP (BVAR (b->base_buffer, begv_marker))); eassert (NILP (BVAR (b->base_buffer, zv_marker))); - BVAR (b->base_buffer, pt_marker) + BVAR (b->base_buffer, pt_marker) = build_marker (b->base_buffer, b->base_buffer->pt, b->base_buffer->pt_byte); BVAR (b->base_buffer, begv_marker) @@ -862,7 +862,7 @@ { /* Note fileio.c:make_temp_name does random differently. */ tem2 = concat2 (name, make_formatted_string - (number, "-%"pI"d", + (number, "-%"pI"d", XFASTINT (Frandom (make_number (999999))))); tem = Fget_buffer (tem2); if (NILP (tem)) === modified file 'src/data.c' --- src/data.c 2012-07-10 08:43:46 +0000 +++ src/data.c 2012-07-13 14:51:32 +0000 @@ -91,7 +91,8 @@ static Lisp_Object Qcompiled_function, Qframe, Qvector; Lisp_Object Qbuffer; static Lisp_Object Qchar_table, Qbool_vector, Qhash_table; -static Lisp_Object Qsubrp, Qmany, Qunevalled; +Lisp_Object Qsubrp; +static Lisp_Object Qmany, Qunevalled; Lisp_Object Qfont_spec, Qfont_entity, Qfont_object; static Lisp_Object Qdefun; === modified file 'src/dispextern.h' --- src/dispextern.h 2012-07-13 03:50:58 +0000 +++ src/dispextern.h 2012-07-13 03:52:53 +0000 @@ -22,6 +22,8 @@ #ifndef DISPEXTERN_H_INCLUDED #define DISPEXTERN_H_INCLUDED +#include "character.h" + #ifdef HAVE_X_WINDOWS #include @@ -265,6 +267,55 @@ Glyphs ***********************************************************************/ +/* The glyph datatype, used to represent characters on the display. + It consists of a char code and a face id. */ + +typedef struct { + int ch; + int face_id; +} GLYPH; + +/* Return a glyph's character code. */ +static inline int GLYPH_CHAR (GLYPH glyph) { return glyph.ch; } + +/* Return a glyph's face ID. */ +static inline int GLYPH_FACE (GLYPH glyph) { return glyph.face_id; } + +#define SET_GLYPH_CHAR(glyph, char) ((glyph).ch = (char)) +#define SET_GLYPH_FACE(glyph, face) ((glyph).face_id = (face)) +#define SET_GLYPH(glyph, char, face) \ + ((glyph).ch = (char), (glyph).face_id = (face)) + +/* The following are valid only if GLYPH_CODE_P (gc). */ + +static inline int +GLYPH_CODE_CHAR (Lisp_Object gc) +{ + return (CONSP (gc) + ? XINT (XCAR (gc)) + : XINT (gc) & MAX_CHAR); +} + +static inline int +GLYPH_CODE_FACE (Lisp_Object gc) +{ + return CONSP (gc) ? XINT (XCDR (gc)) : XINT (gc) >> CHARACTERBITS; +} + +#define SET_GLYPH_FROM_GLYPH_CODE(glyph, gc) \ + do \ + { \ + if (CONSP (gc)) \ + SET_GLYPH (glyph, XINT (XCAR (gc)), XINT (XCDR (gc))); \ + else \ + SET_GLYPH (glyph, (XINT (gc) & ((1 << CHARACTERBITS)-1)), \ + (XINT (gc) >> CHARACTERBITS)); \ + } \ + while (0) + +/* The ID of the mode line highlighting face. */ +enum { GLYPH_MODE_LINE_FACE = 1 }; + /* Enumeration of glyph types. Glyph structures contain a type field containing one of the enumerators defined here. */ @@ -1763,6 +1814,30 @@ #endif /* not HAVE_WINDOW_SYSTEM */ +/* Return 1 if G contains a valid character code. */ +static inline int +GLYPH_CHAR_VALID_P (GLYPH g) +{ + return CHAR_VALID_P (GLYPH_CHAR (g)); +} + +/* The glyph code from a display vector may either be an integer which + encodes a char code in the lower CHARACTERBITS bits and a (very small) + face-id in the upper bits, or it may be a cons (CHAR . FACE-ID). */ + +static inline int +GLYPH_CODE_P (Lisp_Object gc) +{ + return (CONSP (gc) + ? (CHARACTERP (XCAR (gc)) + && RANGED_INTEGERP (0, XCDR (gc), MAX_FACE_ID)) + : (RANGED_INTEGERP + (0, gc, + (MAX_FACE_ID < TYPE_MAXIMUM (EMACS_INT) >> CHARACTERBITS + ? ((EMACS_INT) MAX_FACE_ID << CHARACTERBITS) | MAX_CHAR + : TYPE_MAXIMUM (EMACS_INT))))); +} + /* Non-zero means face attributes have been changed since the last redisplay. Used in redisplay_internal. */ === modified file 'src/eval.c' --- src/eval.c 2012-07-10 16:53:26 +0000 +++ src/eval.c 2012-07-13 03:37:42 +0000 @@ -1931,7 +1931,7 @@ and assumed the docstring will be provided by Snarf-documentation, so it passed us 0 instead. But that leads to accidental sharing in purecopy's hash-consing, so we use a (hopefully) unique integer instead. */ - docstring = make_number (XUNTAG (function, Lisp_Symbol)); + docstring = make_number ((intptr_t) XUNTAG (function, Lisp_Symbol)); return Ffset (function, Fpurecopy (list5 (Qautoload, file, docstring, interactive, type))); === modified file 'src/fns.c' --- src/fns.c 2012-07-10 23:24:36 +0000 +++ src/fns.c 2012-07-13 03:37:42 +0000 @@ -3354,7 +3354,8 @@ /* Various symbols. */ -static Lisp_Object Qhash_table_p, Qkey, Qvalue; +Lisp_Object Qhash_table_p; +static Lisp_Object Qkey, Qvalue; Lisp_Object Qeq, Qeql, Qequal; Lisp_Object QCtest, QCsize, QCrehash_size, QCrehash_threshold, QCweakness; static Lisp_Object Qhash_table_test, Qkey_or_value, Qkey_and_value; === modified file 'src/lisp.h' --- src/lisp.h 2012-07-12 23:56:39 +0000 +++ src/lisp.h 2012-07-13 03:38:40 +0000 @@ -32,10 +32,10 @@ #ifdef GC_CHECK_CONS_LIST extern void check_cons_list (void); -#define CHECK_CONS_LIST() check_cons_list () #else -#define CHECK_CONS_LIST() ((void) 0) +static inline void check_cons_list (void) { } #endif +static inline void CHECK_CONS_LIST (void) { check_cons_list (); } /* Temporarily disable wider-than-pointer integers until they're tested more. Build with CFLAGS='-DWIDE_EMACS_INT' to try them out. */ @@ -45,22 +45,24 @@ EMACS_INT_MAX - maximum value of EMACS_INT; can be used in #if pI - printf length modifier for EMACS_INT EMACS_UINT - unsigned variant of EMACS_INT */ -#ifndef EMACS_INT +#ifndef EMACS_INT_MAX # if LONG_MAX < LLONG_MAX && defined WIDE_EMACS_INT -# define EMACS_INT long long +typedef long long int EMACS_INT; +typedef unsigned long long int EMACS_UINT; # define EMACS_INT_MAX LLONG_MAX # define pI "ll" # elif INT_MAX < LONG_MAX -# define EMACS_INT long +typedef long int EMACS_INT; +typedef unsigned long int EMACS_UINT; # define EMACS_INT_MAX LONG_MAX # define pI "l" # else -# define EMACS_INT int +typedef int EMACS_INT; +typedef unsigned int EMACS_UINT; # define EMACS_INT_MAX INT_MAX # define pI "" # endif #endif -#define EMACS_UINT unsigned EMACS_INT /* Number of bits in some machine integer types. */ enum @@ -153,8 +155,10 @@ variable VAR of type TYPE with the added requirement that it be TYPEBITS-aligned. */ +/* Number of bits in a Lisp_Obect tag. This can be used in #if. */ #define GCTYPEBITS 3 -#define VALBITS (BITS_PER_EMACS_INT - GCTYPEBITS) + +enum { VALBITS = BITS_PER_EMACS_INT - GCTYPEBITS }; /* The maximum value that can be stored in a EMACS_INT, assuming all bits other than the type bits contribute to a nonnegative signed value. @@ -216,14 +220,10 @@ /* Lisp integers use 2 tags, to give them one extra bit, thus extending their range from, e.g., -2^28..2^28-1 to -2^29..2^29-1. */ -#define INTTYPEBITS (GCTYPEBITS - 1) -#define FIXNUM_BITS (VALBITS + 1) +enum { INTTYPEBITS = GCTYPEBITS - 1 }; +enum { FIXNUM_BITS = VALBITS + 1 }; #define INTMASK (EMACS_INT_MAX >> (INTTYPEBITS - 1)) -#define LISP_INT_TAG Lisp_Int0 #define case_Lisp_Int case Lisp_Int0: case Lisp_Int1 -#define LISP_INT1_TAG (USE_LSB_TAG ? 1 << INTTYPEBITS : 1) -#define LISP_STRING_TAG (5 - LISP_INT1_TAG) -#define LISP_INT_TAG_P(x) (((x) & ~LISP_INT1_TAG) == 0) /* Stolen from GDB. The only known compiler that doesn't support enums in bitfields is MSVC. */ @@ -238,7 +238,7 @@ { /* Integer. XINT (obj) is the integer value. */ Lisp_Int0 = 0, - Lisp_Int1 = LISP_INT1_TAG, + Lisp_Int1 = USE_LSB_TAG ? 4 : 1, /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */ Lisp_Symbol = 2, @@ -249,7 +249,7 @@ /* String. XSTRING (object) points to a struct Lisp_String. The length of the string, and its contents, are stored therein. */ - Lisp_String = LISP_STRING_TAG, + Lisp_String = USE_LSB_TAG ? 1 : 4, /* Vector of Lisp objects, or something resembling it. XVECTOR (object) points to a struct Lisp_Vector, which contains @@ -263,6 +263,11 @@ Lisp_Float = 7, }; +/* An older name for Lisp_Int0. */ +enum { LISP_INT_TAG = Lisp_Int0 }; + +static inline int LISP_INT_TAG_P (int x) { return (x & ~Lisp_Int1) == 0; } + /* This is the set of data types that share a common structure. The first member of the structure is a type code from this set. The enum values are arbitrary, but we'll use large numbers to make it @@ -297,7 +302,8 @@ typedef struct { EMACS_INT i; } Lisp_Object; -#define XLI(o) (o).i +static inline EMACS_INT XLI (Lisp_Object o) { return o.i; } + static inline Lisp_Object XIL (EMACS_INT i) { @@ -305,12 +311,6 @@ return o; } -static inline Lisp_Object -LISP_MAKE_RVALUE (Lisp_Object o) -{ - return o; -} - #define LISP_INITIALLY_ZERO {0} #else /* CHECK_LISP_OBJECT_TYPE */ @@ -318,9 +318,8 @@ /* If a struct type is not wanted, define Lisp_Object as just a number. */ typedef EMACS_INT Lisp_Object; -#define XLI(o) (o) -#define XIL(i) (i) -#define LISP_MAKE_RVALUE(o) (0+(o)) +static inline EMACS_INT XLI (Lisp_Object o) { return o; } +static inline Lisp_Object XIL (EMACS_INT i) { return i; } #define LISP_INITIALLY_ZERO 0 #endif /* CHECK_LISP_OBJECT_TYPE */ @@ -368,89 +367,119 @@ only the number of Lisp_Object fields (that need to be traced by the GC). The distinction is used e.g. by Lisp_Process which places extra non-Lisp_Object fields at the end of the structure. */ -#define PSEUDOVECTOR_SIZE_BITS 16 -#define PSEUDOVECTOR_SIZE_MASK ((1 << PSEUDOVECTOR_SIZE_BITS) - 1) -#define PVEC_TYPE_MASK (0x0fff << PSEUDOVECTOR_SIZE_BITS) +enum + { + PSEUDOVECTOR_SIZE_BITS = 16, + PSEUDOVECTOR_SIZE_MASK = (1 << PSEUDOVECTOR_SIZE_BITS) - 1, + PVEC_TYPE_MASK = 0xfff << PSEUDOVECTOR_SIZE_BITS + }; /* Number of bits to put in each character in the internal representation of bool vectors. This should not vary across implementations. */ -#define BOOL_VECTOR_BITS_PER_CHAR 8 - -/* These macros extract various sorts of values from a Lisp_Object. +enum { BOOL_VECTOR_BITS_PER_CHAR = 8 }; + +/* DATA_SEG_BITS forces extra bits to be or'd in with any pointers + which were stored in a Lisp_Object */ +#ifndef DATA_SEG_BITS +# define DATA_SEG_BITS 0 +#endif + +/* These functions extract various sorts of values from a Lisp_Object. For example, if tem is a Lisp_Object whose type is Lisp_Cons, XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons. */ /* Return a perfect hash of the Lisp_Object representation. */ -#define XHASH(a) XLI (a) - -#if USE_LSB_TAG - -#define TYPEMASK ((1 << GCTYPEBITS) - 1) -#define XTYPE(a) ((enum Lisp_Type) (XLI (a) & TYPEMASK)) -#define XINT(a) (XLI (a) >> INTTYPEBITS) -#define XUINT(a) ((EMACS_UINT) XLI (a) >> INTTYPEBITS) -#define make_number(N) XIL ((EMACS_INT) (N) << INTTYPEBITS) -#define XSET(var, type, ptr) \ - (eassert (XTYPE (XIL ((intptr_t) (ptr))) == 0), /* Check alignment. */ \ - (var) = XIL ((type) | (intptr_t) (ptr))) - -#define XPNTR(a) ((intptr_t) (XLI (a) & ~TYPEMASK)) -#define XUNTAG(a, type) ((intptr_t) (XLI (a) - (type))) - -#else /* not USE_LSB_TAG */ - -#define VALMASK VAL_MAX - -#define XTYPE(a) ((enum Lisp_Type) ((EMACS_UINT) XLI (a) >> VALBITS)) - -/* For integers known to be positive, XFASTINT provides fast retrieval - and XSETFASTINT provides fast storage. This takes advantage of the - fact that Lisp integers have zero-bits in their tags. */ -#define XFASTINT(a) (XLI (a) + 0) -#define XSETFASTINT(a, b) ((a) = XIL (b)) - -/* Extract the value of a Lisp_Object as a (un)signed integer. */ - -#define XINT(a) (XLI (a) << INTTYPEBITS >> INTTYPEBITS) -#define XUINT(a) ((EMACS_UINT) (XLI (a) & INTMASK)) -#define make_number(N) XIL ((EMACS_INT) (N) & INTMASK) - -#define XSET(var, type, ptr) \ - ((var) = XIL ((EMACS_INT) ((EMACS_UINT) (type) << VALBITS) \ - + ((intptr_t) (ptr) & VALMASK))) - -#ifdef DATA_SEG_BITS -/* DATA_SEG_BITS forces extra bits to be or'd in with any pointers - which were stored in a Lisp_Object */ -#define XPNTR(a) ((uintptr_t) ((XLI (a) & VALMASK)) | DATA_SEG_BITS)) -#else -#define XPNTR(a) ((uintptr_t) (XLI (a) & VALMASK)) -#endif - -#endif /* not USE_LSB_TAG */ - -/* For integers known to be positive, XFASTINT sometimes provides - faster retrieval and XSETFASTINT provides faster storage. - If not, fallback on the non-accelerated path. */ -#ifndef XFASTINT -# define XFASTINT(a) (XINT (a)) -# define XSETFASTINT(a, b) (XSETINT (a, b)) -#endif - -/* Extract the pointer value of the Lisp object A, under the - assumption that A's type is TYPE. This is a fallback - implementation if nothing faster is available. */ -#ifndef XUNTAG -# define XUNTAG(a, type) XPNTR (a) -#endif - -#define EQ(x, y) (XHASH (x) == XHASH (y)) +static inline EMACS_INT XHASH (Lisp_Object o) { return XLI (o); } + +#define VALMASK (USE_LSB_TAG ? - (1 << GCTYPEBITS) : VAL_MAX) /* Largest and smallest representable fixnum values. These are the C values. */ #define MOST_POSITIVE_FIXNUM (EMACS_INT_MAX >> INTTYPEBITS) #define MOST_NEGATIVE_FIXNUM (-1 - MOST_POSITIVE_FIXNUM) +static inline enum Lisp_Type +XTYPE (Lisp_Object a) +{ + EMACS_UINT i = XLI (a); + return USE_LSB_TAG ? i & ~VALMASK : i >> VALBITS; +} + +/* Extract the value of a Lisp_Object as a signed integer. */ +static inline EMACS_INT +XINT (Lisp_Object a) +{ + EMACS_INT i = XLI (a); + return (USE_LSB_TAG ? i : i << INTTYPEBITS) >> INTTYPEBITS; +} + +/* Like XINT (A), but may be faster. A must be nonnegative. This takes + advantage of the fact that Lisp integers have zero-bits in their tags. */ +static inline EMACS_INT +XFASTINT (Lisp_Object a) +{ + EMACS_INT n = USE_LSB_TAG ? XINT (a) : XLI (a) >> INTTYPEBITS; + eassert (0 <= n); + return n; +} + +/* Extract the value of a Lisp_Object as an unsigned integer. */ +static inline EMACS_UINT +XUINT (Lisp_Object a) +{ + EMACS_UINT i = XLI (a); + return USE_LSB_TAG ? i >> INTTYPEBITS : i & INTMASK; +} + +static inline Lisp_Object +make_number (EMACS_INT n) +{ + return XIL (USE_LSB_TAG ? n << INTTYPEBITS : n & INTMASK); +} + +/* Like make_number (N), but may be faster. N must be in nonnegative range. */ +static inline Lisp_Object +make_natnum (EMACS_INT n) +{ + eassert (0 <= n && n <= MOST_POSITIVE_FIXNUM); + return USE_LSB_TAG ? make_number (n) : XIL (n); +} + +static inline void * +XPNTR (Lisp_Object a) +{ + intptr_t i = (XLI (a) & VALMASK) | DATA_SEG_BITS; + return (void *) i; +} + +/* Extract the pointer value of the Lisp object A, under the + assumption that A's type is TYPE. */ +static inline void * +XUNTAG (Lisp_Object a, int type) +{ + if (USE_LSB_TAG) + { + intptr_t i = XLI (a) - type; + return (void *) i; + } + return XPNTR (a); +} + +static inline int +EQ (Lisp_Object a, Lisp_Object b) +{ + return XHASH (a) == XHASH (b); +} + +/* The ubiquitous min and max macros. */ + +#ifdef max +#undef max +#undef min +#endif +#define min(a, b) ((a) < (b) ? (a) : (b)) +#define max(a, b) ((a) > (b) ? (a) : (b)) + /* Value is non-zero if I doesn't fit into a Lisp fixnum. It is written this way so that it also works if I is of unsigned type or if I is a NaN. */ @@ -463,64 +492,181 @@ { return num < lower ? lower : num <= upper ? num : upper; } + +/* Forward declarations. */ + +/* Defined in this file. */ +union Lisp_Fwd; +static int BOOLFWDP (union Lisp_Fwd *); +static int BOOL_VECTOR_P (Lisp_Object); +static int BUFFER_OBJFWDP (union Lisp_Fwd *); +static int BUFFERP (Lisp_Object); +static int CHAR_TABLE_P (Lisp_Object); +static Lisp_Object CHAR_TABLE_REF_ASCII (Lisp_Object, ptrdiff_t); +static int CONSP (Lisp_Object); +static int FLOATP (Lisp_Object); +static int INTEGERP (Lisp_Object); +static int INTFWDP (union Lisp_Fwd *); +static int KBOARD_OBJFWDP (union Lisp_Fwd *); +static int MARKERP (Lisp_Object); +static int MISCP (Lisp_Object); +static int NILP (Lisp_Object); +static int OBJFWDP (union Lisp_Fwd *); +static int OVERLAYP (Lisp_Object); +static int PROCESSP (Lisp_Object); +static int PSEUDOVECTORP (Lisp_Object, int); +static int SAVE_VALUEP (Lisp_Object); +static int STRINGP (Lisp_Object); +static int SUB_CHAR_TABLE_P (Lisp_Object); +static int SUBRP (Lisp_Object); +static int SYMBOLP (Lisp_Object); +static int VECTORLIKEP (Lisp_Object); +static int WINDOWP (Lisp_Object); + +/* Defined in buffer.c. */ +extern Lisp_Object Qoverlayp; + +/* Defined in chartab.c. */ +extern Lisp_Object char_table_ref (Lisp_Object, int); +extern Lisp_Object char_table_set (Lisp_Object, int, Lisp_Object); +extern int char_table_translate (Lisp_Object, int); + +/* Defined in data.c. */ +extern Lisp_Object Qarrayp, Qbufferp, Qbuffer_or_string_p, Qchar_table_p; +extern Lisp_Object Qconsp, Qfloatp, Qintegerp, Qlambda, Qlistp, Qmarkerp, Qnil; +extern Lisp_Object Qnumberp, Qsubrp, Qstringp, Qsymbolp, Qvectorp; +extern Lisp_Object Qvector_or_char_table_p, Qwholenump; +extern Lisp_Object Ffboundp (Lisp_Object); +extern _Noreturn Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object); + +/* Defined in emacs.c. */ +extern int initialized; + +/* Defined in fns.c */ +extern Lisp_Object Qhash_table_p; + +/* Defined in floatfns.c. */ +extern double extract_float (Lisp_Object); + +/* Defined in process.c. */ +extern Lisp_Object Qprocessp; + +/* Defined in window.c. */ +extern Lisp_Object Qwindowp, Qwindow_configuration_p; + +/* Defined in xdisp.c. */ +extern Lisp_Object Qimage; + /* Extract a value or address from a Lisp_Object. */ -#define XCONS(a) (eassert (CONSP (a)), \ - (struct Lisp_Cons *) XUNTAG (a, Lisp_Cons)) -#define XVECTOR(a) (eassert (VECTORLIKEP (a)), \ - (struct Lisp_Vector *) XUNTAG (a, Lisp_Vectorlike)) -#define XSTRING(a) (eassert (STRINGP (a)), \ - (struct Lisp_String *) XUNTAG (a, Lisp_String)) -#define XSYMBOL(a) (eassert (SYMBOLP (a)), \ - (struct Lisp_Symbol *) XUNTAG (a, Lisp_Symbol)) -#define XFLOAT(a) (eassert (FLOATP (a)), \ - (struct Lisp_Float *) XUNTAG (a, Lisp_Float)) - -/* Misc types. */ - -#define XMISC(a) ((union Lisp_Misc *) XUNTAG (a, Lisp_Misc)) -#define XMISCANY(a) (eassert (MISCP (a)), &(XMISC (a)->u_any)) -#define XMISCTYPE(a) (XMISCANY (a)->type) -#define XMARKER(a) (eassert (MARKERP (a)), &(XMISC (a)->u_marker)) -#define XOVERLAY(a) (eassert (OVERLAYP (a)), &(XMISC (a)->u_overlay)) -#define XSAVE_VALUE(a) (eassert (SAVE_VALUEP (a)), &(XMISC (a)->u_save_value)) - -/* Forwarding object types. */ - -#define XFWDTYPE(a) (a->u_intfwd.type) -#define XINTFWD(a) (eassert (INTFWDP (a)), &((a)->u_intfwd)) -#define XBOOLFWD(a) (eassert (BOOLFWDP (a)), &((a)->u_boolfwd)) -#define XOBJFWD(a) (eassert (OBJFWDP (a)), &((a)->u_objfwd)) -#define XBUFFER_OBJFWD(a) \ - (eassert (BUFFER_OBJFWDP (a)), &((a)->u_buffer_objfwd)) -#define XKBOARD_OBJFWD(a) \ - (eassert (KBOARD_OBJFWDP (a)), &((a)->u_kboard_objfwd)) +static inline struct Lisp_Cons * +XCONS (Lisp_Object a) +{ + eassert (CONSP (a)); + return XUNTAG (a, Lisp_Cons); +} + +static inline struct Lisp_Vector * +XVECTOR (Lisp_Object a) +{ + eassert (VECTORLIKEP (a)); + return XUNTAG (a, Lisp_Vectorlike); +} + +static inline struct Lisp_String * +XSTRING (Lisp_Object a) +{ + eassert (STRINGP (a)); + return XUNTAG (a, Lisp_String); +} + +static inline struct Lisp_Symbol * +XSYMBOL (Lisp_Object a) +{ + eassert (SYMBOLP (a)); + return XUNTAG (a, Lisp_Symbol); +} + +static inline struct Lisp_Float * +XFLOAT (Lisp_Object a) +{ + eassert (FLOATP (a)); + return XUNTAG (a, Lisp_Float); +} /* Pseudovector types. */ -#define XPROCESS(a) (eassert (PROCESSP (a)), \ - (struct Lisp_Process *) XUNTAG (a, Lisp_Vectorlike)) -#define XWINDOW(a) (eassert (WINDOWP (a)), \ - (struct window *) XUNTAG (a, Lisp_Vectorlike)) -#define XTERMINAL(a) (eassert (TERMINALP (a)), \ - (struct terminal *) XUNTAG (a, Lisp_Vectorlike)) -#define XSUBR(a) (eassert (SUBRP (a)), \ - (struct Lisp_Subr *) XUNTAG (a, Lisp_Vectorlike)) -#define XBUFFER(a) (eassert (BUFFERP (a)), \ - (struct buffer *) XUNTAG (a, Lisp_Vectorlike)) -#define XCHAR_TABLE(a) (eassert (CHAR_TABLE_P (a)), \ - (struct Lisp_Char_Table *) XUNTAG (a, Lisp_Vectorlike)) -#define XSUB_CHAR_TABLE(a) (eassert (SUB_CHAR_TABLE_P (a)), \ - ((struct Lisp_Sub_Char_Table *) \ - XUNTAG (a, Lisp_Vectorlike))) -#define XBOOL_VECTOR(a) (eassert (BOOL_VECTOR_P (a)), \ - ((struct Lisp_Bool_Vector *) \ - XUNTAG (a, Lisp_Vectorlike))) +static inline struct Lisp_Process * +XPROCESS (Lisp_Object a) +{ + eassert (PROCESSP (a)); + return XUNTAG (a, Lisp_Vectorlike); +} + +static inline struct window * +XWINDOW (Lisp_Object a) +{ + eassert (WINDOWP (a)); + return XUNTAG (a, Lisp_Vectorlike); +} + +static inline struct terminal * +XTERMINAL (Lisp_Object a) +{ + return XUNTAG (a, Lisp_Vectorlike); +} + +static inline struct Lisp_Subr * +XSUBR (Lisp_Object a) +{ + eassert (SUBRP (a)); + return XUNTAG (a, Lisp_Vectorlike); +} + +static inline struct buffer * +XBUFFER (Lisp_Object a) +{ + eassert (BUFFERP (a)); + return XUNTAG (a, Lisp_Vectorlike); +} + +static inline struct Lisp_Char_Table * +XCHAR_TABLE (Lisp_Object a) +{ + eassert (CHAR_TABLE_P (a)); + return XUNTAG (a, Lisp_Vectorlike); +} + +static inline struct Lisp_Sub_Char_Table * +XSUB_CHAR_TABLE (Lisp_Object a) +{ + eassert (SUB_CHAR_TABLE_P (a)); + return XUNTAG (a, Lisp_Vectorlike); +} + +static inline struct Lisp_Bool_Vector * +XBOOL_VECTOR (Lisp_Object a) +{ + eassert (BOOL_VECTOR_P (a)); + return XUNTAG (a, Lisp_Vectorlike); +} /* Construct a Lisp_Object from a value or address. */ +static inline Lisp_Object +xtag (enum Lisp_Type type, void *ptr) +{ + EMACS_UINT utype = type; + EMACS_INT typebits = USE_LSB_TAG ? type : utype << VALBITS; + Lisp_Object a = XIL (typebits | (intptr_t) ptr); + eassert (XUNTAG (a, type) == ptr); /* Check alignment. */ + return a; +} + +#define XSET(var, type, ptr) ((var) = xtag (type, ptr)) #define XSETINT(a, b) (a) = make_number (b) +#define XSETFASTINT(a, b) ((a) = make_natnum (b)) #define XSETCONS(a, b) XSET (a, Lisp_Cons, b) #define XSETVECTOR(a, b) XSET (a, Lisp_Vectorlike, b) #define XSETSTRING(a, b) XSET (a, Lisp_String, b) @@ -568,48 +714,25 @@ #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR)) #define XSETSUB_CHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUB_CHAR_TABLE)) -/* Convenience macros for dealing with Lisp arrays. */ - -#define AREF(ARRAY, IDX) XVECTOR ((ARRAY))->contents[IDX] -#define ASIZE(ARRAY) XVECTOR ((ARRAY))->header.size -/* The IDX==IDX tries to detect when the macro argument is side-effecting. */ -#define ASET(ARRAY, IDX, VAL) \ - (eassert ((IDX) == (IDX)), \ - eassert ((IDX) >= 0 && (IDX) < ASIZE (ARRAY)), \ - AREF ((ARRAY), (IDX)) = (VAL)) - -/* Convenience macros for dealing with Lisp strings. */ - -#define SDATA(string) (XSTRING (string)->data + 0) -#define SREF(string, index) (SDATA (string)[index] + 0) -#define SSET(string, index, new) (SDATA (string)[index] = (new)) -#define SCHARS(string) (XSTRING (string)->size + 0) -#define SBYTES(string) (STRING_BYTES (XSTRING (string)) + 0) - -/* Avoid "differ in sign" warnings. */ -#define SSDATA(x) ((char *) SDATA (x)) - -#define STRING_SET_CHARS(string, newsize) \ - (XSTRING (string)->size = (newsize)) - -#define STRING_COPYIN(string, index, new, count) \ - memcpy (SDATA (string) + index, new, count) - /* Type checking. */ -#define CHECK_TYPE(ok, Qxxxp, x) \ - do { if (!(ok)) wrong_type_argument (Qxxxp, (x)); } while (0) - - +static inline void +CHECK_TYPE (int ok, Lisp_Object Qxxxp, Lisp_Object x) +{ + if (!ok) + wrong_type_argument (Qxxxp, x); +} /* See the macros in intervals.h. */ typedef struct interval *INTERVAL; /* Complain if object is not string or buffer type */ -#define CHECK_STRING_OR_BUFFER(x) \ - CHECK_TYPE (STRINGP (x) || BUFFERP (x), Qbuffer_or_string_p, x) - +static inline void +CHECK_STRING_OR_BUFFER (Lisp_Object x) +{ + CHECK_TYPE (STRINGP (x) || BUFFERP (x), Qbuffer_or_string_p, x); +} /* In a cons, the markbit of the car is the gc mark bit */ @@ -650,54 +773,68 @@ #endif /* Use these from normal code. */ -#define XCAR(c) LISP_MAKE_RVALUE (XCAR_AS_LVALUE (c)) -#define XCDR(c) LISP_MAKE_RVALUE (XCDR_AS_LVALUE (c)) +static inline Lisp_Object XCAR (Lisp_Object c) { return XCAR_AS_LVALUE (c); } +static inline Lisp_Object XCDR (Lisp_Object c) { return XCDR_AS_LVALUE (c); } /* Use these to set the fields of a cons cell. Note that both arguments may refer to the same object, so 'n' - should not be read after 'c' is first modified. Also, neither - argument should be evaluated more than once; side effects are - especially common in the second argument. */ -#define XSETCAR(c,n) (XCAR_AS_LVALUE (c) = (n)) -#define XSETCDR(c,n) (XCDR_AS_LVALUE (c) = (n)) - -/* Take the car or cdr of something whose type is not known. */ -#define CAR(c) \ - (CONSP ((c)) ? XCAR ((c)) \ - : NILP ((c)) ? Qnil \ - : wrong_type_argument (Qlistp, (c))) - -#define CDR(c) \ - (CONSP ((c)) ? XCDR ((c)) \ - : NILP ((c)) ? Qnil \ - : wrong_type_argument (Qlistp, (c))) - -/* Take the car or cdr of something whose type is not known. */ -#define CAR_SAFE(c) \ - (CONSP ((c)) ? XCAR ((c)) : Qnil) - -#define CDR_SAFE(c) \ - (CONSP ((c)) ? XCDR ((c)) : Qnil) + should not be read after 'c' is first modified. */ +static inline void +XSETCAR (Lisp_Object c, Lisp_Object n) +{ + XCAR_AS_LVALUE (c) = n; +} +static inline void +XSETCDR (Lisp_Object c, Lisp_Object n) +{ + XCDR_AS_LVALUE (c) = n; +} + +/* Take the car or cdr of something whose type is not known. */ +static inline Lisp_Object +CAR (Lisp_Object c) +{ + return (CONSP (c) ? XCAR (c) + : NILP (c) ? Qnil + : wrong_type_argument (Qlistp, c)); +} +static inline Lisp_Object +CDR (Lisp_Object c) +{ + return (CONSP (c) ? XCDR (c) + : NILP (c) ? Qnil + : wrong_type_argument (Qlistp, c)); +} + +/* Take the car or cdr of something whose type is not known. */ +static inline Lisp_Object +CAR_SAFE (Lisp_Object c) +{ + return CONSP (c) ? XCAR (c) : Qnil; +} +static inline Lisp_Object +CDR_SAFE (Lisp_Object c) +{ + return CONSP (c) ? XCDR (c) : Qnil; +} + +/* In a string or vector, the sign bit of the `size' is the gc mark bit. */ + +struct Lisp_String + { + ptrdiff_t size; + ptrdiff_t size_byte; + INTERVAL intervals; /* Text properties in this string. */ + unsigned char *data; + }; /* Nonzero if STR is a multibyte string. */ -#define STRING_MULTIBYTE(STR) \ - (XSTRING (STR)->size_byte >= 0) - -/* Return the length in bytes of STR. */ - -#ifdef GC_CHECK_STRING_BYTES - -struct Lisp_String; -extern ptrdiff_t string_bytes (struct Lisp_String *); -#define STRING_BYTES(S) string_bytes ((S)) - -#else /* not GC_CHECK_STRING_BYTES */ - -#define STRING_BYTES(STR) \ - ((STR)->size_byte < 0 ? (STR)->size : (STR)->size_byte) - -#endif /* not GC_CHECK_STRING_BYTES */ +static inline int +STRING_MULTIBYTE (Lisp_Object str) +{ + return 0 <= XSTRING (str)->size_byte; +} /* An upper bound on the number of bytes in a Lisp string, not counting the terminating null. This a tight enough bound to @@ -727,25 +864,72 @@ else XSTRING (STR)->size_byte = XSTRING (STR)->size; } while (0) /* Get text properties. */ -#define STRING_INTERVALS(STR) (XSTRING (STR)->intervals + 0) +static inline INTERVAL +STRING_INTERVALS (Lisp_Object str) +{ + return XSTRING (str)->intervals; +} /* Set text properties. */ -#define STRING_SET_INTERVALS(STR, INT) (XSTRING (STR)->intervals = (INT)) - -/* In a string or vector, the sign bit of the `size' is the gc mark bit. */ - -struct Lisp_String - { - ptrdiff_t size; - ptrdiff_t size_byte; - INTERVAL intervals; /* Text properties in this string. */ - unsigned char *data; - }; +static inline void +STRING_SET_INTERVALS (Lisp_Object str, INTERVAL intervals) +{ + XSTRING (str)->intervals = intervals; +} + +/* Convenience functions for dealing with Lisp strings. */ + +static inline unsigned char * +SDATA (Lisp_Object string) +{ + return XSTRING (string)->data; +} +static inline char * +SSDATA (Lisp_Object string) +{ + /* Avoid "differ in sign" warnings. */ + return (char *) SDATA (string); +} +static inline unsigned char +SREF (Lisp_Object string, ptrdiff_t index) +{ + return SDATA (string)[index]; +} +static inline void +SSET (Lisp_Object string, ptrdiff_t index, unsigned char new) +{ + SDATA (string)[index] = new; +} +static inline ptrdiff_t +SCHARS (Lisp_Object string) +{ + return XSTRING (string)->size; +} +static inline ptrdiff_t +STRING_BYTES (struct Lisp_String *s) +{ +#ifdef GC_CHECK_STRING_BYTES + extern ptrdiff_t string_bytes (struct Lisp_String *); + return string_bytes (s); +#else + return s->size_byte < 0 ? s->size : s->size_byte; +#endif +} +static inline ptrdiff_t +SBYTES (Lisp_Object string) +{ + return STRING_BYTES (XSTRING (string)); +} +static inline void +STRING_SET_CHARS (Lisp_Object string, ptrdiff_t newsize) +{ + XSTRING (string)->size = newsize; +} /* Header of vector-like objects. This documents the layout constraints on vectors and pseudovectors other than struct Lisp_Subr. It also prevents - compilers from being fooled by Emacs's type punning: the XSETPSEUDOVECTOR - and PSEUDOVECTORP macros cast their pointers to struct vectorlike_header *, + compilers from being fooled by Emacs's type punning: XSETPSEUDOVECTOR + and PSEUDOVECTORP cast their pointers to struct vectorlike_header *, because when two such pointers potentially alias, a compiler won't incorrectly reorder loads and stores to their size fields. See . */ @@ -796,6 +980,23 @@ Lisp_Object contents[1]; }; +/* Conveniences for dealing with Lisp arrays. */ + +/* A macro because it is also used as an lvalue. FIXME: Use ASET instead. */ +#define AREF(ARRAY, IDX) XVECTOR ((ARRAY))->contents[IDX] + +static inline ptrdiff_t +ASIZE (Lisp_Object array) +{ + return XVECTOR (array)->header.size; +} + +static inline void +ASET (Lisp_Object array, ptrdiff_t idx, Lisp_Object val) +{ + XVECTOR (array)->contents[idx] = val; +} + /* If a struct is made to look like a vector, this macro returns the length of the shortest vector that would hold that struct. */ #define VECSIZE(type) ((sizeof (type) \ @@ -810,53 +1011,6 @@ ((offsetof (type, nonlispfield) - offsetof (struct Lisp_Vector, contents[0])) \ / sizeof (Lisp_Object)) -/* A char-table is a kind of vectorlike, with contents are like a - vector but with a few other slots. For some purposes, it makes - sense to handle a char-table with type struct Lisp_Vector. An - element of a char table can be any Lisp objects, but if it is a sub - char-table, we treat it a table that contains information of a - specific range of characters. A sub char-table has the same - structure as a vector. A sub char table appears only in an element - of a char-table, and there's no way to access it directly from - Emacs Lisp program. */ - -/* This is the number of slots that every char table must have. This - counts the ordinary slots and the top, defalt, parent, and purpose - slots. */ -#define CHAR_TABLE_STANDARD_SLOTS (VECSIZE (struct Lisp_Char_Table) - 1) - -/* Return the number of "extra" slots in the char table CT. */ - -#define CHAR_TABLE_EXTRA_SLOTS(CT) \ - (((CT)->header.size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS) - -#ifdef __GNUC__ - -#define CHAR_TABLE_REF_ASCII(CT, IDX) \ - ({struct Lisp_Char_Table *_tbl = NULL; \ - Lisp_Object _val; \ - do { \ - _tbl = _tbl ? XCHAR_TABLE (_tbl->parent) : XCHAR_TABLE (CT); \ - _val = (! SUB_CHAR_TABLE_P (_tbl->ascii) ? _tbl->ascii \ - : XSUB_CHAR_TABLE (_tbl->ascii)->contents[IDX]); \ - if (NILP (_val)) \ - _val = _tbl->defalt; \ - } while (NILP (_val) && ! NILP (_tbl->parent)); \ - _val; }) - -#else /* not __GNUC__ */ - -#define CHAR_TABLE_REF_ASCII(CT, IDX) \ - (! NILP (XCHAR_TABLE (CT)->ascii) \ - ? (! SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii) \ - ? XCHAR_TABLE (CT)->ascii \ - : ! NILP (XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX]) \ - ? XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX] \ - : char_table_ref ((CT), (IDX))) \ - : char_table_ref ((CT), (IDX))) - -#endif /* not __GNUC__ */ - /* Compute A OP B, using the unsigned comparison operator OP. A and B should be integer expressions. This is not the same as mathematical comparison; for example, UNSIGNED_CMP (0, <, -1) @@ -870,31 +1024,23 @@ /* Nonzero iff C is an ASCII character. */ #define ASCII_CHAR_P(c) UNSIGNED_CMP (c, <, 0x80) -/* Almost equivalent to Faref (CT, IDX) with optimization for ASCII - characters. Do not check validity of CT. */ -#define CHAR_TABLE_REF(CT, IDX) \ - (ASCII_CHAR_P (IDX) ? CHAR_TABLE_REF_ASCII ((CT), (IDX)) \ - : char_table_ref ((CT), (IDX))) - -/* Almost equivalent to Faref (CT, IDX). However, if the result is - not a character, return IDX. - - For these characters, do not check validity of CT - and do not follow parent. */ -#define CHAR_TABLE_TRANSLATE(CT, IDX) \ - char_table_translate (CT, IDX) - -/* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and - 8-bit European characters. Do not check validity of CT. */ -#define CHAR_TABLE_SET(CT, IDX, VAL) \ - (ASCII_CHAR_P (IDX) && SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii) \ - ? XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX] = VAL \ - : char_table_set (CT, IDX, VAL)) - -#define CHARTAB_SIZE_BITS_0 6 -#define CHARTAB_SIZE_BITS_1 4 -#define CHARTAB_SIZE_BITS_2 5 -#define CHARTAB_SIZE_BITS_3 7 +/* A char-table is a kind of vectorlike, with contents are like a + vector but with a few other slots. For some purposes, it makes + sense to handle a char-table with type struct Lisp_Vector. An + element of a char table can be any Lisp objects, but if it is a sub + char-table, we treat it a table that contains information of a + specific range of characters. A sub char-table has the same + structure as a vector. A sub char table appears only in an element + of a char-table, and there's no way to access it directly from + Emacs Lisp program. */ + +enum + { + CHARTAB_SIZE_BITS_0 = 6, + CHARTAB_SIZE_BITS_1 = 4, + CHARTAB_SIZE_BITS_2 = 5, + CHARTAB_SIZE_BITS_3 = 7 + }; extern const int chartab_size[4]; @@ -951,6 +1097,70 @@ Lisp_Object contents[1]; }; +/* This is the number of slots that every char table must have. This + counts the ordinary slots and the top, defalt, parent, and purpose + slots. */ +enum { CHAR_TABLE_STANDARD_SLOTS = VECSIZE (struct Lisp_Char_Table) - 1 }; + +/* Return the number of "extra" slots in the char table CT. */ + +static inline int +CHAR_TABLE_EXTRA_SLOTS (struct Lisp_Char_Table *ct) +{ + return ((ct->header.size & PSEUDOVECTOR_SIZE_MASK) + - CHAR_TABLE_STANDARD_SLOTS); +} + +static inline Lisp_Object +CHAR_TABLE_REF_ASCII (Lisp_Object ct, ptrdiff_t idx) +{ + struct Lisp_Char_Table *tbl = NULL; + Lisp_Object val; + do + { + tbl = tbl ? XCHAR_TABLE (tbl->parent) : XCHAR_TABLE (ct); + val = (! SUB_CHAR_TABLE_P (tbl->ascii) ? tbl->ascii + : XSUB_CHAR_TABLE (tbl->ascii)->contents[idx]); + if (NILP (val)) + val = tbl->defalt; + } + while (NILP (val) && ! NILP (tbl->parent)); + + return val; +} + +/* Almost equivalent to Faref (CT, IDX) with optimization for ASCII + characters. Do not check validity of CT. */ +static inline Lisp_Object +CHAR_TABLE_REF (Lisp_Object ct, int idx) +{ + return (ASCII_CHAR_P (idx) + ? CHAR_TABLE_REF_ASCII (ct, idx) + : char_table_ref (ct, idx)); +} + +/* Almost equivalent to Faref (CT, IDX). However, if the result is + not a character, return IDX. + + For these characters, do not check validity of CT + and do not follow parent. */ +static inline int +CHAR_TABLE_TRANSLATE (Lisp_Object ct, int idx) +{ + return char_table_translate (ct, idx); +} + +/* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and + 8-bit European characters. Do not check validity of CT. */ +static inline void +CHAR_TABLE_SET (Lisp_Object ct, int idx, Lisp_Object val) +{ + if (ASCII_CHAR_P (idx) && SUB_CHAR_TABLE_P (XCHAR_TABLE (ct)->ascii)) + XSUB_CHAR_TABLE (XCHAR_TABLE (ct)->ascii)->contents[idx] = val; + else + char_table_set (ct, idx, val); +} + /* A boolvector is a kind of vectorlike, with contents are like a string. */ struct Lisp_Bool_Vector { @@ -1065,41 +1275,86 @@ /* Value is name of symbol. */ -#define SYMBOL_VAL(sym) \ - (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value) -#define SYMBOL_ALIAS(sym) \ - (eassert ((sym)->redirect == SYMBOL_VARALIAS), (sym)->val.alias) -#define SYMBOL_BLV(sym) \ - (eassert ((sym)->redirect == SYMBOL_LOCALIZED), (sym)->val.blv) -#define SYMBOL_FWD(sym) \ - (eassert ((sym)->redirect == SYMBOL_FORWARDED), (sym)->val.fwd) -#define SET_SYMBOL_VAL(sym, v) \ - (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v)) -#define SET_SYMBOL_ALIAS(sym, v) \ - (eassert ((sym)->redirect == SYMBOL_VARALIAS), (sym)->val.alias = (v)) -#define SET_SYMBOL_BLV(sym, v) \ - (eassert ((sym)->redirect == SYMBOL_LOCALIZED), (sym)->val.blv = (v)) -#define SET_SYMBOL_FWD(sym, v) \ - (eassert ((sym)->redirect == SYMBOL_FORWARDED), (sym)->val.fwd = (v)) +static inline Lisp_Object +SYMBOL_VAL (struct Lisp_Symbol *sym) +{ + eassert (sym->redirect == SYMBOL_PLAINVAL); + return sym->val.value; +} +static inline struct Lisp_Symbol * +SYMBOL_ALIAS (struct Lisp_Symbol *sym) +{ + eassert (sym->redirect == SYMBOL_VARALIAS); + return sym->val.alias; +} +static inline struct Lisp_Buffer_Local_Value * +SYMBOL_BLV (struct Lisp_Symbol *sym) +{ + eassert (sym->redirect == SYMBOL_LOCALIZED); + return sym->val.blv; +} +static inline union Lisp_Fwd * +SYMBOL_FWD (struct Lisp_Symbol *sym) +{ + eassert (sym->redirect == SYMBOL_FORWARDED); + return sym->val.fwd; +} +static inline void +SET_SYMBOL_VAL (struct Lisp_Symbol *sym, Lisp_Object v) +{ + eassert (sym->redirect == SYMBOL_PLAINVAL); + sym->val.value = v; +} +static inline void +SET_SYMBOL_ALIAS (struct Lisp_Symbol *sym, struct Lisp_Symbol *v) +{ + eassert (sym->redirect == SYMBOL_VARALIAS); + sym->val.alias = v; +} +static inline void +SET_SYMBOL_BLV (struct Lisp_Symbol *sym, struct Lisp_Buffer_Local_Value *v) +{ + eassert (sym->redirect == SYMBOL_LOCALIZED); + sym->val.blv = v; +} +static inline void +SET_SYMBOL_FWD (struct Lisp_Symbol *sym, union Lisp_Fwd *v) +{ + eassert (sym->redirect == SYMBOL_FORWARDED); + sym->val.fwd = v; +} -#define SYMBOL_NAME(sym) \ - LISP_MAKE_RVALUE (XSYMBOL (sym)->xname) +static inline Lisp_Object +SYMBOL_NAME (Lisp_Object sym) +{ + return XSYMBOL (sym)->xname; +} /* Value is non-zero if SYM is an interned symbol. */ -#define SYMBOL_INTERNED_P(sym) \ - (XSYMBOL (sym)->interned != SYMBOL_UNINTERNED) +static inline int +SYMBOL_INTERNED_P (Lisp_Object sym) +{ + return XSYMBOL (sym)->interned != SYMBOL_UNINTERNED; +} /* Value is non-zero if SYM is interned in initial_obarray. */ -#define SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P(sym) \ - (XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY) +static inline int +SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P (Lisp_Object sym) +{ + return XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY; +} /* Value is non-zero if symbol is considered a constant, i.e. its value cannot be changed (there is an exception for keyword symbols, whose value can be set to the keyword symbol itself). */ -#define SYMBOL_CONSTANT_P(sym) XSYMBOL (sym)->constant +static inline int +SYMBOL_CONSTANT_P (Lisp_Object sym) +{ + return XSYMBOL (sym)->constant; +} #define DEFSYM(sym, name) \ do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (0) @@ -1181,16 +1436,25 @@ }; -#define XHASH_TABLE(OBJ) \ - ((struct Lisp_Hash_Table *) XUNTAG (OBJ, Lisp_Vectorlike)) +static inline struct Lisp_Hash_Table * +XHASH_TABLE (Lisp_Object a) +{ + return XUNTAG (a, Lisp_Vectorlike); +} #define XSET_HASH_TABLE(VAR, PTR) \ (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE)) -#define HASH_TABLE_P(OBJ) PSEUDOVECTORP (OBJ, PVEC_HASH_TABLE) - -#define CHECK_HASH_TABLE(x) \ - CHECK_TYPE (HASH_TABLE_P (x), Qhash_table_p, x) +static inline int +HASH_TABLE_P (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_HASH_TABLE); +} +static inline void +CHECK_HASH_TABLE (Lisp_Object x) +{ + return CHECK_TYPE (HASH_TABLE_P (x), Qhash_table_p, x); +} /* Value is the key part of entry IDX in hash table H. */ @@ -1215,12 +1479,14 @@ #define HASH_INDEX(H, IDX) AREF ((H)->index, (IDX)) /* Value is the size of hash table H. */ - -#define HASH_TABLE_SIZE(H) ASIZE ((H)->next) +static inline ptrdiff_t +HASH_TABLE_SIZE (struct Lisp_Hash_Table *h) +{ + return ASIZE (h->next); +} /* Default size for hash tables if not specified. */ - -#define DEFAULT_HASH_SIZE 65 +enum { DEFAULT_HASH_SIZE = 65 }; /* Default threshold specifying when to resize a hash table. The value gives the ratio of current entries in the hash table and the @@ -1340,6 +1606,43 @@ struct Lisp_Save_Value u_save_value; }; +static inline union Lisp_Misc * +XMISC (Lisp_Object a) +{ + return XUNTAG (a, Lisp_Misc); +} + +static inline struct Lisp_Misc_Any * +XMISCANY (Lisp_Object a) +{ + eassert (MISCP (a)); + return & XMISC (a)->u_any; +} + +/* A macro because it is also used as an lvalue. FIXME: clean this up. */ +#define XMISCTYPE(a) (XMISCANY (a)->type) + +static inline struct Lisp_Marker * +XMARKER (Lisp_Object a) +{ + eassert (MARKERP (a)); + return & XMISC (a)->u_marker; +} + +static inline struct Lisp_Overlay * +XOVERLAY (Lisp_Object a) +{ + eassert (OVERLAYP (a)); + return & XMISC (a)->u_overlay; +} + +static inline struct Lisp_Save_Value * +XSAVE_VALUE (Lisp_Object a) +{ + eassert (SAVE_VALUEP (a)); + return & XMISC (a)->u_save_value; +} + /* Forwarding pointer to an int variable. This is allowed only in the value cell of a symbol, and it means that the symbol's value really lives in the @@ -1429,13 +1732,29 @@ Lisp_Object valcell; }; -#define BLV_FOUND(blv) \ - (eassert ((blv)->found == !EQ ((blv)->defcell, (blv)->valcell)), (blv)->found) -#define SET_BLV_FOUND(blv, v) \ - (eassert ((v) == !EQ ((blv)->defcell, (blv)->valcell)), (blv)->found = (v)) +static inline int +BLV_FOUND (struct Lisp_Buffer_Local_Value *blv) +{ + eassert (blv->found == !EQ (blv->defcell, blv->valcell)); + return blv->found; +} +static inline void +SET_BLV_FOUND (struct Lisp_Buffer_Local_Value *blv, int v) +{ + eassert (v == !EQ (blv->defcell, blv->valcell)); + blv->found = v; +} -#define BLV_VALUE(blv) (XCDR ((blv)->valcell)) -#define SET_BLV_VALUE(blv, v) (XSETCDR ((blv)->valcell, v)) +static inline Lisp_Object +BLV_VALUE (struct Lisp_Buffer_Local_Value *blv) +{ + return XCDR (blv->valcell); +} +static inline void +SET_BLV_VALUE (struct Lisp_Buffer_Local_Value *blv, Lisp_Object v) +{ + XSETCDR (blv->valcell, v); +} /* Like Lisp_Objfwd except that value lives in a slot in the current kboard. */ @@ -1453,6 +1772,47 @@ struct Lisp_Buffer_Objfwd u_buffer_objfwd; struct Lisp_Kboard_Objfwd u_kboard_objfwd; }; + +static inline enum Lisp_Fwd_Type +XFWDTYPE (union Lisp_Fwd *a) +{ + return a->u_intfwd.type; +} + +static inline struct Lisp_Intfwd * +XINTFWD (union Lisp_Fwd *a) +{ + eassert (INTFWDP (a)); + return &a->u_intfwd; +} + +static inline struct Lisp_Boolfwd * +XBOOLFWD (union Lisp_Fwd *a) +{ + eassert (BOOLFWDP (a)); + return &a->u_boolfwd; +} + +static inline struct Lisp_Objfwd * +XOBJFWD (union Lisp_Fwd *a) +{ + eassert (OBJFWDP (a)); + return &a->u_objfwd; +} + +static inline struct Lisp_Buffer_Objfwd * +XBUFFER_OBJFWD (union Lisp_Fwd *a) +{ + eassert (BUFFER_OBJFWDP (a)); + return &a->u_buffer_objfwd; +} + +static inline struct Lisp_Kboard_Objfwd * +XKBOARD_OBJFWD (union Lisp_Fwd *a) +{ + eassert (KBOARD_OBJFWDP (a)); + return &a->u_kboard_objfwd; +} /* Lisp floating point type. */ struct Lisp_Float @@ -1468,13 +1828,24 @@ } u; }; +static inline double +XFLOAT_DATA (Lisp_Object f) +{ #ifdef HIDE_LISP_IMPLEMENTATION -#define XFLOAT_DATA(f) (0 ? XFLOAT (f)->u.data_ : XFLOAT (f)->u.data_) + return XFLOAT (f)->u.data_; #else -#define XFLOAT_DATA(f) (0 ? XFLOAT (f)->u.data : XFLOAT (f)->u.data) + return XFLOAT (f)->u.data; +#endif +} + +#ifndef HIDE_LISP_IMPLEMENTATION /* This should be used only in alloc.c, which always disables HIDE_LISP_IMPLEMENTATION. */ -#define XFLOAT_INIT(f,n) (XFLOAT (f)->u.data = (n)) +static inline void +XFLOAT_INIT (Lisp_Object f, double n) +{ + XFLOAT (f)->u.data = n; +} #endif /* A character, declared with the following typedef, is a member @@ -1485,91 +1856,36 @@ #endif /* Meanings of slots in a Lisp_Compiled: */ - -#define COMPILED_ARGLIST 0 -#define COMPILED_BYTECODE 1 -#define COMPILED_CONSTANTS 2 -#define COMPILED_STACK_DEPTH 3 -#define COMPILED_DOC_STRING 4 -#define COMPILED_INTERACTIVE 5 +enum + { + COMPILED_ARGLIST, + COMPILED_BYTECODE, + COMPILED_CONSTANTS, + COMPILED_STACK_DEPTH, + COMPILED_DOC_STRING, + COMPILED_INTERACTIVE + }; /* Flag bits in a character. These also get used in termhooks.h. Richard Stallman thinks that MULE (MUlti-Lingual Emacs) might need 22 bits for the character value itself, so we probably shouldn't use any bits lower than 0x0400000. */ -#define CHAR_ALT (0x0400000) -#define CHAR_SUPER (0x0800000) -#define CHAR_HYPER (0x1000000) -#define CHAR_SHIFT (0x2000000) -#define CHAR_CTL (0x4000000) -#define CHAR_META (0x8000000) - -#define CHAR_MODIFIER_MASK \ - (CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META) - +enum + { + CHAR_ALT = 0x0400000, + CHAR_SUPER = 0x0800000, + CHAR_HYPER = 0x1000000, + CHAR_SHIFT = 0x2000000, + CHAR_CTL = 0x4000000, + CHAR_META = 0x8000000, + CHAR_MODIFIER_MASK = + CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META + }; /* Actually, the current Emacs uses 22 bits for the character value itself. */ -#define CHARACTERBITS 22 - - -/* The glyph datatype, used to represent characters on the display. - It consists of a char code and a face id. */ - -typedef struct { - int ch; - int face_id; -} GLYPH; - -/* Return a glyph's character code. */ -#define GLYPH_CHAR(glyph) ((glyph).ch) - -/* Return a glyph's face ID. */ -#define GLYPH_FACE(glyph) ((glyph).face_id) - -#define SET_GLYPH_CHAR(glyph, char) ((glyph).ch = (char)) -#define SET_GLYPH_FACE(glyph, face) ((glyph).face_id = (face)) -#define SET_GLYPH(glyph, char, face) ((glyph).ch = (char), (glyph).face_id = (face)) - -/* Return 1 if GLYPH contains valid character code. */ -#define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (GLYPH_CHAR (glyph)) - - -/* Glyph Code from a display vector may either be an integer which - encodes a char code in the lower CHARACTERBITS bits and a (very small) - face-id in the upper bits, or it may be a cons (CHAR . FACE-ID). */ - -#define GLYPH_CODE_P(gc) \ - (CONSP (gc) \ - ? (CHARACTERP (XCAR (gc)) \ - && RANGED_INTEGERP (0, XCDR (gc), MAX_FACE_ID)) \ - : (RANGED_INTEGERP \ - (0, gc, \ - (MAX_FACE_ID < TYPE_MAXIMUM (EMACS_INT) >> CHARACTERBITS \ - ? ((EMACS_INT) MAX_FACE_ID << CHARACTERBITS) | MAX_CHAR \ - : TYPE_MAXIMUM (EMACS_INT))))) - -/* The following are valid only if GLYPH_CODE_P (gc). */ - -#define GLYPH_CODE_CHAR(gc) \ - (CONSP (gc) ? XINT (XCAR (gc)) : XINT (gc) & ((1 << CHARACTERBITS) - 1)) - -#define GLYPH_CODE_FACE(gc) \ - (CONSP (gc) ? XINT (XCDR (gc)) : XINT (gc) >> CHARACTERBITS) - -#define SET_GLYPH_FROM_GLYPH_CODE(glyph, gc) \ - do \ - { \ - if (CONSP (gc)) \ - SET_GLYPH (glyph, XINT (XCAR (gc)), XINT (XCDR (gc))); \ - else \ - SET_GLYPH (glyph, (XINT (gc) & ((1 << CHARACTERBITS)-1)), \ - (XINT (gc) >> CHARACTERBITS)); \ - } \ - while (0) - -/* The ID of the mode line highlighting face. */ -#define GLYPH_MODE_LINE_FACE 1 +enum { CHARACTERBITS = 22 }; + /* Structure to hold mouse highlight data. This is here because other header files need it for defining struct x_output etc. */ @@ -1608,140 +1924,304 @@ /* Data type checking */ -#define NILP(x) EQ (x, Qnil) - -#define NUMBERP(x) (INTEGERP (x) || FLOATP (x)) -#define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0) - -#define RANGED_INTEGERP(lo, x, hi) \ - (INTEGERP (x) && (lo) <= XINT (x) && XINT (x) <= (hi)) +static inline int +NILP (Lisp_Object x) +{ + return EQ (x, Qnil); +} + +static inline int +NUMBERP (Lisp_Object x) +{ + return INTEGERP (x) || FLOATP (x); +} +static inline int +NATNUMP (Lisp_Object x) +{ + return INTEGERP (x) && 0 <= XINT (x); +} + +static inline int +RANGED_INTEGERP (intmax_t lo, Lisp_Object x, intmax_t hi) +{ + return INTEGERP (x) && lo <= XINT (x) && XINT (x) <= hi; +} + #define TYPE_RANGED_INTEGERP(type, x) \ - (TYPE_SIGNED (type) \ - ? RANGED_INTEGERP (TYPE_MINIMUM (type), x, TYPE_MAXIMUM (type)) \ - : RANGED_INTEGERP (0, x, TYPE_MAXIMUM (type))) - -#define INTEGERP(x) (LISP_INT_TAG_P (XTYPE ((x)))) -#define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol) -#define MISCP(x) (XTYPE ((x)) == Lisp_Misc) -#define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike) -#define STRINGP(x) (XTYPE ((x)) == Lisp_String) -#define CONSP(x) (XTYPE ((x)) == Lisp_Cons) - -#define FLOATP(x) (XTYPE ((x)) == Lisp_Float) -#define VECTORP(x) (VECTORLIKEP (x) && !(ASIZE (x) & PSEUDOVECTOR_FLAG)) -#define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay) -#define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker) -#define SAVE_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Save_Value) - -#define INTFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Int) -#define BOOLFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Bool) -#define OBJFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Obj) -#define BUFFER_OBJFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Buffer_Obj) -#define KBOARD_OBJFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Kboard_Obj) - -/* True if object X is a pseudovector whose code is CODE. The cast to struct - vectorlike_header * avoids aliasing issues. */ -#define PSEUDOVECTORP(x, code) \ - TYPED_PSEUDOVECTORP (x, vectorlike_header, code) - -#define PSEUDOVECTOR_TYPEP(v, code) \ - (((v)->size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK)) \ - == (PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_SIZE_BITS))) - -/* True if object X, with internal type struct T *, is a pseudovector whose - code is CODE. */ -#define TYPED_PSEUDOVECTORP(x, t, code) \ - (VECTORLIKEP (x) \ - && PSEUDOVECTOR_TYPEP ((struct t *) XUNTAG (x, Lisp_Vectorlike), code)) + (INTEGERP (x) \ + && (TYPE_SIGNED (type) ? TYPE_MINIMUM (type) <= XINT (x) : 0 <= XINT (x)) \ + && XINT (x) <= TYPE_MAXIMUM (type)) + +static inline int CONSP (Lisp_Object x) { return XTYPE (x) == Lisp_Cons; } +static inline int FLOATP (Lisp_Object x) { return XTYPE (x) == Lisp_Float; } +static inline int MISCP (Lisp_Object x) { return XTYPE (x) == Lisp_Misc; } +static inline int STRINGP (Lisp_Object x) { return XTYPE (x) == Lisp_String; } +static inline int SYMBOLP (Lisp_Object x) { return XTYPE (x) == Lisp_Symbol; } +static inline int +INTEGERP (Lisp_Object x) +{ + return LISP_INT_TAG_P (XTYPE (x)); +} +static inline int +VECTORLIKEP (Lisp_Object x) +{ + return XTYPE (x) == Lisp_Vectorlike; +} +static inline int +VECTORP (Lisp_Object x) +{ + return VECTORLIKEP (x) && ! (ASIZE (x) & PSEUDOVECTOR_FLAG); +} +static inline int +OVERLAYP (Lisp_Object x) +{ + return MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay; +} +static inline int +MARKERP (Lisp_Object x) +{ + return MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker; +} +static inline int +SAVE_VALUEP (Lisp_Object x) +{ + return MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Save_Value; +} + +static inline int +INTFWDP (union Lisp_Fwd *a) +{ + return XFWDTYPE (a) == Lisp_Fwd_Int; +} +static inline int +BOOLFWDP (union Lisp_Fwd *a) +{ + return XFWDTYPE (a) == Lisp_Fwd_Bool; +} +static inline int +OBJFWDP (union Lisp_Fwd *a) +{ + return XFWDTYPE (a) == Lisp_Fwd_Obj; +} +static inline int +BUFFER_OBJFWDP (union Lisp_Fwd *a) +{ + return XFWDTYPE (a) == Lisp_Fwd_Buffer_Obj; +} +static inline int +KBOARD_OBJFWDP (union Lisp_Fwd *a) +{ + return XFWDTYPE (a) == Lisp_Fwd_Kboard_Obj; +} + +/* True if the size field SIZE of a pseudovector is that of a + pseudovector whose code is CODE. */ +static inline int +PSEUDOVECTOR_SIZE_TYPEP (ptrdiff_t size, int code) +{ + return ((size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK)) + == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_SIZE_BITS))); +} + +/* True if A is a pseudovector whose code is CODE. */ +static inline int +PSEUDOVECTORP (Lisp_Object a, int code) +{ + if (! VECTORLIKEP (a)) + return 0; + else + { + /* Converting to struct vectorlike_header * avoids aliasing issues. */ + struct vectorlike_header *h = XUNTAG (a, Lisp_Vectorlike); + return PSEUDOVECTOR_SIZE_TYPEP (h->size, code); + } +} + /* Test for specific pseudovector types. */ -#define WINDOW_CONFIGURATIONP(x) PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION) -#define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS) -#define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW) -#define TERMINALP(x) PSEUDOVECTORP (x, PVEC_TERMINAL) + +static inline int +WINDOW_CONFIGURATIONP (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_WINDOW_CONFIGURATION); +} + +static inline int +PROCESSP (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_PROCESS); +} + +static inline int +WINDOWP (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_WINDOW); +} + +static inline int +TERMINALP (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_TERMINAL); +} + /* SUBRP is special since Lisp_Subr lacks struct vectorlike_header. */ -#define SUBRP(x) TYPED_PSEUDOVECTORP (x, Lisp_Subr, PVEC_SUBR) -#define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED) -#define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER) -#define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE) -#define SUB_CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_SUB_CHAR_TABLE) -#define BOOL_VECTOR_P(x) PSEUDOVECTORP (x, PVEC_BOOL_VECTOR) -#define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME) +static inline int +SUBRP (Lisp_Object a) +{ + if (! VECTORLIKEP (a)) + return 0; + else + { + struct Lisp_Subr *h = XUNTAG (a, Lisp_Vectorlike); + return PSEUDOVECTOR_SIZE_TYPEP (h->size, PVEC_SUBR); + } +} + +static inline int +COMPILEDP (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_COMPILED); +} + +static inline int +BUFFERP (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_BUFFER); +} + +static inline int +CHAR_TABLE_P (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_CHAR_TABLE); +} + +static inline int +SUB_CHAR_TABLE_P (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_SUB_CHAR_TABLE); +} + +static inline int +BOOL_VECTOR_P (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_BOOL_VECTOR); +} + +static inline int +FRAMEP (Lisp_Object a) +{ + return PSEUDOVECTORP (a, PVEC_FRAME); +} /* Test for image (image . spec) */ -#define IMAGEP(x) (CONSP (x) && EQ (XCAR (x), Qimage)) +static inline int +IMAGEP (Lisp_Object x) +{ + return CONSP (x) && EQ (XCAR (x), Qimage); +} /* Array types. */ - -#define ARRAYP(x) \ - (VECTORP (x) || STRINGP (x) || CHAR_TABLE_P (x) || BOOL_VECTOR_P (x)) +static inline int +ARRAYP (Lisp_Object x) +{ + return VECTORP (x) || STRINGP (x) || CHAR_TABLE_P (x) || BOOL_VECTOR_P (x); +} -#define CHECK_LIST(x) \ - CHECK_TYPE (CONSP (x) || NILP (x), Qlistp, x) - -#define CHECK_LIST_CONS(x, y) \ - CHECK_TYPE (CONSP (x), Qlistp, y) - -#define CHECK_LIST_END(x, y) \ - CHECK_TYPE (NILP (x), Qlistp, y) - -#define CHECK_STRING(x) \ - CHECK_TYPE (STRINGP (x), Qstringp, x) - -#define CHECK_STRING_CAR(x) \ - CHECK_TYPE (STRINGP (XCAR (x)), Qstringp, XCAR (x)) - -#define CHECK_CONS(x) \ - CHECK_TYPE (CONSP (x), Qconsp, x) - -#define CHECK_SYMBOL(x) \ - CHECK_TYPE (SYMBOLP (x), Qsymbolp, x) - -#define CHECK_CHAR_TABLE(x) \ - CHECK_TYPE (CHAR_TABLE_P (x), Qchar_table_p, x) - -#define CHECK_VECTOR(x) \ - CHECK_TYPE (VECTORP (x), Qvectorp, x) - -#define CHECK_VECTOR_OR_STRING(x) \ - CHECK_TYPE (VECTORP (x) || STRINGP (x), Qarrayp, x) - -#define CHECK_ARRAY(x, Qxxxp) \ - CHECK_TYPE (ARRAYP (x), Qxxxp, x) - -#define CHECK_VECTOR_OR_CHAR_TABLE(x) \ - CHECK_TYPE (VECTORP (x) || CHAR_TABLE_P (x), Qvector_or_char_table_p, x) - -#define CHECK_BUFFER(x) \ - CHECK_TYPE (BUFFERP (x), Qbufferp, x) - -#define CHECK_WINDOW(x) \ - CHECK_TYPE (WINDOWP (x), Qwindowp, x) - -#define CHECK_WINDOW_CONFIGURATION(x) \ - CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x) - -/* This macro rejects windows on the interior of the window tree as - "dead", which is what we want; this is an argument-checking macro, and - the user should never get access to interior windows. - - A window of any sort, leaf or interior, is dead if the buffer, - vchild, and hchild members are all nil. */ - -#define CHECK_LIVE_WINDOW(x) \ - CHECK_TYPE (WINDOWP (x) && !NILP (XWINDOW (x)->buffer), Qwindow_live_p, x) - -#define CHECK_PROCESS(x) \ - CHECK_TYPE (PROCESSP (x), Qprocessp, x) - -#define CHECK_SUBR(x) \ - CHECK_TYPE (SUBRP (x), Qsubrp, x) - -#define CHECK_NUMBER(x) \ - CHECK_TYPE (INTEGERP (x), Qintegerp, x) - -#define CHECK_NATNUM(x) \ - CHECK_TYPE (NATNUMP (x), Qwholenump, x) +static inline void +CHECK_LIST (Lisp_Object x) +{ + CHECK_TYPE (CONSP (x) || NILP (x), Qlistp, x); +} +static inline void +CHECK_LIST_CONS (Lisp_Object x, Lisp_Object y) +{ + CHECK_TYPE (CONSP (x), Qlistp, y); +} +static inline void +CHECK_LIST_END (Lisp_Object x, Lisp_Object y) +{ + CHECK_TYPE (NILP (x), Qlistp, y); +} +static inline void +CHECK_STRING (Lisp_Object x) +{ + CHECK_TYPE (STRINGP (x), Qstringp, x); +} +static inline void +CHECK_STRING_CAR (Lisp_Object x) +{ + CHECK_TYPE (STRINGP (XCAR (x)), Qstringp, XCAR (x)); +} +static inline void +CHECK_CONS (Lisp_Object x) +{ + CHECK_TYPE (CONSP (x), Qconsp, x); +} +static inline void +CHECK_SYMBOL (Lisp_Object x) +{ + CHECK_TYPE (SYMBOLP (x), Qsymbolp, x); +} +static inline void +CHECK_CHAR_TABLE (Lisp_Object x) +{ + CHECK_TYPE (CHAR_TABLE_P (x), Qchar_table_p, x); +} +static inline void +CHECK_VECTOR (Lisp_Object x) +{ + CHECK_TYPE (VECTORP (x), Qvectorp, x); +} +static inline void +CHECK_VECTOR_OR_STRING (Lisp_Object x) +{ + CHECK_TYPE (VECTORP (x) || STRINGP (x), Qarrayp, x); +} +static inline void +CHECK_ARRAY (Lisp_Object x, Lisp_Object Qxxxp) +{ + CHECK_TYPE (ARRAYP (x), Qxxxp, x); +} +static inline void +CHECK_VECTOR_OR_CHAR_TABLE (Lisp_Object x) +{ + CHECK_TYPE (VECTORP (x) || CHAR_TABLE_P (x), Qvector_or_char_table_p, x); +} +static inline void +CHECK_BUFFER (Lisp_Object x) +{ + CHECK_TYPE (BUFFERP (x), Qbufferp, x); +} +static inline void +CHECK_WINDOW (Lisp_Object x) +{ + CHECK_TYPE (WINDOWP (x), Qwindowp, x); +} +static inline void +CHECK_WINDOW_CONFIGURATION (Lisp_Object x) +{ + CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x); +} +static inline void +CHECK_PROCESS (Lisp_Object x) +{ + CHECK_TYPE (PROCESSP (x), Qprocessp, x); +} +static inline void +CHECK_SUBR (Lisp_Object x) +{ + CHECK_TYPE (SUBRP (x), Qsubrp, x); +} +static inline void +CHECK_NUMBER (Lisp_Object x) +{ + CHECK_TYPE (INTEGERP (x), Qintegerp, x); +} +static inline void +CHECK_NATNUM (Lisp_Object x) +{ + CHECK_TYPE (NATNUMP (x), Qwholenump, x); +} #define CHECK_RANGED_INTEGER(x, lo, hi) \ do { \ @@ -1762,57 +2242,76 @@ CHECK_RANGED_INTEGER (x, 0, TYPE_MAXIMUM (type)); \ } while (0) -#define CHECK_MARKER(x) \ - CHECK_TYPE (MARKERP (x), Qmarkerp, x) +static inline void +CHECK_MARKER (Lisp_Object x) +{ + CHECK_TYPE (MARKERP (x), Qmarkerp, x); +} #define CHECK_NUMBER_COERCE_MARKER(x) \ do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \ else CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); } while (0) -#define XFLOATINT(n) extract_float((n)) - -#define CHECK_FLOAT(x) \ - CHECK_TYPE (FLOATP (x), Qfloatp, x) - -#define CHECK_NUMBER_OR_FLOAT(x) \ - CHECK_TYPE (FLOATP (x) || INTEGERP (x), Qnumberp, x) +static inline double +XFLOATINT (Lisp_Object n) +{ + return extract_float (n); +} + +static inline void +CHECK_FLOAT (Lisp_Object x) +{ + CHECK_TYPE (FLOATP (x), Qfloatp, x); +} +static inline void +CHECK_NUMBER_OR_FLOAT (Lisp_Object x) +{ + CHECK_TYPE (FLOATP (x) || INTEGERP (x), Qnumberp, x); +} #define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x) \ do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x)); \ else CHECK_TYPE (INTEGERP (x) || FLOATP (x), Qnumber_or_marker_p, x); } while (0) -#define CHECK_OVERLAY(x) \ - CHECK_TYPE (OVERLAYP (x), Qoverlayp, x) +static inline void +CHECK_OVERLAY (Lisp_Object x) +{ + CHECK_TYPE (OVERLAYP (x), Qoverlayp, x); +} /* Since we can't assign directly to the CAR or CDR fields of a cons cell, use these when checking that those fields contain numbers. */ -#define CHECK_NUMBER_CAR(x) \ - do { \ - Lisp_Object tmp = XCAR (x); \ - CHECK_NUMBER (tmp); \ - XSETCAR ((x), tmp); \ - } while (0) - -#define CHECK_NUMBER_CDR(x) \ - do { \ - Lisp_Object tmp = XCDR (x); \ - CHECK_NUMBER (tmp); \ - XSETCDR ((x), tmp); \ - } while (0) - -#define CHECK_NATNUM_CAR(x) \ - do { \ - Lisp_Object tmp = XCAR (x); \ - CHECK_NATNUM (tmp); \ - XSETCAR ((x), tmp); \ - } while (0) - -#define CHECK_NATNUM_CDR(x) \ - do { \ - Lisp_Object tmp = XCDR (x); \ - CHECK_NATNUM (tmp); \ - XSETCDR ((x), tmp); \ - } while (0) +static inline void +CHECK_NUMBER_CAR (Lisp_Object x) +{ + Lisp_Object tmp = XCAR (x); + CHECK_NUMBER (tmp); + XSETCAR (x, tmp); +} + +static inline void +CHECK_NUMBER_CDR (Lisp_Object x) +{ + Lisp_Object tmp = XCDR (x); + CHECK_NUMBER (tmp); + XSETCDR (x, tmp); +} + +static inline void +CHECK_NATNUM_CAR (Lisp_Object x) +{ + Lisp_Object tmp = XCAR (x); + CHECK_NATNUM (tmp); + XSETCAR (x, tmp); +} + +static inline void +CHECK_NATNUM_CDR (Lisp_Object x) +{ + Lisp_Object tmp = XCDR (x); + CHECK_NATNUM (tmp); + XSETCDR (x, tmp); +} /* Define a built-in function for calling from Lisp. `lname' should be the name to give the function in Lisp, @@ -1879,18 +2378,20 @@ Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object) /* Non-zero if OBJ is a Lisp function. */ -#define FUNCTIONP(OBJ) \ - ((CONSP (OBJ) && EQ (XCAR (OBJ), Qlambda)) \ - || (SYMBOLP (OBJ) && !NILP (Ffboundp (OBJ))) \ - || COMPILEDP (OBJ) \ - || SUBRP (OBJ)) +static inline int +FUNCTIONP (Lisp_Object obj) +{ + return ((CONSP (obj) && EQ (XCAR (obj), Qlambda)) + || (SYMBOLP (obj) && !NILP (Ffboundp (obj))) + || COMPILEDP (obj) + || SUBRP (obj)); +} /* defsubr (Sname); is how we define the symbol for function `name' at start-up time. */ extern void defsubr (struct Lisp_Subr *); -#define MANY -2 -#define UNEVALLED -1 +enum { MANY = -2, UNEVALLED = -1 }; extern void defvar_lisp (struct Lisp_Objfwd *, const char *, Lisp_Object *); extern void defvar_lisp_nopro (struct Lisp_Objfwd *, const char *, Lisp_Object *); @@ -1983,7 +2484,11 @@ extern struct specbinding *specpdl_ptr; extern ptrdiff_t specpdl_size; -#define SPECPDL_INDEX() (specpdl_ptr - specpdl) +static inline ptrdiff_t +SPECPDL_INDEX (void) +{ + return specpdl_ptr - specpdl; +} /* Everything needed to describe an active condition case. */ struct handler @@ -2301,6 +2806,8 @@ #define EXFUN(fnname, maxargs) \ extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs +#include "globals.h" + /* Forward declarations for prototypes. */ struct window; struct frame; @@ -2334,6 +2841,7 @@ extern Lisp_Object Qinteger; +extern Lisp_Object Qsubrp; extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object; EXFUN (Fbyteorder, 0) ATTRIBUTE_CONST; @@ -2429,6 +2937,7 @@ extern Lisp_Object Qcursor_in_echo_area; extern Lisp_Object Qstring_lessp; extern Lisp_Object QCsize, QCtest, QCweakness, Qequal, Qeq, Qeql; +extern Lisp_Object Qhash_table_p; EMACS_UINT hash_string (char const *, ptrdiff_t); EMACS_UINT sxhash (Lisp_Object, int); Lisp_Object make_hash_table (Lisp_Object, Lisp_Object, Lisp_Object, @@ -2714,7 +3223,7 @@ Lisp_Object); extern Lisp_Object internal_with_output_to_temp_buffer (const char *, Lisp_Object (*) (Lisp_Object), Lisp_Object); -#define FLOAT_TO_STRING_BUFSIZE 350 +enum { FLOAT_TO_STRING_BUFSIZE = 350 }; extern int float_to_string (char *, double); extern void syms_of_print (void); @@ -2737,10 +3246,12 @@ extern Lisp_Object intern_1 (const char *, ptrdiff_t); extern Lisp_Object intern_c_string_1 (const char *, ptrdiff_t); extern Lisp_Object oblookup (Lisp_Object, const char *, ptrdiff_t, ptrdiff_t); -#define LOADHIST_ATTACH(x) \ - do { \ - if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list); \ - } while (0) +static inline void +LOADHIST_ATTACH (Lisp_Object x) +{ + if (initialized) + Vcurrent_load_list = Fcons (x, Vcurrent_load_list); +} extern int openp (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object *, Lisp_Object); Lisp_Object string_to_number (char const *, int, int); @@ -2858,6 +3369,7 @@ extern Lisp_Object Vbuffer_alist; extern Lisp_Object set_buffer_if_live (Lisp_Object); extern Lisp_Object other_buffer_safely (Lisp_Object); +extern Lisp_Object Qoverlayp; extern Lisp_Object Qpriority, Qwindow, Qbefore_string, Qafter_string; extern Lisp_Object get_truename_buffer (Lisp_Object); extern struct buffer *all_buffers; @@ -3015,10 +3527,10 @@ void synchronize_system_messages_locale (void); void synchronize_system_time_locale (void); #else -#define setlocale(category, locale) -#define fixup_locale() -#define synchronize_system_messages_locale() -#define synchronize_system_time_locale() +static inline char *setlocale (int cat, char const *locale) { return 0; } +static inline void fixup_locale (void) {} +static inline void synchronize_system_messages_locale (void) {} +static inline void synchronize_system_time_locale (void) {} #endif void shut_down_emacs (int, int, Lisp_Object); /* Nonzero means don't do interactive redisplay and don't change tty modes. */ @@ -3281,19 +3793,19 @@ in addition to a device separator. Set the path separator to '/', and don't test for a device separator in IS_ANY_SEP. */ -#define DIRECTORY_SEP '/' +enum { DIRECTORY_SEP = '/' }; #ifndef IS_DIRECTORY_SEP -#define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP) +static inline int IS_DIRECTORY_SEP (int c) { return c == DIRECTORY_SEP; } #endif #ifndef IS_DEVICE_SEP #ifndef DEVICE_SEP -#define IS_DEVICE_SEP(_c_) 0 +static inline int IS_DEVICE_SEP (int c) { return 0; } #else -#define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP) +static inline int IS_DEVICE_SEP (int c) { return c == DEVICE_SEP; } #endif #endif #ifndef IS_ANY_SEP -#define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_)) +static inline int IS_ANY_SEP (int c) { return IS_DIRECTORY_SEP (c); } #endif #define SWITCH_ENUM_CAST(x) (x) @@ -3313,15 +3825,6 @@ # define lint_assume(cond) ((void) (0 && (cond))) #endif -/* The ubiquitous min and max macros. */ - -#ifdef max -#undef max -#undef min -#endif -#define min(a, b) ((a) < (b) ? (a) : (b)) -#define max(a, b) ((a) > (b) ? (a) : (b)) - /* We used to use `abs', but that clashes with system headers on some platforms, and using a name reserved by Standard C is a bad idea anyway. */ @@ -3364,7 +3867,7 @@ /* SAFE_ALLOCA normally allocates memory on the stack, but if size is larger than MAX_ALLOCA, use xmalloc to avoid overflowing the stack. */ -#define MAX_ALLOCA 16*1024 +enum { MAX_ALLOCA = 16*1024 }; extern Lisp_Object safe_alloca_unwind (Lisp_Object); @@ -3433,7 +3936,4 @@ memory_full (SIZE_MAX); \ } while (0) - -#include "globals.h" - #endif /* EMACS_LISP_H */ === modified file 'src/mem-limits.h' --- src/mem-limits.h 2012-07-09 16:38:45 +0000 +++ src/mem-limits.h 2012-07-13 03:37:42 +0000 @@ -36,9 +36,7 @@ extern char *start_of_data (void) ATTRIBUTE_CONST; #if USE_LSB_TAG || UINTPTR_MAX <= VAL_MAX #define EXCEEDS_LISP_PTR(ptr) 0 -#elif defined DATA_SEG_BITS +#else #define EXCEEDS_LISP_PTR(ptr) \ (((uintptr_t) (ptr) & ~DATA_SEG_BITS) >> VALBITS) -#else -#define EXCEEDS_LISP_PTR(ptr) ((uintptr_t) (ptr) >> VALBITS) #endif === modified file 'src/window.c' --- src/window.c 2012-07-10 16:53:26 +0000 +++ src/window.c 2012-07-13 03:37:42 +0000 @@ -51,8 +51,8 @@ #include "nsterm.h" #endif -Lisp_Object Qwindowp, Qwindow_live_p; -static Lisp_Object Qwindow_configuration_p, Qrecord_window_buffer; +Lisp_Object Qwindowp, Qwindow_live_p, Qwindow_configuration_p; +static Lisp_Object Qrecord_window_buffer; static Lisp_Object Qwindow_deletable_p, Qdelete_window, Qdisplay_buffer; static Lisp_Object Qreplace_buffer_in_windows, Qget_mru_window; static Lisp_Object Qwindow_resize_root_window, Qwindow_resize_root_window_vertically; === modified file 'src/window.h' --- src/window.h 2012-07-05 15:20:12 +0000 +++ src/window.h 2012-07-13 03:37:42 +0000 @@ -885,7 +885,7 @@ /* These used to be in lisp.h. */ -extern Lisp_Object Qwindowp, Qwindow_live_p; +extern Lisp_Object Qwindow_live_p; extern Lisp_Object Vwindow_list; extern int compare_window_configurations (Lisp_Object, Lisp_Object, int); @@ -900,4 +900,17 @@ extern void syms_of_window (void); extern void keys_of_window (void); +/* CHECK_LIVE_WINDOW rejects windows on the interior of the window tree as + "dead", which is what we want; this is an argument-checking function, and + the user should never get access to interior windows. + + A window of any sort, leaf or interior, is dead if the buffer, + vchild, and hchild members are all nil. */ +static inline void +CHECK_LIVE_WINDOW (Lisp_Object x) +{ + CHECK_TYPE (WINDOWP (x) && !NILP (XWINDOW (x)->buffer), Qwindow_live_p, x); +} + + #endif /* not WINDOW_H_INCLUDED */ From debbugs-submit-bounces@debbugs.gnu.org Fri Jul 13 22:25:58 2012 Received: (at 11935) by debbugs.gnu.org; 14 Jul 2012 02:25:58 +0000 Received: from localhost ([127.0.0.1]:39994 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sps3R-0002wy-Lx for submit@debbugs.gnu.org; Fri, 13 Jul 2012 22:25:57 -0400 Received: from fencepost.gnu.org ([208.118.235.10]:53044) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sps3P-0002wl-8T for 11935@debbugs.gnu.org; Fri, 13 Jul 2012 22:25:55 -0400 Received: from rms by fencepost.gnu.org with local (Exim 4.71) (envelope-from ) id 1Sprxu-0007gg-5D; Fri, 13 Jul 2012 22:20:14 -0400 Date: Fri, 13 Jul 2012 22:20:14 -0400 Message-Id: Content-Type: text/plain; charset=ISO-8859-15 From: Richard Stallman To: Paul Eggert In-reply-to: <500039B7.8050106@cs.ucla.edu> (message from Paul Eggert on Fri, 13 Jul 2012 08:07:35 -0700) Subject: Re: [TRUNCATED MESSAGE 2746 87596] bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> X-Spam-Score: -6.9 (------) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: rms@gnu.org 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: -6.9 (------) In the old days Emacs had to use macros for this sort of thing, because C compilers generated significantly faster code with macros. Modern C compilers, however, don't have this problem. That could be true if the functions are inlined. How does this change affect performance with -O0? -- Dr Richard Stallman President, Free Software Foundation 51 Franklin St Boston MA 02110 USA www.fsf.org www.gnu.org Skype: No way! That's nonfree (freedom-denying) software. Use Ekiga or an ordinary phone call From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 15 09:47:21 2012 Received: (at 11935) by debbugs.gnu.org; 15 Jul 2012 13:47:21 +0000 Received: from localhost ([127.0.0.1]:42615 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqPAP-000362-4N for submit@debbugs.gnu.org; Sun, 15 Jul 2012 09:47:21 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:35680) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqPAN-00035u-29 for 11935@debbugs.gnu.org; Sun, 15 Jul 2012 09:47:20 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 94150A60001; Sun, 15 Jul 2012 06:41:29 -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 ZFNZt2CJD5kA; Sun, 15 Jul 2012 06:41:28 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id ADA9A39E8008; Sun, 15 Jul 2012 06:41:28 -0700 (PDT) Message-ID: <5002C895.4080400@cs.ucla.edu> Date: Sun, 15 Jul 2012 06:41:41 -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: rms@gnu.org Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> In-Reply-To: Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@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 07/13/2012 07:20 PM, Richard Stallman wrote: > How does this change affect performance with -O0? It hurts it. In normal operation I don't notice -- everything is plenty fast enough -- but in an artificial benchmark designed to stress the new code (see below) the performance is significantly worse. If this is an issue, we can mark these new functions with __attribute__ ((__always_inline__)), but I'm inclined to try things without this attribute, and resort to the attribute only if needed. I did two measures of performance. "text" simply counts the number of bytes in the text segment. "bench" counts the number of CPU seconds consumed by running the benchmark described below. "current" refers to trunk bzr 109093, and "patched" to that bzr after the proposed patch is applied. In both cases I've normalized the numbers to the current default (so it scores as 1), and smaller numbers are better. text bench 1.000 1.00 current (default optimization) 0.995 0.99 patched (default optimization) 1.332 1.82 current (-O0) 1.410 11.86 patched (-O0) My benchmark was (benchmark 100000), with the following code, byte-compiled. My platform is Fedora 15 x86-64, compiled with GCC 4.7.1. Benchmark timings are sloppy, as usual, so I wouldn't attach much significance past the first couple of digits. (defvar longlist '(a b c d e f g h i j k l m n o p q r s t u v w x y z)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (setq longlist (append longlist longlist)) (defvar x) (defun benchmark-with (n) (let ((start (float-time (get-internal-run-time))) (v (make-vector 1 0)) (i 0)) (while (< i n) (setq x (nth 8000 longlist)) (setq i (1+ i))) (- (float-time (get-internal-run-time)) start))) (defun benchmark-without (n) (let ((start (float-time (get-internal-run-time))) (v (make-vector 1 0)) (i 0)) (while (< i n) (setq i (1+ i))) (- (float-time (get-internal-run-time)) start))) (defun benchmark (n) (- (benchmark-with n) (benchmark-without n))) From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 15 10:47:46 2012 Received: (at 11935) by debbugs.gnu.org; 15 Jul 2012 14:47:46 +0000 Received: from localhost ([127.0.0.1]:42886 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqQ6r-0005LS-Uz for submit@debbugs.gnu.org; Sun, 15 Jul 2012 10:47:46 -0400 Received: from fencepost.gnu.org ([208.118.235.10]:49797) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqQ6p-0005LK-D8 for 11935@debbugs.gnu.org; Sun, 15 Jul 2012 10:47:44 -0400 Received: from cm162.gamma80.maxonline.com.sg ([202.156.80.162]:34039 helo=ulysses) by fencepost.gnu.org with esmtpsa (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1SqQ1A-00015j-Dn; Sun, 15 Jul 2012 10:41:53 -0400 From: Chong Yidong To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> Date: Sun, 15 Jul 2012 22:41:41 +0800 In-Reply-To: <500039B7.8050106@cs.ucla.edu> (Paul Eggert's message of "Fri, 13 Jul 2012 08:07:35 -0700") Message-ID: <87629p9jdm.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.1.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Score: -6.9 (------) X-Debbugs-Envelope-To: 11935 Cc: 11935@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: -6.9 (------) Paul Eggert writes: > Here's a patch I plan to install after some more testing. It changes > lisp.h to prefer functions to function-like macros, and constants to > object-like macros, when either will do. I think this is too fundamental a change for 24.2. Please don't install. From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 15 12:46:18 2012 Received: (at 11935) by debbugs.gnu.org; 15 Jul 2012 16:46:18 +0000 Received: from localhost ([127.0.0.1]:42996 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqRxZ-0000RI-J2 for submit@debbugs.gnu.org; Sun, 15 Jul 2012 12:46:18 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:40069) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqRxV-0000R8-1G for 11935@debbugs.gnu.org; Sun, 15 Jul 2012 12:46:14 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 6007EA60001; Sun, 15 Jul 2012 09:40:22 -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 lQN0Vdipdh4J; Sun, 15 Jul 2012 09:40:22 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id E25FC39E8008; Sun, 15 Jul 2012 09:40:21 -0700 (PDT) Message-ID: <5002F283.2060206@cs.ucla.edu> Date: Sun, 15 Jul 2012 09:40:35 -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: Chong Yidong Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <87629p9jdm.fsf@gnu.org> In-Reply-To: <87629p9jdm.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@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 07/15/2012 07:41 AM, Chong Yidong wrote: > I think this is too fundamental a change for 24.2. I wasn't planning to install it into the emacs-24 branch; only the trunk. Is 24.2 going to come from the emacs-24 branch? If so, what would be the problem with making this change to the trunk? And if not, then where should post-24 changes go? From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 15 18:12:22 2012 Received: (at 11935) by debbugs.gnu.org; 15 Jul 2012 22:12:22 +0000 Received: from localhost ([127.0.0.1]:43202 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqX37-0007eo-N6 for submit@debbugs.gnu.org; Sun, 15 Jul 2012 18:12:21 -0400 Received: from chene.dit.umontreal.ca ([132.204.246.20]:54405) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqX35-0007eg-6W for 11935@debbugs.gnu.org; Sun, 15 Jul 2012 18:12:20 -0400 Received: from fmsmemgm.homelinux.net (lechon.iro.umontreal.ca [132.204.27.242]) by chene.dit.umontreal.ca (8.14.1/8.14.1) with ESMTP id q6FM6Hij030955; Sun, 15 Jul 2012 18:06:18 -0400 Received: by fmsmemgm.homelinux.net (Postfix, from userid 20848) id 8D343AE323; Sun, 15 Jul 2012 18:06:16 -0400 (EDT) From: Stefan Monnier To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions Message-ID: References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> Date: Sun, 15 Jul 2012 18:06:16 -0400 In-Reply-To: <5002C895.4080400@cs.ucla.edu> (Paul Eggert's message of "Sun, 15 Jul 2012 06:41:41 -0700") User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.1.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-NAI-Spam-Flag: NO X-NAI-Spam-Level: X-NAI-Spam-Threshold: 5 X-NAI-Spam-Score: 0.5 X-NAI-Spam-Rules: 2 Rules triggered SUBJ_END_DOT_WORDS=0.5, RV4280=0 X-NAI-Spam-Version: 2.2.0.9309 : core <4280> : streams <785142> : uri <1166196> X-Spam-Score: -3.5 (---) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, rms@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: -3.5 (---) >> How does this change affect performance with -O0? > It hurts it. In normal operation I don't notice -- > everything is plenty fast enough -- but in an artificial > benchmark designed to stress the new code (see below) the > performance is significantly worse. If this is an issue, > we can mark these new functions with __attribute__ > ((__always_inline__)), but I'm inclined to try things > without this attribute, and resort to the attribute only if > needed. I always run with -O0 (plus ENABLE_CHECKING, and to add insult to injury, on Atom-level platforms), so I'd appreciate if you could ensure those functions are inlined even in -O0. > 1.332 1.82 current (-O0) > 1.410 11.86 patched (-O0) That would really hurt: my Emacs sessions already tend to feel sluggish without this extra pain. Stefan From debbugs-submit-bounces@debbugs.gnu.org Sun Jul 15 22:28:50 2012 Received: (at 11935) by debbugs.gnu.org; 16 Jul 2012 02:28:50 +0000 Received: from localhost ([127.0.0.1]:43403 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sqb3J-0004ur-Jv for submit@debbugs.gnu.org; Sun, 15 Jul 2012 22:28:50 -0400 Received: from fencepost.gnu.org ([208.118.235.10]:58096) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sqb3H-0004uk-TL for 11935@debbugs.gnu.org; Sun, 15 Jul 2012 22:28:48 -0400 Received: from cm162.gamma80.maxonline.com.sg ([202.156.80.162]:35359 helo=ulysses) by fencepost.gnu.org with esmtpsa (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1Sqaxa-0007wK-OT; Sun, 15 Jul 2012 22:22:55 -0400 From: Chong Yidong To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <87629p9jdm.fsf@gnu.org> <5002F283.2060206@cs.ucla.edu> Date: Mon, 16 Jul 2012 10:22:48 +0800 In-Reply-To: <5002F283.2060206@cs.ucla.edu> (Paul Eggert's message of "Sun, 15 Jul 2012 09:40:35 -0700") Message-ID: <87vchosavb.fsf@gnu.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.1.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Score: -6.9 (------) X-Debbugs-Envelope-To: 11935 Cc: 11935@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: -6.9 (------) Paul Eggert writes: > I wasn't planning to install it into the emacs-24 branch; only the > trunk. Is 24.2 going to come from the emacs-24 branch? No, from the trunk. I've explained this several times on emacs-devel, but maybe you missed those messages. The emacs-24 branch is only in case of emergency (e.g. security) release. Otherwise, 24.2 will be from the trunk; it will include new features, i.e. it won't be a bugfix-only release. But this change could be rather disruptive, for apparently negligible gain, so better leave it out, I think. > And if not, then where should post-24 changes go? You can make a new branch, if you like, or just keep this as a bug in the BTS. From debbugs-submit-bounces@debbugs.gnu.org Mon Jul 16 11:00:05 2012 Received: (at 11935) by debbugs.gnu.org; 16 Jul 2012 15:00:05 +0000 Received: from localhost ([127.0.0.1]:44304 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqmmK-0005vb-O4 for submit@debbugs.gnu.org; Mon, 16 Jul 2012 11:00:05 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:48121) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqmmJ-0005vI-6l for 11935@debbugs.gnu.org; Mon, 16 Jul 2012 11:00:04 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 8BEE239E800D; Mon, 16 Jul 2012 07:54:07 -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 KumWRhRdS9gg; Mon, 16 Jul 2012 07:54:07 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 1FE1F39E800B; Mon, 16 Jul 2012 07:54:07 -0700 (PDT) Message-ID: <50042B0F.9050105@cs.ucla.edu> Date: Mon, 16 Jul 2012 07:54:07 -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: Stefan Monnier Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> In-Reply-To: Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, rms@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 07/15/2012 03:06 PM, Stefan Monnier wrote: > I always run with -O0 (plus ENABLE_CHECKING, and to add insult to > injury, on Atom-level platforms), so I'd appreciate if you could ensure > those functions are inlined even in -O0. That's easy enough to arrange, without being intrusive -- it would add maybe 10 lines to the patch. Although the benchmark numbers are a bit scary, they greatly exaggerate the real-life performance effect, because most of Emacs's CPU time is spent elsewhere. I just now ran Emacs with the patch compiled with -g -O0, on my main laptop, which is also quite limited and slow (Pentium M 1.86 GHz, circa 2005), and interactive performance was fine. Your mileage may vary, of course, but it might make sense to not inline those functions even with -O0. There are important advantages to not inlining: you can put breakpoints on them, for example. So it might make sense to inline them only as an option. From debbugs-submit-bounces@debbugs.gnu.org Mon Jul 16 11:00:52 2012 Received: (at 11935) by debbugs.gnu.org; 16 Jul 2012 15:00:52 +0000 Received: from localhost ([127.0.0.1]:44307 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sqmn6-0005xb-5K for submit@debbugs.gnu.org; Mon, 16 Jul 2012 11:00:52 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:48164) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sqmn4-0005xV-M8 for 11935@debbugs.gnu.org; Mon, 16 Jul 2012 11:00:51 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 8A0C4A60001; Mon, 16 Jul 2012 07:54:55 -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 ix6kzItHJs7K; Mon, 16 Jul 2012 07:54:55 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 1FE4039E800B; Mon, 16 Jul 2012 07:54:55 -0700 (PDT) Message-ID: <50042B3F.2030008@cs.ucla.edu> Date: Mon, 16 Jul 2012 07:54:55 -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: Chong Yidong Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <87629p9jdm.fsf@gnu.org> <5002F283.2060206@cs.ucla.edu> <87vchosavb.fsf@gnu.org> In-Reply-To: <87vchosavb.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@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 07/15/2012 07:22 PM, Chong Yidong wrote: > You can make a new branch, if you like, or just keep this as a bug in > the BTS. Thanks, I think I'll just keep it as a bug then. And thanks for patiently explaining the plan one more time -- I had read the earlier messages but clearly they did not sink in. From debbugs-submit-bounces@debbugs.gnu.org Mon Jul 16 12:18:18 2012 Received: (at 11935) by debbugs.gnu.org; 16 Jul 2012 16:18:18 +0000 Received: from localhost ([127.0.0.1]:44394 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sqo01-0007lJ-Ns for submit@debbugs.gnu.org; Mon, 16 Jul 2012 12:18:17 -0400 Received: from mtaout23.012.net.il ([80.179.55.175]:63599) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sqnzy-0007lB-K8 for 11935@debbugs.gnu.org; Mon, 16 Jul 2012 12:18:15 -0400 Received: from conversion-daemon.a-mtaout23.012.net.il by a-mtaout23.012.net.il (HyperSendmail v2007.08) id <0M7900A00GTWG600@a-mtaout23.012.net.il> for 11935@debbugs.gnu.org; Mon, 16 Jul 2012 19:12:08 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout23.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M7900ALCH07C530@a-mtaout23.012.net.il>; Mon, 16 Jul 2012 19:12:08 +0300 (IDT) Date: Mon, 16 Jul 2012 19:12:14 +0300 From: Eli Zaretskii Subject: Re: bug#11935: XINT etc. should be functions In-reply-to: <50042B0F.9050105@cs.ucla.edu> X-012-Sender: halo1@inter.net.il To: Paul Eggert Message-id: <83629nbs81.fsf@gnu.org> References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> <50042B0F.9050105@cs.ucla.edu> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, monnier@IRO.UMontreal.CA, rms@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: Mon, 16 Jul 2012 07:54:07 -0700 > From: Paul Eggert > Cc: 11935@debbugs.gnu.org, rms@gnu.org > > There are important advantages to not inlining: you can put > breakpoints on them, for example. Why would we need to put a breakpoint on a function that replaces the XINT macro? We've lived with a macro (where you cannot put a breakpoint) for many years without any problems (AFAIK). We have debugger commands to display values of Lisp integers. So I don't think debuggability will be a problem in this particular case (although it might be in others). From debbugs-submit-bounces@debbugs.gnu.org Mon Jul 16 14:25:35 2012 Received: (at 11935) by debbugs.gnu.org; 16 Jul 2012 18:25:35 +0000 Received: from localhost ([127.0.0.1]:44541 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqpzD-0002Es-IW for submit@debbugs.gnu.org; Mon, 16 Jul 2012 14:25:35 -0400 Received: from fencepost.gnu.org ([208.118.235.10]:44844) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqpzB-0002El-Mx for 11935@debbugs.gnu.org; Mon, 16 Jul 2012 14:25:34 -0400 Received: from rms by fencepost.gnu.org with local (Exim 4.71) (envelope-from ) id 1SqptQ-0004O3-SN; Mon, 16 Jul 2012 14:19:36 -0400 Date: Mon, 16 Jul 2012 14:19:36 -0400 Message-Id: Content-Type: text/plain; charset=ISO-8859-15 From: Richard Stallman To: Paul Eggert In-reply-to: <5002C895.4080400@cs.ucla.edu> (message from Paul Eggert on Sun, 15 Jul 2012 06:41:41 -0700) Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> X-Spam-Score: -6.9 (------) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list Reply-To: rms@gnu.org 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: -6.9 (------) It hurts it. In normal operation I don't notice -- everything is plenty fast enough My machine is a lot slower than yours; I think this will be a big problem. Please set them up to always inline. There can be a macro switch to turn that off with -D. -- Dr Richard Stallman President, Free Software Foundation 51 Franklin St Boston MA 02110 USA www.fsf.org www.gnu.org Skype: No way! That's nonfree (freedom-denying) software. Use Ekiga or an ordinary phone call From debbugs-submit-bounces@debbugs.gnu.org Mon Jul 16 17:46:49 2012 Received: (at 11935) by debbugs.gnu.org; 16 Jul 2012 21:46:49 +0000 Received: from localhost ([127.0.0.1]:44758 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sqt7w-0006pd-RA for submit@debbugs.gnu.org; Mon, 16 Jul 2012 17:46:49 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:40562) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Sqt7u-0006pV-HC for 11935@debbugs.gnu.org; Mon, 16 Jul 2012 17:46:47 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 2525C39E800B; Mon, 16 Jul 2012 14:40:49 -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 p5Hot0cOHpdK; Mon, 16 Jul 2012 14:40:48 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id A601339E8008; Mon, 16 Jul 2012 14:40:48 -0700 (PDT) Message-ID: <50048A52.2050005@cs.ucla.edu> Date: Mon, 16 Jul 2012 14:40:34 -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#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> <50042B0F.9050105@cs.ucla.edu> <83629nbs81.fsf@gnu.org> In-Reply-To: <83629nbs81.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, monnier@IRO.UMontreal.CA, rms@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 07/16/2012 09:12 AM, Eli Zaretskii wrote: > Why would we need to put a breakpoint on a function that replaces the > XINT macro? I was thinking more of larger macros like CHAR_TABLE_REF_ASCII, where it can be helpful to step through the interior loop. This cannot be done easily right now -- I typically drop into machine code, which is painful. Even for XINT, it can be helpful (for a beginner, anyway) to step through a function, for example, to see what happens with integers that are out of range for Emacs fixnums. I know that Emacs has gdb macros that substitute for straightforward commands to print expressions, and these are useful for the long-time Emacs experts who know about them, but it'd be nicer if debugging also worked in the usual way without requiring this additional expertise. From debbugs-submit-bounces@debbugs.gnu.org Mon Jul 16 18:52:34 2012 Received: (at 11935) by debbugs.gnu.org; 16 Jul 2012 22:52:34 +0000 Received: from localhost ([127.0.0.1]:44776 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Squ9Z-0008In-Rd for submit@debbugs.gnu.org; Mon, 16 Jul 2012 18:52:34 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:43563) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Squ9V-0008Id-Du for 11935@debbugs.gnu.org; Mon, 16 Jul 2012 18:52:31 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 059AD39E800B; Mon, 16 Jul 2012 15:46:32 -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 PDrgVHwHMyDU; Mon, 16 Jul 2012 15:46:30 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id B69E939E8008; Mon, 16 Jul 2012 15:46:30 -0700 (PDT) Message-ID: <500499C7.20902@cs.ucla.edu> Date: Mon, 16 Jul 2012 15:46: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: rms@gnu.org Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> In-Reply-To: Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@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 07/16/2012 11:19 AM, Richard Stallman wrote: > Please set them up to always inline. There can be > a macro switch to turn that off with -D. Sure, that's easy. I plan to incorporate something like the patch below, which uses -DINLINING=0 to turn it off (default is INLINING=1). === modified file 'ChangeLog' --- ChangeLog 2012-07-16 06:49:45 +0000 +++ ChangeLog 2012-07-16 22:35:32 +0000 @@ -3,6 +3,9 @@ Use functions, not macros, for XINT etc. * configure.ac (WARN_CFLAGS): Remove -Wbad-function-cast, as it generates bogus warnings about reasonable casts of calls. + (ALWAYS_INLINE): New macro. + (inline): Define to 'ALWAYS_INLINE' when compiling with GCC without + optimization, and without -DINLINING=0. 2012-07-15 Paul Eggert === modified file 'configure.ac' --- configure.ac 2012-07-15 00:33:12 +0000 +++ configure.ac 2012-07-16 22:21:37 +0000 @@ -4238,6 +4238,25 @@ #include #include +#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2) +# define ALWAYS_INLINE __attribute__ ((__always_inline__)) +#else +# define ALWAYS_INLINE +#endif + +/* When compiling via GCC without optimization, and without -DINLINING=0, + always inline functions marked 'inline'. This typically improves CPU + performance when debugging. With optimization, trust the compiler + to inline as appropriate. */ +#ifndef INLINING +# define INLINING 1 +#endif +#if (defined __NO_INLINE__ \ + && ! defined __OPTIMIZE__ && ! defined __OPTIMIZE_SIZE__ \ + && INLINING && !defined inline) +# define inline ALWAYS_INLINE +#endif + #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */ #define NO_INLINE __attribute__((noinline)) #else From debbugs-submit-bounces@debbugs.gnu.org Mon Jul 16 23:10:10 2012 Received: (at 11935) by debbugs.gnu.org; 17 Jul 2012 03:10:10 +0000 Received: from localhost ([127.0.0.1]:44947 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqyAr-0005bX-Qy for submit@debbugs.gnu.org; Mon, 16 Jul 2012 23:10:10 -0400 Received: from mtaout23.012.net.il ([80.179.55.175]:33540) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqyAo-0005bJ-SW for 11935@debbugs.gnu.org; Mon, 16 Jul 2012 23:10:07 -0400 Received: from conversion-daemon.a-mtaout23.012.net.il by a-mtaout23.012.net.il (HyperSendmail v2007.08) id <0M7A00D00B32DQ00@a-mtaout23.012.net.il> for 11935@debbugs.gnu.org; Tue, 17 Jul 2012 06:04:06 +0300 (IDT) Received: from HOME-C4E4A596F7 ([87.69.210.75]) by a-mtaout23.012.net.il (HyperSendmail v2007.08) with ESMTPA id <0M7A00D4YB6UCY20@a-mtaout23.012.net.il>; Tue, 17 Jul 2012 06:04:06 +0300 (IDT) Date: Tue, 17 Jul 2012 06:04:14 +0300 From: Eli Zaretskii Subject: Re: bug#11935: XINT etc. should be functions In-reply-to: <500499C7.20902@cs.ucla.edu> X-012-Sender: halo1@inter.net.il To: Paul Eggert Message-id: <83txx79jgx.fsf@gnu.org> References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> <500499C7.20902@cs.ucla.edu> X-Spam-Score: -1.2 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, rms@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: Mon, 16 Jul 2012 15:46:31 -0700 > From: Paul Eggert > Cc: 11935@debbugs.gnu.org > > +#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2) > +# define ALWAYS_INLINE __attribute__ ((__always_inline__)) > +#else > +# define ALWAYS_INLINE > +#endif > + > +/* When compiling via GCC without optimization, and without -DINLINING=0, > + always inline functions marked 'inline'. This typically improves CPU > + performance when debugging. With optimization, trust the compiler > + to inline as appropriate. */ > +#ifndef INLINING > +# define INLINING 1 > +#endif > +#if (defined __NO_INLINE__ \ > + && ! defined __OPTIMIZE__ && ! defined __OPTIMIZE_SIZE__ \ > + && INLINING && !defined inline) > +# define inline ALWAYS_INLINE > +#endif > + Wouldn't this inline all the functions declared 'inline'? If so, that's going too far, IMO. I think we need a facility for doing this only with a few functions that affect performance. From debbugs-submit-bounces@debbugs.gnu.org Tue Jul 17 00:00:12 2012 Received: (at 11935) by debbugs.gnu.org; 17 Jul 2012 04:00:12 +0000 Received: from localhost ([127.0.0.1]:44968 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqyxI-0006jX-Jj for submit@debbugs.gnu.org; Tue, 17 Jul 2012 00:00:12 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:53971) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SqyxG-0006jP-5x for 11935@debbugs.gnu.org; Tue, 17 Jul 2012 00:00:11 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 668CB39E800A; Mon, 16 Jul 2012 20:54: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 EkTLdTc4xzAK; Mon, 16 Jul 2012 20:54:10 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id A282539E8008; Mon, 16 Jul 2012 20:54:10 -0700 (PDT) Message-ID: <5004E1E4.20902@cs.ucla.edu> Date: Mon, 16 Jul 2012 20:54:12 -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#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> <500499C7.20902@cs.ucla.edu> <83txx79jgx.fsf@gnu.org> In-Reply-To: <83txx79jgx.fsf@gnu.org> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, rms@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 07/16/2012 08:04 PM, Eli Zaretskii wrote: > Wouldn't this inline all the functions declared 'inline'? No, only the functions defined after the macro. functions, for example, are unaffected. > I think we need a facility for doing this > only with a few functions that affect performance. I considered that (with a macro "Inline"), but it'd complicate maintenance. I hope that the simpler approach is good enough. If not, we can revisit this, and quite possibly if we do that we'll do "Inline" or something like it. From debbugs-submit-bounces@debbugs.gnu.org Mon Jul 23 22:27:04 2012 Received: (at 11935) by debbugs.gnu.org; 24 Jul 2012 02:27:04 +0000 Received: from localhost ([127.0.0.1]:34317 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1StUpu-000855-Rs for submit@debbugs.gnu.org; Mon, 23 Jul 2012 22:27:04 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:40121) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1StUpk-00084H-TB for 11935@debbugs.gnu.org; Mon, 23 Jul 2012 22:26:57 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 12ED1A60002 for <11935@debbugs.gnu.org>; Mon, 23 Jul 2012 19:20: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 2O4h1fd-R8uK for <11935@debbugs.gnu.org>; Mon, 23 Jul 2012 19:20:06 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 6AF4039E8007 for <11935@debbugs.gnu.org>; Mon, 23 Jul 2012 19:20:06 -0700 (PDT) Message-ID: <500E0657.4050604@cs.ucla.edu> Date: Mon, 23 Jul 2012 19:20:07 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:14.0) Gecko/20120714 Thunderbird/14.0 MIME-Version: 1.0 To: 11935@debbugs.gnu.org Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> <500499C7.20902@cs.ucla.edu> <83txx79jgx.fsf@gnu.org> In-Reply-To: <83txx79jgx.fsf@gnu.org> Content-Type: multipart/mixed; boundary="------------030501010209060903070607" X-Debbugs-Envelope-To: 11935 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. --------------030501010209060903070607 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 07/16/2012 08:04 PM, Eli Zaretskii wrote: > we need a facility for doing this > only with a few functions that affect performance. It turns out that when compiling with -O0, always_inline functions are often slower than macros, as the inlined code also contains unnecessary instructions to copy arguments and results. So instead of using always_inline, it's better to do this performance-critical inlining by hand. I did that (patch relative to trunk bzr 109195 attached), inlining enough so that CPU performance improved by 8.7% compared to the current trunk, when compiled with gcc -O0. (This is the same benchmark as before, on x86-64 with GCC 4.7.1.) The performance win is because I inlined a bit more cleverly than the current code does. Like the earlier version, this patch should improve performance slightly in the default-optimization case too, since this patch is identical to the earlier one when default optimization is used. In short, it should take only a relatively small amount of hand-inlining to address the -O0 performance issue. --------------030501010209060903070607 Content-Type: text/plain; charset=UTF-8; name="inline-diff.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="inline-diff.txt" PT09IG1vZGlmaWVkIGZpbGUgJ0NoYW5nZUxvZycKLS0tIENoYW5nZUxvZwkyMDEyLTA3LTE3 IDA3OjMwOjI1ICswMDAwCisrKyBDaGFuZ2VMb2cJMjAxMi0wNy0yNCAwMjowMDozMyArMDAw MApAQCAtMSwzICsxLDkgQEAKKzIwMTItMDctMjQgIFBhdWwgRWdnZXJ0ICA8ZWdnZXJ0QGNz LnVjbGEuZWR1PgorCisJVXNlIGZ1bmN0aW9ucywgbm90IG1hY3JvcywgZm9yIFhJTlQgZXRj LiAoQnVnIzExOTM1KS4KKwkqIGNvbmZpZ3VyZS5hYyAoV0FSTl9DRkxBR1MpOiBSZW1vdmUg LVdiYWQtZnVuY3Rpb24tY2FzdCwKKwlhcyBpdCBnZW5lcmF0ZXMgYm9ndXMgd2FybmluZ3Mg YWJvdXQgcmVhc29uYWJsZSBjYXN0cyBvZiBjYWxscy4KKwogMjAxMi0wNy0xNyAgRG1pdHJ5 IEFudGlwb3YgIDxkbWFudGlwb3ZAeWFuZGV4LnJ1PgogCiAJRml4IHRvb2xraXQgY29uZmln dXJhdGlvbiByZXBvcnQuCgo9PT0gbW9kaWZpZWQgZmlsZSAnY29uZmlndXJlLmFjJwotLS0g Y29uZmlndXJlLmFjCTIwMTItMDctMTcgMDc6MzA6MjUgKzAwMDAKKysrIGNvbmZpZ3VyZS5h YwkyMDEyLTA3LTE3IDE2OjI3OjIwICswMDAwCkBAIC02NzUsNiArNjc1LDcgQEAKICAgbnc9 IiRudyAtV2lubGluZSIgICAgICAgICAgICAgICAgICMgT0sgdG8gaWdub3JlICdpbmxpbmUn CiAgIG53PSIkbncgLVdzeW5jLW5hbmQiICAgICAgICAgICAgICAjIGlycmVsZXZhbnQgaGVy ZSwgYW5kIHByb3Zva2VzIE9iakMgd2FybmluZwogICBudz0iJG53IC1XdW5zYWZlLWxvb3At b3B0aW1pemF0aW9ucyIgIyBPSyB0byBzdXBwcmVzcyB1bnNhZmUgb3B0aW1pemF0aW9ucwor ICBudz0iJG53IC1XYmFkLWZ1bmN0aW9uLWNhc3QiICAgICAgIyBUaGVzZSBjYXN0cyBhcmUg bm8gd29yc2UgdGhhbiBvdGhlcnMuCiAKICAgIyBFbWFjcyBkb2Vzbid0IGNhcmUgYWJvdXQg c2hhZG93aW5nOyBzZWUKICAgIyA8aHR0cDovL2xpc3RzLmdudS5vcmcvYXJjaGl2ZS9odG1s L2VtYWNzLWRpZmZzLzIwMTEtMTEvbXNnMDAyNjUuaHRtbD4uCgo9PT0gbW9kaWZpZWQgZmls ZSAnc3JjL0NoYW5nZUxvZycKLS0tIHNyYy9DaGFuZ2VMb2cJMjAxMi0wNy0yMyAxNjo1Nzoy MCArMDAwMAorKysgc3JjL0NoYW5nZUxvZwkyMDEyLTA3LTI0IDAyOjAwOjMzICswMDAwCkBA IC0xLDMgKzEsMTMyIEBACisyMDEyLTA3LTI0ICBQYXVsIEVnZ2VydCAgPGVnZ2VydEBjcy51 Y2xhLmVkdT4KKworCVVzZSBmdW5jdGlvbnMsIG5vdCBtYWNyb3MsIGZvciBYSU5UIGV0Yy4g KEJ1ZyMxMTkzNSkuCisJSW4gbGlzcC5oLCBwcmVmZXIgZnVuY3Rpb25zIHRvIGZ1bmN0aW9u LWxpa2UgbWFjcm9zLCBhbmQKKwljb25zdGFudHMgdG8gb2JqZWN0LWxpa2UgbWFjcm9zLCB3 aGVuIGVpdGhlciB3aWxsIGRvLiAgVGhpczoKKwkgLiBtYWtlcyB0aGUgY29kZSBlYXNpZXIg dG8gZGVidWcsIGFzIHRoZSBzeW1ib2xzIGFyZSB2aXNpYmxlIHRvIEdEQi4KKwkgLiBzaW1w bGlmaWVzIHVzZSwgYXMgdGhlcmUncyBubyBtb3JlIG5lZWQgdG8gd29ycnkgYWJvdXQKKwkg ICBhcmd1bWVudHMnIHNpZGUgZWZmZWN0cyBiZWluZyBldmFsdWF0ZWQgbXVsdGlwbGUgdGlt ZXMuCisJIC4gc2hyaW5rcyB0aGUgc2l6ZSBvZiBFbWFjcydzIHRleHQgc2VnbWVudCBieSAw LjUlCisJICAgb24gbXkgcGxhdGZvcm0gKHg4Ni02NCwgR0NDIDQuNy4xKS4KKwkqIGJ1ZmZl ci5jIChRb3ZlcmxhcCk6CisJKiBkYXRhLmMgKFFzdWJycCk6CisJKiBmbnMuYyAoUWhhc2hf dGFibGVfcCk6CisJTm93IGV4dGVybiwgc28gbGlzcC5oIGNhbiB1c2UgdGhlc2Ugc3ltYm9s cy4KKwkqIGRpc3BleHRlcm4uaDogSW5jbHVkZSBjaGFyYWN0ZXIuaCwgZm9yIE1BWF9DSEFS IGV0Yy4KKwkoR0xZUEgsIEdMWVBIX0NIQVIsIEdMWVBIX0ZBQ0UsIFNFVF9HTFlQSF9DSEFS LCBTRVRfR0xZUEhfRkFDRSkKKwkoU0VUX0dMWVBILCBHTFlQSF9DT0RFX0NIQVIsIEdMWVBI X0NPREVfRkFDRSkKKwkoU0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERSwgR0xZUEhfTU9ERV9M SU5FX0ZBQ0UsIEdMWVBIX0NIQVJfVkFMSURfUCkKKwkoR0xZUEhfQ09ERV9QKTogTW92ZSBo ZXJlIGZyb20gbGlzcC5oLgorCShHTFlQSF9DSEFSLCBHTFlQSF9GQUNFLCBHTFlQSF9DT0RF X0NIQVIsIEdMWVBIX0NPREVfRkFDRSkKKwkoR0xZUEhfQ0hBUl9WQUxJRF9QLCBHTFlQSF9D T0RFX1ApOiBOb3cgZnVuY3Rpb25zLCBub3QgbWFjcm9zLgorCShHTFlQSF9NT0RFX0xJTkVf RkFDRSk6IE5vdyBlbnVtcywgbm90IG1hY3Jvcy4KKwkqIGV2YWwuYyAoRmF1dG9sb2FkKTog Q2FzdCBYVU5UQUcgb3V0cHV0IHRvIGludHB0cl90LCBzaW5jZQorCVhVTlRBRyBub3cgcmV0 dXJucyB2b2lkICouCisJKiBsaXNwLmggKFhMSSwgWElMLCBDSEVDS19UWVBFLCBDSEVDS19M SVNUX0NPTlMsIENIRUNLX05VTUJFUikKKwkoQ0hFQ0tfU1lNQk9MLCBDT05TUCwgRVEsIEZM T0FUUCwgSU5URUdFUlAsIExJU1BfSU5UX1RBR19QLCBNQVJLRVJQKQorCShNSVNDUCwgTklM UCwgU0VUX1NZTUJPTF9WQUwsIFNZTUJPTF9DT05TVEFOVF9QLCBTWU1CT0xfVkFMLCBTWU1C T0xQKQorCShWRUNUT1JMSUtFUCwgWENBUiwgWENEUiwgWENPTlMsIFhIQVNILCBYUE5UUiwg WFNZTUJPTCk6CisJSWYgY29tcGlsaW5nIHZpYSBHQ0Mgd2l0aG91dCBvcHRpbWl6YXRpb24s IGlubGluZSB0aGVzZSBmdW5jdGlvbnMKKwltYW51YWxseSwgYnkgZGVmaW5pbmcgbWFjcm9z IGluIGFkZGl0aW9uIHRvIGlubGluZSBmdW5jdGlvbnMuCisJVG8gZGlzYWJsZSB0aGlzLCBj b21waWxlIHdpdGggLURJTkxJTklORz0wLgorCShtYWtlX251bWJlciwgWEZBU1RJTlQsIFhJ TlQsIFhUWVBFLCBYVU5UQUcpOiBMaWtld2lzZSwgYnV0CisJaGFuZC1vcHRpbWl6ZSBvbmx5 IGluIHRoZSBVU0VfTFNCX1RBRyBjYXNlLCBhcyBHTlVpc2ggaG9zdHMgZG8gdGhhdC4KKwko Q0hFQ0tfQ09OU19MSVNULCBMSVNQX0lOVF9UQUdfUCwgWExJLCBYSUwsIFhIQVNILCBYVFlQ RSkKKwkoWElOVCwgWEZBU1RJTlQsIFhVSU5ULCBtYWtlX251bWJlciwgWFBOVFIsIFhVTlRB RywgRVEsIFhDT05TLCBYVkVDVE9SKQorCShYU1RSSU5HLCBYU1lNQk9MLCBYRkxPQVQsIFhQ Uk9DRVNTLCBYV0lORE9XLCBYVEVSTUlOQUwsIFhTVUJSKQorCShYQlVGRkVSLCBYQ0hBUl9U QUJMRSwgWFNVQl9DSEFSX1RBQkxFLCBYQk9PTF9WRUNUT1IsIENIRUNLX1RZUEUpCisJKENI RUNLX1NUUklOR19PUl9CVUZGRVIsIFhDQVIsIFhDRFIsIFhTRVRDQVIsIFhTRVRDRFIsIENB UiwgQ0RSKQorCShDQVJfU0FGRSwgQ0RSX1NBRkUsIFNUUklOR19NVUxUSUJZVEUsIFNUUklO R19JTlRFUlZBTFMpCisJKFNUUklOR19TRVRfSU5URVJWQUxTLCBTREFUQSwgU1NEQVRBLCBT UkVGLCBTU0VULCBTQ0hBUlMpCisJKFNUUklOR19CWVRFUywgU0JZVEVTLCBTVFJJTkdfU0VU X0NIQVJTLCBBU0laRSwgQVNFVCkKKwkoQ0hBUl9UQUJMRV9FWFRSQV9TTE9UUywgQ0hBUl9U QUJMRV9SRUZfQVNDSUksIENIQVJfVEFCTEVfUkVGKQorCShDSEFSX1RBQkxFX1RSQU5TTEFU RSwgQ0hBUl9UQUJMRV9TRVQsIFNZTUJPTF9WQUwsIFNZTUJPTF9BTElBUykKKwkoU1lNQk9M X0JMViwgU1lNQk9MX0ZXRCwgU0VUX1NZTUJPTF9WQUwsIFNFVF9TWU1CT0xfQUxJQVMpCisJ KFNFVF9TWU1CT0xfQkxWLCBTRVRfU1lNQk9MX0ZXRCwgU1lNQk9MX05BTUUsIFNZTUJPTF9J TlRFUk5FRF9QKQorCShTWU1CT0xfSU5URVJORURfSU5fSU5JVElBTF9PQkFSUkFZX1AsIFNZ TUJPTF9DT05TVEFOVF9QKQorCShYSEFTSF9UQUJMRSwgSEFTSF9UQUJMRV9QLCBDSEVDS19I QVNIX1RBQkxFLCBIQVNIX1RBQkxFX1NJWkUpCisJKFhNSVNDLCBYTUlTQ0FOWSwgWE1BUktF UiwgWE9WRVJMQVksIFhTQVZFX1ZBTFVFLCBYU0VUTUlTQ1RZUEUpCisJKEJMVl9GT1VORCwg U0VUX0JMVl9GT1VORCwgQkxWX1ZBTFVFLCBTRVRfQkxWX1ZBTFVFLCBYRldEVFlQRSkKKwko WElOVEZXRCwgWEJPT0xGV0QsIFhPQkpGV0QsIFhCVUZGRVJfT0JKRldELCBYS0JPQVJEX09C SkZXRCkKKwkoWEZMT0FUX0RBVEEsIFhGTE9BVF9JTklULCBOSUxQLCBOVU1CRVJQLCBOQVRO VU1QKQorCShSQU5HRURfSU5URUdFUlAsIENPTlNQLCBGTE9BVFAsIE1JU0NQLCBTVFJJTkdQ LCBTWU1CT0xQKQorCShJTlRFR0VSUCwgVkVDVE9STElLRVAsIFZFQ1RPUlAsIE9WRVJMQVlQ KQorCShNQVJLRVJQLCBTQVZFX1ZBTFVFUCwgSU5URldEUCwgQk9PTEZXRFAsIE9CSkZXRFAp CisJKEJVRkZFUl9PQkpGV0RQLCBLQk9BUkRfT0JKRldEUCkKKwkoUFNFVURPVkVDVE9SUCwg V0lORE9XX0NPTkZJR1VSQVRJT05QLCBQUk9DRVNTUCwgV0lORE9XUCkKKwkoVEVSTUlOQUxQ LCBTVUJSUCwgQ09NUElMRURQLCBCVUZGRVJQLCBDSEFSX1RBQkxFX1ApCisJKFNVQl9DSEFS X1RBQkxFX1AsIEJPT0xfVkVDVE9SX1AsIEZSQU1FUCwgSU1BR0VQLCBBUlJBWVApCisJKENI RUNLX0xJU1QsIENIRUNLX0xJU1RfQ09OUywgQ0hFQ0tfTElTVF9FTkQsIENIRUNLX1NUUklO RykKKwkoQ0hFQ0tfU1RSSU5HX0NBUiwgQ0hFQ0tfQ09OUywgQ0hFQ0tfU1lNQk9MLCBDSEVD S19DSEFSX1RBQkxFKQorCShDSEVDS19WRUNUT1IsIENIRUNLX1ZFQ1RPUl9PUl9TVFJJTkcs IENIRUNLX0FSUkFZKQorCShDSEVDS19WRUNUT1JfT1JfQ0hBUl9UQUJMRSwgQ0hFQ0tfQlVG RkVSLCBDSEVDS19XSU5ET1cpCisJKENIRUNLX1dJTkRPV19DT05GSUdVUkFUSU9OLCBDSEVD S19QUk9DRVNTLCBDSEVDS19TVUJSKQorCShDSEVDS19OVU1CRVIsIENIRUNLX05BVE5VTSwg Q0hFQ0tfTUFSS0VSLCBYRkxPQVRJTlQpCisJKENIRUNLX0ZMT0FULCBDSEVDS19OVU1CRVJf T1JfRkxPQVQsIENIRUNLX09WRVJMQVkpCisJKENIRUNLX05VTUJFUl9DQVIsIENIRUNLX05V TUJFUl9DRFIsIENIRUNLX05BVE5VTV9DQVIpCisJKENIRUNLX05BVE5VTV9DRFIsIEZVTkNU SU9OUCwgU1BFQ1BETF9JTkRFWCwgTE9BREhJU1RfQVRUQUNIKQorCShJU19ESVJFQ1RPUllf U0VQLCBJU19ERVZJQ0VfU0VQLCBJU19BTllfU0VQKToKKwlOb3cgc3RhdGljIGlubGluZSBm dW5jdGlvbnMuCisJKFBTRVVET1ZFQ1RPUl9TSVpFX1RZUEVQKSBOZXcgc3RhdGljIGlubGlu ZSBmdW5jdGlvbiwgcmVwbGFjaW5nIC4uLgorCShQU0VVRE9WRUNUT1JfVFlQRVApOiBSZW1v dmUgbWFjcm8uICBBbGwgdXNlcyBjaGFuZ2VkIHRvIHRoZSBuZXcgQVBJLgorCShjaGVja19j b25zX2xpc3QpIFshR0NfQ0hFQ0tfQ09OU19MSVNUXTogTmV3IGVtcHR5IGZ1bmN0aW9uLgor CShFTUFDU19JTlQsIEVNQUNTX1VJTlQpOiBOb3cgdHlwZWRlZnMsIG5vdCBtYWNyb3MuCisJ KFZBTEJJVFMsIElOVFRZUEVCSVRTLCBGSVhOVU1fQklUUywgTElTUF9JTlRfVEFHKQorCShQ U0VVRE9WRUNUT1JfU0laRV9CSVRTLCBQU0VVRE9WRUNUT1JfU0laRV9NQVNLLCBQVkVDX1RZ UEVfTUFTSykKKwkoQk9PTF9WRUNUT1JfQklUU19QRVJfQ0hBUiwgQ0hBUl9UQUJMRV9TVEFO REFSRF9TTE9UUykKKwkoQ0hBUlRBQl9TSVpFX0JJVFNfMCwgQ0hBUlRBQl9TSVpFX0JJVFNf MSkKKwkoQ0hBUlRBQl9TSVpFX0JJVFNfMiwgQ0hBUlRBQl9TSVpFX0JJVFNfMywgREVGQVVM VF9IQVNIX1NJWkUpCisJKENPTVBJTEVEX0FSR0xJU1QsIENPTVBJTEVEX0JZVEVDT0RFLCBD T01QSUxFRF9DT05TVEFOVFMpCisJKENPTVBJTEVEX1NUQUNLX0RFUFRILCBDT01QSUxFRF9E T0NfU1RSSU5HLCBDT01QSUxFRF9JTlRFUkFDVElWRSkKKwkoQ0hBUl9BTFQsIENIQVJfU1VQ RVIsIENIQVJfSFlQRVIsIENIQVJfU0hJRlQsIENIQVJfQ1RMLCBDSEFSX01FVEEpCisJKENI QVJfTU9ESUZJRVJfTUFTSywgTUFOWSwgVU5FVkFMTEVELCBGTE9BVF9UT19TVFJJTkdfQlVG U0laRSk6CisJKERJUkVDVE9SWV9TRVAsIE1BWF9BTExPQ0EpOgorCU5vdyBjb25zdGFudHMs IG5vdCBtYWNyb3MuCisJKExJU1BfSU5UMV9UQUcsIExJU1BfU1RSSU5HX1RBRywgTElTUF9N QUtFX1JWQUxVRSwgVFlQRU1BU0spOgorCVJlbW92ZTsgbm8gbG9uZ2VyIG5lZWRlZC4KKwko REFUQV9TRUdfQklUUyk6IERlZmF1bHQgdG8gMCwgYXMgdGhpcyBzaW1wbGlmaWVzIHRoZSBy ZXN0IG9mIHRoZSBjb2RlLgorCShWQUxNQVNLKTogRGVmaW5lIGluIG9uZSBwbGFjZSByYXRo ZXIgdGhhbiBpbiB0d28sIG1lcmdpbmcgdGhlCisJVVNFX0xTQl9UQUcgcGFydHM7IHRoaXMg aXMgc2ltcGxlci4KKwkoTU9TVF9QT1NJVElWRV9GSVhOVU0sIE1PU1RfTkVHQVRJVkVfRklY TlVNLCBtYXgsIG1pbikKKwkoc3RydWN0IExpc3BfU3RyaW5nLCBVTlNJR05FRF9DTVAsIEFT Q0lJX0NIQVJfUCk6CisJTW92ZSB1cCwgdG8gYXZvaWQgdXNlIGJlZm9yZSBkZWZpbml0aW9u LgorCUFsc28gaW5jbHVkZSAiZ2xvYmFscy5oIiBlYXJsaWVyLCBmb3IgdGhlIHNhbWUgcmVh c29uLgorCShtYWtlX25hdG51bSwgeHRhZyk6IE5ldyBmdW5jdGlvbnMuCisJKFhVTlRBRyk6 IE5vdyByZXR1cm5zIHZvaWQgKiwgbm90IGludHB0cl90LCBhcyB0aGlzIG1lYW5zIGZld2Vy IGNhc3RzLgorCSh1bmlvbiBMaXNwX0Z3ZCwgQk9PTEZXRFAsIEJPT0xfVkVDVE9SX1AsIEJV RkZFUl9PQkpGV0RQLCBCVUZGRVJQKQorCShDSEFSX1RBQkxFX1AsIENIQVJfVEFCTEVfUkVG X0FTQ0lJLCBDT05TUCwgRkxPQVRQLCBJTlRFR0VSUCwgSU5URldEUCkKKwkoS0JPQVJEX09C SkZXRFAsIE1BUktFUlAsIE1JU0NQLCBOSUxQLCBPQkpGV0RQLCBPVkVSTEFZUCwgUFJPQ0VT U1ApCisJKFBTRVVET1ZFQ1RPUlAsIFNBVkVfVkFMVUVQLCBTVFJJTkdQLCBTVUJfQ0hBUl9U QUJMRV9QLCBTVUJSUCwgU1lNQk9MUCkKKwkoVkVDVE9STElLRVAsIFdJTkRPV1AsIFFvdmVy bGF5cCwgY2hhcl90YWJsZV9yZWYsIGNoYXJfdGFibGVfc2V0KQorCShjaGFyX3RhYmxlX3Ry YW5zbGF0ZSwgUWFycmF5cCwgUWJ1ZmZlcnAsIFFidWZmZXJfb3Jfc3RyaW5nX3ApCisJKFFj aGFyX3RhYmxlX3AsIFFjb25zcCwgUWZsb2F0cCwgUWludGVnZXJwLCBRbGFtYmRhLCBRbGlz dHAsIFFtYXJrZXJwKQorCShRbmlsLCBRbnVtYmVycCwgUXN1YnJwLCBRc3RyaW5ncCwgUXN5 bWJvbHAsIFF2ZWN0b3JwKQorCShRdmVjdG9yX29yX2NoYXJfdGFibGVfcCwgUXdob2xlbnVt cCwgRmZib3VuZHAsIHdyb25nX3R5cGVfYXJndW1lbnQpCisJKGluaXRpYWxpemVkLCBRaGFz aF90YWJsZV9wLCBleHRyYWN0X2Zsb2F0LCBRcHJvY2Vzc3AsIFF3aW5kb3dwKQorCShRd2lu ZG93X2NvbmZpZ3VyYXRpb25fcCwgUWltYWdlKTogTmV3IGZvcndhcmQgZGVjbGFyYXRpb25z LgorCShYU0VUKTogU2ltcGxpZnkgYnkgcmV3cml0aW5nIGluIHRlcm1zIG9mIHh0YWcuCisJ KFhTRVRGQVNUSU5UKTogU2ltcGxpZnkgYnkgcmV3cml0aW5nIGluIHRlcm1zIG9mIG1ha2Vf bmF0bnVtLgorCShTVFJJTkdfQ09QWUlOKTogUmVtb3ZlOyB1bnVzZWQuCisJKEdMWVBILCBH TFlQSF9DSEFSLCBHTFlQSF9GQUNFLCBTRVRfR0xZUEhfQ0hBUiwgU0VUX0dMWVBIX0ZBQ0Up CisJKFNFVF9HTFlQSCwgR0xZUEhfQ09ERV9DSEFSLCBHTFlQSF9DT0RFX0ZBQ0UpCisJKFNF VF9HTFlQSF9GUk9NX0dMWVBIX0NPREUsIEdMWVBIX01PREVfTElORV9GQUNFLCBHTFlQSF9D SEFSX1ZBTElEX1ApCisJKEdMWVBIX0NPREVfUCk6IE1vdmUgdG8gZGlzcGV4dGVybi5oLCB0 byBhdm9pZCBkZWZpbmUtYmVmb3JlLXVzZS4KKwkoVFlQRV9SQU5HRURfSU5URUdFUlApOiBT aW1wbGlmeS4KKwkoUFNFVURPVkVDVE9SX1NJWkVfVFlQRVApOiBSZW5hbWUgZnJvbSBQU0VV RE9WRUNUT1JQX1RZUEVQIGFuZAorCWNoYW5nZSB0aGUgZmlyc3QgYXJnIHRvIGJlIGEgc2l6 ZSByYXRoZXIgdGhhbiBhIHBvaW50ZXIsCisJdG8gbWFrZSBpdCB1c2FibGUgYXMgYSBmdW5j dGlvbi4gIEFsbCB1c2VzIGNoYW5nZWQuCisJKFFzdWJycCwgUWhhc2hfdGFibGVfcCwgUW92 ZXJsYXlwKTogTmV3IGV4dGVybiBkZWNscy4KKwkoc2V0bG9jYWxlLCBmaXh1cF9sb2NhbGUs IHN5bmNocm9uaXplX3N5c3RlbV9tZXNzYWdlc19sb2NhbGUpCisJKHN5bmNocm9uaXplX3N5 c3RlbV90aW1lX2xvY2FsZSkgWyFIQVZFX1NFVExPQ0FMRV06CisJTm93IGVtcHR5IGZ1bmN0 aW9ucywgbm90IG1hY3Jvcy4KKwkqIG1lbS1saW1pdHMuaCAoRVhDRUVEU19MSVNQX1BUUikg WyFkZWZpbmVkIERBVEFfU0VHX0JJVFNdOgorCVJlbW92ZSwgYXMgREFUQV9TRUdfQklUUyBp cyBhbHdheXMgZGVmaW5lZCBub3csIGlmIG9ubHkgdG8gemVyby4KKwkqIHdpbmRvdy5jIChR d2luZG93X2NvbmZpZ3VyYXRpb25fcCk6CisJTm93IGV4dGVybiwgc28gd2luZG93LmggY2Fu IHVzZSBpdC4KKwkqIHdpbmRvdy5oIChRd2luZG93cCk6IE1vdmUgZGVjbCBiYWNrIHRvIGxp c3AuaC4KKwkoQ0hFQ0tfTElWRV9XSU5ET1cpOiBNb3ZlIGhlcmUgZnJvbSBsaXNwLmgsIHNv IHdpbmRvdy5oIGludGVybmFscworCW5lZWQgbm90IGJlIG1vdmVkIHRvIGxpc3AuaC4gIE5v dyBhIGZ1bmN0aW9uLCBub3QgYSBtYWNyby4KKwogMjAxMi0wNy0yMyAgRWxpIFphcmV0c2tp aSAgPGVsaXpAZ251Lm9yZz4KIAogCSogcHJpbnQuYyAocHJpbnRfb2JqZWN0KTogRG9uJ3Qg Y3Jhc2ggd2hlbiBhIGZyYW1lJ3MgbmFtZSBpcyBuaWwKCj09PSBtb2RpZmllZCBmaWxlICdz cmMvYWxsb2MuYycKLS0tIHNyYy9hbGxvYy5jCTIwMTItMDctMjMgMTE6MTU6NDMgKzAwMDAK KysrIHNyYy9hbGxvYy5jCTIwMTItMDctMjMgMjE6NTg6MTAgKzAwMDAKQEAgLTMwNzQsMTIg KzMwNzQsMTIgQEAKICAgICsgVkVDVE9SX0JMT0NLX0JZVEVTIC0gVkJMT0NLX0JZVEVTX01J TikKIAogLyogTnVtYmVyIG9mIGJ5dGVzIHVzZWQgYnkgdmVjdG9yLWJsb2NrLWFsbG9jYXRl ZCBvYmplY3QuICBUaGlzIGlzIHRoZSBvbmx5Ci0gICBwbGFjZSB3aGVyZSB3ZSBhY3R1YWxs eSB1c2UgdGhlIGBuYnl0ZXMnIGZpZWxkIG9mIHRoZSB2ZWN0b3ItaGVhZGVyLgotICAgSS5l LiB3ZSBjb3VsZCBnZXQgcmlkIG9mIHRoZSBgbmJ5dGVzJyBmaWVsZCBieSBjb21wdXRpbmcg aXQgYmFzZWQgb24gdGhlCisgICBwbGFjZSB3aGVyZSB3ZSBhY3R1YWxseSB1c2UgdGhlICdz aXplJyBmaWVsZCBvZiB0aGUgdmVjdG9yLWhlYWRlci4KKyAgIEkuZS4gd2UgY291bGQgZ2V0 IHJpZCBvZiB0aGUgJ3NpemUnIGZpZWxkIGJ5IGNvbXB1dGluZyBpdCBiYXNlZCBvbiB0aGUK ICAgIHZlY3Rvci10eXBlLiAgKi8KIAogI2RlZmluZSBQU0VVRE9WRUNUT1JfTkJZVEVTKHZl Y3RvcikgXAotICAoUFNFVURPVkVDVE9SX1RZUEVQICgmdmVjdG9yLT5oZWFkZXIsIFBWRUNf RlJFRSkJXAorICAoUFNFVURPVkVDVE9SX1NJWkVfVFlQRVAgKHZlY3Rvci0+aGVhZGVyLnNp emUsIFBWRUNfRlJFRSkJXAogICAgPyB2ZWN0b3ItPmhlYWRlci5zaXplICYgUFNFVURPVkVD VE9SX1NJWkVfTUFTSwlcCiAgICA6IHZlY3Rvci0+aGVhZGVyLm5leHQubmJ5dGVzKQogCkBA IC0zMTcxLDcgKzMxNzEsOCBAQAogCSAgICAgIC8qIEFsbCBub24tYm9vbCBwc2V1ZG92ZWN0 b3JzIGFyZSBzbWFsbCBlbm91Z2ggdG8gYmUgYWxsb2NhdGVkCiAJCSBmcm9tIHZlY3RvciBi bG9ja3MuICBUaGlzIGNvZGUgc2hvdWxkIGJlIHJlZGVzaWduZWQgaWYgc29tZQogCQkgcHNl dWRvdmVjdG9yIHR5cGUgZ3Jvd3MgYmV5b25kIFZCTE9DS19CWVRFU19NQVguICAqLwotCSAg ICAgIGVhc3NlcnQgKFBTRVVET1ZFQ1RPUl9UWVBFUCAoJnZlY3Rvci0+aGVhZGVyLCBQVkVD X0JPT0xfVkVDVE9SKSk7CisJICAgICAgZWFzc2VydCAoUFNFVURPVkVDVE9SX1NJWkVfVFlQ RVAgKHZlY3Rvci0+aGVhZGVyLnNpemUsCisJCQkJCQlQVkVDX0JPT0xfVkVDVE9SKSk7CiAK IAkgICAgICB0b3RhbF92ZWN0b3Jfc2xvdHMKIAkJKz0gKGJvb2xfaGVhZGVyX3NpemUKQEAg LTQzOTIsNyArNDM5Myw3IEBACiAgICAgICB3aGlsZSAoVkVDVE9SX0lOX0JMT0NLICh2ZWN0 b3IsIGJsb2NrKQogCSAgICAgJiYgdmVjdG9yIDw9IChzdHJ1Y3QgTGlzcF9WZWN0b3IgKikg cCkKIAl7Ci0JICBpZiAoUFNFVURPVkVDVE9SX1RZUEVQICgmdmVjdG9yLT5oZWFkZXIsIFBW RUNfRlJFRSkpCisJICBpZiAoUFNFVURPVkVDVE9SX1NJWkVfVFlQRVAgKHZlY3Rvci0+aGVh ZGVyLnNpemUsIFBWRUNfRlJFRSkpCiAJICAgIHZlY3RvciA9IEFEVkFOQ0UgKHZlY3Rvciwg KHZlY3Rvci0+aGVhZGVyLnNpemUKIAkJCQkgICAgICAgJiBQU0VVRE9WRUNUT1JfU0laRV9N QVNLKSk7CiAJICBlbHNlIGlmICh2ZWN0b3IgPT0gcCkKCj09PSBtb2RpZmllZCBmaWxlICdz cmMvYnVmZmVyLmMnCi0tLSBzcmMvYnVmZmVyLmMJMjAxMi0wNy0yMyAxMToxNTo0MyArMDAw MAorKysgc3JjL2J1ZmZlci5jCTIwMTItMDctMjMgMjE6NTA6MzYgKzAwMDAKQEAgLTEzOSw3 ICsxMzksNyBAQAogCiBzdGF0aWMgTGlzcF9PYmplY3QgUWdldF9maWxlX2J1ZmZlcjsKIAot c3RhdGljIExpc3BfT2JqZWN0IFFvdmVybGF5cDsKK0xpc3BfT2JqZWN0IFFvdmVybGF5cDsK IAogTGlzcF9PYmplY3QgUXByaW9yaXR5LCBRYmVmb3JlX3N0cmluZywgUWFmdGVyX3N0cmlu ZzsKIAoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9kYXRhLmMnCi0tLSBzcmMvZGF0YS5jCTIw MTItMDctMTkgMjI6MzU6NTggKzAwMDAKKysrIHNyYy9kYXRhLmMJMjAxMi0wNy0yMyAyMTo1 MDozNiArMDAwMApAQCAtOTEsNyArOTEsOCBAQAogc3RhdGljIExpc3BfT2JqZWN0IFFjb21w aWxlZF9mdW5jdGlvbiwgUWZyYW1lOwogTGlzcF9PYmplY3QgUWJ1ZmZlcjsKIHN0YXRpYyBM aXNwX09iamVjdCBRY2hhcl90YWJsZSwgUWJvb2xfdmVjdG9yLCBRaGFzaF90YWJsZTsKLXN0 YXRpYyBMaXNwX09iamVjdCBRc3VicnAsIFFtYW55LCBRdW5ldmFsbGVkOworTGlzcF9PYmpl Y3QgUXN1YnJwOworc3RhdGljIExpc3BfT2JqZWN0IFFtYW55LCBRdW5ldmFsbGVkOwogTGlz cF9PYmplY3QgUWZvbnRfc3BlYywgUWZvbnRfZW50aXR5LCBRZm9udF9vYmplY3Q7CiBzdGF0 aWMgTGlzcF9PYmplY3QgUWRlZnVuOwogCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2Rpc3Bl eHRlcm4uaCcKLS0tIHNyYy9kaXNwZXh0ZXJuLmgJMjAxMi0wNy0xMyAwMzo1MDo1OCArMDAw MAorKysgc3JjL2Rpc3BleHRlcm4uaAkyMDEyLTA3LTEzIDAzOjUyOjUzICswMDAwCkBAIC0y Miw2ICsyMiw4IEBACiAjaWZuZGVmIERJU1BFWFRFUk5fSF9JTkNMVURFRAogI2RlZmluZSBE SVNQRVhURVJOX0hfSU5DTFVERUQKIAorI2luY2x1ZGUgImNoYXJhY3Rlci5oIgorCiAjaWZk ZWYgSEFWRV9YX1dJTkRPV1MKIAogI2luY2x1ZGUgPFgxMS9YbGliLmg+CkBAIC0yNjUsNiAr MjY3LDU1IEBACiAJCQkJR2x5cGhzCiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKKy8qIFRoZSBn bHlwaCBkYXRhdHlwZSwgdXNlZCB0byByZXByZXNlbnQgY2hhcmFjdGVycyBvbiB0aGUgZGlz cGxheS4KKyAgIEl0IGNvbnNpc3RzIG9mIGEgY2hhciBjb2RlIGFuZCBhIGZhY2UgaWQuICAq LworCit0eXBlZGVmIHN0cnVjdCB7CisgIGludCBjaDsKKyAgaW50IGZhY2VfaWQ7Cit9IEdM WVBIOworCisvKiBSZXR1cm4gYSBnbHlwaCdzIGNoYXJhY3RlciBjb2RlLiAgKi8KK3N0YXRp YyBpbmxpbmUgaW50IEdMWVBIX0NIQVIgKEdMWVBIIGdseXBoKSB7IHJldHVybiBnbHlwaC5j aDsgfQorCisvKiBSZXR1cm4gYSBnbHlwaCdzIGZhY2UgSUQuICAqLworc3RhdGljIGlubGlu ZSBpbnQgR0xZUEhfRkFDRSAoR0xZUEggZ2x5cGgpIHsgcmV0dXJuIGdseXBoLmZhY2VfaWQ7 IH0KKworI2RlZmluZSBTRVRfR0xZUEhfQ0hBUihnbHlwaCwgY2hhcikgKChnbHlwaCkuY2gg PSAoY2hhcikpCisjZGVmaW5lIFNFVF9HTFlQSF9GQUNFKGdseXBoLCBmYWNlKSAoKGdseXBo KS5mYWNlX2lkID0gKGZhY2UpKQorI2RlZmluZSBTRVRfR0xZUEgoZ2x5cGgsIGNoYXIsIGZh Y2UpIFwKKyAgKChnbHlwaCkuY2ggPSAoY2hhciksIChnbHlwaCkuZmFjZV9pZCA9IChmYWNl KSkKKworLyogVGhlIGZvbGxvd2luZyBhcmUgdmFsaWQgb25seSBpZiBHTFlQSF9DT0RFX1Ag KGdjKS4gICovCisKK3N0YXRpYyBpbmxpbmUgaW50CitHTFlQSF9DT0RFX0NIQVIgKExpc3Bf T2JqZWN0IGdjKQoreworICByZXR1cm4gKENPTlNQIChnYykKKwkgID8gWElOVCAoWENBUiAo Z2MpKQorCSAgOiBYSU5UIChnYykgJiBNQVhfQ0hBUik7Cit9CisKK3N0YXRpYyBpbmxpbmUg aW50CitHTFlQSF9DT0RFX0ZBQ0UgKExpc3BfT2JqZWN0IGdjKQoreworICByZXR1cm4gQ09O U1AgKGdjKSA/IFhJTlQgKFhDRFIgKGdjKSkgOiBYSU5UIChnYykgPj4gQ0hBUkFDVEVSQklU UzsKK30KKworI2RlZmluZSBTRVRfR0xZUEhfRlJPTV9HTFlQSF9DT0RFKGdseXBoLCBnYykJ CQkJXAorICBkbwkJCQkJCQkJCVwKKyAgICB7CQkJCQkJCQkJXAorICAgICAgaWYgKENPTlNQ IChnYykpCQkJCQkJCVwKKwlTRVRfR0xZUEggKGdseXBoLCBYSU5UIChYQ0FSIChnYykpLCBY SU5UIChYQ0RSIChnYykpKTsJCVwKKyAgICAgIGVsc2UJCQkJCQkJCVwKKwlTRVRfR0xZUEgg KGdseXBoLCAoWElOVCAoZ2MpICYgKCgxIDw8IENIQVJBQ1RFUkJJVFMpLTEpKSwJXAorCQkg ICAoWElOVCAoZ2MpID4+IENIQVJBQ1RFUkJJVFMpKTsJCQlcCisgICAgfQkJCQkJCQkJCVwK KyAgd2hpbGUgKDApCisKKy8qIFRoZSBJRCBvZiB0aGUgbW9kZSBsaW5lIGhpZ2hsaWdodGlu ZyBmYWNlLiAgKi8KK2VudW0geyBHTFlQSF9NT0RFX0xJTkVfRkFDRSA9IDEgfTsKKwogLyog RW51bWVyYXRpb24gb2YgZ2x5cGggdHlwZXMuICBHbHlwaCBzdHJ1Y3R1cmVzIGNvbnRhaW4g YSB0eXBlIGZpZWxkCiAgICBjb250YWluaW5nIG9uZSBvZiB0aGUgZW51bWVyYXRvcnMgZGVm aW5lZCBoZXJlLiAgKi8KIApAQCAtMTc2Myw2ICsxODE0LDMwIEBACiAKICNlbmRpZiAvKiBu b3QgSEFWRV9XSU5ET1dfU1lTVEVNICovCiAKKy8qIFJldHVybiAxIGlmIEcgY29udGFpbnMg YSB2YWxpZCBjaGFyYWN0ZXIgY29kZS4gICovCitzdGF0aWMgaW5saW5lIGludAorR0xZUEhf Q0hBUl9WQUxJRF9QIChHTFlQSCBnKQoreworICByZXR1cm4gQ0hBUl9WQUxJRF9QIChHTFlQ SF9DSEFSIChnKSk7Cit9CisKKy8qIFRoZSBnbHlwaCBjb2RlIGZyb20gYSBkaXNwbGF5IHZl Y3RvciBtYXkgZWl0aGVyIGJlIGFuIGludGVnZXIgd2hpY2gKKyAgIGVuY29kZXMgYSBjaGFy IGNvZGUgaW4gdGhlIGxvd2VyIENIQVJBQ1RFUkJJVFMgYml0cyBhbmQgYSAodmVyeSBzbWFs bCkKKyAgIGZhY2UtaWQgaW4gdGhlIHVwcGVyIGJpdHMsIG9yIGl0IG1heSBiZSBhIGNvbnMg KENIQVIgLiBGQUNFLUlEKS4gICovCisKK3N0YXRpYyBpbmxpbmUgaW50CitHTFlQSF9DT0RF X1AgKExpc3BfT2JqZWN0IGdjKQoreworICByZXR1cm4gKENPTlNQIChnYykKKwkgID8gKENI QVJBQ1RFUlAgKFhDQVIgKGdjKSkKKwkgICAgICYmIFJBTkdFRF9JTlRFR0VSUCAoMCwgWENE UiAoZ2MpLCBNQVhfRkFDRV9JRCkpCisJICA6IChSQU5HRURfSU5URUdFUlAKKwkgICAgICgw LCBnYywKKwkgICAgICAoTUFYX0ZBQ0VfSUQgPCBUWVBFX01BWElNVU0gKEVNQUNTX0lOVCkg Pj4gQ0hBUkFDVEVSQklUUworCSAgICAgICA/ICgoRU1BQ1NfSU5UKSBNQVhfRkFDRV9JRCA8 PCBDSEFSQUNURVJCSVRTKSB8IE1BWF9DSEFSCisJICAgICAgIDogVFlQRV9NQVhJTVVNIChF TUFDU19JTlQpKSkpKTsKK30KKwogLyogTm9uLXplcm8gbWVhbnMgZmFjZSBhdHRyaWJ1dGVz IGhhdmUgYmVlbiBjaGFuZ2VkIHNpbmNlIHRoZSBsYXN0CiAgICByZWRpc3BsYXkuICBVc2Vk IGluIHJlZGlzcGxheV9pbnRlcm5hbC4gICovCiAKCj09PSBtb2RpZmllZCBmaWxlICdzcmMv ZXZhbC5jJwotLS0gc3JjL2V2YWwuYwkyMDEyLTA3LTIwIDA1OjI4OjAwICswMDAwCisrKyBz cmMvZXZhbC5jCTIwMTItMDctMjMgMjE6NTA6MzYgKzAwMDAKQEAgLTE5MTksNyArMTkxOSw3 IEBACiAgICAgICAgYW5kIGFzc3VtZWQgdGhlIGRvY3N0cmluZyB3aWxsIGJlIHByb3ZpZGVk IGJ5IFNuYXJmLWRvY3VtZW50YXRpb24sIHNvIGl0CiAgICAgICAgcGFzc2VkIHVzIDAgaW5z dGVhZC4gIEJ1dCB0aGF0IGxlYWRzIHRvIGFjY2lkZW50YWwgc2hhcmluZyBpbiBwdXJlY29w eSdzCiAgICAgICAgaGFzaC1jb25zaW5nLCBzbyB3ZSB1c2UgYSAoaG9wZWZ1bGx5KSB1bmlx dWUgaW50ZWdlciBpbnN0ZWFkLiAgKi8KLSAgICBkb2NzdHJpbmcgPSBtYWtlX251bWJlciAo WFVOVEFHIChmdW5jdGlvbiwgTGlzcF9TeW1ib2wpKTsKKyAgICBkb2NzdHJpbmcgPSBtYWtl X251bWJlciAoKGludHB0cl90KSBYVU5UQUcgKGZ1bmN0aW9uLCBMaXNwX1N5bWJvbCkpOwog ICByZXR1cm4gRmZzZXQgKGZ1bmN0aW9uLAogCQlGcHVyZWNvcHkgKGxpc3Q1IChRYXV0b2xv YWQsIGZpbGUsIGRvY3N0cmluZywKIAkJCQkgIGludGVyYWN0aXZlLCB0eXBlKSkpOwoKPT09 IG1vZGlmaWVkIGZpbGUgJ3NyYy9mbnMuYycKLS0tIHNyYy9mbnMuYwkyMDEyLTA3LTIwIDA3 OjI5OjA0ICswMDAwCisrKyBzcmMvZm5zLmMJMjAxMi0wNy0yMyAyMTo1MDozNiArMDAwMApA QCAtMzM1NCw3ICszMzU0LDggQEAKIAogLyogVmFyaW91cyBzeW1ib2xzLiAgKi8KIAotc3Rh dGljIExpc3BfT2JqZWN0IFFoYXNoX3RhYmxlX3AsIFFrZXksIFF2YWx1ZTsKK0xpc3BfT2Jq ZWN0IFFoYXNoX3RhYmxlX3A7CitzdGF0aWMgTGlzcF9PYmplY3QgUWtleSwgUXZhbHVlOwog TGlzcF9PYmplY3QgUWVxLCBRZXFsLCBRZXF1YWw7CiBMaXNwX09iamVjdCBRQ3Rlc3QsIFFD c2l6ZSwgUUNyZWhhc2hfc2l6ZSwgUUNyZWhhc2hfdGhyZXNob2xkLCBRQ3dlYWtuZXNzOwog c3RhdGljIExpc3BfT2JqZWN0IFFoYXNoX3RhYmxlX3Rlc3QsIFFrZXlfb3JfdmFsdWUsIFFr ZXlfYW5kX3ZhbHVlOwoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9saXNwLmgnCi0tLSBzcmMv bGlzcC5oCTIwMTItMDctMjMgMTE6MTU6NDMgKzAwMDAKKysrIHNyYy9saXNwLmgJMjAxMi0w Ny0yNCAwMTo1NzoxOCArMDAwMApAQCAtMzIsMTAgKzMyLDEwIEBACiAKICNpZmRlZiBHQ19D SEVDS19DT05TX0xJU1QKIGV4dGVybiB2b2lkIGNoZWNrX2NvbnNfbGlzdCAodm9pZCk7Ci0j ZGVmaW5lIENIRUNLX0NPTlNfTElTVCgpIGNoZWNrX2NvbnNfbGlzdCAoKQogI2Vsc2UKLSNk ZWZpbmUgQ0hFQ0tfQ09OU19MSVNUKCkgKCh2b2lkKSAwKQorc3RhdGljIGlubGluZSB2b2lk IGNoZWNrX2NvbnNfbGlzdCAodm9pZCkgeyB9CiAjZW5kaWYKK3N0YXRpYyBpbmxpbmUgdm9p ZCBDSEVDS19DT05TX0xJU1QgKHZvaWQpIHsgY2hlY2tfY29uc19saXN0ICgpOyB9CiAKIC8q IFRlbXBvcmFyaWx5IGRpc2FibGUgd2lkZXItdGhhbi1wb2ludGVyIGludGVnZXJzIHVudGls IHRoZXkncmUgdGVzdGVkIG1vcmUuCiAgICBCdWlsZCB3aXRoIENGTEFHUz0nLURXSURFX0VN QUNTX0lOVCcgdG8gdHJ5IHRoZW0gb3V0LiAgKi8KQEAgLTQ1LDIyICs0NSwyNCBAQAogICAg RU1BQ1NfSU5UX01BWCAtIG1heGltdW0gdmFsdWUgb2YgRU1BQ1NfSU5UOyBjYW4gYmUgdXNl ZCBpbiAjaWYKICAgIHBJIC0gcHJpbnRmIGxlbmd0aCBtb2RpZmllciBmb3IgRU1BQ1NfSU5U CiAgICBFTUFDU19VSU5UIC0gdW5zaWduZWQgdmFyaWFudCBvZiBFTUFDU19JTlQgKi8KLSNp Zm5kZWYgRU1BQ1NfSU5UCisjaWZuZGVmIEVNQUNTX0lOVF9NQVgKICMgaWYgTE9OR19NQVgg PCBMTE9OR19NQVggJiYgZGVmaW5lZCBXSURFX0VNQUNTX0lOVAotIyAgZGVmaW5lIEVNQUNT X0lOVCBsb25nIGxvbmcKK3R5cGVkZWYgbG9uZyBsb25nIGludCBFTUFDU19JTlQ7Cit0eXBl ZGVmIHVuc2lnbmVkIGxvbmcgbG9uZyBpbnQgRU1BQ1NfVUlOVDsKICMgIGRlZmluZSBFTUFD U19JTlRfTUFYIExMT05HX01BWAogIyAgZGVmaW5lIHBJICJsbCIKICMgZWxpZiBJTlRfTUFY IDwgTE9OR19NQVgKLSMgIGRlZmluZSBFTUFDU19JTlQgbG9uZwordHlwZWRlZiBsb25nIGlu dCBFTUFDU19JTlQ7Cit0eXBlZGVmIHVuc2lnbmVkIGxvbmcgaW50IEVNQUNTX1VJTlQ7CiAj ICBkZWZpbmUgRU1BQ1NfSU5UX01BWCBMT05HX01BWAogIyAgZGVmaW5lIHBJICJsIgogIyBl bHNlCi0jICBkZWZpbmUgRU1BQ1NfSU5UIGludAordHlwZWRlZiBpbnQgRU1BQ1NfSU5UOwor dHlwZWRlZiB1bnNpZ25lZCBpbnQgRU1BQ1NfVUlOVDsKICMgIGRlZmluZSBFTUFDU19JTlRf TUFYIElOVF9NQVgKICMgIGRlZmluZSBwSSAiIgogIyBlbmRpZgogI2VuZGlmCi0jZGVmaW5l IEVNQUNTX1VJTlQgdW5zaWduZWQgRU1BQ1NfSU5UCiAKIC8qIE51bWJlciBvZiBiaXRzIGlu IHNvbWUgbWFjaGluZSBpbnRlZ2VyIHR5cGVzLiAgKi8KIGVudW0KQEAgLTE1Myw4ICsxNTUs MTAgQEAKICAgIHZhcmlhYmxlIFZBUiBvZiB0eXBlIFRZUEUgd2l0aCB0aGUgYWRkZWQgcmVx dWlyZW1lbnQgdGhhdCBpdCBiZQogICAgVFlQRUJJVFMtYWxpZ25lZC4gICovCiAKKy8qIE51 bWJlciBvZiBiaXRzIGluIGEgTGlzcF9PYmVjdCB0YWcuICBUaGlzIGNhbiBiZSB1c2VkIGlu ICNpZi4gICovCiAjZGVmaW5lIEdDVFlQRUJJVFMgMwotI2RlZmluZSBWQUxCSVRTIChCSVRT X1BFUl9FTUFDU19JTlQgLSBHQ1RZUEVCSVRTKQorCitlbnVtIHsgVkFMQklUUyA9IEJJVFNf UEVSX0VNQUNTX0lOVCAtIEdDVFlQRUJJVFMgfTsKIAogLyogVGhlIG1heGltdW0gdmFsdWUg dGhhdCBjYW4gYmUgc3RvcmVkIGluIGEgRU1BQ1NfSU5ULCBhc3N1bWluZyBhbGwKICAgIGJp dHMgb3RoZXIgdGhhbiB0aGUgdHlwZSBiaXRzIGNvbnRyaWJ1dGUgdG8gYSBub25uZWdhdGl2 ZSBzaWduZWQgdmFsdWUuCkBAIC0yMTAsMjAgKzIxNCw3MiBAQAogI2VuZGlmCiAKIAorLyog V2hlbiBjb21waWxpbmcgdmlhIEdDQyB3aXRob3V0IG9wdGltaXphdGlvbiwgaW5saW5lIGEg ZmV3IGZ1bmN0aW9ucworICAgbWFudWFsbHksIGFzIEVtYWNzIGlzIHRvbyBzbG93IG90aGVy d2lzZS4gIFRoZXJlJ3Mgbm8gbmVlZCB0bworICAgaW5saW5lIGV2ZXJ5dGhpbmcsIGp1c3Qg dGhlIGZ1bmN0aW9ucyB0aGF0IHdvdWxkIGNhdXNlIGEgc2VyaW91cworICAgcGVyZm9ybWFu Y2UgcHJvYmxlbSB3aGVuIGRlYnVnZ2luZy4gIFRvIGRpc2FibGUgdGhpcyBoYW5kLW9wdGlt aXphdGlvbiwKKyAgIGNvbXBpbGUgd2l0aCAtRElOTElOSU5HPTAuCisKKyAgIENvbW1lbnRh cnkgZm9yIHRoZXNlIG1hY3JvcyBjYW4gYmUgZm91bmQgbmVhciB0aGVpciBjb3JyZXNwb25k aW5nCisgICBmdW5jdGlvbnMsIGJlbG93LiAgKi8KKyNpZiAoZGVmaW5lZCBfX05PX0lOTElO RV9fIFwKKyAgICAgJiYgISBkZWZpbmVkIF9fT1BUSU1JWkVfXyAmJiAhIGRlZmluZWQgX19P UFRJTUlaRV9TSVpFX18gXAorICAgICAmJiAhIChkZWZpbmVkIElOTElOSU5HICYmICEgSU5M SU5JTkcpKQorIyBpZiBDSEVDS19MSVNQX09CSkVDVF9UWVBFCisjICBkZWZpbmUgWExJKG8p IChvKS5pCisjICBkZWZpbmUgWElMKGkpIChMaXNwX09iamVjdCkgeyBpIH0KKyMgZWxzZQor IyAgZGVmaW5lIFhMSShvKSAobykKKyMgIGRlZmluZSBYSUwoaSkgKGkpCisjIGVuZGlmCisj IGRlZmluZSBDSEVDS19UWVBFKG9rLCBReHh4cCwgeCkgXAorICAgICgodm9pZCkgKChvaykg fHwgd3JvbmdfdHlwZV9hcmd1bWVudCAoUXh4eHAsIHgpKSkKKyMgZGVmaW5lIENIRUNLX0xJ U1RfQ09OUyh4LCB5KSBDSEVDS19UWVBFIChDT05TUCAoeCksIFFsaXN0cCwgeSkKKyMgZGVm aW5lIENIRUNLX05VTUJFUih4KSBDSEVDS19UWVBFIChJTlRFR0VSUCAoeCksIFFpbnRlZ2Vy cCwgeCkKKyMgZGVmaW5lIENIRUNLX1NZTUJPTCh4KSBDSEVDS19UWVBFIChTWU1CT0xQICh4 KSwgUXN5bWJvbHAsIHgpCisjIGRlZmluZSBDT05TUCh4KSAoWFRZUEUgKHgpID09IExpc3Bf Q29ucykKKyMgZGVmaW5lIEVRKGEsIGIpIChYSEFTSCAoYSkgPT0gWEhBU0ggKGIpKQorIyBk ZWZpbmUgRkxPQVRQKHgpIChYVFlQRSAoeCkgPT0gTGlzcF9GbG9hdCkKKyMgZGVmaW5lIElO VEVHRVJQKHgpIExJU1BfSU5UX1RBR19QIChYVFlQRSAoeCkpCisjIGRlZmluZSBMSVNQX0lO VF9UQUdfUCh4KSAoKCh4KSAmIH5MaXNwX0ludDEpID09IDApCisjIGRlZmluZSBNQVJLRVJQ KHgpIChNSVNDUCAoeCkgJiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01pc2NfTWFya2VyKQor IyBkZWZpbmUgTUlTQ1AoeCkgKFhUWVBFICh4KSA9PSBMaXNwX01pc2MpCisjIGRlZmluZSBO SUxQKHgpIEVRICh4LCBRbmlsKQorIyBkZWZpbmUgU0VUX1NZTUJPTF9WQUwoc3ltLCB2KSBc CisgICAgKGVhc3NlcnQgKChzeW0pLT5yZWRpcmVjdCA9PSBTWU1CT0xfUExBSU5WQUwpLCAo c3ltKS0+dmFsLnZhbHVlID0gKHYpKQorIyBkZWZpbmUgU1lNQk9MX0NPTlNUQU5UX1Aoc3lt KSAoWFNZTUJPTCAoc3ltKS0+Y29uc3RhbnQpCisjIGRlZmluZSBTWU1CT0xfVkFMKHN5bSkJ CQkJCQlcCisgICAgKGVhc3NlcnQgKChzeW0pLT5yZWRpcmVjdCA9PSBTWU1CT0xfUExBSU5W QUwpLCAoc3ltKS0+dmFsLnZhbHVlKQorIyBkZWZpbmUgU1lNQk9MUCh4KSAoWFRZUEUgKHgp ID09IExpc3BfU3ltYm9sKQorIyBkZWZpbmUgVkVDVE9STElLRVAoeCkgKFhUWVBFICh4KSA9 PSBMaXNwX1ZlY3Rvcmxpa2UpCisjIGRlZmluZSBYQ0FSKGMpIFhDQVJfQVNfTFZBTFVFIChj KQorIyBkZWZpbmUgWENEUihjKSBYQ0RSX0FTX0xWQUxVRSAoYykKKyMgZGVmaW5lIFhDT05T KGEpIFwKKyAgICAoZWFzc2VydCAoQ09OU1AgKGEpKSwgKHN0cnVjdCBMaXNwX0NvbnMgKikg WFVOVEFHIChhLCBMaXNwX0NvbnMpKQorIyBkZWZpbmUgWEhBU0gobykgWExJIChvKQorIyBk ZWZpbmUgWFBOVFIoYSkgKCh2b2lkICopIChpbnRwdHJfdCkgKChYTEkgKGEpICYgVkFMTUFT SykgfCBEQVRBX1NFR19CSVRTKSkKKyMgZGVmaW5lIFhTWU1CT0woYSkgXAorICAgIChlYXNz ZXJ0IChTWU1CT0xQIChhKSksIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKikgWFVOVEFHIChhLCBM aXNwX1N5bWJvbCkpCisjIGlmIFVTRV9MU0JfVEFHCisjICBkZWZpbmUgbWFrZV9udW1iZXIo bikgWElMICgoRU1BQ1NfSU5UKSAobikgPDwgSU5UVFlQRUJJVFMpCisjICBkZWZpbmUgWEZB U1RJTlQoYSkgWElOVCAoYSkKKyMgIGRlZmluZSBYSU5UKGEpIChYTEkgKGEpID4+IElOVFRZ UEVCSVRTKQorIyAgZGVmaW5lIFhUWVBFKGEpICgoZW51bSBMaXNwX1R5cGUpIChYTEkgKGEp ICYgflZBTE1BU0spKQorIyAgZGVmaW5lIFhVTlRBRyhhLCB0eXBlKSAoKHZvaWQgKikgKFhM SSAoYSkgLSAodHlwZSkpKQorIyBlbmRpZgorI2VuZGlmCisKKwogLyogRGVmaW5lIHRoZSBm dW5kYW1lbnRhbCBMaXNwIGRhdGEgc3RydWN0dXJlcy4gICovCiAKIC8qIFRoaXMgaXMgdGhl IHNldCBvZiBMaXNwIGRhdGEgdHlwZXMuICAqLwogCiAvKiBMaXNwIGludGVnZXJzIHVzZSAy IHRhZ3MsIHRvIGdpdmUgdGhlbSBvbmUgZXh0cmEgYml0LCB0aHVzCiAgICBleHRlbmRpbmcg dGhlaXIgcmFuZ2UgZnJvbSwgZS5nLiwgLTJeMjguLjJeMjgtMSB0byAtMl4yOS4uMl4yOS0x LiAgKi8KLSNkZWZpbmUgSU5UVFlQRUJJVFMgKEdDVFlQRUJJVFMgLSAxKQotI2RlZmluZSBG SVhOVU1fQklUUyAoVkFMQklUUyArIDEpCitlbnVtIHsgSU5UVFlQRUJJVFMgPSBHQ1RZUEVC SVRTIC0gMSB9OworZW51bSB7IEZJWE5VTV9CSVRTID0gVkFMQklUUyArIDEgfTsKICNkZWZp bmUgSU5UTUFTSyAoRU1BQ1NfSU5UX01BWCA+PiAoSU5UVFlQRUJJVFMgLSAxKSkKLSNkZWZp bmUgTElTUF9JTlRfVEFHIExpc3BfSW50MAogI2RlZmluZSBjYXNlX0xpc3BfSW50IGNhc2Ug TGlzcF9JbnQwOiBjYXNlIExpc3BfSW50MQotI2RlZmluZSBMSVNQX0lOVDFfVEFHIChVU0Vf TFNCX1RBRyA/IDEgPDwgSU5UVFlQRUJJVFMgOiAxKQotI2RlZmluZSBMSVNQX1NUUklOR19U QUcgKDUgLSBMSVNQX0lOVDFfVEFHKQotI2RlZmluZSBMSVNQX0lOVF9UQUdfUCh4KSAoKCh4 KSAmIH5MSVNQX0lOVDFfVEFHKSA9PSAwKQogCiAvKiBTdG9sZW4gZnJvbSBHREIuICBUaGUg b25seSBrbm93biBjb21waWxlciB0aGF0IGRvZXNuJ3Qgc3VwcG9ydAogICAgZW51bXMgaW4g Yml0ZmllbGRzIGlzIE1TVkMuICAqLwpAQCAtMjM4LDcgKzI5NCw3IEBACiAgIHsKICAgICAv KiBJbnRlZ2VyLiAgWElOVCAob2JqKSBpcyB0aGUgaW50ZWdlciB2YWx1ZS4gICovCiAgICAg TGlzcF9JbnQwID0gMCwKLSAgICBMaXNwX0ludDEgPSBMSVNQX0lOVDFfVEFHLAorICAgIExp c3BfSW50MSA9IFVTRV9MU0JfVEFHID8gNCA6IDEsCiAKICAgICAvKiBTeW1ib2wuICBYU1lN Qk9MIChvYmplY3QpIHBvaW50cyB0byBhIHN0cnVjdCBMaXNwX1N5bWJvbC4gICovCiAgICAg TGlzcF9TeW1ib2wgPSAyLApAQCAtMjQ5LDcgKzMwNSw3IEBACiAKICAgICAvKiBTdHJpbmcu ICBYU1RSSU5HIChvYmplY3QpIHBvaW50cyB0byBhIHN0cnVjdCBMaXNwX1N0cmluZy4KICAg ICAgICBUaGUgbGVuZ3RoIG9mIHRoZSBzdHJpbmcsIGFuZCBpdHMgY29udGVudHMsIGFyZSBz dG9yZWQgdGhlcmVpbi4gICovCi0gICAgTGlzcF9TdHJpbmcgPSBMSVNQX1NUUklOR19UQUcs CisgICAgTGlzcF9TdHJpbmcgPSBVU0VfTFNCX1RBRyA/IDEgOiA0LAogCiAgICAgLyogVmVj dG9yIG9mIExpc3Agb2JqZWN0cywgb3Igc29tZXRoaW5nIHJlc2VtYmxpbmcgaXQuCiAgICAg ICAgWFZFQ1RPUiAob2JqZWN0KSBwb2ludHMgdG8gYSBzdHJ1Y3QgTGlzcF9WZWN0b3IsIHdo aWNoIGNvbnRhaW5zCkBAIC0yNjMsNiArMzE5LDExIEBACiAgICAgTGlzcF9GbG9hdCA9IDcs CiAgIH07CiAKKy8qIEFuIG9sZGVyIG5hbWUgZm9yIExpc3BfSW50MC4gICovCitlbnVtIHsg TElTUF9JTlRfVEFHID0gTGlzcF9JbnQwIH07CisKK3N0YXRpYyBpbmxpbmUgaW50IChMSVNQ X0lOVF9UQUdfUCkgKGludCB4KSB7IHJldHVybiAoeCAmIH5MaXNwX0ludDEpID09IDA7IH0K KwogLyogVGhpcyBpcyB0aGUgc2V0IG9mIGRhdGEgdHlwZXMgdGhhdCBzaGFyZSBhIGNvbW1v biBzdHJ1Y3R1cmUuCiAgICBUaGUgZmlyc3QgbWVtYmVyIG9mIHRoZSBzdHJ1Y3R1cmUgaXMg YSB0eXBlIGNvZGUgZnJvbSB0aGlzIHNldC4KICAgIFRoZSBlbnVtIHZhbHVlcyBhcmUgYXJi aXRyYXJ5LCBidXQgd2UnbGwgdXNlIGxhcmdlIG51bWJlcnMgdG8gbWFrZSBpdApAQCAtMjk3 LDIwICszNTgsMTUgQEAKIAogdHlwZWRlZiBzdHJ1Y3QgeyBFTUFDU19JTlQgaTsgfSBMaXNw X09iamVjdDsKIAotI2RlZmluZSBYTEkobykgKG8pLmkKK3N0YXRpYyBpbmxpbmUgRU1BQ1Nf SU5UIChYTEkpIChMaXNwX09iamVjdCBvKSB7IHJldHVybiBvLmk7IH0KKwogc3RhdGljIGlu bGluZSBMaXNwX09iamVjdAotWElMIChFTUFDU19JTlQgaSkKKyhYSUwpIChFTUFDU19JTlQg aSkKIHsKICAgTGlzcF9PYmplY3QgbyA9IHsgaSB9OwogICByZXR1cm4gbzsKIH0KIAotc3Rh dGljIGlubGluZSBMaXNwX09iamVjdAotTElTUF9NQUtFX1JWQUxVRSAoTGlzcF9PYmplY3Qg bykKLXsKLSAgICByZXR1cm4gbzsKLX0KLQogI2RlZmluZSBMSVNQX0lOSVRJQUxMWV9aRVJP IHswfQogCiAjZWxzZSAvKiBDSEVDS19MSVNQX09CSkVDVF9UWVBFICovCkBAIC0zMTgsOSAr Mzc0LDggQEAKIC8qIElmIGEgc3RydWN0IHR5cGUgaXMgbm90IHdhbnRlZCwgZGVmaW5lIExp c3BfT2JqZWN0IGFzIGp1c3QgYSBudW1iZXIuICAqLwogCiB0eXBlZGVmIEVNQUNTX0lOVCBM aXNwX09iamVjdDsKLSNkZWZpbmUgWExJKG8pIChvKQotI2RlZmluZSBYSUwoaSkgKGkpCi0j ZGVmaW5lIExJU1BfTUFLRV9SVkFMVUUobykgKDArKG8pKQorc3RhdGljIGlubGluZSBFTUFD U19JTlQgKFhMSSkgKExpc3BfT2JqZWN0IG8pIHsgcmV0dXJuIG87IH0KK3N0YXRpYyBpbmxp bmUgTGlzcF9PYmplY3QgKFhJTCkgKEVNQUNTX0lOVCBpKSB7IHJldHVybiBpOyB9CiAjZGVm aW5lIExJU1BfSU5JVElBTExZX1pFUk8gMAogI2VuZGlmIC8qIENIRUNLX0xJU1BfT0JKRUNU X1RZUEUgKi8KIApAQCAtMzY4LDg5ICs0MjMsMTE5IEBACiAgICBvbmx5IHRoZSBudW1iZXIg b2YgTGlzcF9PYmplY3QgZmllbGRzICh0aGF0IG5lZWQgdG8gYmUgdHJhY2VkIGJ5IHRoZSBH QykuCiAgICBUaGUgZGlzdGluY3Rpb24gaXMgdXNlZCBlLmcuIGJ5IExpc3BfUHJvY2VzcyB3 aGljaCBwbGFjZXMgZXh0cmEKICAgIG5vbi1MaXNwX09iamVjdCBmaWVsZHMgYXQgdGhlIGVu ZCBvZiB0aGUgc3RydWN0dXJlLiAgKi8KLSNkZWZpbmUgUFNFVURPVkVDVE9SX1NJWkVfQklU UyAxNgotI2RlZmluZSBQU0VVRE9WRUNUT1JfU0laRV9NQVNLICgoMSA8PCBQU0VVRE9WRUNU T1JfU0laRV9CSVRTKSAtIDEpCi0jZGVmaW5lIFBWRUNfVFlQRV9NQVNLICgweDBmZmYgPDwg UFNFVURPVkVDVE9SX1NJWkVfQklUUykKK2VudW0KKyAgeworICAgIFBTRVVET1ZFQ1RPUl9T SVpFX0JJVFMgPSAxNiwKKyAgICBQU0VVRE9WRUNUT1JfU0laRV9NQVNLID0gKDEgPDwgUFNF VURPVkVDVE9SX1NJWkVfQklUUykgLSAxLAorICAgIFBWRUNfVFlQRV9NQVNLID0gMHhmZmYg PDwgUFNFVURPVkVDVE9SX1NJWkVfQklUUworICB9OwogCiAvKiBOdW1iZXIgb2YgYml0cyB0 byBwdXQgaW4gZWFjaCBjaGFyYWN0ZXIgaW4gdGhlIGludGVybmFsIHJlcHJlc2VudGF0aW9u CiAgICBvZiBib29sIHZlY3RvcnMuICBUaGlzIHNob3VsZCBub3QgdmFyeSBhY3Jvc3MgaW1w bGVtZW50YXRpb25zLiAgKi8KLSNkZWZpbmUgQk9PTF9WRUNUT1JfQklUU19QRVJfQ0hBUiA4 Ci0MCi0vKiBUaGVzZSBtYWNyb3MgZXh0cmFjdCB2YXJpb3VzIHNvcnRzIG9mIHZhbHVlcyBm cm9tIGEgTGlzcF9PYmplY3QuCitlbnVtIHsgQk9PTF9WRUNUT1JfQklUU19QRVJfQ0hBUiA9 IDggfTsKKwwKKy8qIERBVEFfU0VHX0JJVFMgZm9yY2VzIGV4dHJhIGJpdHMgdG8gYmUgb3In ZCBpbiB3aXRoIGFueSBwb2ludGVycworICAgd2hpY2ggd2VyZSBzdG9yZWQgaW4gYSBMaXNw X09iamVjdCAqLworI2lmbmRlZiBEQVRBX1NFR19CSVRTCisjIGRlZmluZSBEQVRBX1NFR19C SVRTIDAKKyNlbmRpZgorDAorLyogVGhlc2UgZnVuY3Rpb25zIGV4dHJhY3QgdmFyaW91cyBz b3J0cyBvZiB2YWx1ZXMgZnJvbSBhIExpc3BfT2JqZWN0LgogIEZvciBleGFtcGxlLCBpZiB0 ZW0gaXMgYSBMaXNwX09iamVjdCB3aG9zZSB0eXBlIGlzIExpc3BfQ29ucywKICBYQ09OUyAo dGVtKSBpcyB0aGUgc3RydWN0IExpc3BfQ29ucyAqIHBvaW50aW5nIHRvIHRoZSBtZW1vcnkg Zm9yIHRoYXQgY29ucy4gICovCiAKIC8qIFJldHVybiBhIHBlcmZlY3QgaGFzaCBvZiB0aGUg TGlzcF9PYmplY3QgcmVwcmVzZW50YXRpb24uICAqLwotI2RlZmluZSBYSEFTSChhKSBYTEkg KGEpCi0KLSNpZiBVU0VfTFNCX1RBRwotCi0jZGVmaW5lIFRZUEVNQVNLICgoMSA8PCBHQ1RZ UEVCSVRTKSAtIDEpCi0jZGVmaW5lIFhUWVBFKGEpICgoZW51bSBMaXNwX1R5cGUpIChYTEkg KGEpICYgVFlQRU1BU0spKQotI2RlZmluZSBYSU5UKGEpIChYTEkgKGEpID4+IElOVFRZUEVC SVRTKQotI2RlZmluZSBYVUlOVChhKSAoKEVNQUNTX1VJTlQpIFhMSSAoYSkgPj4gSU5UVFlQ RUJJVFMpCi0jZGVmaW5lIG1ha2VfbnVtYmVyKE4pIFhJTCAoKEVNQUNTX0lOVCkgKE4pIDw8 IElOVFRZUEVCSVRTKQotI2RlZmluZSBYU0VUKHZhciwgdHlwZSwgcHRyKQkJCQkJCSAgIFwK LSAgKGVhc3NlcnQgKFhUWVBFIChYSUwgKChpbnRwdHJfdCkgKHB0cikpKSA9PSAwKSwgLyog Q2hlY2sgYWxpZ25tZW50LiAgKi8gIFwKLSAgICh2YXIpID0gWElMICgodHlwZSkgfCAoaW50 cHRyX3QpIChwdHIpKSkKLQotI2RlZmluZSBYUE5UUihhKSAoKGludHB0cl90KSAoWExJIChh KSAmIH5UWVBFTUFTSykpCi0jZGVmaW5lIFhVTlRBRyhhLCB0eXBlKSAoKGludHB0cl90KSAo WExJIChhKSAtICh0eXBlKSkpCi0KLSNlbHNlICAvKiBub3QgVVNFX0xTQl9UQUcgKi8KLQot I2RlZmluZSBWQUxNQVNLIFZBTF9NQVgKLQotI2RlZmluZSBYVFlQRShhKSAoKGVudW0gTGlz cF9UeXBlKSAoKEVNQUNTX1VJTlQpIFhMSSAoYSkgPj4gVkFMQklUUykpCi0KLS8qIEZvciBp bnRlZ2VycyBrbm93biB0byBiZSBwb3NpdGl2ZSwgWEZBU1RJTlQgcHJvdmlkZXMgZmFzdCBy ZXRyaWV2YWwKLSAgIGFuZCBYU0VURkFTVElOVCBwcm92aWRlcyBmYXN0IHN0b3JhZ2UuICBU aGlzIHRha2VzIGFkdmFudGFnZSBvZiB0aGUKLSAgIGZhY3QgdGhhdCBMaXNwIGludGVnZXJz IGhhdmUgemVyby1iaXRzIGluIHRoZWlyIHRhZ3MuICAqLwotI2RlZmluZSBYRkFTVElOVChh KSAoWExJIChhKSArIDApCi0jZGVmaW5lIFhTRVRGQVNUSU5UKGEsIGIpICgoYSkgPSBYSUwg KGIpKQotCi0vKiBFeHRyYWN0IHRoZSB2YWx1ZSBvZiBhIExpc3BfT2JqZWN0IGFzIGEgKHVu KXNpZ25lZCBpbnRlZ2VyLiAgKi8KLQotI2RlZmluZSBYSU5UKGEpIChYTEkgKGEpIDw8IElO VFRZUEVCSVRTID4+IElOVFRZUEVCSVRTKQotI2RlZmluZSBYVUlOVChhKSAoKEVNQUNTX1VJ TlQpIChYTEkgKGEpICYgSU5UTUFTSykpCi0jZGVmaW5lIG1ha2VfbnVtYmVyKE4pIFhJTCAo KEVNQUNTX0lOVCkgKE4pICYgSU5UTUFTSykKLQotI2RlZmluZSBYU0VUKHZhciwgdHlwZSwg cHRyKQkJCQkgICAgICBcCi0gICgodmFyKSA9IFhJTCAoKEVNQUNTX0lOVCkgKChFTUFDU19V SU5UKSAodHlwZSkgPDwgVkFMQklUUykgIFwKLQkJKyAoKGludHB0cl90KSAocHRyKSAmIFZB TE1BU0spKSkKLQotI2lmZGVmIERBVEFfU0VHX0JJVFMKLS8qIERBVEFfU0VHX0JJVFMgZm9y Y2VzIGV4dHJhIGJpdHMgdG8gYmUgb3InZCBpbiB3aXRoIGFueSBwb2ludGVycwotICAgd2hp Y2ggd2VyZSBzdG9yZWQgaW4gYSBMaXNwX09iamVjdCAqLwotI2RlZmluZSBYUE5UUihhKSAo KHVpbnRwdHJfdCkgKChYTEkgKGEpICYgVkFMTUFTSykpIHwgREFUQV9TRUdfQklUUykpCi0j ZWxzZQotI2RlZmluZSBYUE5UUihhKSAoKHVpbnRwdHJfdCkgKFhMSSAoYSkgJiBWQUxNQVNL KSkKLSNlbmRpZgotCi0jZW5kaWYgLyogbm90IFVTRV9MU0JfVEFHICovCi0KLS8qIEZvciBp bnRlZ2VycyBrbm93biB0byBiZSBwb3NpdGl2ZSwgWEZBU1RJTlQgc29tZXRpbWVzIHByb3Zp ZGVzCi0gICBmYXN0ZXIgcmV0cmlldmFsIGFuZCBYU0VURkFTVElOVCBwcm92aWRlcyBmYXN0 ZXIgc3RvcmFnZS4KLSAgIElmIG5vdCwgZmFsbGJhY2sgb24gdGhlIG5vbi1hY2NlbGVyYXRl ZCBwYXRoLiAgKi8KLSNpZm5kZWYgWEZBU1RJTlQKLSMgZGVmaW5lIFhGQVNUSU5UKGEpIChY SU5UIChhKSkKLSMgZGVmaW5lIFhTRVRGQVNUSU5UKGEsIGIpIChYU0VUSU5UIChhLCBiKSkK LSNlbmRpZgotCi0vKiBFeHRyYWN0IHRoZSBwb2ludGVyIHZhbHVlIG9mIHRoZSBMaXNwIG9i amVjdCBBLCB1bmRlciB0aGUKLSAgIGFzc3VtcHRpb24gdGhhdCBBJ3MgdHlwZSBpcyBUWVBF LiAgVGhpcyBpcyBhIGZhbGxiYWNrCi0gICBpbXBsZW1lbnRhdGlvbiBpZiBub3RoaW5nIGZh c3RlciBpcyBhdmFpbGFibGUuICAqLwotI2lmbmRlZiBYVU5UQUcKLSMgZGVmaW5lIFhVTlRB RyhhLCB0eXBlKSBYUE5UUiAoYSkKLSNlbmRpZgotCi0jZGVmaW5lIEVRKHgsIHkpIChYSEFT SCAoeCkgPT0gWEhBU0ggKHkpKQorc3RhdGljIGlubGluZSBFTUFDU19JTlQgKFhIQVNIKSAo TGlzcF9PYmplY3QgbykgeyByZXR1cm4gWExJIChvKTsgfQorCisjZGVmaW5lIFZBTE1BU0sg KFVTRV9MU0JfVEFHID8gLSAoMSA8PCBHQ1RZUEVCSVRTKSA6IFZBTF9NQVgpCiAKIC8qIExh cmdlc3QgYW5kIHNtYWxsZXN0IHJlcHJlc2VudGFibGUgZml4bnVtIHZhbHVlcy4gIFRoZXNl IGFyZSB0aGUgQwogICAgdmFsdWVzLiAgKi8KICNkZWZpbmUgTU9TVF9QT1NJVElWRV9GSVhO VU0gKEVNQUNTX0lOVF9NQVggPj4gSU5UVFlQRUJJVFMpCiAjZGVmaW5lIE1PU1RfTkVHQVRJ VkVfRklYTlVNICgtMSAtIE1PU1RfUE9TSVRJVkVfRklYTlVNKQogCitzdGF0aWMgaW5saW5l IGVudW0gTGlzcF9UeXBlCisoWFRZUEUpIChMaXNwX09iamVjdCBhKQoreworICBFTUFDU19V SU5UIGkgPSBYTEkgKGEpOworICByZXR1cm4gVVNFX0xTQl9UQUcgPyBpICYgflZBTE1BU0sg OiBpID4+IFZBTEJJVFM7Cit9CisKKy8qIEV4dHJhY3QgdGhlIHZhbHVlIG9mIGEgTGlzcF9P YmplY3QgYXMgYSBzaWduZWQgaW50ZWdlci4gICovCitzdGF0aWMgaW5saW5lIEVNQUNTX0lO VAorKFhJTlQpIChMaXNwX09iamVjdCBhKQoreworICBFTUFDU19JTlQgaSA9IFhMSSAoYSk7 CisgIHJldHVybiAoVVNFX0xTQl9UQUcgPyBpIDogaSA8PCBJTlRUWVBFQklUUykgPj4gSU5U VFlQRUJJVFM7Cit9CisKKy8qIExpa2UgWElOVCAoQSksIGJ1dCBtYXkgYmUgZmFzdGVyLiAg QSBtdXN0IGJlIG5vbm5lZ2F0aXZlLiAgVGhpcyB0YWtlcworICAgYWR2YW50YWdlIG9mIHRo ZSBmYWN0IHRoYXQgTGlzcCBpbnRlZ2VycyBoYXZlIHplcm8tYml0cyBpbiB0aGVpciB0YWdz LiAgKi8KK3N0YXRpYyBpbmxpbmUgRU1BQ1NfSU5UCisoWEZBU1RJTlQpIChMaXNwX09iamVj dCBhKQoreworICBFTUFDU19JTlQgbiA9IFVTRV9MU0JfVEFHID8gWElOVCAoYSkgOiBYTEkg KGEpID4+IElOVFRZUEVCSVRTOworICBlYXNzZXJ0ICgwIDw9IG4pOworICByZXR1cm4gbjsK K30KKworLyogRXh0cmFjdCB0aGUgdmFsdWUgb2YgYSBMaXNwX09iamVjdCBhcyBhbiB1bnNp Z25lZCBpbnRlZ2VyLiAgKi8KK3N0YXRpYyBpbmxpbmUgRU1BQ1NfVUlOVAorWFVJTlQgKExp c3BfT2JqZWN0IGEpCit7CisgIEVNQUNTX1VJTlQgaSA9IFhMSSAoYSk7CisgIHJldHVybiBV U0VfTFNCX1RBRyA/IGkgPj4gSU5UVFlQRUJJVFMgOiBpICYgSU5UTUFTSzsKK30KKworc3Rh dGljIGlubGluZSBMaXNwX09iamVjdAorKG1ha2VfbnVtYmVyKSAoRU1BQ1NfSU5UIG4pCit7 CisgIHJldHVybiBYSUwgKFVTRV9MU0JfVEFHID8gbiA8PCBJTlRUWVBFQklUUyA6IG4gJiBJ TlRNQVNLKTsKK30KKworLyogTGlrZSBtYWtlX251bWJlciAoTiksIGJ1dCBtYXkgYmUgZmFz dGVyLiAgTiBtdXN0IGJlIGluIG5vbm5lZ2F0aXZlIHJhbmdlLiAgKi8KK3N0YXRpYyBpbmxp bmUgTGlzcF9PYmplY3QKK21ha2VfbmF0bnVtIChFTUFDU19JTlQgbikKK3sKKyAgZWFzc2Vy dCAoMCA8PSBuICYmIG4gPD0gTU9TVF9QT1NJVElWRV9GSVhOVU0pOworICByZXR1cm4gVVNF X0xTQl9UQUcgPyBtYWtlX251bWJlciAobikgOiBYSUwgKG4pOworfQorCitzdGF0aWMgaW5s aW5lIHZvaWQgKgorKFhQTlRSKSAoTGlzcF9PYmplY3QgYSkKK3sKKyAgaW50cHRyX3QgaSA9 IChYTEkgKGEpICYgVkFMTUFTSykgfCBEQVRBX1NFR19CSVRTOworICByZXR1cm4gKHZvaWQg KikgaTsKK30KKworLyogRXh0cmFjdCB0aGUgcG9pbnRlciB2YWx1ZSBvZiB0aGUgTGlzcCBv YmplY3QgQSwgdW5kZXIgdGhlCisgICBhc3N1bXB0aW9uIHRoYXQgQSdzIHR5cGUgaXMgVFlQ RS4gICovCitzdGF0aWMgaW5saW5lIHZvaWQgKgorKFhVTlRBRykgKExpc3BfT2JqZWN0IGEs IGludCB0eXBlKQoreworICBpZiAoVVNFX0xTQl9UQUcpCisgICAgeworICAgICAgaW50cHRy X3QgaSA9IFhMSSAoYSkgLSB0eXBlOworICAgICAgcmV0dXJuICh2b2lkICopIGk7CisgICAg fQorICByZXR1cm4gWFBOVFIgKGEpOworfQorCitzdGF0aWMgaW5saW5lIGludAorKEVRKSAo TGlzcF9PYmplY3QgYSwgTGlzcF9PYmplY3QgYikKK3sKKyAgcmV0dXJuIFhIQVNIIChhKSA9 PSBYSEFTSCAoYik7Cit9CisKKy8qIFRoZSB1YmlxdWl0b3VzIG1pbiBhbmQgbWF4IG1hY3Jv cy4gICovCisKKyNpZmRlZiBtYXgKKyN1bmRlZiBtYXgKKyN1bmRlZiBtaW4KKyNlbmRpZgor I2RlZmluZSBtaW4oYSwgYikJKChhKSA8IChiKSA/IChhKSA6IChiKSkKKyNkZWZpbmUgbWF4 KGEsIGIpCSgoYSkgPiAoYikgPyAoYSkgOiAoYikpCisKIC8qIFZhbHVlIGlzIG5vbi16ZXJv IGlmIEkgZG9lc24ndCBmaXQgaW50byBhIExpc3AgZml4bnVtLiAgSXQgaXMKICAgIHdyaXR0 ZW4gdGhpcyB3YXkgc28gdGhhdCBpdCBhbHNvIHdvcmtzIGlmIEkgaXMgb2YgdW5zaWduZWQK ICAgIHR5cGUgb3IgaWYgSSBpcyBhIE5hTi4gICovCkBAIC00NjMsNjQgKzU0OCwxODEgQEAK IHsKICAgcmV0dXJuIG51bSA8IGxvd2VyID8gbG93ZXIgOiBudW0gPD0gdXBwZXIgPyBudW0g OiB1cHBlcjsKIH0KKwwKKy8qIEZvcndhcmQgZGVjbGFyYXRpb25zLiAgKi8KKworLyogRGVm aW5lZCBpbiB0aGlzIGZpbGUuICAqLwordW5pb24gTGlzcF9Gd2Q7CitzdGF0aWMgaW50IEJP T0xGV0RQICh1bmlvbiBMaXNwX0Z3ZCAqKTsKK3N0YXRpYyBpbnQgQk9PTF9WRUNUT1JfUCAo TGlzcF9PYmplY3QpOworc3RhdGljIGludCBCVUZGRVJfT0JKRldEUCAodW5pb24gTGlzcF9G d2QgKik7CitzdGF0aWMgaW50IEJVRkZFUlAgKExpc3BfT2JqZWN0KTsKK3N0YXRpYyBpbnQg Q0hBUl9UQUJMRV9QIChMaXNwX09iamVjdCk7CitzdGF0aWMgTGlzcF9PYmplY3QgQ0hBUl9U QUJMRV9SRUZfQVNDSUkgKExpc3BfT2JqZWN0LCBwdHJkaWZmX3QpOworc3RhdGljIGludCAo Q09OU1ApIChMaXNwX09iamVjdCk7CitzdGF0aWMgaW50IChGTE9BVFApIChMaXNwX09iamVj dCk7CitzdGF0aWMgaW50IChJTlRFR0VSUCkgKExpc3BfT2JqZWN0KTsKK3N0YXRpYyBpbnQg SU5URldEUCAodW5pb24gTGlzcF9Gd2QgKik7CitzdGF0aWMgaW50IEtCT0FSRF9PQkpGV0RQ ICh1bmlvbiBMaXNwX0Z3ZCAqKTsKK3N0YXRpYyBpbnQgKE1BUktFUlApIChMaXNwX09iamVj dCk7CitzdGF0aWMgaW50IChNSVNDUCkgKExpc3BfT2JqZWN0KTsKK3N0YXRpYyBpbnQgKE5J TFApIChMaXNwX09iamVjdCk7CitzdGF0aWMgaW50IE9CSkZXRFAgKHVuaW9uIExpc3BfRndk ICopOworc3RhdGljIGludCBPVkVSTEFZUCAoTGlzcF9PYmplY3QpOworc3RhdGljIGludCBQ Uk9DRVNTUCAoTGlzcF9PYmplY3QpOworc3RhdGljIGludCBQU0VVRE9WRUNUT1JQIChMaXNw X09iamVjdCwgaW50KTsKK3N0YXRpYyBpbnQgU0FWRV9WQUxVRVAgKExpc3BfT2JqZWN0KTsK K3N0YXRpYyBpbnQgU1RSSU5HUCAoTGlzcF9PYmplY3QpOworc3RhdGljIGludCBTVUJfQ0hB Ul9UQUJMRV9QIChMaXNwX09iamVjdCk7CitzdGF0aWMgaW50IFNVQlJQIChMaXNwX09iamVj dCk7CitzdGF0aWMgaW50IChTWU1CT0xQKSAoTGlzcF9PYmplY3QpOworc3RhdGljIGludCAo VkVDVE9STElLRVApIChMaXNwX09iamVjdCk7CitzdGF0aWMgaW50IFdJTkRPV1AgKExpc3Bf T2JqZWN0KTsKKworLyogRGVmaW5lZCBpbiBidWZmZXIuYy4gICovCitleHRlcm4gTGlzcF9P YmplY3QgUW92ZXJsYXlwOworCisvKiBEZWZpbmVkIGluIGNoYXJ0YWIuYy4gICovCitleHRl cm4gTGlzcF9PYmplY3QgY2hhcl90YWJsZV9yZWYgKExpc3BfT2JqZWN0LCBpbnQpOworZXh0 ZXJuIExpc3BfT2JqZWN0IGNoYXJfdGFibGVfc2V0IChMaXNwX09iamVjdCwgaW50LCBMaXNw X09iamVjdCk7CitleHRlcm4gaW50IGNoYXJfdGFibGVfdHJhbnNsYXRlIChMaXNwX09iamVj dCwgaW50KTsKKworLyogRGVmaW5lZCBpbiBkYXRhLmMuICAqLworZXh0ZXJuIExpc3BfT2Jq ZWN0IFFhcnJheXAsIFFidWZmZXJwLCBRYnVmZmVyX29yX3N0cmluZ19wLCBRY2hhcl90YWJs ZV9wOworZXh0ZXJuIExpc3BfT2JqZWN0IFFjb25zcCwgUWZsb2F0cCwgUWludGVnZXJwLCBR bGFtYmRhLCBRbGlzdHAsIFFtYXJrZXJwLCBRbmlsOworZXh0ZXJuIExpc3BfT2JqZWN0IFFu dW1iZXJwLCBRc3VicnAsIFFzdHJpbmdwLCBRc3ltYm9scCwgUXZlY3RvcnA7CitleHRlcm4g TGlzcF9PYmplY3QgUXZlY3Rvcl9vcl9jaGFyX3RhYmxlX3AsIFF3aG9sZW51bXA7CitleHRl cm4gTGlzcF9PYmplY3QgRmZib3VuZHAgKExpc3BfT2JqZWN0KTsKK2V4dGVybiBfTm9yZXR1 cm4gTGlzcF9PYmplY3Qgd3JvbmdfdHlwZV9hcmd1bWVudCAoTGlzcF9PYmplY3QsIExpc3Bf T2JqZWN0KTsKKworLyogRGVmaW5lZCBpbiBlbWFjcy5jLiAgKi8KK2V4dGVybiBpbnQgaW5p dGlhbGl6ZWQ7CisKKy8qIERlZmluZWQgaW4gZm5zLmMgICovCitleHRlcm4gTGlzcF9PYmpl Y3QgUWhhc2hfdGFibGVfcDsKKworLyogRGVmaW5lZCBpbiBmbG9hdGZucy5jLiAgKi8KK2V4 dGVybiBkb3VibGUgZXh0cmFjdF9mbG9hdCAoTGlzcF9PYmplY3QpOworCisvKiBEZWZpbmVk IGluIHByb2Nlc3MuYy4gICovCitleHRlcm4gTGlzcF9PYmplY3QgUXByb2Nlc3NwOworCisv KiBEZWZpbmVkIGluIHdpbmRvdy5jLiAgKi8KK2V4dGVybiBMaXNwX09iamVjdCBRd2luZG93 cCwgUXdpbmRvd19jb25maWd1cmF0aW9uX3A7CisKKy8qIERlZmluZWQgaW4geGRpc3AuYy4g ICovCitleHRlcm4gTGlzcF9PYmplY3QgUWltYWdlOworDAogCiAvKiBFeHRyYWN0IGEgdmFs dWUgb3IgYWRkcmVzcyBmcm9tIGEgTGlzcF9PYmplY3QuICAqLwogCi0jZGVmaW5lIFhDT05T KGEpICAgKGVhc3NlcnQgKENPTlNQIChhKSksIFwKLQkJICAgIChzdHJ1Y3QgTGlzcF9Db25z ICopIFhVTlRBRyAoYSwgTGlzcF9Db25zKSkKLSNkZWZpbmUgWFZFQ1RPUihhKSAoZWFzc2Vy dCAoVkVDVE9STElLRVAgKGEpKSwgXAotCQkgICAgKHN0cnVjdCBMaXNwX1ZlY3RvciAqKSBY VU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSkpCi0jZGVmaW5lIFhTVFJJTkcoYSkgKGVhc3Nl cnQgKFNUUklOR1AgKGEpKSwgXAotCQkgICAgKHN0cnVjdCBMaXNwX1N0cmluZyAqKSBYVU5U QUcgKGEsIExpc3BfU3RyaW5nKSkKLSNkZWZpbmUgWFNZTUJPTChhKSAoZWFzc2VydCAoU1lN Qk9MUCAoYSkpLCBcCi0JCSAgICAoc3RydWN0IExpc3BfU3ltYm9sICopIFhVTlRBRyAoYSwg TGlzcF9TeW1ib2wpKQotI2RlZmluZSBYRkxPQVQoYSkgIChlYXNzZXJ0IChGTE9BVFAgKGEp KSwgXAotCQkgICAgKHN0cnVjdCBMaXNwX0Zsb2F0ICopIFhVTlRBRyAoYSwgTGlzcF9GbG9h dCkpCi0KLS8qIE1pc2MgdHlwZXMuICAqLwotCi0jZGVmaW5lIFhNSVNDKGEpCSgodW5pb24g TGlzcF9NaXNjICopIFhVTlRBRyAoYSwgTGlzcF9NaXNjKSkKLSNkZWZpbmUgWE1JU0NBTlko YSkJKGVhc3NlcnQgKE1JU0NQIChhKSksICYoWE1JU0MgKGEpLT51X2FueSkpCi0jZGVmaW5l IFhNSVNDVFlQRShhKSAgIChYTUlTQ0FOWSAoYSktPnR5cGUpCi0jZGVmaW5lIFhNQVJLRVIo YSkJKGVhc3NlcnQgKE1BUktFUlAgKGEpKSwgJihYTUlTQyAoYSktPnVfbWFya2VyKSkKLSNk ZWZpbmUgWE9WRVJMQVkoYSkJKGVhc3NlcnQgKE9WRVJMQVlQIChhKSksICYoWE1JU0MgKGEp LT51X292ZXJsYXkpKQotI2RlZmluZSBYU0FWRV9WQUxVRShhKQkoZWFzc2VydCAoU0FWRV9W QUxVRVAgKGEpKSwgJihYTUlTQyAoYSktPnVfc2F2ZV92YWx1ZSkpCi0KLS8qIEZvcndhcmRp bmcgb2JqZWN0IHR5cGVzLiAgKi8KLQotI2RlZmluZSBYRldEVFlQRShhKSAgICAgKGEtPnVf aW50ZndkLnR5cGUpCi0jZGVmaW5lIFhJTlRGV0QoYSkJKGVhc3NlcnQgKElOVEZXRFAgKGEp KSwgJigoYSktPnVfaW50ZndkKSkKLSNkZWZpbmUgWEJPT0xGV0QoYSkJKGVhc3NlcnQgKEJP T0xGV0RQIChhKSksICYoKGEpLT51X2Jvb2xmd2QpKQotI2RlZmluZSBYT0JKRldEKGEpCShl YXNzZXJ0IChPQkpGV0RQIChhKSksICYoKGEpLT51X29iamZ3ZCkpCi0jZGVmaW5lIFhCVUZG RVJfT0JKRldEKGEpIFwKLSAgKGVhc3NlcnQgKEJVRkZFUl9PQkpGV0RQIChhKSksICYoKGEp LT51X2J1ZmZlcl9vYmpmd2QpKQotI2RlZmluZSBYS0JPQVJEX09CSkZXRChhKSBcCi0gIChl YXNzZXJ0IChLQk9BUkRfT0JKRldEUCAoYSkpLCAmKChhKS0+dV9rYm9hcmRfb2JqZndkKSkK K3N0YXRpYyBpbmxpbmUgc3RydWN0IExpc3BfQ29ucyAqCisoWENPTlMpIChMaXNwX09iamVj dCBhKQoreworICBlYXNzZXJ0IChDT05TUCAoYSkpOworICByZXR1cm4gWFVOVEFHIChhLCBM aXNwX0NvbnMpOworfQorCitzdGF0aWMgaW5saW5lIHN0cnVjdCBMaXNwX1ZlY3RvciAqCitY VkVDVE9SIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChWRUNUT1JMSUtFUCAoYSkp OworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitzdGF0aWMg aW5saW5lIHN0cnVjdCBMaXNwX1N0cmluZyAqCitYU1RSSU5HIChMaXNwX09iamVjdCBhKQor eworICBlYXNzZXJ0IChTVFJJTkdQIChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3Bf U3RyaW5nKTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgTGlzcF9TeW1ib2wgKgorKFhT WU1CT0wpIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChTWU1CT0xQIChhKSk7Cisg IHJldHVybiBYVU5UQUcgKGEsIExpc3BfU3ltYm9sKTsKK30KKworc3RhdGljIGlubGluZSBz dHJ1Y3QgTGlzcF9GbG9hdCAqCitYRkxPQVQgKExpc3BfT2JqZWN0IGEpCit7CisgIGVhc3Nl cnQgKEZMT0FUUCAoYSkpOworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX0Zsb2F0KTsKK30K IAogLyogUHNldWRvdmVjdG9yIHR5cGVzLiAgKi8KIAotI2RlZmluZSBYUFJPQ0VTUyhhKSAo ZWFzc2VydCAoUFJPQ0VTU1AgKGEpKSwgXAotCQkgICAgIChzdHJ1Y3QgTGlzcF9Qcm9jZXNz ICopIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKSkKLSNkZWZpbmUgWFdJTkRPVyhhKSAo ZWFzc2VydCAoV0lORE9XUCAoYSkpLCBcCi0JCSAgICAoc3RydWN0IHdpbmRvdyAqKSBYVU5U QUcgKGEsIExpc3BfVmVjdG9ybGlrZSkpCi0jZGVmaW5lIFhURVJNSU5BTChhKSAoZWFzc2Vy dCAoVEVSTUlOQUxQIChhKSksIFwKLQkJICAgICAgKHN0cnVjdCB0ZXJtaW5hbCAqKSBYVU5U QUcgKGEsIExpc3BfVmVjdG9ybGlrZSkpCi0jZGVmaW5lIFhTVUJSKGEpIChlYXNzZXJ0IChT VUJSUCAoYSkpLCBcCi0JCSAgKHN0cnVjdCBMaXNwX1N1YnIgKikgWFVOVEFHIChhLCBMaXNw X1ZlY3Rvcmxpa2UpKQotI2RlZmluZSBYQlVGRkVSKGEpIChlYXNzZXJ0IChCVUZGRVJQIChh KSksIFwKLQkJICAgIChzdHJ1Y3QgYnVmZmVyICopIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3Js aWtlKSkKLSNkZWZpbmUgWENIQVJfVEFCTEUoYSkgKGVhc3NlcnQgKENIQVJfVEFCTEVfUCAo YSkpLCBcCi0JCQkoc3RydWN0IExpc3BfQ2hhcl9UYWJsZSAqKSBYVU5UQUcgKGEsIExpc3Bf VmVjdG9ybGlrZSkpCi0jZGVmaW5lIFhTVUJfQ0hBUl9UQUJMRShhKSAoZWFzc2VydCAoU1VC X0NIQVJfVEFCTEVfUCAoYSkpLCBcCi0JCQkgICAgKChzdHJ1Y3QgTGlzcF9TdWJfQ2hhcl9U YWJsZSAqKSBcCi0JCQkgICAgIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKSkpCi0jZGVm aW5lIFhCT09MX1ZFQ1RPUihhKSAoZWFzc2VydCAoQk9PTF9WRUNUT1JfUCAoYSkpLCBcCi0J CQkgKChzdHJ1Y3QgTGlzcF9Cb29sX1ZlY3RvciAqKSBcCi0JCQkgIFhVTlRBRyAoYSwgTGlz cF9WZWN0b3JsaWtlKSkpCitzdGF0aWMgaW5saW5lIHN0cnVjdCBMaXNwX1Byb2Nlc3MgKgor WFBST0NFU1MgKExpc3BfT2JqZWN0IGEpCit7CisgIGVhc3NlcnQgKFBST0NFU1NQIChhKSk7 CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSk7Cit9CisKK3N0YXRpYyBp bmxpbmUgc3RydWN0IHdpbmRvdyAqCitYV0lORE9XIChMaXNwX09iamVjdCBhKQoreworICBl YXNzZXJ0IChXSU5ET1dQIChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVjdG9y bGlrZSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IHRlcm1pbmFsICoKK1hURVJNSU5B TCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3Js aWtlKTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgTGlzcF9TdWJyICoKK1hTVUJSIChM aXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChTVUJSUCAoYSkpOworICByZXR1cm4gWFVO VEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitzdGF0aWMgaW5saW5lIHN0cnVjdCBi dWZmZXIgKgorWEJVRkZFUiAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoQlVGRkVS UCAoYSkpOworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitz dGF0aWMgaW5saW5lIHN0cnVjdCBMaXNwX0NoYXJfVGFibGUgKgorWENIQVJfVEFCTEUgKExp c3BfT2JqZWN0IGEpCit7CisgIGVhc3NlcnQgKENIQVJfVEFCTEVfUCAoYSkpOworICByZXR1 cm4gWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitzdGF0aWMgaW5saW5lIHN0 cnVjdCBMaXNwX1N1Yl9DaGFyX1RhYmxlICoKK1hTVUJfQ0hBUl9UQUJMRSAoTGlzcF9PYmpl Y3QgYSkKK3sKKyAgZWFzc2VydCAoU1VCX0NIQVJfVEFCTEVfUCAoYSkpOworICByZXR1cm4g WFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitzdGF0aWMgaW5saW5lIHN0cnVj dCBMaXNwX0Jvb2xfVmVjdG9yICoKK1hCT09MX1ZFQ1RPUiAoTGlzcF9PYmplY3QgYSkKK3sK KyAgZWFzc2VydCAoQk9PTF9WRUNUT1JfUCAoYSkpOworICByZXR1cm4gWFVOVEFHIChhLCBM aXNwX1ZlY3Rvcmxpa2UpOworfQogCiAvKiBDb25zdHJ1Y3QgYSBMaXNwX09iamVjdCBmcm9t IGEgdmFsdWUgb3IgYWRkcmVzcy4gICovCiAKK3N0YXRpYyBpbmxpbmUgTGlzcF9PYmplY3QK K3h0YWcgKGVudW0gTGlzcF9UeXBlIHR5cGUsIHZvaWQgKnB0cikKK3sKKyAgRU1BQ1NfVUlO VCB1dHlwZSA9IHR5cGU7CisgIEVNQUNTX0lOVCB0eXBlYml0cyA9IFVTRV9MU0JfVEFHID8g dHlwZSA6IHV0eXBlIDw8IFZBTEJJVFM7CisgIExpc3BfT2JqZWN0IGEgPSBYSUwgKHR5cGVi aXRzIHwgKGludHB0cl90KSBwdHIpOworICBlYXNzZXJ0IChYVU5UQUcgKGEsIHR5cGUpID09 IHB0cik7ICAvKiBDaGVjayBhbGlnbm1lbnQuICAqLworICByZXR1cm4gYTsKK30KKworI2Rl ZmluZSBYU0VUKHZhciwgdHlwZSwgcHRyKSAoKHZhcikgPSB4dGFnICh0eXBlLCBwdHIpKQog I2RlZmluZSBYU0VUSU5UKGEsIGIpIChhKSA9IG1ha2VfbnVtYmVyIChiKQorI2RlZmluZSBY U0VURkFTVElOVChhLCBiKSAoKGEpID0gbWFrZV9uYXRudW0gKGIpKQogI2RlZmluZSBYU0VU Q09OUyhhLCBiKSBYU0VUIChhLCBMaXNwX0NvbnMsIGIpCiAjZGVmaW5lIFhTRVRWRUNUT1Io YSwgYikgWFNFVCAoYSwgTGlzcF9WZWN0b3JsaWtlLCBiKQogI2RlZmluZSBYU0VUU1RSSU5H KGEsIGIpIFhTRVQgKGEsIExpc3BfU3RyaW5nLCBiKQpAQCAtNTY4LDQ4ICs3NzAsMjUgQEAK ICNkZWZpbmUgWFNFVEJPT0xfVkVDVE9SKGEsIGIpIChYU0VUUFNFVURPVkVDVE9SIChhLCBi LCBQVkVDX0JPT0xfVkVDVE9SKSkKICNkZWZpbmUgWFNFVFNVQl9DSEFSX1RBQkxFKGEsIGIp IChYU0VUUFNFVURPVkVDVE9SIChhLCBiLCBQVkVDX1NVQl9DSEFSX1RBQkxFKSkKIAotLyog Q29udmVuaWVuY2UgbWFjcm9zIGZvciBkZWFsaW5nIHdpdGggTGlzcCBhcnJheXMuICAqLwot Ci0jZGVmaW5lIEFSRUYoQVJSQVksIElEWCkJWFZFQ1RPUiAoKEFSUkFZKSktPmNvbnRlbnRz W0lEWF0KLSNkZWZpbmUgQVNJWkUoQVJSQVkpCQlYVkVDVE9SICgoQVJSQVkpKS0+aGVhZGVy LnNpemUKLS8qIFRoZSBJRFg9PUlEWCB0cmllcyB0byBkZXRlY3Qgd2hlbiB0aGUgbWFjcm8g YXJndW1lbnQgaXMgc2lkZS1lZmZlY3RpbmcuICAqLwotI2RlZmluZSBBU0VUKEFSUkFZLCBJ RFgsIFZBTCkJXAotICAoZWFzc2VydCAoKElEWCkgPT0gKElEWCkpLAkJCQlcCi0gICBlYXNz ZXJ0ICgoSURYKSA+PSAwICYmIChJRFgpIDwgQVNJWkUgKEFSUkFZKSksCVwKLSAgIEFSRUYg KChBUlJBWSksIChJRFgpKSA9IChWQUwpKQotCi0vKiBDb252ZW5pZW5jZSBtYWNyb3MgZm9y IGRlYWxpbmcgd2l0aCBMaXNwIHN0cmluZ3MuICAqLwotCi0jZGVmaW5lIFNEQVRBKHN0cmlu ZykJCShYU1RSSU5HIChzdHJpbmcpLT5kYXRhICsgMCkKLSNkZWZpbmUgU1JFRihzdHJpbmcs IGluZGV4KQkoU0RBVEEgKHN0cmluZylbaW5kZXhdICsgMCkKLSNkZWZpbmUgU1NFVChzdHJp bmcsIGluZGV4LCBuZXcpIChTREFUQSAoc3RyaW5nKVtpbmRleF0gPSAobmV3KSkKLSNkZWZp bmUgU0NIQVJTKHN0cmluZykJCShYU1RSSU5HIChzdHJpbmcpLT5zaXplICsgMCkKLSNkZWZp bmUgU0JZVEVTKHN0cmluZykJCShTVFJJTkdfQllURVMgKFhTVFJJTkcgKHN0cmluZykpICsg MCkKLQotLyogQXZvaWQgImRpZmZlciBpbiBzaWduIiB3YXJuaW5ncy4gICovCi0jZGVmaW5l IFNTREFUQSh4KSAgKChjaGFyICopIFNEQVRBICh4KSkKLQotI2RlZmluZSBTVFJJTkdfU0VU X0NIQVJTKHN0cmluZywgbmV3c2l6ZSkgXAotICAgIChYU1RSSU5HIChzdHJpbmcpLT5zaXpl ID0gKG5ld3NpemUpKQotCi0jZGVmaW5lIFNUUklOR19DT1BZSU4oc3RyaW5nLCBpbmRleCwg bmV3LCBjb3VudCkgXAotICAgIG1lbWNweSAoU0RBVEEgKHN0cmluZykgKyBpbmRleCwgbmV3 LCBjb3VudCkKLQogLyogVHlwZSBjaGVja2luZy4gICovCiAKLSNkZWZpbmUgQ0hFQ0tfVFlQ RShvaywgUXh4eHAsIHgpIFwKLSAgZG8geyBpZiAoIShvaykpIHdyb25nX3R5cGVfYXJndW1l bnQgKFF4eHhwLCAoeCkpOyB9IHdoaWxlICgwKQotCi0KK3N0YXRpYyBpbmxpbmUgdm9pZAor KENIRUNLX1RZUEUpIChpbnQgb2ssIExpc3BfT2JqZWN0IFF4eHhwLCBMaXNwX09iamVjdCB4 KQoreworICBpZiAoIW9rKQorICAgIHdyb25nX3R5cGVfYXJndW1lbnQgKFF4eHhwLCB4KTsK K30KIAwKIC8qIFNlZSB0aGUgbWFjcm9zIGluIGludGVydmFscy5oLiAgKi8KIAogdHlwZWRl ZiBzdHJ1Y3QgaW50ZXJ2YWwgKklOVEVSVkFMOwogCiAvKiBDb21wbGFpbiBpZiBvYmplY3Qg aXMgbm90IHN0cmluZyBvciBidWZmZXIgdHlwZSAqLwotI2RlZmluZSBDSEVDS19TVFJJTkdf T1JfQlVGRkVSKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoU1RSSU5HUCAoeCkgfHwgQlVGRkVSUCAo eCksIFFidWZmZXJfb3Jfc3RyaW5nX3AsIHgpCi0KK3N0YXRpYyBpbmxpbmUgdm9pZAorQ0hF Q0tfU1RSSU5HX09SX0JVRkZFUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQRSAo U1RSSU5HUCAoeCkgfHwgQlVGRkVSUCAoeCksIFFidWZmZXJfb3Jfc3RyaW5nX3AsIHgpOwor fQogDAogLyogSW4gYSBjb25zLCB0aGUgbWFya2JpdCBvZiB0aGUgY2FyIGlzIHRoZSBnYyBt YXJrIGJpdCAqLwogCkBAIC02NTAsNTQgKzgyOSw2OCBAQAogI2VuZGlmCiAKIC8qIFVzZSB0 aGVzZSBmcm9tIG5vcm1hbCBjb2RlLiAgKi8KLSNkZWZpbmUgWENBUihjKQlMSVNQX01BS0Vf UlZBTFVFIChYQ0FSX0FTX0xWQUxVRSAoYykpCi0jZGVmaW5lIFhDRFIoYykgTElTUF9NQUtF X1JWQUxVRSAoWENEUl9BU19MVkFMVUUgKGMpKQorc3RhdGljIGlubGluZSBMaXNwX09iamVj dCAoWENBUikgKExpc3BfT2JqZWN0IGMpIHsgcmV0dXJuIFhDQVJfQVNfTFZBTFVFIChjKTsg fQorc3RhdGljIGlubGluZSBMaXNwX09iamVjdCAoWENEUikgKExpc3BfT2JqZWN0IGMpIHsg cmV0dXJuIFhDRFJfQVNfTFZBTFVFIChjKTsgfQogCiAvKiBVc2UgdGhlc2UgdG8gc2V0IHRo ZSBmaWVsZHMgb2YgYSBjb25zIGNlbGwuCiAKICAgIE5vdGUgdGhhdCBib3RoIGFyZ3VtZW50 cyBtYXkgcmVmZXIgdG8gdGhlIHNhbWUgb2JqZWN0LCBzbyAnbicKLSAgIHNob3VsZCBub3Qg YmUgcmVhZCBhZnRlciAnYycgaXMgZmlyc3QgbW9kaWZpZWQuICBBbHNvLCBuZWl0aGVyCi0g ICBhcmd1bWVudCBzaG91bGQgYmUgZXZhbHVhdGVkIG1vcmUgdGhhbiBvbmNlOyBzaWRlIGVm ZmVjdHMgYXJlCi0gICBlc3BlY2lhbGx5IGNvbW1vbiBpbiB0aGUgc2Vjb25kIGFyZ3VtZW50 LiAgKi8KLSNkZWZpbmUgWFNFVENBUihjLG4pIChYQ0FSX0FTX0xWQUxVRSAoYykgPSAobikp Ci0jZGVmaW5lIFhTRVRDRFIoYyxuKSAoWENEUl9BU19MVkFMVUUgKGMpID0gKG4pKQotCi0v KiBUYWtlIHRoZSBjYXIgb3IgY2RyIG9mIHNvbWV0aGluZyB3aG9zZSB0eXBlIGlzIG5vdCBr bm93bi4gICovCi0jZGVmaW5lIENBUihjKQkJCQkJXAotIChDT05TUCAoKGMpKSA/IFhDQVIg KChjKSkJCQlcCi0gIDogTklMUCAoKGMpKSA/IFFuaWwJCQkJXAotICA6IHdyb25nX3R5cGVf YXJndW1lbnQgKFFsaXN0cCwgKGMpKSkKLQotI2RlZmluZSBDRFIoYykJCQkJCVwKLSAoQ09O U1AgKChjKSkgPyBYQ0RSICgoYykpCQkJXAotICA6IE5JTFAgKChjKSkgPyBRbmlsCQkJCVwK LSAgOiB3cm9uZ190eXBlX2FyZ3VtZW50IChRbGlzdHAsIChjKSkpCi0KLS8qIFRha2UgdGhl IGNhciBvciBjZHIgb2Ygc29tZXRoaW5nIHdob3NlIHR5cGUgaXMgbm90IGtub3duLiAgKi8K LSNkZWZpbmUgQ0FSX1NBRkUoYykJCQkJXAotICAoQ09OU1AgKChjKSkgPyBYQ0FSICgoYykp IDogUW5pbCkKLQotI2RlZmluZSBDRFJfU0FGRShjKQkJCQlcCi0gIChDT05TUCAoKGMpKSA/ IFhDRFIgKChjKSkgOiBRbmlsKQorICAgc2hvdWxkIG5vdCBiZSByZWFkIGFmdGVyICdjJyBp cyBmaXJzdCBtb2RpZmllZC4gICovCitzdGF0aWMgaW5saW5lIHZvaWQKK1hTRVRDQVIgKExp c3BfT2JqZWN0IGMsIExpc3BfT2JqZWN0IG4pCit7CisgIFhDQVJfQVNfTFZBTFVFIChjKSA9 IG47Cit9CitzdGF0aWMgaW5saW5lIHZvaWQKK1hTRVRDRFIgKExpc3BfT2JqZWN0IGMsIExp c3BfT2JqZWN0IG4pCit7CisgIFhDRFJfQVNfTFZBTFVFIChjKSA9IG47Cit9CisKKy8qIFRh a2UgdGhlIGNhciBvciBjZHIgb2Ygc29tZXRoaW5nIHdob3NlIHR5cGUgaXMgbm90IGtub3du LiAgKi8KK3N0YXRpYyBpbmxpbmUgTGlzcF9PYmplY3QKK0NBUiAoTGlzcF9PYmplY3QgYykK K3sKKyAgcmV0dXJuIChDT05TUCAoYykgPyBYQ0FSIChjKQorCSAgOiBOSUxQIChjKSA/IFFu aWwKKwkgIDogd3JvbmdfdHlwZV9hcmd1bWVudCAoUWxpc3RwLCBjKSk7Cit9CitzdGF0aWMg aW5saW5lIExpc3BfT2JqZWN0CitDRFIgKExpc3BfT2JqZWN0IGMpCit7CisgIHJldHVybiAo Q09OU1AgKGMpID8gWENEUiAoYykKKwkgIDogTklMUCAoYykgPyBRbmlsCisJICA6IHdyb25n X3R5cGVfYXJndW1lbnQgKFFsaXN0cCwgYykpOworfQorCisvKiBUYWtlIHRoZSBjYXIgb3Ig Y2RyIG9mIHNvbWV0aGluZyB3aG9zZSB0eXBlIGlzIG5vdCBrbm93bi4gICovCitzdGF0aWMg aW5saW5lIExpc3BfT2JqZWN0CitDQVJfU0FGRSAoTGlzcF9PYmplY3QgYykKK3sKKyAgcmV0 dXJuIENPTlNQIChjKSA/IFhDQVIgKGMpIDogUW5pbDsKK30KK3N0YXRpYyBpbmxpbmUgTGlz cF9PYmplY3QKK0NEUl9TQUZFIChMaXNwX09iamVjdCBjKQoreworICByZXR1cm4gQ09OU1Ag KGMpID8gWENEUiAoYykgOiBRbmlsOworfQorCisvKiBJbiBhIHN0cmluZyBvciB2ZWN0b3Is IHRoZSBzaWduIGJpdCBvZiB0aGUgYHNpemUnIGlzIHRoZSBnYyBtYXJrIGJpdC4gICovCisK K3N0cnVjdCBMaXNwX1N0cmluZworICB7CisgICAgcHRyZGlmZl90IHNpemU7CisgICAgcHRy ZGlmZl90IHNpemVfYnl0ZTsKKyAgICBJTlRFUlZBTCBpbnRlcnZhbHM7CQkvKiBUZXh0IHBy b3BlcnRpZXMgaW4gdGhpcyBzdHJpbmcuICAqLworICAgIHVuc2lnbmVkIGNoYXIgKmRhdGE7 CisgIH07CiAKIC8qIE5vbnplcm8gaWYgU1RSIGlzIGEgbXVsdGlieXRlIHN0cmluZy4gICov Ci0jZGVmaW5lIFNUUklOR19NVUxUSUJZVEUoU1RSKSAgXAotICAoWFNUUklORyAoU1RSKS0+ c2l6ZV9ieXRlID49IDApCi0KLS8qIFJldHVybiB0aGUgbGVuZ3RoIGluIGJ5dGVzIG9mIFNU Ui4gICovCi0KLSNpZmRlZiBHQ19DSEVDS19TVFJJTkdfQllURVMKLQotc3RydWN0IExpc3Bf U3RyaW5nOwotZXh0ZXJuIHB0cmRpZmZfdCBzdHJpbmdfYnl0ZXMgKHN0cnVjdCBMaXNwX1N0 cmluZyAqKTsKLSNkZWZpbmUgU1RSSU5HX0JZVEVTKFMpIHN0cmluZ19ieXRlcyAoKFMpKQot Ci0jZWxzZSAvKiBub3QgR0NfQ0hFQ0tfU1RSSU5HX0JZVEVTICovCi0KLSNkZWZpbmUgU1RS SU5HX0JZVEVTKFNUUikgIFwKLSAgKChTVFIpLT5zaXplX2J5dGUgPCAwID8gKFNUUiktPnNp emUgOiAoU1RSKS0+c2l6ZV9ieXRlKQotCi0jZW5kaWYgLyogbm90IEdDX0NIRUNLX1NUUklO R19CWVRFUyAqLworc3RhdGljIGlubGluZSBpbnQKK1NUUklOR19NVUxUSUJZVEUgKExpc3Bf T2JqZWN0IHN0cikKK3sKKyAgcmV0dXJuIDAgPD0gWFNUUklORyAoc3RyKS0+c2l6ZV9ieXRl OworfQogCiAvKiBBbiB1cHBlciBib3VuZCBvbiB0aGUgbnVtYmVyIG9mIGJ5dGVzIGluIGEg TGlzcCBzdHJpbmcsIG5vdAogICAgY291bnRpbmcgdGhlIHRlcm1pbmF0aW5nIG51bGwuICBU aGlzIGEgdGlnaHQgZW5vdWdoIGJvdW5kIHRvCkBAIC03MjcsMjUgKzkyMCw3MiBAQAogICAg IGVsc2UgWFNUUklORyAoU1RSKS0+c2l6ZV9ieXRlID0gWFNUUklORyAoU1RSKS0+c2l6ZTsg fSB3aGlsZSAoMCkKIAogLyogR2V0IHRleHQgcHJvcGVydGllcy4gICovCi0jZGVmaW5lIFNU UklOR19JTlRFUlZBTFMoU1RSKSAgKFhTVFJJTkcgKFNUUiktPmludGVydmFscyArIDApCitz dGF0aWMgaW5saW5lIElOVEVSVkFMCitTVFJJTkdfSU5URVJWQUxTIChMaXNwX09iamVjdCBz dHIpCit7CisgIHJldHVybiBYU1RSSU5HIChzdHIpLT5pbnRlcnZhbHM7Cit9CiAKIC8qIFNl dCB0ZXh0IHByb3BlcnRpZXMuICAqLwotI2RlZmluZSBTVFJJTkdfU0VUX0lOVEVSVkFMUyhT VFIsIElOVCkgKFhTVFJJTkcgKFNUUiktPmludGVydmFscyA9IChJTlQpKQotCi0vKiBJbiBh IHN0cmluZyBvciB2ZWN0b3IsIHRoZSBzaWduIGJpdCBvZiB0aGUgYHNpemUnIGlzIHRoZSBn YyBtYXJrIGJpdC4gICovCi0KLXN0cnVjdCBMaXNwX1N0cmluZwotICB7Ci0gICAgcHRyZGlm Zl90IHNpemU7Ci0gICAgcHRyZGlmZl90IHNpemVfYnl0ZTsKLSAgICBJTlRFUlZBTCBpbnRl cnZhbHM7CQkvKiBUZXh0IHByb3BlcnRpZXMgaW4gdGhpcyBzdHJpbmcuICAqLwotICAgIHVu c2lnbmVkIGNoYXIgKmRhdGE7Ci0gIH07CitzdGF0aWMgaW5saW5lIHZvaWQKK1NUUklOR19T RVRfSU5URVJWQUxTIChMaXNwX09iamVjdCBzdHIsIElOVEVSVkFMIGludGVydmFscykKK3sK KyAgWFNUUklORyAoc3RyKS0+aW50ZXJ2YWxzID0gaW50ZXJ2YWxzOworfQorCisvKiBDb252 ZW5pZW5jZSBmdW5jdGlvbnMgZm9yIGRlYWxpbmcgd2l0aCBMaXNwIHN0cmluZ3MuICAqLwor CitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGNoYXIgKgorU0RBVEEgKExpc3BfT2JqZWN0IHN0 cmluZykKK3sKKyAgcmV0dXJuIFhTVFJJTkcgKHN0cmluZyktPmRhdGE7Cit9CitzdGF0aWMg aW5saW5lIGNoYXIgKgorU1NEQVRBIChMaXNwX09iamVjdCBzdHJpbmcpCit7CisgIC8qIEF2 b2lkICJkaWZmZXIgaW4gc2lnbiIgd2FybmluZ3MuICAqLworICByZXR1cm4gKGNoYXIgKikg U0RBVEEgKHN0cmluZyk7Cit9CitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGNoYXIKK1NSRUYg KExpc3BfT2JqZWN0IHN0cmluZywgcHRyZGlmZl90IGluZGV4KQoreworICByZXR1cm4gU0RB VEEgKHN0cmluZylbaW5kZXhdOworfQorc3RhdGljIGlubGluZSB2b2lkCitTU0VUIChMaXNw X09iamVjdCBzdHJpbmcsIHB0cmRpZmZfdCBpbmRleCwgdW5zaWduZWQgY2hhciBuZXcpCit7 CisgIFNEQVRBIChzdHJpbmcpW2luZGV4XSA9IG5ldzsKK30KK3N0YXRpYyBpbmxpbmUgcHRy ZGlmZl90CitTQ0hBUlMgKExpc3BfT2JqZWN0IHN0cmluZykKK3sKKyAgcmV0dXJuIFhTVFJJ TkcgKHN0cmluZyktPnNpemU7Cit9CitzdGF0aWMgaW5saW5lIHB0cmRpZmZfdAorU1RSSU5H X0JZVEVTIChzdHJ1Y3QgTGlzcF9TdHJpbmcgKnMpCit7CisjaWZkZWYgR0NfQ0hFQ0tfU1RS SU5HX0JZVEVTCisgIGV4dGVybiBwdHJkaWZmX3Qgc3RyaW5nX2J5dGVzIChzdHJ1Y3QgTGlz cF9TdHJpbmcgKik7CisgIHJldHVybiBzdHJpbmdfYnl0ZXMgKHMpOworI2Vsc2UKKyAgcmV0 dXJuIHMtPnNpemVfYnl0ZSA8IDAgPyBzLT5zaXplIDogcy0+c2l6ZV9ieXRlOworI2VuZGlm Cit9CitzdGF0aWMgaW5saW5lIHB0cmRpZmZfdAorU0JZVEVTIChMaXNwX09iamVjdCBzdHJp bmcpCit7CisgIHJldHVybiBTVFJJTkdfQllURVMgKFhTVFJJTkcgKHN0cmluZykpOworfQor c3RhdGljIGlubGluZSB2b2lkCitTVFJJTkdfU0VUX0NIQVJTIChMaXNwX09iamVjdCBzdHJp bmcsIHB0cmRpZmZfdCBuZXdzaXplKQoreworICBYU1RSSU5HIChzdHJpbmcpLT5zaXplID0g bmV3c2l6ZTsKK30KIAogLyogSGVhZGVyIG9mIHZlY3Rvci1saWtlIG9iamVjdHMuICBUaGlz IGRvY3VtZW50cyB0aGUgbGF5b3V0IGNvbnN0cmFpbnRzIG9uCiAgICB2ZWN0b3JzIGFuZCBw c2V1ZG92ZWN0b3JzIG90aGVyIHRoYW4gc3RydWN0IExpc3BfU3Vici4gIEl0IGFsc28gcHJl dmVudHMKLSAgIGNvbXBpbGVycyBmcm9tIGJlaW5nIGZvb2xlZCBieSBFbWFjcydzIHR5cGUg cHVubmluZzogdGhlIFhTRVRQU0VVRE9WRUNUT1IKLSAgIGFuZCBQU0VVRE9WRUNUT1JQIG1h Y3JvcyBjYXN0IHRoZWlyIHBvaW50ZXJzIHRvIHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRlciAq LAorICAgY29tcGlsZXJzIGZyb20gYmVpbmcgZm9vbGVkIGJ5IEVtYWNzJ3MgdHlwZSBwdW5u aW5nOiBYU0VUUFNFVURPVkVDVE9SCisgICBhbmQgUFNFVURPVkVDVE9SUCBjYXN0IHRoZWly IHBvaW50ZXJzIHRvIHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRlciAqLAogICAgYmVjYXVzZSB3 aGVuIHR3byBzdWNoIHBvaW50ZXJzIHBvdGVudGlhbGx5IGFsaWFzLCBhIGNvbXBpbGVyIHdv bid0CiAgICBpbmNvcnJlY3RseSByZW9yZGVyIGxvYWRzIGFuZCBzdG9yZXMgdG8gdGhlaXIg c2l6ZSBmaWVsZHMuICBTZWUKICAgIDxodHRwOi8vZGViYnVncy5nbnUub3JnL2NnaS9idWdy ZXBvcnQuY2dpP2J1Zz04NTQ2Pi4gICovCkBAIC03OTYsNiArMTAzNiwyMyBAQAogICAgIExp c3BfT2JqZWN0IGNvbnRlbnRzWzFdOwogICB9OwogCisvKiBDb252ZW5pZW5jZXMgZm9yIGRl YWxpbmcgd2l0aCBMaXNwIGFycmF5cy4gICovCisKKy8qIEEgbWFjcm8gYmVjYXVzZSBpdCBp cyBhbHNvIHVzZWQgYXMgYW4gbHZhbHVlLiAgRklYTUU6IFVzZSBBU0VUIGluc3RlYWQuICAq LworI2RlZmluZSBBUkVGKEFSUkFZLCBJRFgpCVhWRUNUT1IgKChBUlJBWSkpLT5jb250ZW50 c1tJRFhdCisKK3N0YXRpYyBpbmxpbmUgcHRyZGlmZl90CitBU0laRSAoTGlzcF9PYmplY3Qg YXJyYXkpCit7CisgIHJldHVybiBYVkVDVE9SIChhcnJheSktPmhlYWRlci5zaXplOworfQor CitzdGF0aWMgaW5saW5lIHZvaWQKK0FTRVQgKExpc3BfT2JqZWN0IGFycmF5LCBwdHJkaWZm X3QgaWR4LCBMaXNwX09iamVjdCB2YWwpCit7CisgIFhWRUNUT1IgKGFycmF5KS0+Y29udGVu dHNbaWR4XSA9IHZhbDsKK30KKwogLyogSWYgYSBzdHJ1Y3QgaXMgbWFkZSB0byBsb29rIGxp a2UgYSB2ZWN0b3IsIHRoaXMgbWFjcm8gcmV0dXJucyB0aGUgbGVuZ3RoCiAgICBvZiB0aGUg c2hvcnRlc3QgdmVjdG9yIHRoYXQgd291bGQgaG9sZCB0aGF0IHN0cnVjdC4gICovCiAjZGVm aW5lIFZFQ1NJWkUodHlwZSkgKChzaXplb2YgKHR5cGUpCQkJCQkgIFwKQEAgLTgxMCw1MyAr MTA2Nyw2IEBACiAgICgob2Zmc2V0b2YgKHR5cGUsIG5vbmxpc3BmaWVsZCkgLSBvZmZzZXRv ZiAoc3RydWN0IExpc3BfVmVjdG9yLCBjb250ZW50c1swXSkpIFwKICAgIC8gc2l6ZW9mIChM aXNwX09iamVjdCkpCiAKLS8qIEEgY2hhci10YWJsZSBpcyBhIGtpbmQgb2YgdmVjdG9ybGlr ZSwgd2l0aCBjb250ZW50cyBhcmUgbGlrZSBhCi0gICB2ZWN0b3IgYnV0IHdpdGggYSBmZXcg b3RoZXIgc2xvdHMuICBGb3Igc29tZSBwdXJwb3NlcywgaXQgbWFrZXMKLSAgIHNlbnNlIHRv IGhhbmRsZSBhIGNoYXItdGFibGUgd2l0aCB0eXBlIHN0cnVjdCBMaXNwX1ZlY3Rvci4gIEFu Ci0gICBlbGVtZW50IG9mIGEgY2hhciB0YWJsZSBjYW4gYmUgYW55IExpc3Agb2JqZWN0cywg YnV0IGlmIGl0IGlzIGEgc3ViCi0gICBjaGFyLXRhYmxlLCB3ZSB0cmVhdCBpdCBhIHRhYmxl IHRoYXQgY29udGFpbnMgaW5mb3JtYXRpb24gb2YgYQotICAgc3BlY2lmaWMgcmFuZ2Ugb2Yg Y2hhcmFjdGVycy4gIEEgc3ViIGNoYXItdGFibGUgaGFzIHRoZSBzYW1lCi0gICBzdHJ1Y3R1 cmUgYXMgYSB2ZWN0b3IuICBBIHN1YiBjaGFyIHRhYmxlIGFwcGVhcnMgb25seSBpbiBhbiBl bGVtZW50Ci0gICBvZiBhIGNoYXItdGFibGUsIGFuZCB0aGVyZSdzIG5vIHdheSB0byBhY2Nl c3MgaXQgZGlyZWN0bHkgZnJvbQotICAgRW1hY3MgTGlzcCBwcm9ncmFtLiAgKi8KLQotLyog VGhpcyBpcyB0aGUgbnVtYmVyIG9mIHNsb3RzIHRoYXQgZXZlcnkgY2hhciB0YWJsZSBtdXN0 IGhhdmUuICBUaGlzCi0gICBjb3VudHMgdGhlIG9yZGluYXJ5IHNsb3RzIGFuZCB0aGUgdG9w LCBkZWZhbHQsIHBhcmVudCwgYW5kIHB1cnBvc2UKLSAgIHNsb3RzLiAgKi8KLSNkZWZpbmUg Q0hBUl9UQUJMRV9TVEFOREFSRF9TTE9UUyAoVkVDU0laRSAoc3RydWN0IExpc3BfQ2hhcl9U YWJsZSkgLSAxKQotCi0vKiBSZXR1cm4gdGhlIG51bWJlciBvZiAiZXh0cmEiIHNsb3RzIGlu IHRoZSBjaGFyIHRhYmxlIENULiAgKi8KLQotI2RlZmluZSBDSEFSX1RBQkxFX0VYVFJBX1NM T1RTKENUKQlcCi0gICgoKENUKS0+aGVhZGVyLnNpemUgJiBQU0VVRE9WRUNUT1JfU0laRV9N QVNLKSAtIENIQVJfVEFCTEVfU1RBTkRBUkRfU0xPVFMpCi0KLSNpZmRlZiBfX0dOVUNfXwot Ci0jZGVmaW5lIENIQVJfVEFCTEVfUkVGX0FTQ0lJKENULCBJRFgpCQkJCQlcCi0gICh7c3Ry dWN0IExpc3BfQ2hhcl9UYWJsZSAqX3RibCA9IE5VTEw7CQkJCVwKLSAgICBMaXNwX09iamVj dCBfdmFsOwkJCQkJCQlcCi0gICAgZG8gewkJCQkJCQkJXAotICAgICAgX3RibCA9IF90Ymwg PyBYQ0hBUl9UQUJMRSAoX3RibC0+cGFyZW50KSA6IFhDSEFSX1RBQkxFIChDVCk7CVwKLSAg ICAgIF92YWwgPSAoISBTVUJfQ0hBUl9UQUJMRV9QIChfdGJsLT5hc2NpaSkgPyBfdGJsLT5h c2NpaQkJXAotCSAgICAgIDogWFNVQl9DSEFSX1RBQkxFIChfdGJsLT5hc2NpaSktPmNvbnRl bnRzW0lEWF0pOwkJXAotICAgICAgaWYgKE5JTFAgKF92YWwpKQkJCQkJCQlcCi0JX3ZhbCA9 IF90YmwtPmRlZmFsdDsJCQkJCQlcCi0gICAgfSB3aGlsZSAoTklMUCAoX3ZhbCkgJiYgISBO SUxQIChfdGJsLT5wYXJlbnQpKTsJCQlcCi0gICAgX3ZhbDsgfSkKLQotI2Vsc2UgIC8qIG5v dCBfX0dOVUNfXyAqLwotCi0jZGVmaW5lIENIQVJfVEFCTEVfUkVGX0FTQ0lJKENULCBJRFgp CQkJCQkgIFwKLSAgKCEgTklMUCAoWENIQVJfVEFCTEUgKENUKS0+YXNjaWkpCQkJCQkgIFwK LSAgID8gKCEgU1VCX0NIQVJfVEFCTEVfUCAoWENIQVJfVEFCTEUgKENUKS0+YXNjaWkpCQkJ ICBcCi0gICAgICA/IFhDSEFSX1RBQkxFIChDVCktPmFzY2lpCQkJCQkJICBcCi0gICAgICA6 ICEgTklMUCAoWFNVQl9DSEFSX1RBQkxFIChYQ0hBUl9UQUJMRSAoQ1QpLT5hc2NpaSktPmNv bnRlbnRzW0lEWF0pIFwKLSAgICAgID8gWFNVQl9DSEFSX1RBQkxFIChYQ0hBUl9UQUJMRSAo Q1QpLT5hc2NpaSktPmNvbnRlbnRzW0lEWF0JICBcCi0gICAgICA6IGNoYXJfdGFibGVfcmVm ICgoQ1QpLCAoSURYKSkpCQkJCQkgIFwKLSAgIDogIGNoYXJfdGFibGVfcmVmICgoQ1QpLCAo SURYKSkpCi0KLSNlbmRpZgkvKiBub3QgX19HTlVDX18gKi8KLQogLyogQ29tcHV0ZSBBIE9Q IEIsIHVzaW5nIHRoZSB1bnNpZ25lZCBjb21wYXJpc29uIG9wZXJhdG9yIE9QLiAgQSBhbmQg QgogICAgc2hvdWxkIGJlIGludGVnZXIgZXhwcmVzc2lvbnMuICBUaGlzIGlzIG5vdCB0aGUg c2FtZSBhcwogICAgbWF0aGVtYXRpY2FsIGNvbXBhcmlzb247IGZvciBleGFtcGxlLCBVTlNJ R05FRF9DTVAgKDAsIDwsIC0xKQpAQCAtODcwLDMxICsxMDgwLDIzIEBACiAvKiBOb256ZXJv IGlmZiBDIGlzIGFuIEFTQ0lJIGNoYXJhY3Rlci4gICovCiAjZGVmaW5lIEFTQ0lJX0NIQVJf UChjKSBVTlNJR05FRF9DTVAgKGMsIDwsIDB4ODApCiAKLS8qIEFsbW9zdCBlcXVpdmFsZW50 IHRvIEZhcmVmIChDVCwgSURYKSB3aXRoIG9wdGltaXphdGlvbiBmb3IgQVNDSUkKLSAgIGNo YXJhY3RlcnMuICBEbyBub3QgY2hlY2sgdmFsaWRpdHkgb2YgQ1QuICAqLwotI2RlZmluZSBD SEFSX1RBQkxFX1JFRihDVCwgSURYKQkJCQkJXAotICAoQVNDSUlfQ0hBUl9QIChJRFgpID8g Q0hBUl9UQUJMRV9SRUZfQVNDSUkgKChDVCksIChJRFgpKQlcCi0gICA6IGNoYXJfdGFibGVf cmVmICgoQ1QpLCAoSURYKSkpCi0KLS8qIEFsbW9zdCBlcXVpdmFsZW50IHRvIEZhcmVmIChD VCwgSURYKS4gIEhvd2V2ZXIsIGlmIHRoZSByZXN1bHQgaXMKLSAgIG5vdCBhIGNoYXJhY3Rl ciwgcmV0dXJuIElEWC4KLQotICAgRm9yIHRoZXNlIGNoYXJhY3RlcnMsIGRvIG5vdCBjaGVj ayB2YWxpZGl0eSBvZiBDVAotICAgYW5kIGRvIG5vdCBmb2xsb3cgcGFyZW50LiAgKi8KLSNk ZWZpbmUgQ0hBUl9UQUJMRV9UUkFOU0xBVEUoQ1QsIElEWCkJXAotICBjaGFyX3RhYmxlX3Ry YW5zbGF0ZSAoQ1QsIElEWCkKLQotLyogRXF1aXZhbGVudCB0byBGYXNldCAoQ1QsIElEWCwg VkFMKSB3aXRoIG9wdGltaXphdGlvbiBmb3IgQVNDSUkgYW5kCi0gICA4LWJpdCBFdXJvcGVh biBjaGFyYWN0ZXJzLiAgRG8gbm90IGNoZWNrIHZhbGlkaXR5IG9mIENULiAgKi8KLSNkZWZp bmUgQ0hBUl9UQUJMRV9TRVQoQ1QsIElEWCwgVkFMKQkJCQkJXAotICAoQVNDSUlfQ0hBUl9Q IChJRFgpICYmIFNVQl9DSEFSX1RBQkxFX1AgKFhDSEFSX1RBQkxFIChDVCktPmFzY2lpKQlc Ci0gICA/IFhTVUJfQ0hBUl9UQUJMRSAoWENIQVJfVEFCTEUgKENUKS0+YXNjaWkpLT5jb250 ZW50c1tJRFhdID0gVkFMCVwKLSAgIDogY2hhcl90YWJsZV9zZXQgKENULCBJRFgsIFZBTCkp Ci0KLSNkZWZpbmUgQ0hBUlRBQl9TSVpFX0JJVFNfMCA2Ci0jZGVmaW5lIENIQVJUQUJfU0la RV9CSVRTXzEgNAotI2RlZmluZSBDSEFSVEFCX1NJWkVfQklUU18yIDUKLSNkZWZpbmUgQ0hB UlRBQl9TSVpFX0JJVFNfMyA3CisvKiBBIGNoYXItdGFibGUgaXMgYSBraW5kIG9mIHZlY3Rv cmxpa2UsIHdpdGggY29udGVudHMgYXJlIGxpa2UgYQorICAgdmVjdG9yIGJ1dCB3aXRoIGEg ZmV3IG90aGVyIHNsb3RzLiAgRm9yIHNvbWUgcHVycG9zZXMsIGl0IG1ha2VzCisgICBzZW5z ZSB0byBoYW5kbGUgYSBjaGFyLXRhYmxlIHdpdGggdHlwZSBzdHJ1Y3QgTGlzcF9WZWN0b3Iu ICBBbgorICAgZWxlbWVudCBvZiBhIGNoYXIgdGFibGUgY2FuIGJlIGFueSBMaXNwIG9iamVj dHMsIGJ1dCBpZiBpdCBpcyBhIHN1YgorICAgY2hhci10YWJsZSwgd2UgdHJlYXQgaXQgYSB0 YWJsZSB0aGF0IGNvbnRhaW5zIGluZm9ybWF0aW9uIG9mIGEKKyAgIHNwZWNpZmljIHJhbmdl IG9mIGNoYXJhY3RlcnMuICBBIHN1YiBjaGFyLXRhYmxlIGhhcyB0aGUgc2FtZQorICAgc3Ry dWN0dXJlIGFzIGEgdmVjdG9yLiAgQSBzdWIgY2hhciB0YWJsZSBhcHBlYXJzIG9ubHkgaW4g YW4gZWxlbWVudAorICAgb2YgYSBjaGFyLXRhYmxlLCBhbmQgdGhlcmUncyBubyB3YXkgdG8g YWNjZXNzIGl0IGRpcmVjdGx5IGZyb20KKyAgIEVtYWNzIExpc3AgcHJvZ3JhbS4gICovCisK K2VudW0KKyAgeworICAgIENIQVJUQUJfU0laRV9CSVRTXzAgPSA2LAorICAgIENIQVJUQUJf U0laRV9CSVRTXzEgPSA0LAorICAgIENIQVJUQUJfU0laRV9CSVRTXzIgPSA1LAorICAgIENI QVJUQUJfU0laRV9CSVRTXzMgPSA3CisgIH07CiAKIGV4dGVybiBjb25zdCBpbnQgY2hhcnRh Yl9zaXplWzRdOwogCkBAIC05NTEsNiArMTE1Myw3MCBAQAogICAgIExpc3BfT2JqZWN0IGNv bnRlbnRzWzFdOwogICB9OwogCisvKiBUaGlzIGlzIHRoZSBudW1iZXIgb2Ygc2xvdHMgdGhh dCBldmVyeSBjaGFyIHRhYmxlIG11c3QgaGF2ZS4gIFRoaXMKKyAgIGNvdW50cyB0aGUgb3Jk aW5hcnkgc2xvdHMgYW5kIHRoZSB0b3AsIGRlZmFsdCwgcGFyZW50LCBhbmQgcHVycG9zZQor ICAgc2xvdHMuICAqLworZW51bSB7IENIQVJfVEFCTEVfU1RBTkRBUkRfU0xPVFMgPSBWRUNT SVpFIChzdHJ1Y3QgTGlzcF9DaGFyX1RhYmxlKSAtIDEgfTsKKworLyogUmV0dXJuIHRoZSBu dW1iZXIgb2YgImV4dHJhIiBzbG90cyBpbiB0aGUgY2hhciB0YWJsZSBDVC4gICovCisKK3N0 YXRpYyBpbmxpbmUgaW50CitDSEFSX1RBQkxFX0VYVFJBX1NMT1RTIChzdHJ1Y3QgTGlzcF9D aGFyX1RhYmxlICpjdCkKK3sKKyAgcmV0dXJuICgoY3QtPmhlYWRlci5zaXplICYgUFNFVURP VkVDVE9SX1NJWkVfTUFTSykKKwkgIC0gQ0hBUl9UQUJMRV9TVEFOREFSRF9TTE9UUyk7Cit9 CisKK3N0YXRpYyBpbmxpbmUgTGlzcF9PYmplY3QKK0NIQVJfVEFCTEVfUkVGX0FTQ0lJIChM aXNwX09iamVjdCBjdCwgcHRyZGlmZl90IGlkeCkKK3sKKyAgc3RydWN0IExpc3BfQ2hhcl9U YWJsZSAqdGJsID0gTlVMTDsKKyAgTGlzcF9PYmplY3QgdmFsOworICBkbworICAgIHsKKyAg ICAgIHRibCA9IHRibCA/IFhDSEFSX1RBQkxFICh0YmwtPnBhcmVudCkgOiBYQ0hBUl9UQUJM RSAoY3QpOworICAgICAgdmFsID0gKCEgU1VCX0NIQVJfVEFCTEVfUCAodGJsLT5hc2NpaSkg PyB0YmwtPmFzY2lpCisJICAgICA6IFhTVUJfQ0hBUl9UQUJMRSAodGJsLT5hc2NpaSktPmNv bnRlbnRzW2lkeF0pOworICAgICAgaWYgKE5JTFAgKHZhbCkpCisJdmFsID0gdGJsLT5kZWZh bHQ7CisgICAgfQorICB3aGlsZSAoTklMUCAodmFsKSAmJiAhIE5JTFAgKHRibC0+cGFyZW50 KSk7CisKKyAgcmV0dXJuIHZhbDsKK30KKworLyogQWxtb3N0IGVxdWl2YWxlbnQgdG8gRmFy ZWYgKENULCBJRFgpIHdpdGggb3B0aW1pemF0aW9uIGZvciBBU0NJSQorICAgY2hhcmFjdGVy cy4gIERvIG5vdCBjaGVjayB2YWxpZGl0eSBvZiBDVC4gICovCitzdGF0aWMgaW5saW5lIExp c3BfT2JqZWN0CitDSEFSX1RBQkxFX1JFRiAoTGlzcF9PYmplY3QgY3QsIGludCBpZHgpCit7 CisgIHJldHVybiAoQVNDSUlfQ0hBUl9QIChpZHgpCisJICA/IENIQVJfVEFCTEVfUkVGX0FT Q0lJIChjdCwgaWR4KQorCSAgOiBjaGFyX3RhYmxlX3JlZiAoY3QsIGlkeCkpOworfQorCisv KiBBbG1vc3QgZXF1aXZhbGVudCB0byBGYXJlZiAoQ1QsIElEWCkuICBIb3dldmVyLCBpZiB0 aGUgcmVzdWx0IGlzCisgICBub3QgYSBjaGFyYWN0ZXIsIHJldHVybiBJRFguCisKKyAgIEZv ciB0aGVzZSBjaGFyYWN0ZXJzLCBkbyBub3QgY2hlY2sgdmFsaWRpdHkgb2YgQ1QKKyAgIGFu ZCBkbyBub3QgZm9sbG93IHBhcmVudC4gICovCitzdGF0aWMgaW5saW5lIGludAorQ0hBUl9U QUJMRV9UUkFOU0xBVEUgKExpc3BfT2JqZWN0IGN0LCBpbnQgaWR4KQoreworICByZXR1cm4g Y2hhcl90YWJsZV90cmFuc2xhdGUgKGN0LCBpZHgpOworfQorCisvKiBFcXVpdmFsZW50IHRv IEZhc2V0IChDVCwgSURYLCBWQUwpIHdpdGggb3B0aW1pemF0aW9uIGZvciBBU0NJSSBhbmQK KyAgIDgtYml0IEV1cm9wZWFuIGNoYXJhY3RlcnMuICBEbyBub3QgY2hlY2sgdmFsaWRpdHkg b2YgQ1QuICAqLworc3RhdGljIGlubGluZSB2b2lkCitDSEFSX1RBQkxFX1NFVCAoTGlzcF9P YmplY3QgY3QsIGludCBpZHgsIExpc3BfT2JqZWN0IHZhbCkKK3sKKyAgaWYgKEFTQ0lJX0NI QVJfUCAoaWR4KSAmJiBTVUJfQ0hBUl9UQUJMRV9QIChYQ0hBUl9UQUJMRSAoY3QpLT5hc2Np aSkpCisgICAgWFNVQl9DSEFSX1RBQkxFIChYQ0hBUl9UQUJMRSAoY3QpLT5hc2NpaSktPmNv bnRlbnRzW2lkeF0gPSB2YWw7CisgIGVsc2UKKyAgICBjaGFyX3RhYmxlX3NldCAoY3QsIGlk eCwgdmFsKTsKK30KKwogLyogQSBib29sdmVjdG9yIGlzIGEga2luZCBvZiB2ZWN0b3JsaWtl LCB3aXRoIGNvbnRlbnRzIGFyZSBsaWtlIGEgc3RyaW5nLiAgKi8KIHN0cnVjdCBMaXNwX0Jv b2xfVmVjdG9yCiAgIHsKQEAgLTEwNjUsNDEgKzEzMzEsODYgQEAKIAogLyogVmFsdWUgaXMg bmFtZSBvZiBzeW1ib2wuICAqLwogCi0jZGVmaW5lIFNZTUJPTF9WQUwoc3ltKSAgIFwKLSAg KGVhc3NlcnQgKChzeW0pLT5yZWRpcmVjdCA9PSBTWU1CT0xfUExBSU5WQUwpLCAgKHN5bSkt PnZhbC52YWx1ZSkKLSNkZWZpbmUgU1lNQk9MX0FMSUFTKHN5bSkgXAotICAoZWFzc2VydCAo KHN5bSktPnJlZGlyZWN0ID09IFNZTUJPTF9WQVJBTElBUyksICAoc3ltKS0+dmFsLmFsaWFz KQotI2RlZmluZSBTWU1CT0xfQkxWKHN5bSkgICBcCi0gIChlYXNzZXJ0ICgoc3ltKS0+cmVk aXJlY3QgPT0gU1lNQk9MX0xPQ0FMSVpFRCksIChzeW0pLT52YWwuYmx2KQotI2RlZmluZSBT WU1CT0xfRldEKHN5bSkgICBcCi0gIChlYXNzZXJ0ICgoc3ltKS0+cmVkaXJlY3QgPT0gU1lN Qk9MX0ZPUldBUkRFRCksIChzeW0pLT52YWwuZndkKQotI2RlZmluZSBTRVRfU1lNQk9MX1ZB TChzeW0sIHYpICAgICBcCi0gIChlYXNzZXJ0ICgoc3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9M X1BMQUlOVkFMKSwgIChzeW0pLT52YWwudmFsdWUgPSAodikpCi0jZGVmaW5lIFNFVF9TWU1C T0xfQUxJQVMoc3ltLCB2KSAgIFwKLSAgKGVhc3NlcnQgKChzeW0pLT5yZWRpcmVjdCA9PSBT WU1CT0xfVkFSQUxJQVMpLCAgKHN5bSktPnZhbC5hbGlhcyA9ICh2KSkKLSNkZWZpbmUgU0VU X1NZTUJPTF9CTFYoc3ltLCB2KSAgICAgXAotICAoZWFzc2VydCAoKHN5bSktPnJlZGlyZWN0 ID09IFNZTUJPTF9MT0NBTElaRUQpLCAoc3ltKS0+dmFsLmJsdiA9ICh2KSkKLSNkZWZpbmUg U0VUX1NZTUJPTF9GV0Qoc3ltLCB2KSBcCi0gIChlYXNzZXJ0ICgoc3ltKS0+cmVkaXJlY3Qg PT0gU1lNQk9MX0ZPUldBUkRFRCksIChzeW0pLT52YWwuZndkID0gKHYpKQorc3RhdGljIGlu bGluZSBMaXNwX09iamVjdAorKFNZTUJPTF9WQUwpIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5 bSkKK3sKKyAgZWFzc2VydCAoc3ltLT5yZWRpcmVjdCA9PSBTWU1CT0xfUExBSU5WQUwpOwor ICByZXR1cm4gc3ltLT52YWwudmFsdWU7Cit9CitzdGF0aWMgaW5saW5lIHN0cnVjdCBMaXNw X1N5bWJvbCAqCitTWU1CT0xfQUxJQVMgKHN0cnVjdCBMaXNwX1N5bWJvbCAqc3ltKQorewor ICBlYXNzZXJ0IChzeW0tPnJlZGlyZWN0ID09IFNZTUJPTF9WQVJBTElBUyk7CisgIHJldHVy biBzeW0tPnZhbC5hbGlhczsKK30KK3N0YXRpYyBpbmxpbmUgc3RydWN0IExpc3BfQnVmZmVy X0xvY2FsX1ZhbHVlICoKK1NZTUJPTF9CTFYgKHN0cnVjdCBMaXNwX1N5bWJvbCAqc3ltKQor eworICBlYXNzZXJ0IChzeW0tPnJlZGlyZWN0ID09IFNZTUJPTF9MT0NBTElaRUQpOworICBy ZXR1cm4gc3ltLT52YWwuYmx2OworfQorc3RhdGljIGlubGluZSB1bmlvbiBMaXNwX0Z3ZCAq CitTWU1CT0xfRldEIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSkKK3sKKyAgZWFzc2VydCAo c3ltLT5yZWRpcmVjdCA9PSBTWU1CT0xfRk9SV0FSREVEKTsKKyAgcmV0dXJuIHN5bS0+dmFs LmZ3ZDsKK30KK3N0YXRpYyBpbmxpbmUgdm9pZAorKFNFVF9TWU1CT0xfVkFMKSAoc3RydWN0 IExpc3BfU3ltYm9sICpzeW0sIExpc3BfT2JqZWN0IHYpCit7CisgIGVhc3NlcnQgKHN5bS0+ cmVkaXJlY3QgPT0gU1lNQk9MX1BMQUlOVkFMKTsKKyAgc3ltLT52YWwudmFsdWUgPSB2Owor fQorc3RhdGljIGlubGluZSB2b2lkCitTRVRfU1lNQk9MX0FMSUFTIChzdHJ1Y3QgTGlzcF9T eW1ib2wgKnN5bSwgc3RydWN0IExpc3BfU3ltYm9sICp2KQoreworICBlYXNzZXJ0IChzeW0t PnJlZGlyZWN0ID09IFNZTUJPTF9WQVJBTElBUyk7CisgIHN5bS0+dmFsLmFsaWFzID0gdjsK K30KK3N0YXRpYyBpbmxpbmUgdm9pZAorU0VUX1NZTUJPTF9CTFYgKHN0cnVjdCBMaXNwX1N5 bWJvbCAqc3ltLCBzdHJ1Y3QgTGlzcF9CdWZmZXJfTG9jYWxfVmFsdWUgKnYpCit7CisgIGVh c3NlcnQgKHN5bS0+cmVkaXJlY3QgPT0gU1lNQk9MX0xPQ0FMSVpFRCk7CisgIHN5bS0+dmFs LmJsdiA9IHY7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQKK1NFVF9TWU1CT0xfRldEIChzdHJ1 Y3QgTGlzcF9TeW1ib2wgKnN5bSwgdW5pb24gTGlzcF9Gd2QgKnYpCit7CisgIGVhc3NlcnQg KHN5bS0+cmVkaXJlY3QgPT0gU1lNQk9MX0ZPUldBUkRFRCk7CisgIHN5bS0+dmFsLmZ3ZCA9 IHY7Cit9CiAKLSNkZWZpbmUgU1lNQk9MX05BTUUoc3ltKSAgXAotICAgICBMSVNQX01BS0Vf UlZBTFVFIChYU1lNQk9MIChzeW0pLT54bmFtZSkKK3N0YXRpYyBpbmxpbmUgTGlzcF9PYmpl Y3QKK1NZTUJPTF9OQU1FIChMaXNwX09iamVjdCBzeW0pCit7CisgIHJldHVybiBYU1lNQk9M IChzeW0pLT54bmFtZTsKK30KIAogLyogVmFsdWUgaXMgbm9uLXplcm8gaWYgU1lNIGlzIGFu IGludGVybmVkIHN5bWJvbC4gICovCiAKLSNkZWZpbmUgU1lNQk9MX0lOVEVSTkVEX1Aoc3lt KSAgXAotICAgICAoWFNZTUJPTCAoc3ltKS0+aW50ZXJuZWQgIT0gU1lNQk9MX1VOSU5URVJO RUQpCitzdGF0aWMgaW5saW5lIGludAorU1lNQk9MX0lOVEVSTkVEX1AgKExpc3BfT2JqZWN0 IHN5bSkKK3sKKyAgcmV0dXJuIFhTWU1CT0wgKHN5bSktPmludGVybmVkICE9IFNZTUJPTF9V TklOVEVSTkVEOworfQogCiAvKiBWYWx1ZSBpcyBub24temVybyBpZiBTWU0gaXMgaW50ZXJu ZWQgaW4gaW5pdGlhbF9vYmFycmF5LiAgKi8KIAotI2RlZmluZSBTWU1CT0xfSU5URVJORURf SU5fSU5JVElBTF9PQkFSUkFZX1Aoc3ltKSBcCi0gICAgIChYU1lNQk9MIChzeW0pLT5pbnRl cm5lZCA9PSBTWU1CT0xfSU5URVJORURfSU5fSU5JVElBTF9PQkFSUkFZKQorc3RhdGljIGlu bGluZSBpbnQKK1NZTUJPTF9JTlRFUk5FRF9JTl9JTklUSUFMX09CQVJSQVlfUCAoTGlzcF9P YmplY3Qgc3ltKQoreworICByZXR1cm4gWFNZTUJPTCAoc3ltKS0+aW50ZXJuZWQgPT0gU1lN Qk9MX0lOVEVSTkVEX0lOX0lOSVRJQUxfT0JBUlJBWTsKK30KIAogLyogVmFsdWUgaXMgbm9u LXplcm8gaWYgc3ltYm9sIGlzIGNvbnNpZGVyZWQgYSBjb25zdGFudCwgaS5lLiBpdHMKICAg IHZhbHVlIGNhbm5vdCBiZSBjaGFuZ2VkICh0aGVyZSBpcyBhbiBleGNlcHRpb24gZm9yIGtl eXdvcmQgc3ltYm9scywKICAgIHdob3NlIHZhbHVlIGNhbiBiZSBzZXQgdG8gdGhlIGtleXdv cmQgc3ltYm9sIGl0c2VsZikuICAqLwogCi0jZGVmaW5lIFNZTUJPTF9DT05TVEFOVF9QKHN5 bSkgICBYU1lNQk9MIChzeW0pLT5jb25zdGFudAorc3RhdGljIGlubGluZSBpbnQKKyhTWU1C T0xfQ09OU1RBTlRfUCkgKExpc3BfT2JqZWN0IHN5bSkKK3sKKyAgcmV0dXJuIFhTWU1CT0wg KHN5bSktPmNvbnN0YW50OworfQogCiAjZGVmaW5lIERFRlNZTShzeW0sIG5hbWUpCVwKICAg ZG8geyAoc3ltKSA9IGludGVybl9jX3N0cmluZyAoKG5hbWUpKTsgc3RhdGljcHJvICgmKHN5 bSkpOyB9IHdoaWxlICgwKQpAQCAtMTE4MSwxNiArMTQ5MiwyNSBAQAogfTsKIAogCi0jZGVm aW5lIFhIQVNIX1RBQkxFKE9CSikgXAotICAgICAoKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUg KikgWFVOVEFHIChPQkosIExpc3BfVmVjdG9ybGlrZSkpCitzdGF0aWMgaW5saW5lIHN0cnVj dCBMaXNwX0hhc2hfVGFibGUgKgorWEhBU0hfVEFCTEUgKExpc3BfT2JqZWN0IGEpCit7Cisg IHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSk7Cit9CiAKICNkZWZpbmUgWFNF VF9IQVNIX1RBQkxFKFZBUiwgUFRSKSBcCiAgICAgIChYU0VUUFNFVURPVkVDVE9SIChWQVIs IFBUUiwgUFZFQ19IQVNIX1RBQkxFKSkKIAotI2RlZmluZSBIQVNIX1RBQkxFX1AoT0JKKSAg UFNFVURPVkVDVE9SUCAoT0JKLCBQVkVDX0hBU0hfVEFCTEUpCi0KLSNkZWZpbmUgQ0hFQ0tf SEFTSF9UQUJMRSh4KSBcCi0gIENIRUNLX1RZUEUgKEhBU0hfVEFCTEVfUCAoeCksIFFoYXNo X3RhYmxlX3AsIHgpCitzdGF0aWMgaW5saW5lIGludAorSEFTSF9UQUJMRV9QIChMaXNwX09i amVjdCBhKQoreworICByZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZFQ19IQVNIX1RBQkxF KTsKK30KK3N0YXRpYyBpbmxpbmUgdm9pZAorQ0hFQ0tfSEFTSF9UQUJMRSAoTGlzcF9PYmpl Y3QgeCkKK3sKKyAgcmV0dXJuIENIRUNLX1RZUEUgKEhBU0hfVEFCTEVfUCAoeCksIFFoYXNo X3RhYmxlX3AsIHgpOworfQogCiAvKiBWYWx1ZSBpcyB0aGUga2V5IHBhcnQgb2YgZW50cnkg SURYIGluIGhhc2ggdGFibGUgSC4gICovCiAKQEAgLTEyMTUsMTIgKzE1MzUsMTQgQEAKICNk ZWZpbmUgSEFTSF9JTkRFWChILCBJRFgpICBBUkVGICgoSCktPmluZGV4LCAoSURYKSkKIAog LyogVmFsdWUgaXMgdGhlIHNpemUgb2YgaGFzaCB0YWJsZSBILiAgKi8KLQotI2RlZmluZSBI QVNIX1RBQkxFX1NJWkUoSCkgQVNJWkUgKChIKS0+bmV4dCkKK3N0YXRpYyBpbmxpbmUgcHRy ZGlmZl90CitIQVNIX1RBQkxFX1NJWkUgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgpCit7 CisgIHJldHVybiBBU0laRSAoaC0+bmV4dCk7Cit9CiAKIC8qIERlZmF1bHQgc2l6ZSBmb3Ig aGFzaCB0YWJsZXMgaWYgbm90IHNwZWNpZmllZC4gICovCi0KLSNkZWZpbmUgREVGQVVMVF9I QVNIX1NJWkUgNjUKK2VudW0geyBERUZBVUxUX0hBU0hfU0laRSA9IDY1IH07CiAKIC8qIERl ZmF1bHQgdGhyZXNob2xkIHNwZWNpZnlpbmcgd2hlbiB0byByZXNpemUgYSBoYXNoIHRhYmxl LiAgVGhlCiAgICB2YWx1ZSBnaXZlcyB0aGUgcmF0aW8gb2YgY3VycmVudCBlbnRyaWVzIGlu IHRoZSBoYXNoIHRhYmxlIGFuZCB0aGUKQEAgLTEzMzAsNiArMTY1Miw0MyBAQAogICAgIHN0 cnVjdCBMaXNwX1NhdmVfVmFsdWUgdV9zYXZlX3ZhbHVlOwogICB9OwogCitzdGF0aWMgaW5s aW5lIHVuaW9uIExpc3BfTWlzYyAqCitYTUlTQyAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0 dXJuIFhVTlRBRyAoYSwgTGlzcF9NaXNjKTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3Qg TGlzcF9NaXNjX0FueSAqCitYTUlTQ0FOWSAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2Vy dCAoTUlTQ1AgKGEpKTsKKyAgcmV0dXJuICYgWE1JU0MgKGEpLT51X2FueTsKK30KKworLyog QSBtYWNybyBiZWNhdXNlIGl0IGlzIGFsc28gdXNlZCBhcyBhbiBsdmFsdWUuICBGSVhNRTog Y2xlYW4gdGhpcyB1cC4gICovCisjZGVmaW5lIFhNSVNDVFlQRShhKSAgIChYTUlTQ0FOWSAo YSktPnR5cGUpCisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IExpc3BfTWFya2VyICoKK1hNQVJL RVIgKExpc3BfT2JqZWN0IGEpCit7CisgIGVhc3NlcnQgKE1BUktFUlAgKGEpKTsKKyAgcmV0 dXJuICYgWE1JU0MgKGEpLT51X21hcmtlcjsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3Qg TGlzcF9PdmVybGF5ICoKK1hPVkVSTEFZIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0 IChPVkVSTEFZUCAoYSkpOworICByZXR1cm4gJiBYTUlTQyAoYSktPnVfb3ZlcmxheTsKK30K Kworc3RhdGljIGlubGluZSBzdHJ1Y3QgTGlzcF9TYXZlX1ZhbHVlICoKK1hTQVZFX1ZBTFVF IChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChTQVZFX1ZBTFVFUCAoYSkpOworICBy ZXR1cm4gJiBYTUlTQyAoYSktPnVfc2F2ZV92YWx1ZTsKK30KKwwKIC8qIEZvcndhcmRpbmcg cG9pbnRlciB0byBhbiBpbnQgdmFyaWFibGUuCiAgICBUaGlzIGlzIGFsbG93ZWQgb25seSBp biB0aGUgdmFsdWUgY2VsbCBvZiBhIHN5bWJvbCwKICAgIGFuZCBpdCBtZWFucyB0aGF0IHRo ZSBzeW1ib2wncyB2YWx1ZSByZWFsbHkgbGl2ZXMgaW4gdGhlCkBAIC0xNDE5LDEzICsxNzc4 LDI5IEBACiAgICAgTGlzcF9PYmplY3QgdmFsY2VsbDsKICAgfTsKIAotI2RlZmluZSBCTFZf Rk9VTkQoYmx2KSBcCi0gIChlYXNzZXJ0ICgoYmx2KS0+Zm91bmQgPT0gIUVRICgoYmx2KS0+ ZGVmY2VsbCwgKGJsdiktPnZhbGNlbGwpKSwgKGJsdiktPmZvdW5kKQotI2RlZmluZSBTRVRf QkxWX0ZPVU5EKGJsdiwgdikgXAotICAoZWFzc2VydCAoKHYpID09ICFFUSAoKGJsdiktPmRl ZmNlbGwsIChibHYpLT52YWxjZWxsKSksIChibHYpLT5mb3VuZCA9ICh2KSkKK3N0YXRpYyBp bmxpbmUgaW50CitCTFZfRk9VTkQgKHN0cnVjdCBMaXNwX0J1ZmZlcl9Mb2NhbF9WYWx1ZSAq Ymx2KQoreworICBlYXNzZXJ0IChibHYtPmZvdW5kID09ICFFUSAoYmx2LT5kZWZjZWxsLCBi bHYtPnZhbGNlbGwpKTsKKyAgcmV0dXJuIGJsdi0+Zm91bmQ7Cit9CitzdGF0aWMgaW5saW5l IHZvaWQKK1NFVF9CTFZfRk9VTkQgKHN0cnVjdCBMaXNwX0J1ZmZlcl9Mb2NhbF9WYWx1ZSAq Ymx2LCBpbnQgdikKK3sKKyAgZWFzc2VydCAodiA9PSAhRVEgKGJsdi0+ZGVmY2VsbCwgYmx2 LT52YWxjZWxsKSk7CisgIGJsdi0+Zm91bmQgPSB2OworfQogCi0jZGVmaW5lIEJMVl9WQUxV RShibHYpIChYQ0RSICgoYmx2KS0+dmFsY2VsbCkpCi0jZGVmaW5lIFNFVF9CTFZfVkFMVUUo Ymx2LCB2KSAoWFNFVENEUiAoKGJsdiktPnZhbGNlbGwsIHYpKQorc3RhdGljIGlubGluZSBM aXNwX09iamVjdAorQkxWX1ZBTFVFIChzdHJ1Y3QgTGlzcF9CdWZmZXJfTG9jYWxfVmFsdWUg KmJsdikKK3sKKyAgcmV0dXJuIFhDRFIgKGJsdi0+dmFsY2VsbCk7Cit9CitzdGF0aWMgaW5s aW5lIHZvaWQKK1NFVF9CTFZfVkFMVUUgKHN0cnVjdCBMaXNwX0J1ZmZlcl9Mb2NhbF9WYWx1 ZSAqYmx2LCBMaXNwX09iamVjdCB2KQoreworICBYU0VUQ0RSIChibHYtPnZhbGNlbGwsIHYp OworfQogCiAvKiBMaWtlIExpc3BfT2JqZndkIGV4Y2VwdCB0aGF0IHZhbHVlIGxpdmVzIGlu IGEgc2xvdCBpbiB0aGUKICAgIGN1cnJlbnQga2JvYXJkLiAgKi8KQEAgLTE0NDMsNiArMTgx OCw0NyBAQAogICAgIHN0cnVjdCBMaXNwX0J1ZmZlcl9PYmpmd2QgdV9idWZmZXJfb2JqZndk OwogICAgIHN0cnVjdCBMaXNwX0tib2FyZF9PYmpmd2QgdV9rYm9hcmRfb2JqZndkOwogICB9 OworCitzdGF0aWMgaW5saW5lIGVudW0gTGlzcF9Gd2RfVHlwZQorWEZXRFRZUEUgKHVuaW9u IExpc3BfRndkICphKQoreworICByZXR1cm4gYS0+dV9pbnRmd2QudHlwZTsKK30KKworc3Rh dGljIGlubGluZSBzdHJ1Y3QgTGlzcF9JbnRmd2QgKgorWElOVEZXRCAodW5pb24gTGlzcF9G d2QgKmEpCit7CisgIGVhc3NlcnQgKElOVEZXRFAgKGEpKTsKKyAgcmV0dXJuICZhLT51X2lu dGZ3ZDsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgTGlzcF9Cb29sZndkICoKK1hCT09M RldEICh1bmlvbiBMaXNwX0Z3ZCAqYSkKK3sKKyAgZWFzc2VydCAoQk9PTEZXRFAgKGEpKTsK KyAgcmV0dXJuICZhLT51X2Jvb2xmd2Q7Cit9CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IExp c3BfT2JqZndkICoKK1hPQkpGV0QgKHVuaW9uIExpc3BfRndkICphKQoreworICBlYXNzZXJ0 IChPQkpGV0RQIChhKSk7CisgIHJldHVybiAmYS0+dV9vYmpmd2Q7Cit9CisKK3N0YXRpYyBp bmxpbmUgc3RydWN0IExpc3BfQnVmZmVyX09iamZ3ZCAqCitYQlVGRkVSX09CSkZXRCAodW5p b24gTGlzcF9Gd2QgKmEpCit7CisgIGVhc3NlcnQgKEJVRkZFUl9PQkpGV0RQIChhKSk7Cisg IHJldHVybiAmYS0+dV9idWZmZXJfb2JqZndkOworfQorCitzdGF0aWMgaW5saW5lIHN0cnVj dCBMaXNwX0tib2FyZF9PYmpmd2QgKgorWEtCT0FSRF9PQkpGV0QgKHVuaW9uIExpc3BfRndk ICphKQoreworICBlYXNzZXJ0IChLQk9BUkRfT0JKRldEUCAoYSkpOworICByZXR1cm4gJmEt PnVfa2JvYXJkX29iamZ3ZDsKK30KIAwKIC8qIExpc3AgZmxvYXRpbmcgcG9pbnQgdHlwZS4g ICovCiBzdHJ1Y3QgTGlzcF9GbG9hdApAQCAtMTQ1OCwxMyArMTg3NCwyNCBAQAogICAgIH0g dTsKICAgfTsKIAorc3RhdGljIGlubGluZSBkb3VibGUKK1hGTE9BVF9EQVRBIChMaXNwX09i amVjdCBmKQorewogI2lmZGVmIEhJREVfTElTUF9JTVBMRU1FTlRBVElPTgotI2RlZmluZSBY RkxPQVRfREFUQShmKQkoMCA/IFhGTE9BVCAoZiktPnUuZGF0YV8gOiBYRkxPQVQgKGYpLT51 LmRhdGFfKQorICByZXR1cm4gWEZMT0FUIChmKS0+dS5kYXRhXzsKICNlbHNlCi0jZGVmaW5l IFhGTE9BVF9EQVRBKGYpCSgwID8gWEZMT0FUIChmKS0+dS5kYXRhIDogIFhGTE9BVCAoZikt PnUuZGF0YSkKKyAgcmV0dXJuIFhGTE9BVCAoZiktPnUuZGF0YTsKKyNlbmRpZgorfQorCisj aWZuZGVmIEhJREVfTElTUF9JTVBMRU1FTlRBVElPTgogLyogVGhpcyBzaG91bGQgYmUgdXNl ZCBvbmx5IGluIGFsbG9jLmMsIHdoaWNoIGFsd2F5cyBkaXNhYmxlcwogICAgSElERV9MSVNQ X0lNUExFTUVOVEFUSU9OLiAgKi8KLSNkZWZpbmUgWEZMT0FUX0lOSVQoZixuKSAoWEZMT0FU IChmKS0+dS5kYXRhID0gKG4pKQorc3RhdGljIGlubGluZSB2b2lkCitYRkxPQVRfSU5JVCAo TGlzcF9PYmplY3QgZiwgZG91YmxlIG4pCit7CisgIFhGTE9BVCAoZiktPnUuZGF0YSA9IG47 Cit9CiAjZW5kaWYKIAogLyogQSBjaGFyYWN0ZXIsIGRlY2xhcmVkIHdpdGggdGhlIGZvbGxv d2luZyB0eXBlZGVmLCBpcyBhIG1lbWJlcgpAQCAtMTQ3NSw5MSArMTkwMiwzNiBAQAogI2Vu ZGlmCiAKIC8qIE1lYW5pbmdzIG9mIHNsb3RzIGluIGEgTGlzcF9Db21waWxlZDogICovCi0K LSNkZWZpbmUgQ09NUElMRURfQVJHTElTVCAwCi0jZGVmaW5lIENPTVBJTEVEX0JZVEVDT0RF IDEKLSNkZWZpbmUgQ09NUElMRURfQ09OU1RBTlRTIDIKLSNkZWZpbmUgQ09NUElMRURfU1RB Q0tfREVQVEggMwotI2RlZmluZSBDT01QSUxFRF9ET0NfU1RSSU5HIDQKLSNkZWZpbmUgQ09N UElMRURfSU5URVJBQ1RJVkUgNQorZW51bQorICB7CisgICAgQ09NUElMRURfQVJHTElTVCwK KyAgICBDT01QSUxFRF9CWVRFQ09ERSwKKyAgICBDT01QSUxFRF9DT05TVEFOVFMsCisgICAg Q09NUElMRURfU1RBQ0tfREVQVEgsCisgICAgQ09NUElMRURfRE9DX1NUUklORywKKyAgICBD T01QSUxFRF9JTlRFUkFDVElWRQorICB9OwogCiAvKiBGbGFnIGJpdHMgaW4gYSBjaGFyYWN0 ZXIuICBUaGVzZSBhbHNvIGdldCB1c2VkIGluIHRlcm1ob29rcy5oLgogICAgUmljaGFyZCBT dGFsbG1hbiA8cm1zQGdudS5haS5taXQuZWR1PiB0aGlua3MgdGhhdCBNVUxFCiAgICAoTVVs dGktTGluZ3VhbCBFbWFjcykgbWlnaHQgbmVlZCAyMiBiaXRzIGZvciB0aGUgY2hhcmFjdGVy IHZhbHVlCiAgICBpdHNlbGYsIHNvIHdlIHByb2JhYmx5IHNob3VsZG4ndCB1c2UgYW55IGJp dHMgbG93ZXIgdGhhbiAweDA0MDAwMDAuICAqLwotI2RlZmluZSBDSEFSX0FMVCAgICgweDA0 MDAwMDApCi0jZGVmaW5lIENIQVJfU1VQRVIgKDB4MDgwMDAwMCkKLSNkZWZpbmUgQ0hBUl9I WVBFUiAoMHgxMDAwMDAwKQotI2RlZmluZSBDSEFSX1NISUZUICgweDIwMDAwMDApCi0jZGVm aW5lIENIQVJfQ1RMICAgKDB4NDAwMDAwMCkKLSNkZWZpbmUgQ0hBUl9NRVRBICAoMHg4MDAw MDAwKQotCi0jZGVmaW5lIENIQVJfTU9ESUZJRVJfTUFTSyBcCi0gIChDSEFSX0FMVCB8IENI QVJfU1VQRVIgfCBDSEFSX0hZUEVSICB8IENIQVJfU0hJRlQgfCBDSEFSX0NUTCB8IENIQVJf TUVUQSkKLQorZW51bQorICB7CisgICAgQ0hBUl9BTFQgICA9IDB4MDQwMDAwMCwKKyAgICBD SEFSX1NVUEVSID0gMHgwODAwMDAwLAorICAgIENIQVJfSFlQRVIgPSAweDEwMDAwMDAsCisg ICAgQ0hBUl9TSElGVCA9IDB4MjAwMDAwMCwKKyAgICBDSEFSX0NUTCAgID0gMHg0MDAwMDAw LAorICAgIENIQVJfTUVUQSAgPSAweDgwMDAwMDAsCisgICAgQ0hBUl9NT0RJRklFUl9NQVNL ID0KKyAgICAgIENIQVJfQUxUIHwgQ0hBUl9TVVBFUiB8IENIQVJfSFlQRVIgIHwgQ0hBUl9T SElGVCB8IENIQVJfQ1RMIHwgQ0hBUl9NRVRBCisgIH07CiAKIC8qIEFjdHVhbGx5LCB0aGUg Y3VycmVudCBFbWFjcyB1c2VzIDIyIGJpdHMgZm9yIHRoZSBjaGFyYWN0ZXIgdmFsdWUKICAg IGl0c2VsZi4gICovCi0jZGVmaW5lIENIQVJBQ1RFUkJJVFMgMjIKLQotDAotLyogVGhlIGds eXBoIGRhdGF0eXBlLCB1c2VkIHRvIHJlcHJlc2VudCBjaGFyYWN0ZXJzIG9uIHRoZSBkaXNw bGF5LgotICAgSXQgY29uc2lzdHMgb2YgYSBjaGFyIGNvZGUgYW5kIGEgZmFjZSBpZC4gICov Ci0KLXR5cGVkZWYgc3RydWN0IHsKLSAgaW50IGNoOwotICBpbnQgZmFjZV9pZDsKLX0gR0xZ UEg7Ci0KLS8qIFJldHVybiBhIGdseXBoJ3MgY2hhcmFjdGVyIGNvZGUuICAqLwotI2RlZmlu ZSBHTFlQSF9DSEFSKGdseXBoKSAoKGdseXBoKS5jaCkKLQotLyogUmV0dXJuIGEgZ2x5cGgn cyBmYWNlIElELiAgKi8KLSNkZWZpbmUgR0xZUEhfRkFDRShnbHlwaCkgKChnbHlwaCkuZmFj ZV9pZCkKLQotI2RlZmluZSBTRVRfR0xZUEhfQ0hBUihnbHlwaCwgY2hhcikgKChnbHlwaCku Y2ggPSAoY2hhcikpCi0jZGVmaW5lIFNFVF9HTFlQSF9GQUNFKGdseXBoLCBmYWNlKSAoKGds eXBoKS5mYWNlX2lkID0gKGZhY2UpKQotI2RlZmluZSBTRVRfR0xZUEgoZ2x5cGgsIGNoYXIs IGZhY2UpICgoZ2x5cGgpLmNoID0gKGNoYXIpLCAoZ2x5cGgpLmZhY2VfaWQgPSAoZmFjZSkp Ci0KLS8qIFJldHVybiAxIGlmIEdMWVBIIGNvbnRhaW5zIHZhbGlkIGNoYXJhY3RlciBjb2Rl LiAgKi8KLSNkZWZpbmUgR0xZUEhfQ0hBUl9WQUxJRF9QKGdseXBoKSBDSEFSX1ZBTElEX1Ag KEdMWVBIX0NIQVIgKGdseXBoKSkKLQotCi0vKiBHbHlwaCBDb2RlIGZyb20gYSBkaXNwbGF5 IHZlY3RvciBtYXkgZWl0aGVyIGJlIGFuIGludGVnZXIgd2hpY2gKLSAgIGVuY29kZXMgYSBj aGFyIGNvZGUgaW4gdGhlIGxvd2VyIENIQVJBQ1RFUkJJVFMgYml0cyBhbmQgYSAodmVyeSBz bWFsbCkKLSAgIGZhY2UtaWQgaW4gdGhlIHVwcGVyIGJpdHMsIG9yIGl0IG1heSBiZSBhIGNv bnMgKENIQVIgLiBGQUNFLUlEKS4gICovCi0KLSNkZWZpbmUgR0xZUEhfQ09ERV9QKGdjKQkJ CQkJCVwKLSAgKENPTlNQIChnYykJCQkJCQkJCVwKLSAgID8gKENIQVJBQ1RFUlAgKFhDQVIg KGdjKSkJCQkJCQlcCi0gICAgICAmJiBSQU5HRURfSU5URUdFUlAgKDAsIFhDRFIgKGdjKSwg TUFYX0ZBQ0VfSUQpKQkJCVwKLSAgIDogKFJBTkdFRF9JTlRFR0VSUAkJCQkJCQlcCi0gICAg ICAoMCwgZ2MsCQkJCQkJCQlcCi0gICAgICAgKE1BWF9GQUNFX0lEIDwgVFlQRV9NQVhJTVVN IChFTUFDU19JTlQpID4+IENIQVJBQ1RFUkJJVFMJCVwKLQk/ICgoRU1BQ1NfSU5UKSBNQVhf RkFDRV9JRCA8PCBDSEFSQUNURVJCSVRTKSB8IE1BWF9DSEFSCQlcCi0JOiBUWVBFX01BWElN VU0gKEVNQUNTX0lOVCkpKSkpCi0KLS8qIFRoZSBmb2xsb3dpbmcgYXJlIHZhbGlkIG9ubHkg aWYgR0xZUEhfQ09ERV9QIChnYykuICAqLwotCi0jZGVmaW5lIEdMWVBIX0NPREVfQ0hBUihn YykgXAotICAoQ09OU1AgKGdjKSA/IFhJTlQgKFhDQVIgKGdjKSkgOiBYSU5UIChnYykgJiAo KDEgPDwgQ0hBUkFDVEVSQklUUykgLSAxKSkKLQotI2RlZmluZSBHTFlQSF9DT0RFX0ZBQ0Uo Z2MpIFwKLSAgKENPTlNQIChnYykgPyBYSU5UIChYQ0RSIChnYykpIDogWElOVCAoZ2MpID4+ IENIQVJBQ1RFUkJJVFMpCi0KLSNkZWZpbmUgU0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERShn bHlwaCwgZ2MpCQkJCVwKLSAgZG8JCQkJCQkJCQlcCi0gICAgewkJCQkJCQkJCVwKLSAgICAg IGlmIChDT05TUCAoZ2MpKQkJCQkJCQlcCi0JU0VUX0dMWVBIIChnbHlwaCwgWElOVCAoWENB UiAoZ2MpKSwgWElOVCAoWENEUiAoZ2MpKSk7CQlcCi0gICAgICBlbHNlCQkJCQkJCQlcCi0J U0VUX0dMWVBIIChnbHlwaCwgKFhJTlQgKGdjKSAmICgoMSA8PCBDSEFSQUNURVJCSVRTKS0x KSksCVwKLQkJICAgKFhJTlQgKGdjKSA+PiBDSEFSQUNURVJCSVRTKSk7CQkJXAotICAgIH0J CQkJCQkJCQlcCi0gIHdoaWxlICgwKQotCi0vKiBUaGUgSUQgb2YgdGhlIG1vZGUgbGluZSBo aWdobGlnaHRpbmcgZmFjZS4gICovCi0jZGVmaW5lIEdMWVBIX01PREVfTElORV9GQUNFIDEK K2VudW0geyBDSEFSQUNURVJCSVRTID0gMjIgfTsKKwogDAogLyogU3RydWN0dXJlIHRvIGhv bGQgbW91c2UgaGlnaGxpZ2h0IGRhdGEuICBUaGlzIGlzIGhlcmUgYmVjYXVzZSBvdGhlcgog ICAgaGVhZGVyIGZpbGVzIG5lZWQgaXQgZm9yIGRlZmluaW5nIHN0cnVjdCB4X291dHB1dCBl dGMuICAqLwpAQCAtMTU5OCwxNDAgKzE5NzAsMzA4IEBACiAMCiAvKiBEYXRhIHR5cGUgY2hl Y2tpbmcgKi8KIAotI2RlZmluZSBOSUxQKHgpICBFUSAoeCwgUW5pbCkKLQotI2RlZmluZSBO VU1CRVJQKHgpIChJTlRFR0VSUCAoeCkgfHwgRkxPQVRQICh4KSkKLSNkZWZpbmUgTkFUTlVN UCh4KSAoSU5URUdFUlAgKHgpICYmIFhJTlQgKHgpID49IDApCi0KLSNkZWZpbmUgUkFOR0VE X0lOVEVHRVJQKGxvLCB4LCBoaSkgXAotICAoSU5URUdFUlAgKHgpICYmIChsbykgPD0gWElO VCAoeCkgJiYgWElOVCAoeCkgPD0gKGhpKSkKK3N0YXRpYyBpbmxpbmUgaW50CisoTklMUCkg KExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBFUSAoeCwgUW5pbCk7Cit9CisKK3N0YXRp YyBpbmxpbmUgaW50CitOVU1CRVJQIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4gSU5U RUdFUlAgKHgpIHx8IEZMT0FUUCAoeCk7Cit9CitzdGF0aWMgaW5saW5lIGludAorTkFUTlVN UCAoTGlzcF9PYmplY3QgeCkKK3sKKyAgcmV0dXJuIElOVEVHRVJQICh4KSAmJiAwIDw9IFhJ TlQgKHgpOworfQorCitzdGF0aWMgaW5saW5lIGludAorUkFOR0VEX0lOVEVHRVJQIChpbnRt YXhfdCBsbywgTGlzcF9PYmplY3QgeCwgaW50bWF4X3QgaGkpCit7CisgIHJldHVybiBJTlRF R0VSUCAoeCkgJiYgbG8gPD0gWElOVCAoeCkgJiYgWElOVCAoeCkgPD0gaGk7Cit9CisKICNk ZWZpbmUgVFlQRV9SQU5HRURfSU5URUdFUlAodHlwZSwgeCkgXAotICAoVFlQRV9TSUdORUQg KHR5cGUpCQkJCQkJCVwKLSAgID8gUkFOR0VEX0lOVEVHRVJQIChUWVBFX01JTklNVU0gKHR5 cGUpLCB4LCBUWVBFX01BWElNVU0gKHR5cGUpKQlcCi0gICA6IFJBTkdFRF9JTlRFR0VSUCAo MCwgeCwgVFlQRV9NQVhJTVVNICh0eXBlKSkpCi0KLSNkZWZpbmUgSU5URUdFUlAoeCkgKExJ U1BfSU5UX1RBR19QIChYVFlQRSAoKHgpKSkpCi0jZGVmaW5lIFNZTUJPTFAoeCkgKFhUWVBF ICgoeCkpID09IExpc3BfU3ltYm9sKQotI2RlZmluZSBNSVNDUCh4KSAoWFRZUEUgKCh4KSkg PT0gTGlzcF9NaXNjKQotI2RlZmluZSBWRUNUT1JMSUtFUCh4KSAoWFRZUEUgKCh4KSkgPT0g TGlzcF9WZWN0b3JsaWtlKQotI2RlZmluZSBTVFJJTkdQKHgpIChYVFlQRSAoKHgpKSA9PSBM aXNwX1N0cmluZykKLSNkZWZpbmUgQ09OU1AoeCkgKFhUWVBFICgoeCkpID09IExpc3BfQ29u cykKLQotI2RlZmluZSBGTE9BVFAoeCkgKFhUWVBFICgoeCkpID09IExpc3BfRmxvYXQpCi0j ZGVmaW5lIFZFQ1RPUlAoeCkgKFZFQ1RPUkxJS0VQICh4KSAmJiAhKEFTSVpFICh4KSAmIFBT RVVET1ZFQ1RPUl9GTEFHKSkKLSNkZWZpbmUgT1ZFUkxBWVAoeCkgKE1JU0NQICh4KSAmJiBY TUlTQ1RZUEUgKHgpID09IExpc3BfTWlzY19PdmVybGF5KQotI2RlZmluZSBNQVJLRVJQKHgp IChNSVNDUCAoeCkgJiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01pc2NfTWFya2VyKQotI2Rl ZmluZSBTQVZFX1ZBTFVFUCh4KSAoTUlTQ1AgKHgpICYmIFhNSVNDVFlQRSAoeCkgPT0gTGlz cF9NaXNjX1NhdmVfVmFsdWUpCi0KLSNkZWZpbmUgSU5URldEUCh4KSAoWEZXRFRZUEUgKHgp ID09IExpc3BfRndkX0ludCkKLSNkZWZpbmUgQk9PTEZXRFAoeCkgKFhGV0RUWVBFICh4KSA9 PSBMaXNwX0Z3ZF9Cb29sKQotI2RlZmluZSBPQkpGV0RQKHgpIChYRldEVFlQRSAoeCkgPT0g TGlzcF9Gd2RfT2JqKQotI2RlZmluZSBCVUZGRVJfT0JKRldEUCh4KSAoWEZXRFRZUEUgKHgp ID09IExpc3BfRndkX0J1ZmZlcl9PYmopCi0jZGVmaW5lIEtCT0FSRF9PQkpGV0RQKHgpIChY RldEVFlQRSAoeCkgPT0gTGlzcF9Gd2RfS2JvYXJkX09iaikKLQotLyogVHJ1ZSBpZiBvYmpl Y3QgWCBpcyBhIHBzZXVkb3ZlY3RvciB3aG9zZSBjb2RlIGlzIENPREUuICBUaGUgY2FzdCB0 byBzdHJ1Y3QKLSAgIHZlY3Rvcmxpa2VfaGVhZGVyICogYXZvaWRzIGFsaWFzaW5nIGlzc3Vl cy4gICovCi0jZGVmaW5lIFBTRVVET1ZFQ1RPUlAoeCwgY29kZSkJCQkJCVwKLSAgVFlQRURf UFNFVURPVkVDVE9SUCAoeCwgdmVjdG9ybGlrZV9oZWFkZXIsIGNvZGUpCi0KLSNkZWZpbmUg UFNFVURPVkVDVE9SX1RZUEVQKHYsIGNvZGUpCQkJCQlcCi0gICgoKHYpLT5zaXplICYgKFBT RVVET1ZFQ1RPUl9GTEFHIHwgUFZFQ19UWVBFX01BU0spKQkJCVwKLSAgID09IChQU0VVRE9W RUNUT1JfRkxBRyB8ICgoY29kZSkgPDwgUFNFVURPVkVDVE9SX1NJWkVfQklUUykpKQotCi0v KiBUcnVlIGlmIG9iamVjdCBYLCB3aXRoIGludGVybmFsIHR5cGUgc3RydWN0IFQgKiwgaXMg YSBwc2V1ZG92ZWN0b3Igd2hvc2UKLSAgIGNvZGUgaXMgQ09ERS4gICovCi0jZGVmaW5lIFRZ UEVEX1BTRVVET1ZFQ1RPUlAoeCwgdCwgY29kZSkJCQkJXAotICAoVkVDVE9STElLRVAgKHgp CQkJCQkJXAotICAgJiYgUFNFVURPVkVDVE9SX1RZUEVQICgoc3RydWN0IHQgKikgWFVOVEFH ICh4LCBMaXNwX1ZlY3Rvcmxpa2UpLCBjb2RlKSkKKyAgKElOVEVHRVJQICh4KQkJCSAgICAg IFwKKyAgICYmIChUWVBFX1NJR05FRCAodHlwZSkgPyBUWVBFX01JTklNVU0gKHR5cGUpIDw9 IFhJTlQgKHgpIDogMCA8PSBYSU5UICh4KSkgXAorICAgJiYgWElOVCAoeCkgPD0gVFlQRV9N QVhJTVVNICh0eXBlKSkKKworc3RhdGljIGlubGluZSBpbnQgKENPTlNQKSAoTGlzcF9PYmpl Y3QgeCkgeyByZXR1cm4gWFRZUEUgKHgpID09IExpc3BfQ29uczsgfQorc3RhdGljIGlubGlu ZSBpbnQgKEZMT0FUUCkgKExpc3BfT2JqZWN0IHgpIHsgcmV0dXJuIFhUWVBFICh4KSA9PSBM aXNwX0Zsb2F0OyB9CitzdGF0aWMgaW5saW5lIGludCAoTUlTQ1ApIChMaXNwX09iamVjdCB4 KSB7IHJldHVybiBYVFlQRSAoeCkgPT0gTGlzcF9NaXNjOyB9CitzdGF0aWMgaW5saW5lIGlu dCBTVFJJTkdQIChMaXNwX09iamVjdCB4KSB7IHJldHVybiBYVFlQRSAoeCkgPT0gTGlzcF9T dHJpbmc7IH0KK3N0YXRpYyBpbmxpbmUgaW50CisoU1lNQk9MUCkgKExpc3BfT2JqZWN0IHgp Cit7CisgIHJldHVybiBYVFlQRSAoeCkgPT0gTGlzcF9TeW1ib2w7Cit9CitzdGF0aWMgaW5s aW5lIGludAorKElOVEVHRVJQKSAoTGlzcF9PYmplY3QgeCkKK3sKKyAgcmV0dXJuIExJU1Bf SU5UX1RBR19QIChYVFlQRSAoeCkpOworfQorc3RhdGljIGlubGluZSBpbnQKKyhWRUNUT1JM SUtFUCkgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBYVFlQRSAoeCkgPT0gTGlzcF9W ZWN0b3JsaWtlOworfQorc3RhdGljIGlubGluZSBpbnQKK1ZFQ1RPUlAgKExpc3BfT2JqZWN0 IHgpCit7CisgIHJldHVybiBWRUNUT1JMSUtFUCAoeCkgJiYgISAoQVNJWkUgKHgpICYgUFNF VURPVkVDVE9SX0ZMQUcpOworfQorc3RhdGljIGlubGluZSBpbnQKK09WRVJMQVlQIChMaXNw X09iamVjdCB4KQoreworICByZXR1cm4gTUlTQ1AgKHgpICYmIFhNSVNDVFlQRSAoeCkgPT0g TGlzcF9NaXNjX092ZXJsYXk7Cit9CitzdGF0aWMgaW5saW5lIGludAorKE1BUktFUlApIChM aXNwX09iamVjdCB4KQoreworICByZXR1cm4gTUlTQ1AgKHgpICYmIFhNSVNDVFlQRSAoeCkg PT0gTGlzcF9NaXNjX01hcmtlcjsKK30KK3N0YXRpYyBpbmxpbmUgaW50CitTQVZFX1ZBTFVF UCAoTGlzcF9PYmplY3QgeCkKK3sKKyAgcmV0dXJuIE1JU0NQICh4KSAmJiBYTUlTQ1RZUEUg KHgpID09IExpc3BfTWlzY19TYXZlX1ZhbHVlOworfQorCitzdGF0aWMgaW5saW5lIGludAor SU5URldEUCAodW5pb24gTGlzcF9Gd2QgKmEpCit7CisgIHJldHVybiBYRldEVFlQRSAoYSkg PT0gTGlzcF9Gd2RfSW50OworfQorc3RhdGljIGlubGluZSBpbnQKK0JPT0xGV0RQICh1bmlv biBMaXNwX0Z3ZCAqYSkKK3sKKyAgcmV0dXJuIFhGV0RUWVBFIChhKSA9PSBMaXNwX0Z3ZF9C b29sOworfQorc3RhdGljIGlubGluZSBpbnQKK09CSkZXRFAgKHVuaW9uIExpc3BfRndkICph KQoreworICByZXR1cm4gWEZXRFRZUEUgKGEpID09IExpc3BfRndkX09iajsKK30KK3N0YXRp YyBpbmxpbmUgaW50CitCVUZGRVJfT0JKRldEUCAodW5pb24gTGlzcF9Gd2QgKmEpCit7Cisg IHJldHVybiBYRldEVFlQRSAoYSkgPT0gTGlzcF9Gd2RfQnVmZmVyX09iajsKK30KK3N0YXRp YyBpbmxpbmUgaW50CitLQk9BUkRfT0JKRldEUCAodW5pb24gTGlzcF9Gd2QgKmEpCit7Cisg IHJldHVybiBYRldEVFlQRSAoYSkgPT0gTGlzcF9Gd2RfS2JvYXJkX09iajsKK30KKworLyog VHJ1ZSBpZiB0aGUgc2l6ZSBmaWVsZCBTSVpFIG9mIGEgcHNldWRvdmVjdG9yIGlzIHRoYXQg b2YgYQorICAgcHNldWRvdmVjdG9yIHdob3NlIGNvZGUgaXMgQ09ERS4gICovCitzdGF0aWMg aW5saW5lIGludAorUFNFVURPVkVDVE9SX1NJWkVfVFlQRVAgKHB0cmRpZmZfdCBzaXplLCBp bnQgY29kZSkKK3sKKyAgcmV0dXJuICgoc2l6ZSAmIChQU0VVRE9WRUNUT1JfRkxBRyB8IFBW RUNfVFlQRV9NQVNLKSkKKwkgID09IChQU0VVRE9WRUNUT1JfRkxBRyB8IChjb2RlIDw8IFBT RVVET1ZFQ1RPUl9TSVpFX0JJVFMpKSk7Cit9CisKKy8qIFRydWUgaWYgQSBpcyBhIHBzZXVk b3ZlY3RvciB3aG9zZSBjb2RlIGlzIENPREUuICAqLworc3RhdGljIGlubGluZSBpbnQKK1BT RVVET1ZFQ1RPUlAgKExpc3BfT2JqZWN0IGEsIGludCBjb2RlKQoreworICBpZiAoISBWRUNU T1JMSUtFUCAoYSkpCisgICAgcmV0dXJuIDA7CisgIGVsc2UKKyAgICB7CisgICAgICAvKiBD b252ZXJ0aW5nIHRvIHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRlciAqIGF2b2lkcyBhbGlhc2lu ZyBpc3N1ZXMuICAqLworICAgICAgc3RydWN0IHZlY3Rvcmxpa2VfaGVhZGVyICpoID0gWFVO VEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworICAgICAgcmV0dXJuIFBTRVVET1ZFQ1RPUl9T SVpFX1RZUEVQIChoLT5zaXplLCBjb2RlKTsKKyAgICB9Cit9CisKIAogLyogVGVzdCBmb3Ig c3BlY2lmaWMgcHNldWRvdmVjdG9yIHR5cGVzLiAgKi8KLSNkZWZpbmUgV0lORE9XX0NPTkZJ R1VSQVRJT05QKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfV0lORE9XX0NPTkZJR1VSQVRJ T04pCi0jZGVmaW5lIFBST0NFU1NQKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfUFJPQ0VT UykKLSNkZWZpbmUgV0lORE9XUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX1dJTkRPVykK LSNkZWZpbmUgVEVSTUlOQUxQKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfVEVSTUlOQUwp CisKK3N0YXRpYyBpbmxpbmUgaW50CitXSU5ET1dfQ09ORklHVVJBVElPTlAgKExpc3BfT2Jq ZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVDX1dJTkRPV19DT05G SUdVUkFUSU9OKTsKK30KKworc3RhdGljIGlubGluZSBpbnQKK1BST0NFU1NQIChMaXNwX09i amVjdCBhKQoreworICByZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZFQ19QUk9DRVNTKTsK K30KKworc3RhdGljIGlubGluZSBpbnQKK1dJTkRPV1AgKExpc3BfT2JqZWN0IGEpCit7Cisg IHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVDX1dJTkRPVyk7Cit9CisKK3N0YXRpYyBp bmxpbmUgaW50CitURVJNSU5BTFAgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VV RE9WRUNUT1JQIChhLCBQVkVDX1RFUk1JTkFMKTsKK30KKwogLyogU1VCUlAgaXMgc3BlY2lh bCBzaW5jZSBMaXNwX1N1YnIgbGFja3Mgc3RydWN0IHZlY3Rvcmxpa2VfaGVhZGVyLiAgKi8K LSNkZWZpbmUgU1VCUlAoeCkgVFlQRURfUFNFVURPVkVDVE9SUCAoeCwgTGlzcF9TdWJyLCBQ VkVDX1NVQlIpCi0jZGVmaW5lIENPTVBJTEVEUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVD X0NPTVBJTEVEKQotI2RlZmluZSBCVUZGRVJQKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNf QlVGRkVSKQotI2RlZmluZSBDSEFSX1RBQkxFX1AoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZF Q19DSEFSX1RBQkxFKQotI2RlZmluZSBTVUJfQ0hBUl9UQUJMRV9QKHgpIFBTRVVET1ZFQ1RP UlAgKHgsIFBWRUNfU1VCX0NIQVJfVEFCTEUpCi0jZGVmaW5lIEJPT0xfVkVDVE9SX1AoeCkg UFNFVURPVkVDVE9SUCAoeCwgUFZFQ19CT09MX1ZFQ1RPUikKLSNkZWZpbmUgRlJBTUVQKHgp IFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfRlJBTUUpCitzdGF0aWMgaW5saW5lIGludAorU1VC UlAgKExpc3BfT2JqZWN0IGEpCit7CisgIGlmICghIFZFQ1RPUkxJS0VQIChhKSkKKyAgICBy ZXR1cm4gMDsKKyAgZWxzZQorICAgIHsKKyAgICAgIHN0cnVjdCBMaXNwX1N1YnIgKmggPSBY VU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSk7CisgICAgICByZXR1cm4gUFNFVURPVkVDVE9S X1NJWkVfVFlQRVAgKGgtPnNpemUsIFBWRUNfU1VCUik7CisgICAgfQorfQorCitzdGF0aWMg aW5saW5lIGludAorQ09NUElMRURQIChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4gUFNF VURPVkVDVE9SUCAoYSwgUFZFQ19DT01QSUxFRCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50 CitCVUZGRVJQIChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4gUFNFVURPVkVDVE9SUCAo YSwgUFZFQ19CVUZGRVIpOworfQorCitzdGF0aWMgaW5saW5lIGludAorQ0hBUl9UQUJMRV9Q IChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZFQ19D SEFSX1RBQkxFKTsKK30KKworc3RhdGljIGlubGluZSBpbnQKK1NVQl9DSEFSX1RBQkxFX1Ag KExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVDX1NV Ql9DSEFSX1RBQkxFKTsKK30KKworc3RhdGljIGlubGluZSBpbnQKK0JPT0xfVkVDVE9SX1Ag KExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVDX0JP T0xfVkVDVE9SKTsKK30KKworc3RhdGljIGlubGluZSBpbnQKK0ZSQU1FUCAoTGlzcF9PYmpl Y3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEsIFBWRUNfRlJBTUUpOworfQog CiAvKiBUZXN0IGZvciBpbWFnZSAoaW1hZ2UgLiBzcGVjKSAgKi8KLSNkZWZpbmUgSU1BR0VQ KHgpIChDT05TUCAoeCkgJiYgRVEgKFhDQVIgKHgpLCBRaW1hZ2UpKQorc3RhdGljIGlubGlu ZSBpbnQKK0lNQUdFUCAoTGlzcF9PYmplY3QgeCkKK3sKKyAgcmV0dXJuIENPTlNQICh4KSAm JiBFUSAoWENBUiAoeCksIFFpbWFnZSk7Cit9CiAKIC8qIEFycmF5IHR5cGVzLiAgKi8KLQot I2RlZmluZSBBUlJBWVAoeCkgXAotICAoVkVDVE9SUCAoeCkgfHwgU1RSSU5HUCAoeCkgfHwg Q0hBUl9UQUJMRV9QICh4KSB8fCBCT09MX1ZFQ1RPUl9QICh4KSkKK3N0YXRpYyBpbmxpbmUg aW50CitBUlJBWVAgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBWRUNUT1JQICh4KSB8 fCBTVFJJTkdQICh4KSB8fCBDSEFSX1RBQkxFX1AgKHgpIHx8IEJPT0xfVkVDVE9SX1AgKHgp OworfQogDAotI2RlZmluZSBDSEVDS19MSVNUKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoQ09OU1Ag KHgpIHx8IE5JTFAgKHgpLCBRbGlzdHAsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfTElTVF9DT05T KHgsIHkpIFwKLSAgQ0hFQ0tfVFlQRSAoQ09OU1AgKHgpLCBRbGlzdHAsIHkpCi0KLSNkZWZp bmUgQ0hFQ0tfTElTVF9FTkQoeCwgeSkgXAotICBDSEVDS19UWVBFIChOSUxQICh4KSwgUWxp c3RwLCB5KQotCi0jZGVmaW5lIENIRUNLX1NUUklORyh4KSBcCi0gIENIRUNLX1RZUEUgKFNU UklOR1AgKHgpLCBRc3RyaW5ncCwgeCkKLQotI2RlZmluZSBDSEVDS19TVFJJTkdfQ0FSKHgp IFwKLSAgQ0hFQ0tfVFlQRSAoU1RSSU5HUCAoWENBUiAoeCkpLCBRc3RyaW5ncCwgWENBUiAo eCkpCi0KLSNkZWZpbmUgQ0hFQ0tfQ09OUyh4KSBcCi0gIENIRUNLX1RZUEUgKENPTlNQICh4 KSwgUWNvbnNwLCB4KQotCi0jZGVmaW5lIENIRUNLX1NZTUJPTCh4KSBcCi0gIENIRUNLX1RZ UEUgKFNZTUJPTFAgKHgpLCBRc3ltYm9scCwgeCkKLQotI2RlZmluZSBDSEVDS19DSEFSX1RB QkxFKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoQ0hBUl9UQUJMRV9QICh4KSwgUWNoYXJfdGFibGVf cCwgeCkKLQotI2RlZmluZSBDSEVDS19WRUNUT1IoeCkgXAotICBDSEVDS19UWVBFIChWRUNU T1JQICh4KSwgUXZlY3RvcnAsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfVkVDVE9SX09SX1NUUklO Ryh4KSBcCi0gIENIRUNLX1RZUEUgKFZFQ1RPUlAgKHgpIHx8IFNUUklOR1AgKHgpLCBRYXJy YXlwLCB4KQotCi0jZGVmaW5lIENIRUNLX0FSUkFZKHgsIFF4eHhwKSBcCi0gIENIRUNLX1RZ UEUgKEFSUkFZUCAoeCksIFF4eHhwLCB4KQotCi0jZGVmaW5lIENIRUNLX1ZFQ1RPUl9PUl9D SEFSX1RBQkxFKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoVkVDVE9SUCAoeCkgfHwgQ0hBUl9UQUJM RV9QICh4KSwgUXZlY3Rvcl9vcl9jaGFyX3RhYmxlX3AsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tf QlVGRkVSKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoQlVGRkVSUCAoeCksIFFidWZmZXJwLCB4KQot Ci0jZGVmaW5lIENIRUNLX1dJTkRPVyh4KSBcCi0gIENIRUNLX1RZUEUgKFdJTkRPV1AgKHgp LCBRd2luZG93cCwgeCkKLQotI2RlZmluZSBDSEVDS19XSU5ET1dfQ09ORklHVVJBVElPTih4 KSBcCi0gIENIRUNLX1RZUEUgKFdJTkRPV19DT05GSUdVUkFUSU9OUCAoeCksIFF3aW5kb3df Y29uZmlndXJhdGlvbl9wLCB4KQotCi0vKiBUaGlzIG1hY3JvIHJlamVjdHMgd2luZG93cyBv biB0aGUgaW50ZXJpb3Igb2YgdGhlIHdpbmRvdyB0cmVlIGFzCi0gICAiZGVhZCIsIHdoaWNo IGlzIHdoYXQgd2Ugd2FudDsgdGhpcyBpcyBhbiBhcmd1bWVudC1jaGVja2luZyBtYWNybywg YW5kCi0gICB0aGUgdXNlciBzaG91bGQgbmV2ZXIgZ2V0IGFjY2VzcyB0byBpbnRlcmlvciB3 aW5kb3dzLgotCi0gICBBIHdpbmRvdyBvZiBhbnkgc29ydCwgbGVhZiBvciBpbnRlcmlvciwg aXMgZGVhZCBpZiB0aGUgYnVmZmVyLAotICAgdmNoaWxkLCBhbmQgaGNoaWxkIG1lbWJlcnMg YXJlIGFsbCBuaWwuICAqLwotCi0jZGVmaW5lIENIRUNLX0xJVkVfV0lORE9XKHgpIFwKLSAg Q0hFQ0tfVFlQRSAoV0lORE9XUCAoeCkgJiYgIU5JTFAgKFhXSU5ET1cgKHgpLT5idWZmZXIp LCBRd2luZG93X2xpdmVfcCwgeCkKLQotI2RlZmluZSBDSEVDS19QUk9DRVNTKHgpIFwKLSAg Q0hFQ0tfVFlQRSAoUFJPQ0VTU1AgKHgpLCBRcHJvY2Vzc3AsIHgpCi0KLSNkZWZpbmUgQ0hF Q0tfU1VCUih4KSBcCi0gIENIRUNLX1RZUEUgKFNVQlJQICh4KSwgUXN1YnJwLCB4KQotCi0j ZGVmaW5lIENIRUNLX05VTUJFUih4KSBcCi0gIENIRUNLX1RZUEUgKElOVEVHRVJQICh4KSwg UWludGVnZXJwLCB4KQotCi0jZGVmaW5lIENIRUNLX05BVE5VTSh4KSBcCi0gIENIRUNLX1RZ UEUgKE5BVE5VTVAgKHgpLCBRd2hvbGVudW1wLCB4KQorc3RhdGljIGlubGluZSB2b2lkCitD SEVDS19MSVNUIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChDT05TUCAoeCkg fHwgTklMUCAoeCksIFFsaXN0cCwgeCk7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQKKyhDSEVD S19MSVNUX0NPTlMpIChMaXNwX09iamVjdCB4LCBMaXNwX09iamVjdCB5KQoreworICBDSEVD S19UWVBFIChDT05TUCAoeCksIFFsaXN0cCwgeSk7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQK K0NIRUNLX0xJU1RfRU5EIChMaXNwX09iamVjdCB4LCBMaXNwX09iamVjdCB5KQoreworICBD SEVDS19UWVBFIChOSUxQICh4KSwgUWxpc3RwLCB5KTsKK30KK3N0YXRpYyBpbmxpbmUgdm9p ZAorQ0hFQ0tfU1RSSU5HIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChTVFJJ TkdQICh4KSwgUXN0cmluZ3AsIHgpOworfQorc3RhdGljIGlubGluZSB2b2lkCitDSEVDS19T VFJJTkdfQ0FSIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChTVFJJTkdQIChY Q0FSICh4KSksIFFzdHJpbmdwLCBYQ0FSICh4KSk7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQK K0NIRUNLX0NPTlMgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKENPTlNQICh4 KSwgUWNvbnNwLCB4KTsKK30KK3N0YXRpYyBpbmxpbmUgdm9pZAorKENIRUNLX1NZTUJPTCkg KExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKFNZTUJPTFAgKHgpLCBRc3ltYm9s cCwgeCk7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQKK0NIRUNLX0NIQVJfVEFCTEUgKExpc3Bf T2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKENIQVJfVEFCTEVfUCAoeCksIFFjaGFyX3Rh YmxlX3AsIHgpOworfQorc3RhdGljIGlubGluZSB2b2lkCitDSEVDS19WRUNUT1IgKExpc3Bf T2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKFZFQ1RPUlAgKHgpLCBRdmVjdG9ycCwgeCk7 Cit9CitzdGF0aWMgaW5saW5lIHZvaWQKK0NIRUNLX1ZFQ1RPUl9PUl9TVFJJTkcgKExpc3Bf T2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKFZFQ1RPUlAgKHgpIHx8IFNUUklOR1AgKHgp LCBRYXJyYXlwLCB4KTsKK30KK3N0YXRpYyBpbmxpbmUgdm9pZAorQ0hFQ0tfQVJSQVkgKExp c3BfT2JqZWN0IHgsIExpc3BfT2JqZWN0IFF4eHhwKQoreworICBDSEVDS19UWVBFIChBUlJB WVAgKHgpLCBReHh4cCwgeCk7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQKK0NIRUNLX1ZFQ1RP Ul9PUl9DSEFSX1RBQkxFIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChWRUNU T1JQICh4KSB8fCBDSEFSX1RBQkxFX1AgKHgpLCBRdmVjdG9yX29yX2NoYXJfdGFibGVfcCwg eCk7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQKK0NIRUNLX0JVRkZFUiAoTGlzcF9PYmplY3Qg eCkKK3sKKyAgQ0hFQ0tfVFlQRSAoQlVGRkVSUCAoeCksIFFidWZmZXJwLCB4KTsKK30KK3N0 YXRpYyBpbmxpbmUgdm9pZAorQ0hFQ0tfV0lORE9XIChMaXNwX09iamVjdCB4KQoreworICBD SEVDS19UWVBFIChXSU5ET1dQICh4KSwgUXdpbmRvd3AsIHgpOworfQorc3RhdGljIGlubGlu ZSB2b2lkCitDSEVDS19XSU5ET1dfQ09ORklHVVJBVElPTiAoTGlzcF9PYmplY3QgeCkKK3sK KyAgQ0hFQ0tfVFlQRSAoV0lORE9XX0NPTkZJR1VSQVRJT05QICh4KSwgUXdpbmRvd19jb25m aWd1cmF0aW9uX3AsIHgpOworfQorc3RhdGljIGlubGluZSB2b2lkCitDSEVDS19QUk9DRVNT IChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChQUk9DRVNTUCAoeCksIFFwcm9j ZXNzcCwgeCk7Cit9CitzdGF0aWMgaW5saW5lIHZvaWQKK0NIRUNLX1NVQlIgKExpc3BfT2Jq ZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKFNVQlJQICh4KSwgUXN1YnJwLCB4KTsKK30KK3N0 YXRpYyBpbmxpbmUgdm9pZAorKENIRUNLX05VTUJFUikgKExpc3BfT2JqZWN0IHgpCit7Cisg IENIRUNLX1RZUEUgKElOVEVHRVJQICh4KSwgUWludGVnZXJwLCB4KTsKK30KK3N0YXRpYyBp bmxpbmUgdm9pZAorQ0hFQ0tfTkFUTlVNIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19U WVBFIChOQVROVU1QICh4KSwgUXdob2xlbnVtcCwgeCk7Cit9CiAKICNkZWZpbmUgQ0hFQ0tf UkFOR0VEX0lOVEVHRVIoeCwgbG8sIGhpKQkJCQkJXAogICBkbyB7CQkJCQkJCQkJXApAQCAt MTc1Miw1NyArMjI5Miw3NiBAQAogICAgICAgQ0hFQ0tfUkFOR0VEX0lOVEVHRVIgKHgsIDAs IFRZUEVfTUFYSU1VTSAodHlwZSkpOwkJCVwKICAgfSB3aGlsZSAoMCkKIAotI2RlZmluZSBD SEVDS19NQVJLRVIoeCkgXAotICBDSEVDS19UWVBFIChNQVJLRVJQICh4KSwgUW1hcmtlcnAs IHgpCitzdGF0aWMgaW5saW5lIHZvaWQKK0NIRUNLX01BUktFUiAoTGlzcF9PYmplY3QgeCkK K3sKKyAgQ0hFQ0tfVFlQRSAoTUFSS0VSUCAoeCksIFFtYXJrZXJwLCB4KTsKK30KIAogI2Rl ZmluZSBDSEVDS19OVU1CRVJfQ09FUkNFX01BUktFUih4KSBcCiAgIGRvIHsgaWYgKE1BUktF UlAgKCh4KSkpIFhTRVRGQVNUSU5UICh4LCBtYXJrZXJfcG9zaXRpb24gKHgpKTsgXAogICAg IGVsc2UgQ0hFQ0tfVFlQRSAoSU5URUdFUlAgKHgpLCBRaW50ZWdlcl9vcl9tYXJrZXJfcCwg eCk7IH0gd2hpbGUgKDApCiAKLSNkZWZpbmUgWEZMT0FUSU5UKG4pIGV4dHJhY3RfZmxvYXQo KG4pKQotCi0jZGVmaW5lIENIRUNLX0ZMT0FUKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoRkxPQVRQ ICh4KSwgUWZsb2F0cCwgeCkKLQotI2RlZmluZSBDSEVDS19OVU1CRVJfT1JfRkxPQVQoeCkg XAotICBDSEVDS19UWVBFIChGTE9BVFAgKHgpIHx8IElOVEVHRVJQICh4KSwgUW51bWJlcnAs IHgpCitzdGF0aWMgaW5saW5lIGRvdWJsZQorWEZMT0FUSU5UIChMaXNwX09iamVjdCBuKQor eworICByZXR1cm4gZXh0cmFjdF9mbG9hdCAobik7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9p ZAorQ0hFQ0tfRkxPQVQgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKEZMT0FU UCAoeCksIFFmbG9hdHAsIHgpOworfQorc3RhdGljIGlubGluZSB2b2lkCitDSEVDS19OVU1C RVJfT1JfRkxPQVQgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKEZMT0FUUCAo eCkgfHwgSU5URUdFUlAgKHgpLCBRbnVtYmVycCwgeCk7Cit9CiAKICNkZWZpbmUgQ0hFQ0tf TlVNQkVSX09SX0ZMT0FUX0NPRVJDRV9NQVJLRVIoeCkgXAogICBkbyB7IGlmIChNQVJLRVJQ ICh4KSkgWFNFVEZBU1RJTlQgKHgsIG1hcmtlcl9wb3NpdGlvbiAoeCkpOyBcCiAgICAgZWxz ZSBDSEVDS19UWVBFIChJTlRFR0VSUCAoeCkgfHwgRkxPQVRQICh4KSwgUW51bWJlcl9vcl9t YXJrZXJfcCwgeCk7IH0gd2hpbGUgKDApCiAKLSNkZWZpbmUgQ0hFQ0tfT1ZFUkxBWSh4KSBc Ci0gIENIRUNLX1RZUEUgKE9WRVJMQVlQICh4KSwgUW92ZXJsYXlwLCB4KQorc3RhdGljIGlu bGluZSB2b2lkCitDSEVDS19PVkVSTEFZIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19U WVBFIChPVkVSTEFZUCAoeCksIFFvdmVybGF5cCwgeCk7Cit9CiAKIC8qIFNpbmNlIHdlIGNh bid0IGFzc2lnbiBkaXJlY3RseSB0byB0aGUgQ0FSIG9yIENEUiBmaWVsZHMgb2YgYSBjb25z CiAgICBjZWxsLCB1c2UgdGhlc2Ugd2hlbiBjaGVja2luZyB0aGF0IHRob3NlIGZpZWxkcyBj b250YWluIG51bWJlcnMuICAqLwotI2RlZmluZSBDSEVDS19OVU1CRVJfQ0FSKHgpIFwKLSAg ZG8gewkJCQkJXAotICAgIExpc3BfT2JqZWN0IHRtcCA9IFhDQVIgKHgpOwkJXAotICAgIENI RUNLX05VTUJFUiAodG1wKTsJCQlcCi0gICAgWFNFVENBUiAoKHgpLCB0bXApOwkJCVwKLSAg fSB3aGlsZSAoMCkKLQotI2RlZmluZSBDSEVDS19OVU1CRVJfQ0RSKHgpIFwKLSAgZG8gewkJ CQkJXAotICAgIExpc3BfT2JqZWN0IHRtcCA9IFhDRFIgKHgpOwkJXAotICAgIENIRUNLX05V TUJFUiAodG1wKTsJCQlcCi0gICAgWFNFVENEUiAoKHgpLCB0bXApOwkJCVwKLSAgfSB3aGls ZSAoMCkKLQotI2RlZmluZSBDSEVDS19OQVROVU1fQ0FSKHgpIFwKLSAgZG8gewkJCQkJXAot ICAgIExpc3BfT2JqZWN0IHRtcCA9IFhDQVIgKHgpOwkJXAotICAgIENIRUNLX05BVE5VTSAo dG1wKTsJCQlcCi0gICAgWFNFVENBUiAoKHgpLCB0bXApOwkJCVwKLSAgfSB3aGlsZSAoMCkK LQotI2RlZmluZSBDSEVDS19OQVROVU1fQ0RSKHgpIFwKLSAgZG8gewkJCQkJXAotICAgIExp c3BfT2JqZWN0IHRtcCA9IFhDRFIgKHgpOwkJXAotICAgIENIRUNLX05BVE5VTSAodG1wKTsJ CQlcCi0gICAgWFNFVENEUiAoKHgpLCB0bXApOwkJCVwKLSAgfSB3aGlsZSAoMCkKK3N0YXRp YyBpbmxpbmUgdm9pZAorQ0hFQ0tfTlVNQkVSX0NBUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAg TGlzcF9PYmplY3QgdG1wID0gWENBUiAoeCk7CisgIENIRUNLX05VTUJFUiAodG1wKTsKKyAg WFNFVENBUiAoeCwgdG1wKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkCitDSEVDS19OVU1C RVJfQ0RSIChMaXNwX09iamVjdCB4KQoreworICBMaXNwX09iamVjdCB0bXAgPSBYQ0RSICh4 KTsKKyAgQ0hFQ0tfTlVNQkVSICh0bXApOworICBYU0VUQ0RSICh4LCB0bXApOworfQorCitz dGF0aWMgaW5saW5lIHZvaWQKK0NIRUNLX05BVE5VTV9DQVIgKExpc3BfT2JqZWN0IHgpCit7 CisgIExpc3BfT2JqZWN0IHRtcCA9IFhDQVIgKHgpOworICBDSEVDS19OQVROVU0gKHRtcCk7 CisgIFhTRVRDQVIgKHgsIHRtcCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAorQ0hFQ0tf TkFUTlVNX0NEUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgTGlzcF9PYmplY3QgdG1wID0gWENE UiAoeCk7CisgIENIRUNLX05BVE5VTSAodG1wKTsKKyAgWFNFVENEUiAoeCwgdG1wKTsKK30K IAwKIC8qIERlZmluZSBhIGJ1aWx0LWluIGZ1bmN0aW9uIGZvciBjYWxsaW5nIGZyb20gTGlz cC4KICBgbG5hbWUnIHNob3VsZCBiZSB0aGUgbmFtZSB0byBnaXZlIHRoZSBmdW5jdGlvbiBp biBMaXNwLApAQCAtMTg2OSwxOCArMjQyOCwyMCBAQAogCQkJIExpc3BfT2JqZWN0LCBMaXNw X09iamVjdCwgTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0KQogCiAvKiBOb24temVybyBpZiBP QkogaXMgYSBMaXNwIGZ1bmN0aW9uLiAgKi8KLSNkZWZpbmUgRlVOQ1RJT05QKE9CSikJCQkJ CVwKLSAgICAgKChDT05TUCAoT0JKKSAmJiBFUSAoWENBUiAoT0JKKSwgUWxhbWJkYSkpCQlc Ci0gICAgICB8fCAoU1lNQk9MUCAoT0JKKSAmJiAhTklMUCAoRmZib3VuZHAgKE9CSikpKQlc Ci0gICAgICB8fCBDT01QSUxFRFAgKE9CSikJCQkJXAotICAgICAgfHwgU1VCUlAgKE9CSikp CitzdGF0aWMgaW5saW5lIGludAorRlVOQ1RJT05QIChMaXNwX09iamVjdCBvYmopCit7Cisg IHJldHVybiAoKENPTlNQIChvYmopICYmIEVRIChYQ0FSIChvYmopLCBRbGFtYmRhKSkKKwkg IHx8IChTWU1CT0xQIChvYmopICYmICFOSUxQIChGZmJvdW5kcCAob2JqKSkpCisJICB8fCBD T01QSUxFRFAgKG9iaikKKwkgIHx8IFNVQlJQIChvYmopKTsKK30KIAogLyogZGVmc3ViciAo U25hbWUpOwogICAgaXMgaG93IHdlIGRlZmluZSB0aGUgc3ltYm9sIGZvciBmdW5jdGlvbiBg bmFtZScgYXQgc3RhcnQtdXAgdGltZS4gICovCiBleHRlcm4gdm9pZCBkZWZzdWJyIChzdHJ1 Y3QgTGlzcF9TdWJyICopOwogCi0jZGVmaW5lIE1BTlkgLTIKLSNkZWZpbmUgVU5FVkFMTEVE IC0xCitlbnVtIHsgTUFOWSA9IC0yLCBVTkVWQUxMRUQgPSAtMSB9OwogCiBleHRlcm4gdm9p ZCBkZWZ2YXJfbGlzcCAoc3RydWN0IExpc3BfT2JqZndkICosIGNvbnN0IGNoYXIgKiwgTGlz cF9PYmplY3QgKik7CiBleHRlcm4gdm9pZCBkZWZ2YXJfbGlzcF9ub3BybyAoc3RydWN0IExp c3BfT2JqZndkICosIGNvbnN0IGNoYXIgKiwgTGlzcF9PYmplY3QgKik7CkBAIC0xOTczLDcg KzI1MzQsMTEgQEAKIGV4dGVybiBzdHJ1Y3Qgc3BlY2JpbmRpbmcgKnNwZWNwZGxfcHRyOwog ZXh0ZXJuIHB0cmRpZmZfdCBzcGVjcGRsX3NpemU7CiAKLSNkZWZpbmUgU1BFQ1BETF9JTkRF WCgpCShzcGVjcGRsX3B0ciAtIHNwZWNwZGwpCitzdGF0aWMgaW5saW5lIHB0cmRpZmZfdAor U1BFQ1BETF9JTkRFWCAodm9pZCkKK3sKKyAgcmV0dXJuIHNwZWNwZGxfcHRyIC0gc3BlY3Bk bDsKK30KIAogLyogRXZlcnl0aGluZyBuZWVkZWQgdG8gZGVzY3JpYmUgYW4gYWN0aXZlIGNv bmRpdGlvbiBjYXNlLiAgKi8KIHN0cnVjdCBoYW5kbGVyCkBAIC0yMjgzLDYgKzI4NDgsOCBA QAogI2RlZmluZSBFWEZVTihmbm5hbWUsIG1heGFyZ3MpIFwKICAgZXh0ZXJuIExpc3BfT2Jq ZWN0IGZubmFtZSBERUZVTl9BUkdTXyAjIyBtYXhhcmdzCiAKKyNpbmNsdWRlICJnbG9iYWxz LmgiCisKIC8qIEZvcndhcmQgZGVjbGFyYXRpb25zIGZvciBwcm90b3R5cGVzLiAgKi8KIHN0 cnVjdCB3aW5kb3c7CiBzdHJ1Y3QgZnJhbWU7CkBAIC0yMzE3LDYgKzI4ODQsNyBAQAogZXh0 ZXJuIExpc3BfT2JqZWN0IFFpbnRlZ2VyLCBRaW50ZXJ2YWwsIFFzeW1ib2wsIFFzdHJpbmc7 CiBleHRlcm4gTGlzcF9PYmplY3QgUW1pc2MsIFF2ZWN0b3IsIFFmbG9hdCwgUWNvbnMsIFFi dWZmZXI7CiAKK2V4dGVybiBMaXNwX09iamVjdCBRc3VicnA7CiBleHRlcm4gTGlzcF9PYmpl Y3QgUWZvbnRfc3BlYywgUWZvbnRfZW50aXR5LCBRZm9udF9vYmplY3Q7CiAKIEVYRlVOIChG Ynl0ZW9yZGVyLCAwKSBBVFRSSUJVVEVfQ09OU1Q7CkBAIC0yNDExLDYgKzI5NzksNyBAQAog ZXh0ZXJuIExpc3BfT2JqZWN0IFFjdXJzb3JfaW5fZWNob19hcmVhOwogZXh0ZXJuIExpc3Bf T2JqZWN0IFFzdHJpbmdfbGVzc3A7CiBleHRlcm4gTGlzcF9PYmplY3QgUUNzaXplLCBRQ3Rl c3QsIFFDd2Vha25lc3MsIFFlcXVhbCwgUWVxLCBRZXFsOworZXh0ZXJuIExpc3BfT2JqZWN0 IFFoYXNoX3RhYmxlX3A7CiBFTUFDU19VSU5UIGhhc2hfc3RyaW5nIChjaGFyIGNvbnN0ICos IHB0cmRpZmZfdCk7CiBFTUFDU19VSU5UIHN4aGFzaCAoTGlzcF9PYmplY3QsIGludCk7CiBM aXNwX09iamVjdCBtYWtlX2hhc2hfdGFibGUgKExpc3BfT2JqZWN0LCBMaXNwX09iamVjdCwg TGlzcF9PYmplY3QsCkBAIC0yNzA2LDcgKzMyNzUsNyBAQAogCQkJCSBMaXNwX09iamVjdCk7 CiBleHRlcm4gTGlzcF9PYmplY3QgaW50ZXJuYWxfd2l0aF9vdXRwdXRfdG9fdGVtcF9idWZm ZXIKICAgICAgICAgKGNvbnN0IGNoYXIgKiwgTGlzcF9PYmplY3QgKCopIChMaXNwX09iamVj dCksIExpc3BfT2JqZWN0KTsKLSNkZWZpbmUgRkxPQVRfVE9fU1RSSU5HX0JVRlNJWkUgMzUw CitlbnVtIHsgRkxPQVRfVE9fU1RSSU5HX0JVRlNJWkUgPSAzNTAgfTsKIGV4dGVybiBpbnQg ZmxvYXRfdG9fc3RyaW5nIChjaGFyICosIGRvdWJsZSk7CiBleHRlcm4gdm9pZCBzeW1zX29m X3ByaW50ICh2b2lkKTsKIApAQCAtMjcyOSwxMCArMzI5OCwxMiBAQAogZXh0ZXJuIExpc3Bf T2JqZWN0IGludGVybl8xIChjb25zdCBjaGFyICosIHB0cmRpZmZfdCk7CiBleHRlcm4gTGlz cF9PYmplY3QgaW50ZXJuX2Nfc3RyaW5nXzEgKGNvbnN0IGNoYXIgKiwgcHRyZGlmZl90KTsK IGV4dGVybiBMaXNwX09iamVjdCBvYmxvb2t1cCAoTGlzcF9PYmplY3QsIGNvbnN0IGNoYXIg KiwgcHRyZGlmZl90LCBwdHJkaWZmX3QpOwotI2RlZmluZSBMT0FESElTVF9BVFRBQ0goeCkg XAotICBkbyB7CQkJCQkJCQkJXAotICAgIGlmIChpbml0aWFsaXplZCkgVmN1cnJlbnRfbG9h ZF9saXN0ID0gRmNvbnMgKHgsIFZjdXJyZW50X2xvYWRfbGlzdCk7IFwKLSAgfSB3aGlsZSAo MCkKK3N0YXRpYyBpbmxpbmUgdm9pZAorTE9BREhJU1RfQVRUQUNIIChMaXNwX09iamVjdCB4 KQoreworICBpZiAoaW5pdGlhbGl6ZWQpCisgICAgVmN1cnJlbnRfbG9hZF9saXN0ID0gRmNv bnMgKHgsIFZjdXJyZW50X2xvYWRfbGlzdCk7Cit9CiBleHRlcm4gaW50IG9wZW5wIChMaXNw X09iamVjdCwgTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0LAogICAgICAgICAgICAgICAgICAg TGlzcF9PYmplY3QgKiwgTGlzcF9PYmplY3QpOwogTGlzcF9PYmplY3Qgc3RyaW5nX3RvX251 bWJlciAoY2hhciBjb25zdCAqLCBpbnQsIGludCk7CkBAIC0yODUwLDYgKzM0MjEsNyBAQAog ZXh0ZXJuIExpc3BfT2JqZWN0IFZidWZmZXJfYWxpc3Q7CiBleHRlcm4gTGlzcF9PYmplY3Qg c2V0X2J1ZmZlcl9pZl9saXZlIChMaXNwX09iamVjdCk7CiBleHRlcm4gTGlzcF9PYmplY3Qg b3RoZXJfYnVmZmVyX3NhZmVseSAoTGlzcF9PYmplY3QpOworZXh0ZXJuIExpc3BfT2JqZWN0 IFFvdmVybGF5cDsKIGV4dGVybiBMaXNwX09iamVjdCBRcHJpb3JpdHksIFF3aW5kb3csIFFi ZWZvcmVfc3RyaW5nLCBRYWZ0ZXJfc3RyaW5nOwogZXh0ZXJuIExpc3BfT2JqZWN0IGdldF90 cnVlbmFtZV9idWZmZXIgKExpc3BfT2JqZWN0KTsKIGV4dGVybiB2b2lkIGluaXRfYnVmZmVy X29uY2UgKHZvaWQpOwpAQCAtMzAwNywxMCArMzU3OSwxMCBAQAogdm9pZCBzeW5jaHJvbml6 ZV9zeXN0ZW1fbWVzc2FnZXNfbG9jYWxlICh2b2lkKTsKIHZvaWQgc3luY2hyb25pemVfc3lz dGVtX3RpbWVfbG9jYWxlICh2b2lkKTsKICNlbHNlCi0jZGVmaW5lIHNldGxvY2FsZShjYXRl Z29yeSwgbG9jYWxlKQotI2RlZmluZSBmaXh1cF9sb2NhbGUoKQotI2RlZmluZSBzeW5jaHJv bml6ZV9zeXN0ZW1fbWVzc2FnZXNfbG9jYWxlKCkKLSNkZWZpbmUgc3luY2hyb25pemVfc3lz dGVtX3RpbWVfbG9jYWxlKCkKK3N0YXRpYyBpbmxpbmUgY2hhciAqc2V0bG9jYWxlIChpbnQg Y2F0LCBjaGFyIGNvbnN0ICpsb2NhbGUpIHsgcmV0dXJuIDA7IH0KK3N0YXRpYyBpbmxpbmUg dm9pZCBmaXh1cF9sb2NhbGUgKHZvaWQpIHt9CitzdGF0aWMgaW5saW5lIHZvaWQgc3luY2hy b25pemVfc3lzdGVtX21lc3NhZ2VzX2xvY2FsZSAodm9pZCkge30KK3N0YXRpYyBpbmxpbmUg dm9pZCBzeW5jaHJvbml6ZV9zeXN0ZW1fdGltZV9sb2NhbGUgKHZvaWQpIHt9CiAjZW5kaWYK IHZvaWQgc2h1dF9kb3duX2VtYWNzIChpbnQsIGludCwgTGlzcF9PYmplY3QpOwogLyogTm9u emVybyBtZWFucyBkb24ndCBkbyBpbnRlcmFjdGl2ZSByZWRpc3BsYXkgYW5kIGRvbid0IGNo YW5nZSB0dHkgbW9kZXMuICAqLwpAQCAtMzI3MSwxOSArMzg0MywxOSBAQAogICAgaW4gYWRk aXRpb24gdG8gYSBkZXZpY2Ugc2VwYXJhdG9yLiAgU2V0IHRoZSBwYXRoIHNlcGFyYXRvcgog ICAgdG8gJy8nLCBhbmQgZG9uJ3QgdGVzdCBmb3IgYSBkZXZpY2Ugc2VwYXJhdG9yIGluIElT X0FOWV9TRVAuICAqLwogCi0jZGVmaW5lIERJUkVDVE9SWV9TRVAgJy8nCitlbnVtIHsgRElS RUNUT1JZX1NFUCA9ICcvJyB9OwogI2lmbmRlZiBJU19ESVJFQ1RPUllfU0VQCi0jZGVmaW5l IElTX0RJUkVDVE9SWV9TRVAoX2NfKSAoKF9jXykgPT0gRElSRUNUT1JZX1NFUCkKK3N0YXRp YyBpbmxpbmUgaW50IElTX0RJUkVDVE9SWV9TRVAgKGludCBjKSB7IHJldHVybiBjID09IERJ UkVDVE9SWV9TRVA7IH0KICNlbmRpZgogI2lmbmRlZiBJU19ERVZJQ0VfU0VQCiAjaWZuZGVm IERFVklDRV9TRVAKLSNkZWZpbmUgSVNfREVWSUNFX1NFUChfY18pIDAKK3N0YXRpYyBpbmxp bmUgaW50IElTX0RFVklDRV9TRVAgKGludCBjKSB7IHJldHVybiAwOyB9CiAjZWxzZQotI2Rl ZmluZSBJU19ERVZJQ0VfU0VQKF9jXykgKChfY18pID09IERFVklDRV9TRVApCitzdGF0aWMg aW5saW5lIGludCBJU19ERVZJQ0VfU0VQIChpbnQgYykgeyByZXR1cm4gYyA9PSBERVZJQ0Vf U0VQOyB9CiAjZW5kaWYKICNlbmRpZgogI2lmbmRlZiBJU19BTllfU0VQCi0jZGVmaW5lIElT X0FOWV9TRVAoX2NfKSAoSVNfRElSRUNUT1JZX1NFUCAoX2NfKSkKK3N0YXRpYyBpbmxpbmUg aW50IElTX0FOWV9TRVAgKGludCBjKSB7IHJldHVybiBJU19ESVJFQ1RPUllfU0VQIChjKTsg fQogI2VuZGlmCiAKICNkZWZpbmUgU1dJVENIX0VOVU1fQ0FTVCh4KSAoeCkKQEAgLTMzMDMs MTUgKzM4NzUsNiBAQAogIyBkZWZpbmUgbGludF9hc3N1bWUoY29uZCkgKCh2b2lkKSAoMCAm JiAoY29uZCkpKQogI2VuZGlmCiAKLS8qIFRoZSB1YmlxdWl0b3VzIG1pbiBhbmQgbWF4IG1h Y3Jvcy4gICovCi0KLSNpZmRlZiBtYXgKLSN1bmRlZiBtYXgKLSN1bmRlZiBtaW4KLSNlbmRp ZgotI2RlZmluZSBtaW4oYSwgYikJKChhKSA8IChiKSA/IChhKSA6IChiKSkKLSNkZWZpbmUg bWF4KGEsIGIpCSgoYSkgPiAoYikgPyAoYSkgOiAoYikpCi0KIC8qIFdlIHVzZWQgdG8gdXNl IGBhYnMnLCBidXQgdGhhdCBjbGFzaGVzIHdpdGggc3lzdGVtIGhlYWRlcnMgb24gc29tZQog ICAgcGxhdGZvcm1zLCBhbmQgdXNpbmcgYSBuYW1lIHJlc2VydmVkIGJ5IFN0YW5kYXJkIEMg aXMgYSBiYWQgaWRlYQogICAgYW55d2F5LiAgKi8KQEAgLTMzNTQsNyArMzkxNyw3IEBACiAv KiBTQUZFX0FMTE9DQSBub3JtYWxseSBhbGxvY2F0ZXMgbWVtb3J5IG9uIHRoZSBzdGFjaywg YnV0IGlmIHNpemUgaXMKICAgIGxhcmdlciB0aGFuIE1BWF9BTExPQ0EsIHVzZSB4bWFsbG9j IHRvIGF2b2lkIG92ZXJmbG93aW5nIHRoZSBzdGFjay4gICovCiAKLSNkZWZpbmUgTUFYX0FM TE9DQSAxNioxMDI0CitlbnVtIHsgTUFYX0FMTE9DQSA9IDE2KjEwMjQgfTsKIAogZXh0ZXJu IExpc3BfT2JqZWN0IHNhZmVfYWxsb2NhX3Vud2luZCAoTGlzcF9PYmplY3QpOwogCkBAIC0z NDI0LDggKzM5ODcsNiBAQAogICB9IHdoaWxlICgwKQogCiAKLSNpbmNsdWRlICJnbG9iYWxz LmgiCi0KIC8qIENoZWNrIHdoZXRoZXIgaXQncyB0aW1lIGZvciBHQywgYW5kIHJ1biBpdCBp ZiBzby4gICovCiAKIHN0YXRpYyBpbmxpbmUgdm9pZAoKPT09IG1vZGlmaWVkIGZpbGUgJ3Ny Yy9tZW0tbGltaXRzLmgnCi0tLSBzcmMvbWVtLWxpbWl0cy5oCTIwMTItMDctMDkgMTY6Mzg6 NDUgKzAwMDAKKysrIHNyYy9tZW0tbGltaXRzLmgJMjAxMi0wNy0xMyAwMzozNzo0MiArMDAw MApAQCAtMzYsOSArMzYsNyBAQAogZXh0ZXJuIGNoYXIgKnN0YXJ0X29mX2RhdGEgKHZvaWQp IEFUVFJJQlVURV9DT05TVDsKICNpZiBVU0VfTFNCX1RBRyB8fCBVSU5UUFRSX01BWCA8PSBW QUxfTUFYCiAjZGVmaW5lIEVYQ0VFRFNfTElTUF9QVFIocHRyKSAwCi0jZWxpZiBkZWZpbmVk IERBVEFfU0VHX0JJVFMKKyNlbHNlCiAjZGVmaW5lIEVYQ0VFRFNfTElTUF9QVFIocHRyKSBc CiAgICgoKHVpbnRwdHJfdCkgKHB0cikgJiB+REFUQV9TRUdfQklUUykgPj4gVkFMQklUUykK LSNlbHNlCi0jZGVmaW5lIEVYQ0VFRFNfTElTUF9QVFIocHRyKSAoKHVpbnRwdHJfdCkgKHB0 cikgPj4gVkFMQklUUykKICNlbmRpZgoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy93aW5kb3cu YycKLS0tIHNyYy93aW5kb3cuYwkyMDEyLTA3LTIzIDE2OjU3OjIwICswMDAwCisrKyBzcmMv d2luZG93LmMJMjAxMi0wNy0yMyAyMTo1MDozNiArMDAwMApAQCAtNTEsOCArNTEsOCBAQAog I2luY2x1ZGUgIm5zdGVybS5oIgogI2VuZGlmCiAKLUxpc3BfT2JqZWN0IFF3aW5kb3dwLCBR d2luZG93X2xpdmVfcDsKLXN0YXRpYyBMaXNwX09iamVjdCBRd2luZG93X2NvbmZpZ3VyYXRp b25fcCwgUXJlY29yZF93aW5kb3dfYnVmZmVyOworTGlzcF9PYmplY3QgUXdpbmRvd3AsIFF3 aW5kb3dfbGl2ZV9wLCBRd2luZG93X2NvbmZpZ3VyYXRpb25fcDsKK3N0YXRpYyBMaXNwX09i amVjdCBRcmVjb3JkX3dpbmRvd19idWZmZXI7CiBzdGF0aWMgTGlzcF9PYmplY3QgUXdpbmRv d19kZWxldGFibGVfcCwgUWRlbGV0ZV93aW5kb3csIFFkaXNwbGF5X2J1ZmZlcjsKIHN0YXRp YyBMaXNwX09iamVjdCBRcmVwbGFjZV9idWZmZXJfaW5fd2luZG93cywgUWdldF9tcnVfd2lu ZG93Owogc3RhdGljIExpc3BfT2JqZWN0IFF3aW5kb3dfcmVzaXplX3Jvb3Rfd2luZG93LCBR d2luZG93X3Jlc2l6ZV9yb290X3dpbmRvd192ZXJ0aWNhbGx5OwoKPT09IG1vZGlmaWVkIGZp bGUgJ3NyYy93aW5kb3cuaCcKLS0tIHNyYy93aW5kb3cuaAkyMDEyLTA3LTA1IDE1OjIwOjEy ICswMDAwCisrKyBzcmMvd2luZG93LmgJMjAxMi0wNy0xMyAwMzozNzo0MiArMDAwMApAQCAt ODg1LDcgKzg4NSw3IEBACiAKIC8qIFRoZXNlIHVzZWQgdG8gYmUgaW4gbGlzcC5oLiAgKi8K IAotZXh0ZXJuIExpc3BfT2JqZWN0IFF3aW5kb3dwLCBRd2luZG93X2xpdmVfcDsKK2V4dGVy biBMaXNwX09iamVjdCBRd2luZG93X2xpdmVfcDsKIGV4dGVybiBMaXNwX09iamVjdCBWd2lu ZG93X2xpc3Q7CiAKIGV4dGVybiBpbnQgY29tcGFyZV93aW5kb3dfY29uZmlndXJhdGlvbnMg KExpc3BfT2JqZWN0LCBMaXNwX09iamVjdCwgaW50KTsKQEAgLTkwMCw0ICs5MDAsMTcgQEAK IGV4dGVybiB2b2lkIHN5bXNfb2Zfd2luZG93ICh2b2lkKTsKIGV4dGVybiB2b2lkIGtleXNf b2Zfd2luZG93ICh2b2lkKTsKIAorLyogQ0hFQ0tfTElWRV9XSU5ET1cgcmVqZWN0cyB3aW5k b3dzIG9uIHRoZSBpbnRlcmlvciBvZiB0aGUgd2luZG93IHRyZWUgYXMKKyAgICJkZWFkIiwg d2hpY2ggaXMgd2hhdCB3ZSB3YW50OyB0aGlzIGlzIGFuIGFyZ3VtZW50LWNoZWNraW5nIGZ1 bmN0aW9uLCBhbmQKKyAgIHRoZSB1c2VyIHNob3VsZCBuZXZlciBnZXQgYWNjZXNzIHRvIGlu dGVyaW9yIHdpbmRvd3MuCisKKyAgIEEgd2luZG93IG9mIGFueSBzb3J0LCBsZWFmIG9yIGlu dGVyaW9yLCBpcyBkZWFkIGlmIHRoZSBidWZmZXIsCisgICB2Y2hpbGQsIGFuZCBoY2hpbGQg bWVtYmVycyBhcmUgYWxsIG5pbC4gICovCitzdGF0aWMgaW5saW5lIHZvaWQKK0NIRUNLX0xJ VkVfV0lORE9XIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChXSU5ET1dQICh4 KSAmJiAhTklMUCAoWFdJTkRPVyAoeCktPmJ1ZmZlciksIFF3aW5kb3dfbGl2ZV9wLCB4KTsK K30KKworCiAjZW5kaWYgLyogbm90IFdJTkRPV19IX0lOQ0xVREVEICovCg== --------------030501010209060903070607-- From debbugs-submit-bounces@debbugs.gnu.org Tue Jul 24 05:14:32 2012 Received: (at 11935) by debbugs.gnu.org; 24 Jul 2012 09:14:32 +0000 Received: from localhost ([127.0.0.1]:34694 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1StbCK-0003cJ-5x for submit@debbugs.gnu.org; Tue, 24 Jul 2012 05:14:32 -0400 Received: from pruche.dit.umontreal.ca ([132.204.246.22]:43035) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1StbCI-0003cC-7Y for 11935@debbugs.gnu.org; Tue, 24 Jul 2012 05:14:30 -0400 Received: from fmsmemgm.homelinux.net (lechon.iro.umontreal.ca [132.204.27.242]) by pruche.dit.umontreal.ca (8.14.1/8.14.1) with ESMTP id q6O97ftq002840; Tue, 24 Jul 2012 05:07:42 -0400 Received: by fmsmemgm.homelinux.net (Postfix, from userid 20848) id 597DBAE323; Tue, 24 Jul 2012 05:07:39 -0400 (EDT) From: Stefan Monnier To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions Message-ID: References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> <500499C7.20902@cs.ucla.edu> <83txx79jgx.fsf@gnu.org> <500E0657.4050604@cs.ucla.edu> Date: Tue, 24 Jul 2012 05:07:39 -0400 In-Reply-To: <500E0657.4050604@cs.ucla.edu> (Paul Eggert's message of "Mon, 23 Jul 2012 19:20:07 -0700") User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.1.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-NAI-Spam-Flag: NO X-NAI-Spam-Level: X-NAI-Spam-Threshold: 5 X-NAI-Spam-Score: 0.7 X-NAI-Spam-Rules: 3 Rules triggered SUBJ_END_DOT_WORDS=0.5, GEN_SPAM_FEATRE=0.2, RV4288=0 X-NAI-Spam-Version: 2.2.0.9309 : core <4288> : streams <789714> : uri <1173363> X-Spam-Score: -3.5 (---) X-Debbugs-Envelope-To: 11935 Cc: 11935@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: -3.5 (---) > results. So instead of using always_inline, it's better to > do this performance-critical inlining by hand. I did that Could you separate this part of the patch, since I don't know what you mean by "inlining by hand". Stefan From debbugs-submit-bounces@debbugs.gnu.org Tue Jul 24 09:52:08 2012 Received: (at 11935) by debbugs.gnu.org; 24 Jul 2012 13:52:08 +0000 Received: from localhost ([127.0.0.1]:35415 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1StfWx-0003B2-I3 for submit@debbugs.gnu.org; Tue, 24 Jul 2012 09:52:08 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:59550) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1StfWu-0003At-68 for 11935@debbugs.gnu.org; Tue, 24 Jul 2012 09:52:07 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id A44BCA60004; Tue, 24 Jul 2012 06:45:23 -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 HdOB-v4ISYBL; Tue, 24 Jul 2012 06:45:22 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 6BBD8A60002; Tue, 24 Jul 2012 06:45:22 -0700 (PDT) Message-ID: <500EA6F7.6080609@cs.ucla.edu> Date: Tue, 24 Jul 2012 06:45:27 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:14.0) Gecko/20120714 Thunderbird/14.0 MIME-Version: 1.0 To: Stefan Monnier Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> <500499C7.20902@cs.ucla.edu> <83txx79jgx.fsf@gnu.org> <500E0657.4050604@cs.ucla.edu> In-Reply-To: Content-Type: multipart/mixed; boundary="------------020406010201050504050309" X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@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 (-) This is a multi-part message in MIME format. --------------020406010201050504050309 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 07/24/2012 02:07 AM, Stefan Monnier wrote: > Could you separate this part of the patch, since I don't know what you > mean by "inlining by hand". Sure, attached; this assumes the earlier patch in has been applied and merged. --------------020406010201050504050309 Content-Type: text/plain; charset=UTF-8; name="inline-by-hand.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="inline-by-hand.txt" MjAxMi0wNy0yNCAgUGF1bCBFZ2dlcnQgIDxlZ2dlcnRAY3MudWNsYS5lZHU+CiAKCSogbGlz cC5oIChYTEksIFhJTCwgQ0hFQ0tfVFlQRSwgQ0hFQ0tfTElTVF9DT05TLCBDSEVDS19OVU1C RVIpCgkoQ0hFQ0tfU1lNQk9MLCBDT05TUCwgRVEsIEZMT0FUUCwgSU5URUdFUlAsIExJU1Bf SU5UX1RBR19QLCBNQVJLRVJQKQoJKE1JU0NQLCBOSUxQLCBTRVRfU1lNQk9MX1ZBTCwgU1lN Qk9MX0NPTlNUQU5UX1AsIFNZTUJPTF9WQUwsIFNZTUJPTFApCgkoVkVDVE9STElLRVAsIFhD QVIsIFhDRFIsIFhDT05TLCBYSEFTSCwgWFBOVFIsIFhTWU1CT0wpOgoJSWYgY29tcGlsaW5n IHZpYSBHQ0Mgd2l0aG91dCBvcHRpbWl6YXRpb24sIGlubGluZSB0aGVzZSBmdW5jdGlvbnMK CW1hbnVhbGx5LCBieSBkZWZpbmluZyBtYWNyb3MgaW4gYWRkaXRpb24gdG8gaW5saW5lIGZ1 bmN0aW9ucy4KCVRvIGRpc2FibGUgdGhpcywgY29tcGlsZSB3aXRoIC1ESU5MSU5JTkc9MC4K CShtYWtlX251bWJlciwgWEZBU1RJTlQsIFhJTlQsIFhUWVBFLCBYVU5UQUcpOiBMaWtld2lz ZSwgYnV0CgloYW5kLW9wdGltaXplIG9ubHkgaW4gdGhlIFVTRV9MU0JfVEFHIGNhc2UsIGFz IEdOVWlzaCBob3N0cyBkbyB0aGF0LgoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9saXNwLmgn Ci0tLSBzcmMvbGlzcC5oCTIwMTItMDctMjMgMjE6NTg6MTAgKzAwMDAKKysrIHNyYy9saXNw LmgJMjAxMi0wNy0yNCAwMTo1NzoxOCArMDAwMApAQCAtMjE0LDYgKzIxNCw2MiBAQAogI2Vu ZGlmCiAKIAorLyogV2hlbiBjb21waWxpbmcgdmlhIEdDQyB3aXRob3V0IG9wdGltaXphdGlv biwgaW5saW5lIGEgZmV3IGZ1bmN0aW9ucworICAgbWFudWFsbHksIGFzIEVtYWNzIGlzIHRv byBzbG93IG90aGVyd2lzZS4gIFRoZXJlJ3Mgbm8gbmVlZCB0bworICAgaW5saW5lIGV2ZXJ5 dGhpbmcsIGp1c3QgdGhlIGZ1bmN0aW9ucyB0aGF0IHdvdWxkIGNhdXNlIGEgc2VyaW91cwor ICAgcGVyZm9ybWFuY2UgcHJvYmxlbSB3aGVuIGRlYnVnZ2luZy4gIFRvIGRpc2FibGUgdGhp cyBoYW5kLW9wdGltaXphdGlvbiwKKyAgIGNvbXBpbGUgd2l0aCAtRElOTElOSU5HPTAuCisK KyAgIENvbW1lbnRhcnkgZm9yIHRoZXNlIG1hY3JvcyBjYW4gYmUgZm91bmQgbmVhciB0aGVp ciBjb3JyZXNwb25kaW5nCisgICBmdW5jdGlvbnMsIGJlbG93LiAgKi8KKyNpZiAoZGVmaW5l ZCBfX05PX0lOTElORV9fIFwKKyAgICAgJiYgISBkZWZpbmVkIF9fT1BUSU1JWkVfXyAmJiAh IGRlZmluZWQgX19PUFRJTUlaRV9TSVpFX18gXAorICAgICAmJiAhIChkZWZpbmVkIElOTElO SU5HICYmICEgSU5MSU5JTkcpKQorIyBpZiBDSEVDS19MSVNQX09CSkVDVF9UWVBFCisjICBk ZWZpbmUgWExJKG8pIChvKS5pCisjICBkZWZpbmUgWElMKGkpIChMaXNwX09iamVjdCkgeyBp IH0KKyMgZWxzZQorIyAgZGVmaW5lIFhMSShvKSAobykKKyMgIGRlZmluZSBYSUwoaSkgKGkp CisjIGVuZGlmCisjIGRlZmluZSBDSEVDS19UWVBFKG9rLCBReHh4cCwgeCkgXAorICAgICgo dm9pZCkgKChvaykgfHwgd3JvbmdfdHlwZV9hcmd1bWVudCAoUXh4eHAsIHgpKSkKKyMgZGVm aW5lIENIRUNLX0xJU1RfQ09OUyh4LCB5KSBDSEVDS19UWVBFIChDT05TUCAoeCksIFFsaXN0 cCwgeSkKKyMgZGVmaW5lIENIRUNLX05VTUJFUih4KSBDSEVDS19UWVBFIChJTlRFR0VSUCAo eCksIFFpbnRlZ2VycCwgeCkKKyMgZGVmaW5lIENIRUNLX1NZTUJPTCh4KSBDSEVDS19UWVBF IChTWU1CT0xQICh4KSwgUXN5bWJvbHAsIHgpCisjIGRlZmluZSBDT05TUCh4KSAoWFRZUEUg KHgpID09IExpc3BfQ29ucykKKyMgZGVmaW5lIEVRKGEsIGIpIChYSEFTSCAoYSkgPT0gWEhB U0ggKGIpKQorIyBkZWZpbmUgRkxPQVRQKHgpIChYVFlQRSAoeCkgPT0gTGlzcF9GbG9hdCkK KyMgZGVmaW5lIElOVEVHRVJQKHgpIExJU1BfSU5UX1RBR19QIChYVFlQRSAoeCkpCisjIGRl ZmluZSBMSVNQX0lOVF9UQUdfUCh4KSAoKCh4KSAmIH5MaXNwX0ludDEpID09IDApCisjIGRl ZmluZSBNQVJLRVJQKHgpIChNSVNDUCAoeCkgJiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01p c2NfTWFya2VyKQorIyBkZWZpbmUgTUlTQ1AoeCkgKFhUWVBFICh4KSA9PSBMaXNwX01pc2Mp CisjIGRlZmluZSBOSUxQKHgpIEVRICh4LCBRbmlsKQorIyBkZWZpbmUgU0VUX1NZTUJPTF9W QUwoc3ltLCB2KSBcCisgICAgKGVhc3NlcnQgKChzeW0pLT5yZWRpcmVjdCA9PSBTWU1CT0xf UExBSU5WQUwpLCAoc3ltKS0+dmFsLnZhbHVlID0gKHYpKQorIyBkZWZpbmUgU1lNQk9MX0NP TlNUQU5UX1Aoc3ltKSAoWFNZTUJPTCAoc3ltKS0+Y29uc3RhbnQpCisjIGRlZmluZSBTWU1C T0xfVkFMKHN5bSkJCQkJCQlcCisgICAgKGVhc3NlcnQgKChzeW0pLT5yZWRpcmVjdCA9PSBT WU1CT0xfUExBSU5WQUwpLCAoc3ltKS0+dmFsLnZhbHVlKQorIyBkZWZpbmUgU1lNQk9MUCh4 KSAoWFRZUEUgKHgpID09IExpc3BfU3ltYm9sKQorIyBkZWZpbmUgVkVDVE9STElLRVAoeCkg KFhUWVBFICh4KSA9PSBMaXNwX1ZlY3Rvcmxpa2UpCisjIGRlZmluZSBYQ0FSKGMpIFhDQVJf QVNfTFZBTFVFIChjKQorIyBkZWZpbmUgWENEUihjKSBYQ0RSX0FTX0xWQUxVRSAoYykKKyMg ZGVmaW5lIFhDT05TKGEpIFwKKyAgICAoZWFzc2VydCAoQ09OU1AgKGEpKSwgKHN0cnVjdCBM aXNwX0NvbnMgKikgWFVOVEFHIChhLCBMaXNwX0NvbnMpKQorIyBkZWZpbmUgWEhBU0gobykg WExJIChvKQorIyBkZWZpbmUgWFBOVFIoYSkgKCh2b2lkICopIChpbnRwdHJfdCkgKChYTEkg KGEpICYgVkFMTUFTSykgfCBEQVRBX1NFR19CSVRTKSkKKyMgZGVmaW5lIFhTWU1CT0woYSkg XAorICAgIChlYXNzZXJ0IChTWU1CT0xQIChhKSksIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKikg WFVOVEFHIChhLCBMaXNwX1N5bWJvbCkpCisjIGlmIFVTRV9MU0JfVEFHCisjICBkZWZpbmUg bWFrZV9udW1iZXIobikgWElMICgoRU1BQ1NfSU5UKSAobikgPDwgSU5UVFlQRUJJVFMpCisj ICBkZWZpbmUgWEZBU1RJTlQoYSkgWElOVCAoYSkKKyMgIGRlZmluZSBYSU5UKGEpIChYTEkg KGEpID4+IElOVFRZUEVCSVRTKQorIyAgZGVmaW5lIFhUWVBFKGEpICgoZW51bSBMaXNwX1R5 cGUpIChYTEkgKGEpICYgflZBTE1BU0spKQorIyAgZGVmaW5lIFhVTlRBRyhhLCB0eXBlKSAo KHZvaWQgKikgKFhMSSAoYSkgLSAodHlwZSkpKQorIyBlbmRpZgorI2VuZGlmCisKKwogLyog RGVmaW5lIHRoZSBmdW5kYW1lbnRhbCBMaXNwIGRhdGEgc3RydWN0dXJlcy4gICovCiAKIC8q IFRoaXMgaXMgdGhlIHNldCBvZiBMaXNwIGRhdGEgdHlwZXMuICAqLwpAQCAtMjY2LDcgKzMy Miw3IEBACiAvKiBBbiBvbGRlciBuYW1lIGZvciBMaXNwX0ludDAuICAqLwogZW51bSB7IExJ U1BfSU5UX1RBRyA9IExpc3BfSW50MCB9OwogCi1zdGF0aWMgaW5saW5lIGludCBMSVNQX0lO VF9UQUdfUCAoaW50IHgpIHsgcmV0dXJuICh4ICYgfkxpc3BfSW50MSkgPT0gMDsgfQorc3Rh dGljIGlubGluZSBpbnQgKExJU1BfSU5UX1RBR19QKSAoaW50IHgpIHsgcmV0dXJuICh4ICYg fkxpc3BfSW50MSkgPT0gMDsgfQogCiAvKiBUaGlzIGlzIHRoZSBzZXQgb2YgZGF0YSB0eXBl cyB0aGF0IHNoYXJlIGEgY29tbW9uIHN0cnVjdHVyZS4KICAgIFRoZSBmaXJzdCBtZW1iZXIg b2YgdGhlIHN0cnVjdHVyZSBpcyBhIHR5cGUgY29kZSBmcm9tIHRoaXMgc2V0LgpAQCAtMzAy LDEwICszNTgsMTAgQEAKIAogdHlwZWRlZiBzdHJ1Y3QgeyBFTUFDU19JTlQgaTsgfSBMaXNw X09iamVjdDsKIAotc3RhdGljIGlubGluZSBFTUFDU19JTlQgWExJIChMaXNwX09iamVjdCBv KSB7IHJldHVybiBvLmk7IH0KK3N0YXRpYyBpbmxpbmUgRU1BQ1NfSU5UIChYTEkpIChMaXNw X09iamVjdCBvKSB7IHJldHVybiBvLmk7IH0KIAogc3RhdGljIGlubGluZSBMaXNwX09iamVj dAotWElMIChFTUFDU19JTlQgaSkKKyhYSUwpIChFTUFDU19JTlQgaSkKIHsKICAgTGlzcF9P YmplY3QgbyA9IHsgaSB9OwogICByZXR1cm4gbzsKQEAgLTMxOCw4ICszNzQsOCBAQAogLyog SWYgYSBzdHJ1Y3QgdHlwZSBpcyBub3Qgd2FudGVkLCBkZWZpbmUgTGlzcF9PYmplY3QgYXMg anVzdCBhIG51bWJlci4gICovCiAKIHR5cGVkZWYgRU1BQ1NfSU5UIExpc3BfT2JqZWN0Owot c3RhdGljIGlubGluZSBFTUFDU19JTlQgWExJIChMaXNwX09iamVjdCBvKSB7IHJldHVybiBv OyB9Ci1zdGF0aWMgaW5saW5lIExpc3BfT2JqZWN0IFhJTCAoRU1BQ1NfSU5UIGkpIHsgcmV0 dXJuIGk7IH0KK3N0YXRpYyBpbmxpbmUgRU1BQ1NfSU5UIChYTEkpIChMaXNwX09iamVjdCBv KSB7IHJldHVybiBvOyB9CitzdGF0aWMgaW5saW5lIExpc3BfT2JqZWN0IChYSUwpIChFTUFD U19JTlQgaSkgeyByZXR1cm4gaTsgfQogI2RlZmluZSBMSVNQX0lOSVRJQUxMWV9aRVJPIDAK ICNlbmRpZiAvKiBDSEVDS19MSVNQX09CSkVDVF9UWVBFICovCiAKQEAgLTM4OSw3ICs0NDUs NyBAQAogIFhDT05TICh0ZW0pIGlzIHRoZSBzdHJ1Y3QgTGlzcF9Db25zICogcG9pbnRpbmcg dG8gdGhlIG1lbW9yeSBmb3IgdGhhdCBjb25zLiAgKi8KIAogLyogUmV0dXJuIGEgcGVyZmVj dCBoYXNoIG9mIHRoZSBMaXNwX09iamVjdCByZXByZXNlbnRhdGlvbi4gICovCi1zdGF0aWMg aW5saW5lIEVNQUNTX0lOVCBYSEFTSCAoTGlzcF9PYmplY3QgbykgeyByZXR1cm4gWExJIChv KTsgfQorc3RhdGljIGlubGluZSBFTUFDU19JTlQgKFhIQVNIKSAoTGlzcF9PYmplY3Qgbykg eyByZXR1cm4gWExJIChvKTsgfQogCiAjZGVmaW5lIFZBTE1BU0sgKFVTRV9MU0JfVEFHID8g LSAoMSA8PCBHQ1RZUEVCSVRTKSA6IFZBTF9NQVgpCiAKQEAgLTM5OSw3ICs0NTUsNyBAQAog I2RlZmluZSBNT1NUX05FR0FUSVZFX0ZJWE5VTSAoLTEgLSBNT1NUX1BPU0lUSVZFX0ZJWE5V TSkKIAogc3RhdGljIGlubGluZSBlbnVtIExpc3BfVHlwZQotWFRZUEUgKExpc3BfT2JqZWN0 IGEpCisoWFRZUEUpIChMaXNwX09iamVjdCBhKQogewogICBFTUFDU19VSU5UIGkgPSBYTEkg KGEpOwogICByZXR1cm4gVVNFX0xTQl9UQUcgPyBpICYgflZBTE1BU0sgOiBpID4+IFZBTEJJ VFM7CkBAIC00MDcsNyArNDYzLDcgQEAKIAogLyogRXh0cmFjdCB0aGUgdmFsdWUgb2YgYSBM aXNwX09iamVjdCBhcyBhIHNpZ25lZCBpbnRlZ2VyLiAgKi8KIHN0YXRpYyBpbmxpbmUgRU1B Q1NfSU5UCi1YSU5UIChMaXNwX09iamVjdCBhKQorKFhJTlQpIChMaXNwX09iamVjdCBhKQog ewogICBFTUFDU19JTlQgaSA9IFhMSSAoYSk7CiAgIHJldHVybiAoVVNFX0xTQl9UQUcgPyBp IDogaSA8PCBJTlRUWVBFQklUUykgPj4gSU5UVFlQRUJJVFM7CkBAIC00MTYsNyArNDcyLDcg QEAKIC8qIExpa2UgWElOVCAoQSksIGJ1dCBtYXkgYmUgZmFzdGVyLiAgQSBtdXN0IGJlIG5v bm5lZ2F0aXZlLiAgVGhpcyB0YWtlcwogICAgYWR2YW50YWdlIG9mIHRoZSBmYWN0IHRoYXQg TGlzcCBpbnRlZ2VycyBoYXZlIHplcm8tYml0cyBpbiB0aGVpciB0YWdzLiAgKi8KIHN0YXRp YyBpbmxpbmUgRU1BQ1NfSU5UCi1YRkFTVElOVCAoTGlzcF9PYmplY3QgYSkKKyhYRkFTVElO VCkgKExpc3BfT2JqZWN0IGEpCiB7CiAgIEVNQUNTX0lOVCBuID0gVVNFX0xTQl9UQUcgPyBY SU5UIChhKSA6IFhMSSAoYSkgPj4gSU5UVFlQRUJJVFM7CiAgIGVhc3NlcnQgKDAgPD0gbik7 CkBAIC00MzIsNyArNDg4LDcgQEAKIH0KIAogc3RhdGljIGlubGluZSBMaXNwX09iamVjdAot bWFrZV9udW1iZXIgKEVNQUNTX0lOVCBuKQorKG1ha2VfbnVtYmVyKSAoRU1BQ1NfSU5UIG4p CiB7CiAgIHJldHVybiBYSUwgKFVTRV9MU0JfVEFHID8gbiA8PCBJTlRUWVBFQklUUyA6IG4g JiBJTlRNQVNLKTsKIH0KQEAgLTQ0Niw3ICs1MDIsNyBAQAogfQogCiBzdGF0aWMgaW5saW5l IHZvaWQgKgotWFBOVFIgKExpc3BfT2JqZWN0IGEpCisoWFBOVFIpIChMaXNwX09iamVjdCBh KQogewogICBpbnRwdHJfdCBpID0gKFhMSSAoYSkgJiBWQUxNQVNLKSB8IERBVEFfU0VHX0JJ VFM7CiAgIHJldHVybiAodm9pZCAqKSBpOwpAQCAtNDU1LDcgKzUxMSw3IEBACiAvKiBFeHRy YWN0IHRoZSBwb2ludGVyIHZhbHVlIG9mIHRoZSBMaXNwIG9iamVjdCBBLCB1bmRlciB0aGUK ICAgIGFzc3VtcHRpb24gdGhhdCBBJ3MgdHlwZSBpcyBUWVBFLiAgKi8KIHN0YXRpYyBpbmxp bmUgdm9pZCAqCi1YVU5UQUcgKExpc3BfT2JqZWN0IGEsIGludCB0eXBlKQorKFhVTlRBRykg KExpc3BfT2JqZWN0IGEsIGludCB0eXBlKQogewogICBpZiAoVVNFX0xTQl9UQUcpCiAgICAg ewpAQCAtNDY2LDcgKzUyMiw3IEBACiB9CiAKIHN0YXRpYyBpbmxpbmUgaW50Ci1FUSAoTGlz cF9PYmplY3QgYSwgTGlzcF9PYmplY3QgYikKKyhFUSkgKExpc3BfT2JqZWN0IGEsIExpc3Bf T2JqZWN0IGIpCiB7CiAgIHJldHVybiBYSEFTSCAoYSkgPT0gWEhBU0ggKGIpOwogfQpAQCAt NTAzLDE0ICs1NTksMTQgQEAKIHN0YXRpYyBpbnQgQlVGRkVSUCAoTGlzcF9PYmplY3QpOwog c3RhdGljIGludCBDSEFSX1RBQkxFX1AgKExpc3BfT2JqZWN0KTsKIHN0YXRpYyBMaXNwX09i amVjdCBDSEFSX1RBQkxFX1JFRl9BU0NJSSAoTGlzcF9PYmplY3QsIHB0cmRpZmZfdCk7Ci1z dGF0aWMgaW50IENPTlNQIChMaXNwX09iamVjdCk7Ci1zdGF0aWMgaW50IEZMT0FUUCAoTGlz cF9PYmplY3QpOwotc3RhdGljIGludCBJTlRFR0VSUCAoTGlzcF9PYmplY3QpOworc3RhdGlj IGludCAoQ09OU1ApIChMaXNwX09iamVjdCk7CitzdGF0aWMgaW50IChGTE9BVFApIChMaXNw X09iamVjdCk7CitzdGF0aWMgaW50IChJTlRFR0VSUCkgKExpc3BfT2JqZWN0KTsKIHN0YXRp YyBpbnQgSU5URldEUCAodW5pb24gTGlzcF9Gd2QgKik7CiBzdGF0aWMgaW50IEtCT0FSRF9P QkpGV0RQICh1bmlvbiBMaXNwX0Z3ZCAqKTsKLXN0YXRpYyBpbnQgTUFSS0VSUCAoTGlzcF9P YmplY3QpOwotc3RhdGljIGludCBNSVNDUCAoTGlzcF9PYmplY3QpOwotc3RhdGljIGludCBO SUxQIChMaXNwX09iamVjdCk7CitzdGF0aWMgaW50IChNQVJLRVJQKSAoTGlzcF9PYmplY3Qp Oworc3RhdGljIGludCAoTUlTQ1ApIChMaXNwX09iamVjdCk7CitzdGF0aWMgaW50IChOSUxQ KSAoTGlzcF9PYmplY3QpOwogc3RhdGljIGludCBPQkpGV0RQICh1bmlvbiBMaXNwX0Z3ZCAq KTsKIHN0YXRpYyBpbnQgT1ZFUkxBWVAgKExpc3BfT2JqZWN0KTsKIHN0YXRpYyBpbnQgUFJP Q0VTU1AgKExpc3BfT2JqZWN0KTsKQEAgLTUxOSw4ICs1NzUsOCBAQAogc3RhdGljIGludCBT VFJJTkdQIChMaXNwX09iamVjdCk7CiBzdGF0aWMgaW50IFNVQl9DSEFSX1RBQkxFX1AgKExp c3BfT2JqZWN0KTsKIHN0YXRpYyBpbnQgU1VCUlAgKExpc3BfT2JqZWN0KTsKLXN0YXRpYyBp bnQgU1lNQk9MUCAoTGlzcF9PYmplY3QpOwotc3RhdGljIGludCBWRUNUT1JMSUtFUCAoTGlz cF9PYmplY3QpOworc3RhdGljIGludCAoU1lNQk9MUCkgKExpc3BfT2JqZWN0KTsKK3N0YXRp YyBpbnQgKFZFQ1RPUkxJS0VQKSAoTGlzcF9PYmplY3QpOwogc3RhdGljIGludCBXSU5ET1dQ IChMaXNwX09iamVjdCk7CiAKIC8qIERlZmluZWQgaW4gYnVmZmVyLmMuICAqLwpAQCAtNTYx LDcgKzYxNyw3IEBACiAvKiBFeHRyYWN0IGEgdmFsdWUgb3IgYWRkcmVzcyBmcm9tIGEgTGlz cF9PYmplY3QuICAqLwogCiBzdGF0aWMgaW5saW5lIHN0cnVjdCBMaXNwX0NvbnMgKgotWENP TlMgKExpc3BfT2JqZWN0IGEpCisoWENPTlMpIChMaXNwX09iamVjdCBhKQogewogICBlYXNz ZXJ0IChDT05TUCAoYSkpOwogICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX0NvbnMpOwpAQCAt NTgyLDcgKzYzOCw3IEBACiB9CiAKIHN0YXRpYyBpbmxpbmUgc3RydWN0IExpc3BfU3ltYm9s ICoKLVhTWU1CT0wgKExpc3BfT2JqZWN0IGEpCisoWFNZTUJPTCkgKExpc3BfT2JqZWN0IGEp CiB7CiAgIGVhc3NlcnQgKFNZTUJPTFAgKGEpKTsKICAgcmV0dXJuIFhVTlRBRyAoYSwgTGlz cF9TeW1ib2wpOwpAQCAtNzE3LDcgKzc3Myw3IEBACiAvKiBUeXBlIGNoZWNraW5nLiAgKi8K IAogc3RhdGljIGlubGluZSB2b2lkCi1DSEVDS19UWVBFIChpbnQgb2ssIExpc3BfT2JqZWN0 IFF4eHhwLCBMaXNwX09iamVjdCB4KQorKENIRUNLX1RZUEUpIChpbnQgb2ssIExpc3BfT2Jq ZWN0IFF4eHhwLCBMaXNwX09iamVjdCB4KQogewogICBpZiAoIW9rKQogICAgIHdyb25nX3R5 cGVfYXJndW1lbnQgKFF4eHhwLCB4KTsKQEAgLTc3Myw4ICs4MjksOCBAQAogI2VuZGlmCiAK IC8qIFVzZSB0aGVzZSBmcm9tIG5vcm1hbCBjb2RlLiAgKi8KLXN0YXRpYyBpbmxpbmUgTGlz cF9PYmplY3QgWENBUiAoTGlzcF9PYmplY3QgYykgeyByZXR1cm4gWENBUl9BU19MVkFMVUUg KGMpOyB9Ci1zdGF0aWMgaW5saW5lIExpc3BfT2JqZWN0IFhDRFIgKExpc3BfT2JqZWN0IGMp IHsgcmV0dXJuIFhDRFJfQVNfTFZBTFVFIChjKTsgfQorc3RhdGljIGlubGluZSBMaXNwX09i amVjdCAoWENBUikgKExpc3BfT2JqZWN0IGMpIHsgcmV0dXJuIFhDQVJfQVNfTFZBTFVFIChj KTsgfQorc3RhdGljIGlubGluZSBMaXNwX09iamVjdCAoWENEUikgKExpc3BfT2JqZWN0IGMp IHsgcmV0dXJuIFhDRFJfQVNfTFZBTFVFIChjKTsgfQogCiAvKiBVc2UgdGhlc2UgdG8gc2V0 IHRoZSBmaWVsZHMgb2YgYSBjb25zIGNlbGwuCiAKQEAgLTEyNzYsNyArMTMzMiw3IEBACiAv KiBWYWx1ZSBpcyBuYW1lIG9mIHN5bWJvbC4gICovCiAKIHN0YXRpYyBpbmxpbmUgTGlzcF9P YmplY3QKLVNZTUJPTF9WQUwgKHN0cnVjdCBMaXNwX1N5bWJvbCAqc3ltKQorKFNZTUJPTF9W QUwpIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSkKIHsKICAgZWFzc2VydCAoc3ltLT5yZWRp cmVjdCA9PSBTWU1CT0xfUExBSU5WQUwpOwogICByZXR1cm4gc3ltLT52YWwudmFsdWU7CkBA IC0xMzAwLDcgKzEzNTYsNyBAQAogICByZXR1cm4gc3ltLT52YWwuZndkOwogfQogc3RhdGlj IGlubGluZSB2b2lkCi1TRVRfU1lNQk9MX1ZBTCAoc3RydWN0IExpc3BfU3ltYm9sICpzeW0s IExpc3BfT2JqZWN0IHYpCisoU0VUX1NZTUJPTF9WQUwpIChzdHJ1Y3QgTGlzcF9TeW1ib2wg KnN5bSwgTGlzcF9PYmplY3QgdikKIHsKICAgZWFzc2VydCAoc3ltLT5yZWRpcmVjdCA9PSBT WU1CT0xfUExBSU5WQUwpOwogICBzeW0tPnZhbC52YWx1ZSA9IHY7CkBAIC0xMzUxLDcgKzE0 MDcsNyBAQAogICAgd2hvc2UgdmFsdWUgY2FuIGJlIHNldCB0byB0aGUga2V5d29yZCBzeW1i b2wgaXRzZWxmKS4gICovCiAKIHN0YXRpYyBpbmxpbmUgaW50Ci1TWU1CT0xfQ09OU1RBTlRf UCAoTGlzcF9PYmplY3Qgc3ltKQorKFNZTUJPTF9DT05TVEFOVF9QKSAoTGlzcF9PYmplY3Qg c3ltKQogewogICByZXR1cm4gWFNZTUJPTCAoc3ltKS0+Y29uc3RhbnQ7CiB9CkBAIC0xOTE1 LDcgKzE5NzEsNyBAQAogLyogRGF0YSB0eXBlIGNoZWNraW5nICovCiAKIHN0YXRpYyBpbmxp bmUgaW50Ci1OSUxQIChMaXNwX09iamVjdCB4KQorKE5JTFApIChMaXNwX09iamVjdCB4KQog ewogICByZXR1cm4gRVEgKHgsIFFuaWwpOwogfQpAQCAtMTk0MiwxOCArMTk5OCwyMiBAQAog ICAgJiYgKFRZUEVfU0lHTkVEICh0eXBlKSA/IFRZUEVfTUlOSU1VTSAodHlwZSkgPD0gWElO VCAoeCkgOiAwIDw9IFhJTlQgKHgpKSBcCiAgICAmJiBYSU5UICh4KSA8PSBUWVBFX01BWElN VU0gKHR5cGUpKQogCi1zdGF0aWMgaW5saW5lIGludCBDT05TUCAoTGlzcF9PYmplY3QgeCkg eyByZXR1cm4gWFRZUEUgKHgpID09IExpc3BfQ29uczsgfQotc3RhdGljIGlubGluZSBpbnQg RkxPQVRQIChMaXNwX09iamVjdCB4KSB7IHJldHVybiBYVFlQRSAoeCkgPT0gTGlzcF9GbG9h dDsgfQotc3RhdGljIGlubGluZSBpbnQgTUlTQ1AgKExpc3BfT2JqZWN0IHgpIHsgcmV0dXJu IFhUWVBFICh4KSA9PSBMaXNwX01pc2M7IH0KK3N0YXRpYyBpbmxpbmUgaW50IChDT05TUCkg KExpc3BfT2JqZWN0IHgpIHsgcmV0dXJuIFhUWVBFICh4KSA9PSBMaXNwX0NvbnM7IH0KK3N0 YXRpYyBpbmxpbmUgaW50IChGTE9BVFApIChMaXNwX09iamVjdCB4KSB7IHJldHVybiBYVFlQ RSAoeCkgPT0gTGlzcF9GbG9hdDsgfQorc3RhdGljIGlubGluZSBpbnQgKE1JU0NQKSAoTGlz cF9PYmplY3QgeCkgeyByZXR1cm4gWFRZUEUgKHgpID09IExpc3BfTWlzYzsgfQogc3RhdGlj IGlubGluZSBpbnQgU1RSSU5HUCAoTGlzcF9PYmplY3QgeCkgeyByZXR1cm4gWFRZUEUgKHgp ID09IExpc3BfU3RyaW5nOyB9Ci1zdGF0aWMgaW5saW5lIGludCBTWU1CT0xQIChMaXNwX09i amVjdCB4KSB7IHJldHVybiBYVFlQRSAoeCkgPT0gTGlzcF9TeW1ib2w7IH0KLXN0YXRpYyBp bmxpbmUgaW50Ci1JTlRFR0VSUCAoTGlzcF9PYmplY3QgeCkKK3N0YXRpYyBpbmxpbmUgaW50 CisoU1lNQk9MUCkgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBYVFlQRSAoeCkgPT0g TGlzcF9TeW1ib2w7Cit9CitzdGF0aWMgaW5saW5lIGludAorKElOVEVHRVJQKSAoTGlzcF9P YmplY3QgeCkKIHsKICAgcmV0dXJuIExJU1BfSU5UX1RBR19QIChYVFlQRSAoeCkpOwogfQog c3RhdGljIGlubGluZSBpbnQKLVZFQ1RPUkxJS0VQIChMaXNwX09iamVjdCB4KQorKFZFQ1RP UkxJS0VQKSAoTGlzcF9PYmplY3QgeCkKIHsKICAgcmV0dXJuIFhUWVBFICh4KSA9PSBMaXNw X1ZlY3Rvcmxpa2U7CiB9CkBAIC0xOTY4LDcgKzIwMjgsNyBAQAogICByZXR1cm4gTUlTQ1Ag KHgpICYmIFhNSVNDVFlQRSAoeCkgPT0gTGlzcF9NaXNjX092ZXJsYXk7CiB9CiBzdGF0aWMg aW5saW5lIGludAotTUFSS0VSUCAoTGlzcF9PYmplY3QgeCkKKyhNQVJLRVJQKSAoTGlzcF9P YmplY3QgeCkKIHsKICAgcmV0dXJuIE1JU0NQICh4KSAmJiBYTUlTQ1RZUEUgKHgpID09IExp c3BfTWlzY19NYXJrZXI7CiB9CkBAIC0yMTIzLDcgKzIxODMsNyBAQAogICBDSEVDS19UWVBF IChDT05TUCAoeCkgfHwgTklMUCAoeCksIFFsaXN0cCwgeCk7CiB9CiBzdGF0aWMgaW5saW5l IHZvaWQKLUNIRUNLX0xJU1RfQ09OUyAoTGlzcF9PYmplY3QgeCwgTGlzcF9PYmplY3QgeSkK KyhDSEVDS19MSVNUX0NPTlMpIChMaXNwX09iamVjdCB4LCBMaXNwX09iamVjdCB5KQogewog ICBDSEVDS19UWVBFIChDT05TUCAoeCksIFFsaXN0cCwgeSk7CiB9CkBAIC0yMTQ4LDcgKzIy MDgsNyBAQAogICBDSEVDS19UWVBFIChDT05TUCAoeCksIFFjb25zcCwgeCk7CiB9CiBzdGF0 aWMgaW5saW5lIHZvaWQKLUNIRUNLX1NZTUJPTCAoTGlzcF9PYmplY3QgeCkKKyhDSEVDS19T WU1CT0wpIChMaXNwX09iamVjdCB4KQogewogICBDSEVDS19UWVBFIChTWU1CT0xQICh4KSwg UXN5bWJvbHAsIHgpOwogfQpAQCAtMjIwMyw3ICsyMjYzLDcgQEAKICAgQ0hFQ0tfVFlQRSAo U1VCUlAgKHgpLCBRc3VicnAsIHgpOwogfQogc3RhdGljIGlubGluZSB2b2lkCi1DSEVDS19O VU1CRVIgKExpc3BfT2JqZWN0IHgpCisoQ0hFQ0tfTlVNQkVSKSAoTGlzcF9PYmplY3QgeCkK IHsKICAgQ0hFQ0tfVFlQRSAoSU5URUdFUlAgKHgpLCBRaW50ZWdlcnAsIHgpOwogfQo= --------------020406010201050504050309-- From debbugs-submit-bounces@debbugs.gnu.org Tue Jul 24 18:03:57 2012 Received: (at 11935) by debbugs.gnu.org; 24 Jul 2012 22:03:57 +0000 Received: from localhost ([127.0.0.1]:37348 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1StnCu-0006zg-W0 for submit@debbugs.gnu.org; Tue, 24 Jul 2012 18:03:57 -0400 Received: from pruche.dit.umontreal.ca ([132.204.246.22]:46635) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1StnCt-0006za-QN for 11935@debbugs.gnu.org; Tue, 24 Jul 2012 18:03:56 -0400 Received: from fmsmemgm.homelinux.net (lechon.iro.umontreal.ca [132.204.27.242]) by pruche.dit.umontreal.ca (8.14.1/8.14.1) with ESMTP id q6OLvAr8016022; Tue, 24 Jul 2012 17:57:10 -0400 Received: by fmsmemgm.homelinux.net (Postfix, from userid 20848) id BCF64AE2FE; Tue, 24 Jul 2012 17:57:09 -0400 (EDT) From: Stefan Monnier To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions Message-ID: References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> <500499C7.20902@cs.ucla.edu> <83txx79jgx.fsf@gnu.org> <500E0657.4050604@cs.ucla.edu> <500EA6F7.6080609@cs.ucla.edu> Date: Tue, 24 Jul 2012 17:57:09 -0400 In-Reply-To: <500EA6F7.6080609@cs.ucla.edu> (Paul Eggert's message of "Tue, 24 Jul 2012 06:45:27 -0700") User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.1.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-NAI-Spam-Flag: NO X-NAI-Spam-Level: X-NAI-Spam-Threshold: 5 X-NAI-Spam-Score: 0.5 X-NAI-Spam-Rules: 2 Rules triggered SUBJ_END_DOT_WORDS=0.5, RV4289=0 X-NAI-Spam-Version: 2.2.0.9309 : core <4289> : streams <789863> : uri <1173943> X-Spam-Score: -3.5 (---) X-Debbugs-Envelope-To: 11935 Cc: 11935@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: -3.5 (---) > Sure, attached; this assumes the earlier patch in > > has been applied and merged. I'm not sure I understand what it does. It seems to define XLI first as a macro then as a function. Is that right? If so, why is it any better than using only the macro form? Stefan From debbugs-submit-bounces@debbugs.gnu.org Wed Jul 25 00:14:06 2012 Received: (at 11935) by debbugs.gnu.org; 25 Jul 2012 04:14:06 +0000 Received: from localhost ([127.0.0.1]:37876 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Stsz7-0006j0-SI for submit@debbugs.gnu.org; Wed, 25 Jul 2012 00:14:06 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:50927) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Stsz5-0006it-Po for 11935@debbugs.gnu.org; Wed, 25 Jul 2012 00:14:05 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 1197F39E8014; Tue, 24 Jul 2012 21:07:20 -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 MyEgp-j+d+MS; Tue, 24 Jul 2012 21:07:19 -0700 (PDT) Received: from [192.168.1.4] (pool-108-23-119-2.lsanca.fios.verizon.net [108.23.119.2]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 87A4639E8013; Tue, 24 Jul 2012 21:07:19 -0700 (PDT) Message-ID: <500F7100.9080407@cs.ucla.edu> Date: Tue, 24 Jul 2012 21:07:28 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux i686; rv:14.0) Gecko/20120714 Thunderbird/14.0 MIME-Version: 1.0 To: Stefan Monnier Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <5002C895.4080400@cs.ucla.edu> <500499C7.20902@cs.ucla.edu> <83txx79jgx.fsf@gnu.org> <500E0657.4050604@cs.ucla.edu> <500EA6F7.6080609@cs.ucla.edu> In-Reply-To: Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -1.9 (-) X-Debbugs-Envelope-To: 11935 Cc: 11935@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 07/24/2012 02:57 PM, Stefan Monnier wrote: > It seems to define XLI first as > a macro then as a function. Is that right? Yes. The macro is purely for performance with -O0. The function is for all other purposes, including having XLI work in expressions given to GDB. > why is it any better than using only the macro form? Mostly for debuggability, though there's also a small performance win when compiling with default (-O2) optimization. Having the functions makes GDB more useful when printing expressions. Here's a trivial example: (gdb) p SYMBOLP (Qnil) $3 = 1 With the patch, this works if one compiles with -g -O0, regardless of whether -DINLINING=0 is also specified. This is because SYMBOLP is defined as a function, regardless of whether it is also defined as a macro. Also, having the functions makes backtraces work better, even when compiling with default optimization. For example, here's the start of a GDB backtrace of a patched Emacs compiled with default optimization: (gdb) where #0 XTYPE (a=0) at lisp.h:461 #1 VECTORLIKEP (x=0) at lisp.h:2018 #2 PSEUDOVECTORP (code=2, a=0) at lisp.h:2080 #3 PROCESSP (a=0) at lisp.h:2102 #4 Fget_process (name=0) at process.c:680 #5 0x0000000000573e87 in eval_sub (form=form@entry=16514534) at eval.c:2146 ... When the macro forms are used, levels #0 through #3 are lost, which makes things harder to follow, particularly when one is not expert in the code. This debuggability win is partly lost when compiling with plain -O0, because then some functions turn into macros. But that's OK, since one can compile with -O0 -DINLINING=0 to get nicer debugging. From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 06 11:59:10 2013 Received: (at 11935) by debbugs.gnu.org; 6 Jun 2013 15:59:10 +0000 Received: from localhost ([127.0.0.1]:54532 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Ukcaj-0006Fu-Qc for submit@debbugs.gnu.org; Thu, 06 Jun 2013 11:59:10 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:35723) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1Ukcag-0006FF-Ob for 11935@debbugs.gnu.org; Thu, 06 Jun 2013 11:59:07 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 0ECCD39E8106 for <11935@debbugs.gnu.org>; Thu, 6 Jun 2013 08:56:51 -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 CggqubvYdOZM for <11935@debbugs.gnu.org>; Thu, 6 Jun 2013 08:56:46 -0700 (PDT) Received: from penguin.cs.ucla.edu (Penguin.CS.UCLA.EDU [131.179.64.200]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id AF66939E8100 for <11935@debbugs.gnu.org>; Thu, 6 Jun 2013 08:56:46 -0700 (PDT) Message-ID: <51B0B137.5020705@cs.ucla.edu> Date: Thu, 06 Jun 2013 08:56:39 -0700 From: Paul Eggert User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130514 Thunderbird/17.0.6 MIME-Version: 1.0 To: 11935@debbugs.gnu.org Subject: Re: bug#11935: XINT etc. should be functions Content-Type: multipart/mixed; boundary="------------050709090604060200090702" X-Debbugs-Envelope-To: 11935 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. --------------050709090604060200090702 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit Attached is an updated version of this patch, relative to the current trunk (bzr 112869). Since the last version of the patch we've added several inline functions to lisp.h, such as specpdl_symbol, make_lisp_proc, SAVE_VALUEP, and I've merged them all in. I'd like to apply this soon. --------------050709090604060200090702 Content-Type: text/plain; charset=us-ascii; name="inline4.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="inline4.txt" PT09IG1vZGlmaWVkIGZpbGUgJ0NoYW5nZUxvZycKLS0tIENoYW5nZUxvZwkyMDEzLTA2LTAz IDE5OjM4OjA2ICswMDAwCisrKyBDaGFuZ2VMb2cJMjAxMy0wNi0wNiAxNTo0MDoxNCArMDAw MApAQCAtMSwzICsxLDkgQEAKKzIwMTMtMDYtMDYgIFBhdWwgRWdnZXJ0ICA8ZWdnZXJ0QGNz LnVjbGEuZWR1PgorCisJVXNlIGZ1bmN0aW9ucywgbm90IG1hY3JvcywgZm9yIFhJTlQgZXRj LiAoQnVnIzExOTM1KS4KKwkqIGNvbmZpZ3VyZS5hYyAoV0FSTl9DRkxBR1MpOiBSZW1vdmUg LVdiYWQtZnVuY3Rpb24tY2FzdCwKKwlhcyBpdCBnZW5lcmF0ZXMgYm9ndXMgd2FybmluZ3Mg YWJvdXQgcmVhc29uYWJsZSBjYXN0cyBvZiBjYWxscy4KKwogMjAxMy0wNi0wMyAgTWljaGFl bCBBbGJpbnVzICA8bWljaGFlbC5hbGJpbnVzQGdteC5kZT4KIAogCSogY29uZmlndXJlLmFj IChIQVZFX0dGSUxFTk9USUZZKTogQ2hlY2sgZm9yIGdpbyA+PSAyLjI0LgpAQCAtMTgzLDcg KzE4OSw3IEBACiAJYC1XbCwtYnBlLWkzODYnLCB3aGljaCBpcyBjb25mdXNpbmcgaW4gdGhl IDY0LWJpdCBjYXNlLgogCShCdWcjMTI5OTMpCiAKLTIwMTMtMDQtMDcgIFBhdWwgRWdnZXJ0 ICA8ZWdnZXJ0QGNzLnVjbGEuZWR1PgorMjAxMy0wNC0wNiAgUGF1bCBFZ2dlcnQgIDxlZ2dl cnRAY3MudWNsYS5lZHU+CiAKIAlGaXggLS1lbmFibGUtcHJvZmlsaW5nIGJ1ZyBpbnRyb2R1 Y2VkIGJ5IDIwMTMtMDItMjUgY2hhbmdlIChCdWcjMTM3ODMpLgogCSogY29uZmlndXJlLmFj IChMRF9TV0lUQ0hfU1lTVEVNX1RFTUFDUyk6IEFwcGVuZCAtcGcgaWYgcHJvZmlsaW5nCgo9 PT0gbW9kaWZpZWQgZmlsZSAnY29uZmlndXJlLmFjJwotLS0gY29uZmlndXJlLmFjCTIwMTMt MDYtMDMgMTk6Mzg6MDYgKzAwMDAKKysrIGNvbmZpZ3VyZS5hYwkyMDEzLTA2LTA1IDA0OjM4 OjA0ICswMDAwCkBAIC03NzYsNiArNzc2LDcgQEAKICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICMgc2lnbmVkIG92ZXJmbG93IGhhcyB1bmRlZmluZWQgYmVoYXZpb3IK ICAgbnc9IiRudyAtV3N5bmMtbmFuZCIgICAgICAgICAgICAgICMgaXJyZWxldmFudCBoZXJl LCBhbmQgcHJvdm9rZXMgT2JqQyB3YXJuaW5nCiAgIG53PSIkbncgLVd1bnNhZmUtbG9vcC1v cHRpbWl6YXRpb25zIiAjIE9LIHRvIHN1cHByZXNzIHVuc2FmZSBvcHRpbWl6YXRpb25zCisg IG53PSIkbncgLVdiYWQtZnVuY3Rpb24tY2FzdCIgICAgICAjIFRoZXNlIGNhc3RzIGFyZSBu byB3b3JzZSB0aGFuIG90aGVycy4KIAogICAjIEVtYWNzIGRvZXNuJ3QgY2FyZSBhYm91dCBz aGFkb3dpbmc7IHNlZQogICAjIDxodHRwOi8vbGlzdHMuZ251Lm9yZy9hcmNoaXZlL2h0bWwv ZW1hY3MtZGlmZnMvMjAxMS0xMS9tc2cwMDI2NS5odG1sPi4KCj09PSBtb2RpZmllZCBmaWxl ICdzcmMvQ2hhbmdlTG9nJwotLS0gc3JjL0NoYW5nZUxvZwkyMDEzLTA2LTA2IDA3OjA0OjM1 ICswMDAwCisrKyBzcmMvQ2hhbmdlTG9nCTIwMTMtMDYtMDYgMTU6NDA6MTQgKzAwMDAKQEAg LTEsNSArMSwxMTUgQEAKIDIwMTMtMDYtMDYgIFBhdWwgRWdnZXJ0ICA8ZWdnZXJ0QGNzLnVj bGEuZWR1PgogCisJVXNlIGZ1bmN0aW9ucywgbm90IG1hY3JvcywgZm9yIFhJTlQgZXRjLiAo QnVnIzExOTM1KS4KKwlJbiBsaXNwLmgsIHByZWZlciBmdW5jdGlvbnMgdG8gZnVuY3Rpb24t bGlrZSBtYWNyb3MsIGFuZAorCWNvbnN0YW50cyB0byBvYmplY3QtbGlrZSBtYWNyb3MsIHdo ZW4gZWl0aGVyIHdpbGwgZG8uICBUaGlzOgorCSAuIHNpbXBsaWZpZXMgdXNlLCBhcyB0aGVy ZSdzIG5vIG1vcmUgbmVlZCB0byB3b3JyeSBhYm91dAorCSAgIGFyZ3VtZW50cycgc2lkZSBl ZmZlY3RzIGJlaW5nIGV2YWx1YXRlZCBtdWx0aXBsZSB0aW1lcy4KKwkgLiBtYWtlcyB0aGUg Y29kZSBlYXNpZXIgdG8gZGVidWcgb24gc29tZSBwbGF0Zm9ybXMuCisJKiBhbGxvYy5jIChn ZGJfbWFrZV9lbnVtc192aXNpYmxlKSBbVVNFX0xTQl9UQUddOgorCVJlbW92ZSBlbnVtIGxz Yl9iaXRzOyBubyBsb25nZXIgbmVlZGVkLgorCShhbGxvY2F0ZV9taXNjLCBmcmVlX21pc2Mp OiBEb24ndCB1c2UgWE1JU0NUWVBFIGFzIGFuIGx2YWx1ZS4KKwkqIGJ1ZmZlci5jIChRb3Zl cmxhcCk6CisJKiBkYXRhLmMgKFFzdWJycCk6CisJKiBmbnMuYyAoUWhhc2hfdGFibGVfcCk6 CisJTm93IGV4dGVybiwgc28gbGlzcC5oIGNhbiB1c2UgdGhlc2Ugc3ltYm9scy4KKwkqIGRp c3BleHRlcm4uaDogSW5jbHVkZSBjaGFyYWN0ZXIuaCwgZm9yIE1BWF9DSEFSIGV0Yy4KKwko R0xZUEgsIEdMWVBIX0NIQVIsIEdMWVBIX0ZBQ0UsIFNFVF9HTFlQSF9DSEFSLCBTRVRfR0xZ UEhfRkFDRSkKKwkoU0VUX0dMWVBILCBHTFlQSF9DT0RFX0NIQVIsIEdMWVBIX0NPREVfRkFD RSkKKwkoU0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERSwgR0xZUEhfTU9ERV9MSU5FX0ZBQ0Us IEdMWVBIX0NIQVJfVkFMSURfUCkKKwkoR0xZUEhfQ09ERV9QKTogTW92ZSBoZXJlIGZyb20g bGlzcC5oLgorCShHTFlQSF9DSEFSLCBHTFlQSF9GQUNFLCBHTFlQSF9DT0RFX0NIQVIsIEdM WVBIX0NPREVfRkFDRSkKKwkoR0xZUEhfQ0hBUl9WQUxJRF9QLCBHTFlQSF9DT0RFX1ApOiBO b3cgZnVuY3Rpb25zLCBub3QgbWFjcm9zLgorCShHTFlQSF9NT0RFX0xJTkVfRkFDRSk6IE5v dyBlbnVtcywgbm90IG1hY3Jvcy4KKwkqIGV2YWwuYyAoRmF1dG9sb2FkKTogQ2FzdCBYVU5U QUcgb3V0cHV0IHRvIGludHB0cl90LCBzaW5jZQorCVhVTlRBRyBub3cgcmV0dXJucyB2b2lk ICouCisJKiBsaXNwLmggKFhMSSwgWElMLCBDSEVDS19MSVNUX0NPTlMsIENIRUNLX05VTUJF UiBDSEVDS19TWU1CT0wpCisJKENIRUNLX1RZUEUsIENPTlNQLCBFUSwgRkxPQVRQLCBJTlRF R0VSUCwgTElTUF9JTlRfVEFHX1AsIE1BUktFUlApCisJKE1JU0NQLCBOSUxQLCBTRVRfU1lN Qk9MX1ZBTCwgU1lNQk9MX0NPTlNUQU5UX1AsIFNZTUJPTF9WQUwsIFNZTUJPTFApCisJKFZF Q1RPUkxJS0VQLCBYQ0FSLCBYQ0RSLCBYQ09OUywgWEhBU0gsIFhQTlRSLCBYU1lNQk9MKToK KwlJZiBjb21waWxpbmcgdmlhIEdDQyB3aXRob3V0IG9wdGltaXphdGlvbiwgaW5saW5lIHRo ZXNlIGZ1bmN0aW9ucworCW1hbnVhbGx5LCBieSBkZWZpbmluZyBtYWNyb3MgaW4gYWRkaXRp b24gdG8gaW5saW5lIGZ1bmN0aW9ucy4KKwlUbyBkaXNhYmxlIHRoaXMsIGNvbXBpbGUgd2l0 aCAtRElOTElOSU5HPTAuCisJKGNoZWNrX2NvbnNfbGlzdCkgWyFHQ19DSEVDS19DT05TX0xJ U1RdOiBMaWtld2lzZS4KKwkobWFrZV9udW1iZXIsIFhGQVNUSU5ULCBYSU5ULCBYVFlQRSwg WFVOVEFHKTogTGlrZXdpc2UsIGJ1dAorCWhhbmQtb3B0aW1pemUgb25seSBpbiB0aGUgVVNF X0xTQl9UQUcgY2FzZSwgYXMgR05VaXNoIGhvc3RzIGRvIHRoYXQuCisJKElOVE1BU0ssIFZB TE1BU0spOiBOb3cgbWFjcm9zLCBzaW5jZSBzdGF0aWMgdmFsdWVzIGNhbm5vdCBiZQorCWFj Y2Vzc2VkIGZyb20gZXh0ZXJuIGlubGluZSBmdW5jdGlvbnMuCisJKFZBTE1BU0spOiBBbHNv IGEgY29uc3RhbnQsIGZvciBiZW5lZml0IG9mIG9sZCBHREIuCisJKExJU1BfSU5UX1RBR19Q LCBYTEksIFhJTCwgWEhBU0gsIFhUWVBFLFhJTlQsIFhGQVNUSU5ULCBYVUlOVCkKKwkobWFr ZV9udW1iZXIsIFhQTlRSLCBYVU5UQUcsIEVRLCBYQ09OUywgWFZFQ1RPUiwgWFNUUklORywg WFNZTUJPTCkKKwkoWEZMT0FULCBYUFJPQ0VTUywgWFdJTkRPVywgWFRFUk1JTkFMLCBYU1VC UiwgWEJVRkZFUiwgWENIQVJfVEFCTEUpCisJKFhTVUJfQ0hBUl9UQUJMRSwgWEJPT0xfVkVD VE9SLCBtYWtlX2xpc3BfcHRyLCBDSEVDS19UWVBFKQorCShDSEVDS19TVFJJTkdfT1JfQlVG RkVSLCBYQ0FSLCBYQ0RSLCBYU0VUQ0FSLCBYU0VUQ0RSLCBDQVIsIENEUikKKwkoQ0FSX1NB RkUsIENEUl9TQUZFLCBTVFJJTkdfTVVMVElCWVRFLCBTREFUQSwgU1NEQVRBLCBTUkVGLCBT U0VUKQorCShTQ0hBUlMsIFNUUklOR19CWVRFUywgU0JZVEVTLCBTVFJJTkdfU0VUX0NIQVJT LCBTVFJJTkdfQ09QWUlOLCBBUkVGKQorCShBU0laRSwgQVNFVCwgQ0hBUl9UQUJMRV9SRUZf QVNDSUksIENIQVJfVEFCTEVfUkVGKQorCShDSEFSX1RBQkxFX1NFVCwgQ0hBUl9UQUJMRV9F WFRSQV9TTE9UUywgU1lNQk9MX1ZBTCwgU1lNQk9MX0FMSUFTKQorCShTWU1CT0xfQkxWLCBT WU1CT0xfRldELCBTRVRfU1lNQk9MX1ZBTCwgU0VUX1NZTUJPTF9BTElBUykKKwkoU0VUX1NZ TUJPTF9CTFYsIFNFVF9TWU1CT0xfRldELCBTWU1CT0xfTkFNRSwgU1lNQk9MX0lOVEVSTkVE X1ApCisJKFNZTUJPTF9JTlRFUk5FRF9JTl9JTklUSUFMX09CQVJSQVlfUCwgU1lNQk9MX0NP TlNUQU5UX1ApCisJKFhIQVNIX1RBQkxFLCBIQVNIX1RBQkxFX1AsIENIRUNLX0hBU0hfVEFC TEUsIEhBU0hfS0VZLCBIQVNIX1ZBTFVFKQorCShIQVNIX05FWFQsIEhBU0hfSEFTSCwgSEFT SF9JTkRFWCwgSEFTSF9UQUJMRV9TSVpFKQorCShYTUlTQywgWE1JU0NBTlksIFhNQVJLRVIs IFhPVkVSTEFZLCBYU0FWRV9WQUxVRSwgWEZXRFRZUEUpCisJKFhJTlRGV0QsIFhCT09MRldE LCBYT0JKRldELCBYQlVGRkVSX09CSkZXRCwgWEtCT0FSRF9PQkpGV0QpCisJKFhGTE9BVF9E QVRBLCBYRkxPQVRfSU5JVCwgTklMUCwgTlVNQkVSUCwgTkFUTlVNUCkKKwkoUkFOR0VEX0lO VEVHRVJQLCBDT05TUCwgRkxPQVRQLCBNSVNDUCwgU1RSSU5HUCwgU1lNQk9MUCkKKwkoSU5U RUdFUlAsIFZFQ1RPUkxJS0VQLCBWRUNUT1JQLCBPVkVSTEFZUCkKKwkoTUFSS0VSUCwgU0FW RV9WQUxVRVAsIEFVVE9MT0FEUCwgSU5URldEUCwgQk9PTEZXRFAsIE9CSkZXRFApCisJKEJV RkZFUl9PQkpGV0RQLCBLQk9BUkRfT0JKRldEUCwgUFNFVURPVkVDVE9SX1RZUEVQKQorCShQ U0VVRE9WRUNUT1JQLCBXSU5ET1dfQ09ORklHVVJBVElPTlAsIFBST0NFU1NQLCBXSU5ET1dQ KQorCShURVJNSU5BTFAsIFNVQlJQLCBDT01QSUxFRFAsIEJVRkZFUlAsIENIQVJfVEFCTEVf UCkKKwkoU1VCX0NIQVJfVEFCTEVfUCwgQk9PTF9WRUNUT1JfUCwgRlJBTUVQLCBJTUFHRVAs IEFSUkFZUCkKKwkoQ0hFQ0tfTElTVCwgQ0hFQ0tfTElTVF9DT05TLCBDSEVDS19MSVNUX0VO RCwgQ0hFQ0tfU1RSSU5HKQorCShDSEVDS19TVFJJTkdfQ0FSLCBDSEVDS19DT05TLCBDSEVD S19TWU1CT0wsIENIRUNLX0NIQVJfVEFCTEUpCisJKENIRUNLX1ZFQ1RPUiwgQ0hFQ0tfVkVD VE9SX09SX1NUUklORywgQ0hFQ0tfQVJSQVkpCisJKENIRUNLX1ZFQ1RPUl9PUl9DSEFSX1RB QkxFLCBDSEVDS19CVUZGRVIsIENIRUNLX1dJTkRPVykKKwkoQ0hFQ0tfV0lORE9XX0NPTkZJ R1VSQVRJT04sIENIRUNLX1BST0NFU1MsIENIRUNLX1NVQlIpCisJKENIRUNLX05VTUJFUiwg Q0hFQ0tfTkFUTlVNLCBDSEVDS19NQVJLRVIsIFhGTE9BVElOVCkKKwkoQ0hFQ0tfRkxPQVQs IENIRUNLX05VTUJFUl9PUl9GTE9BVCwgQ0hFQ0tfT1ZFUkxBWSkKKwkoQ0hFQ0tfTlVNQkVS X0NBUiwgQ0hFQ0tfTlVNQkVSX0NEUiwgQ0hFQ0tfTkFUTlVNX0NBUikKKwkoQ0hFQ0tfTkFU TlVNX0NEUiwgRlVOQ1RJT05QLCBTUEVDUERMX0lOREVYLCBMT0FESElTVF9BVFRBQ0gpCisJ Tm93IGZ1bmN0aW9ucy4KKwkoY2hlY2tfY29uc19saXN0KSBbIUdDX0NIRUNLX0NPTlNfTElT VF06IE5ldyBlbXB0eSBmdW5jdGlvbi4KKwkoTElTUF9NQUtFX1JWQUxVRSwgVFlQRU1BU0sp OiBSZW1vdmU7IG5vIGxvbmdlciBuZWVkZWQuCisJKFZBTE1BU0spOiBEZWZpbmUgaW4gb25l IHBsYWNlIHJhdGhlciB0aGFuIGluIHR3bywgbWVyZ2luZyB0aGUKKwlVU0VfTFNCX1RBRyBw YXJ0czsgdGhpcyBpcyBzaW1wbGVyLgorCShhcmVmX2FkZHIsIGdjX2FzZXQsIE1PU1RfUE9T SVRJVkVfRklYTlVNLCBNT1NUX05FR0FUSVZFX0ZJWE5VTSkKKwkobWF4LCBtaW4sIHN0cnVj dCBMaXNwX1N0cmluZywgVU5TSUdORURfQ01QLCBBU0NJSV9DSEFSX1ApOgorCU1vdmUgdXAs IHRvIGF2b2lkIHVzZSBiZWZvcmUgZGVmaW5pdGlvbi4KKwlBbHNvIGluY2x1ZGUgImdsb2Jh bHMuaCIgZWFybGllciwgZm9yIHRoZSBzYW1lIHJlYXNvbi4KKwkobWFrZV9uYXRudW0pOiBO ZXcgZnVuY3Rpb24uCisJKFhVTlRBRyk6IE5vdyByZXR1cm5zIHZvaWQgKiwgbm90IGludHB0 cl90LCBhcyB0aGlzIG1lYW5zIGZld2VyIGNhc3RzLgorCSh1bmlvbiBMaXNwX0Z3ZCwgQk9P TEZXRFAsIEJPT0xfVkVDVE9SX1AsIEJVRkZFUl9PQkpGV0RQLCBCVUZGRVJQKQorCShDSEFS X1RBQkxFX1AsIENIQVJfVEFCTEVfUkVGX0FTQ0lJLCBDT05TUCwgRkxPQVRQLCBJTlRFR0VS UCwgSU5URldEUCkKKwkoS0JPQVJEX09CSkZXRFAsIE1BUktFUlAsIE1JU0NQLCBOSUxQLCBP QkpGV0RQLCBPVkVSTEFZUCwgUFJPQ0VTU1ApCisJKFBTRVVET1ZFQ1RPUlAsIFNBVkVfVkFM VUVQLCBTVFJJTkdQLCBTVUJfQ0hBUl9UQUJMRV9QLCBTVUJSUCwgU1lNQk9MUCkKKwkoVkVD VE9STElLRVAsIFdJTkRPV1AsIFFvdmVybGF5cCwgY2hhcl90YWJsZV9yZWYsIGNoYXJfdGFi bGVfc2V0KQorCShjaGFyX3RhYmxlX3RyYW5zbGF0ZSwgUWFycmF5cCwgUWJ1ZmZlcnAsIFFi dWZmZXJfb3Jfc3RyaW5nX3ApCisJKFFjaGFyX3RhYmxlX3AsIFFjb25zcCwgUWZsb2F0cCwg UWludGVnZXJwLCBRbGFtYmRhLCBRbGlzdHAsIFFtYXJrZXJwKQorCShRbmlsLCBRbnVtYmVy cCwgUXN1YnJwLCBRc3RyaW5ncCwgUXN5bWJvbHAsIFF2ZWN0b3JwKQorCShRdmVjdG9yX29y X2NoYXJfdGFibGVfcCwgUXdob2xlbnVtcCwgRmZib3VuZHAsIHdyb25nX3R5cGVfYXJndW1l bnQpCisJKGluaXRpYWxpemVkLCBRaGFzaF90YWJsZV9wLCBleHRyYWN0X2Zsb2F0LCBRcHJv Y2Vzc3AsIFF3aW5kb3dwKQorCShRd2luZG93X2NvbmZpZ3VyYXRpb25fcCwgUWltYWdlKTog TmV3IGZvcndhcmQgZGVjbGFyYXRpb25zLgorCShYU0VURkFTVElOVCk6IFNpbXBsaWZ5IGJ5 IHJld3JpdGluZyBpbiB0ZXJtcyBvZiBtYWtlX25hdG51bS4KKwkoU1RSSU5HX0NPUFlJTik6 IFJlbW92ZTsgdW51c2VkLgorCShYQ0FSX0FTX0xWQUxVRSwgWENEUl9BU19MVkFMVUUpOiBS ZW1vdmUgdGhlc2UgbWFjcm9zLCByZXBsYWNpbmcgd2l0aCAuLi4KKwkoeGNhcl9hZGRyLCB4 Y2RyX2FkZHIpOiBOZXcgZnVuY3Rpb25zLiAgQWxsIHVzZXMgY2hhbmdlZC4KKwkoSUVFRV9G TE9BVElOR19QT0lOVCk6IE5vdyBhIGNvbnN0YW50LCBub3QgYSBtYWNyby4KKwkoR0xZUEgs IEdMWVBIX0NIQVIsIEdMWVBIX0ZBQ0UsIFNFVF9HTFlQSF9DSEFSLCBTRVRfR0xZUEhfRkFD RSkKKwkoU0VUX0dMWVBILCBHTFlQSF9DT0RFX0NIQVIsIEdMWVBIX0NPREVfRkFDRSkKKwko U0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERSwgR0xZUEhfTU9ERV9MSU5FX0ZBQ0UsIEdMWVBI X0NIQVJfVkFMSURfUCkKKwkoR0xZUEhfQ09ERV9QKTogTW92ZSB0byBkaXNwZXh0ZXJuLmgs IHRvIGF2b2lkIGRlZmluZS1iZWZvcmUtdXNlLgorCShUWVBFX1JBTkdFRF9JTlRFR0VSUCk6 IFNpbXBsaWZ5LgorCShRc3VicnAsIFFoYXNoX3RhYmxlX3AsIFFvdmVybGF5cCk6IE5ldyBl eHRlcm4gZGVjbHMuCisJKHNldGxvY2FsZSwgZml4dXBfbG9jYWxlLCBzeW5jaHJvbml6ZV9z eXN0ZW1fbWVzc2FnZXNfbG9jYWxlKQorCShzeW5jaHJvbml6ZV9zeXN0ZW1fdGltZV9sb2Nh bGUpIFshSEFWRV9TRVRMT0NBTEVdOgorCU5vdyBlbXB0eSBmdW5jdGlvbnMsIG5vdCBtYWNy b3MuCisJKGZ1bmN0aW9ucCk6IFJldHVybiBib29sLCBub3QgaW50LgorCSogd2luZG93LmMg KFF3aW5kb3dfY29uZmlndXJhdGlvbl9wKTogTm93IGV4dGVybiwKKwlzbyB3aW5kb3cuaCBj YW4gdXNlIGl0LgorCSogd2luZG93LmggKFF3aW5kb3dwKTogTW92ZSBkZWNsIGJhY2sgdG8g bGlzcC5oLgorCiAJQSBmZXcgcG9ydGluZyBldGMuIGZpeGVzIGZvciB0aGUgbmV3IGZpbGUg bW9uaXRvciBjb2RlLgogCVNlZSB0aGUgdGhyZWFkIGNvbnRhaW5pbmcKIAk8aHR0cDovL2xp c3RzLmdudS5vcmcvYXJjaGl2ZS9odG1sL2VtYWNzLWRldmVsLzIwMTMtMDYvbXNnMDAxMDku aHRtbD4uCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2FsbG9jLmMnCi0tLSBzcmMvYWxsb2Mu YwkyMDEzLTA2LTAzIDA5OjAxOjUzICswMDAwCisrKyBzcmMvYWxsb2MuYwkyMDEzLTA2LTA1 IDA0OjM4OjA0ICswMDAwCkBAIC0zMzA5LDcgKzMzMDksNyBAQAogICAtLXRvdGFsX2ZyZWVf bWFya2VyczsKICAgY29uc2luZ19zaW5jZV9nYyArPSBzaXplb2YgKHVuaW9uIExpc3BfTWlz Yyk7CiAgIG1pc2Nfb2JqZWN0c19jb25zZWQrKzsKLSAgWE1JU0NUWVBFICh2YWwpID0gdHlw ZTsKKyAgWE1JU0NBTlkgKHZhbCktPnR5cGUgPSB0eXBlOwogICBYTUlTQ0FOWSAodmFsKS0+ Z2NtYXJrYml0ID0gMDsKICAgcmV0dXJuIHZhbDsKIH0KQEAgLTMzMTksNyArMzMxOSw3IEBA CiB2b2lkCiBmcmVlX21pc2MgKExpc3BfT2JqZWN0IG1pc2MpCiB7Ci0gIFhNSVNDVFlQRSAo bWlzYykgPSBMaXNwX01pc2NfRnJlZTsKKyAgWE1JU0NBTlkgKG1pc2MpLT50eXBlID0gTGlz cF9NaXNjX0ZyZWU7CiAgIFhNSVNDIChtaXNjKS0+dV9mcmVlLmNoYWluID0gbWFya2VyX2Zy ZWVfbGlzdDsKICAgbWFya2VyX2ZyZWVfbGlzdCA9IFhNSVNDIChtaXNjKTsKICAgY29uc2lu Z19zaW5jZV9nYyAtPSBzaXplb2YgKHVuaW9uIExpc3BfTWlzYyk7CkBAIC01NjQ3LDcgKzU2 NDcsNyBAQAogCXsKIAkgIENPTlNfTUFSSyAoWENPTlMgKHRhaWwpKTsKIAkgIG1hcmtfb2Jq ZWN0IChYQ0FSICh0YWlsKSk7Ci0JICBwcmV2ID0gJlhDRFJfQVNfTFZBTFVFICh0YWlsKTsK KwkgIHByZXYgPSB4Y2RyX2FkZHIgKHRhaWwpOwogCX0KICAgICB9CiAgIG1hcmtfb2JqZWN0 ICh0YWlsKTsKQEAgLTY2ODksOCArNjY4OSw1IEBACiAgIGVudW0gTUFYX0FMTE9DQSBNQVhf QUxMT0NBOwogICBlbnVtIE1vcmVfTGlzcF9CaXRzIE1vcmVfTGlzcF9CaXRzOwogICBlbnVt IHB2ZWNfdHlwZSBwdmVjX3R5cGU7Ci0jaWYgVVNFX0xTQl9UQUcKLSAgZW51bSBsc2JfYml0 cyBsc2JfYml0czsKLSNlbmRpZgogfSBjb25zdCBFWFRFUk5BTExZX1ZJU0lCTEUgZ2RiX21h a2VfZW51bXNfdmlzaWJsZSA9IHswfTsKICNlbmRpZgkvKiBfX0dOVUNfXyAqLwoKPT09IG1v ZGlmaWVkIGZpbGUgJ3NyYy9idWZmZXIuYycKLS0tIHNyYy9idWZmZXIuYwkyMDEzLTA1LTA3 IDE0OjEyOjU3ICswMDAwCisrKyBzcmMvYnVmZmVyLmMJMjAxMy0wNi0wNSAwNDozODowNCAr MDAwMApAQCAtMTM0LDcgKzEzNCw3IEBACiAKIHN0YXRpYyBMaXNwX09iamVjdCBRZ2V0X2Zp bGVfYnVmZmVyOwogCi1zdGF0aWMgTGlzcF9PYmplY3QgUW92ZXJsYXlwOworTGlzcF9PYmpl Y3QgUW92ZXJsYXlwOwogCiBMaXNwX09iamVjdCBRcHJpb3JpdHksIFFiZWZvcmVfc3RyaW5n LCBRYWZ0ZXJfc3RyaW5nOwogCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2RhdGEuYycKLS0t IHNyYy9kYXRhLmMJMjAxMy0wNi0wMyAxODoyOTozMCArMDAwMAorKysgc3JjL2RhdGEuYwky MDEzLTA2LTA1IDA0OjM4OjA0ICswMDAwCkBAIC03Niw3ICs3Niw4IEBACiBzdGF0aWMgTGlz cF9PYmplY3QgUWNvbXBpbGVkX2Z1bmN0aW9uLCBRZnJhbWU7CiBMaXNwX09iamVjdCBRYnVm ZmVyOwogc3RhdGljIExpc3BfT2JqZWN0IFFjaGFyX3RhYmxlLCBRYm9vbF92ZWN0b3IsIFFo YXNoX3RhYmxlOwotc3RhdGljIExpc3BfT2JqZWN0IFFzdWJycCwgUW1hbnksIFF1bmV2YWxs ZWQ7CitMaXNwX09iamVjdCBRc3VicnA7CitzdGF0aWMgTGlzcF9PYmplY3QgUW1hbnksIFF1 bmV2YWxsZWQ7CiBMaXNwX09iamVjdCBRZm9udF9zcGVjLCBRZm9udF9lbnRpdHksIFFmb250 X29iamVjdDsKIHN0YXRpYyBMaXNwX09iamVjdCBRZGVmdW47CiAKCj09PSBtb2RpZmllZCBm aWxlICdzcmMvZGlzcGV4dGVybi5oJwotLS0gc3JjL2Rpc3BleHRlcm4uaAkyMDEzLTA1LTA0 IDEwOjE5OjEzICswMDAwCisrKyBzcmMvZGlzcGV4dGVybi5oCTIwMTMtMDYtMDUgMDQ6Mzg6 MDQgKzAwMDAKQEAgLTIyLDYgKzIyLDggQEAKICNpZm5kZWYgRElTUEVYVEVSTl9IX0lOQ0xV REVECiAjZGVmaW5lIERJU1BFWFRFUk5fSF9JTkNMVURFRAogCisjaW5jbHVkZSAiY2hhcmFj dGVyLmgiCisKICNpZmRlZiBIQVZFX1hfV0lORE9XUwogCiAjaW5jbHVkZSA8WDExL1hsaWIu aD4KQEAgLTI3MCw2ICsyNzIsNTUgQEAKIAkJCQlHbHlwaHMKICAqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq Ki8KIAorLyogVGhlIGdseXBoIGRhdGF0eXBlLCB1c2VkIHRvIHJlcHJlc2VudCBjaGFyYWN0 ZXJzIG9uIHRoZSBkaXNwbGF5LgorICAgSXQgY29uc2lzdHMgb2YgYSBjaGFyIGNvZGUgYW5k IGEgZmFjZSBpZC4gICovCisKK3R5cGVkZWYgc3RydWN0IHsKKyAgaW50IGNoOworICBpbnQg ZmFjZV9pZDsKK30gR0xZUEg7CisKKy8qIFJldHVybiBhIGdseXBoJ3MgY2hhcmFjdGVyIGNv ZGUuICAqLworRElTUEVYVEVSTl9JTkxJTkUgaW50IEdMWVBIX0NIQVIgKEdMWVBIIGdseXBo KSB7IHJldHVybiBnbHlwaC5jaDsgfQorCisvKiBSZXR1cm4gYSBnbHlwaCdzIGZhY2UgSUQu ICAqLworRElTUEVYVEVSTl9JTkxJTkUgaW50IEdMWVBIX0ZBQ0UgKEdMWVBIIGdseXBoKSB7 IHJldHVybiBnbHlwaC5mYWNlX2lkOyB9CisKKyNkZWZpbmUgU0VUX0dMWVBIX0NIQVIoZ2x5 cGgsIGNoYXIpICgoZ2x5cGgpLmNoID0gKGNoYXIpKQorI2RlZmluZSBTRVRfR0xZUEhfRkFD RShnbHlwaCwgZmFjZSkgKChnbHlwaCkuZmFjZV9pZCA9IChmYWNlKSkKKyNkZWZpbmUgU0VU X0dMWVBIKGdseXBoLCBjaGFyLCBmYWNlKSBcCisgICgoZ2x5cGgpLmNoID0gKGNoYXIpLCAo Z2x5cGgpLmZhY2VfaWQgPSAoZmFjZSkpCisKKy8qIFRoZSBmb2xsb3dpbmcgYXJlIHZhbGlk IG9ubHkgaWYgR0xZUEhfQ09ERV9QIChnYykuICAqLworCitESVNQRVhURVJOX0lOTElORSBp bnQKK0dMWVBIX0NPREVfQ0hBUiAoTGlzcF9PYmplY3QgZ2MpCit7CisgIHJldHVybiAoQ09O U1AgKGdjKQorCSAgPyBYSU5UIChYQ0FSIChnYykpCisJICA6IFhJTlQgKGdjKSAmIE1BWF9D SEFSKTsKK30KKworRElTUEVYVEVSTl9JTkxJTkUgaW50CitHTFlQSF9DT0RFX0ZBQ0UgKExp c3BfT2JqZWN0IGdjKQoreworICByZXR1cm4gQ09OU1AgKGdjKSA/IFhJTlQgKFhDRFIgKGdj KSkgOiBYSU5UIChnYykgPj4gQ0hBUkFDVEVSQklUUzsKK30KKworI2RlZmluZSBTRVRfR0xZ UEhfRlJPTV9HTFlQSF9DT0RFKGdseXBoLCBnYykJCQkJXAorICBkbwkJCQkJCQkJCVwKKyAg ICB7CQkJCQkJCQkJXAorICAgICAgaWYgKENPTlNQIChnYykpCQkJCQkJCVwKKwlTRVRfR0xZ UEggKGdseXBoLCBYSU5UIChYQ0FSIChnYykpLCBYSU5UIChYQ0RSIChnYykpKTsJCVwKKyAg ICAgIGVsc2UJCQkJCQkJCVwKKwlTRVRfR0xZUEggKGdseXBoLCAoWElOVCAoZ2MpICYgKCgx IDw8IENIQVJBQ1RFUkJJVFMpLTEpKSwJXAorCQkgICAoWElOVCAoZ2MpID4+IENIQVJBQ1RF UkJJVFMpKTsJCQlcCisgICAgfQkJCQkJCQkJCVwKKyAgd2hpbGUgKDApCisKKy8qIFRoZSBJ RCBvZiB0aGUgbW9kZSBsaW5lIGhpZ2hsaWdodGluZyBmYWNlLiAgKi8KK2VudW0geyBHTFlQ SF9NT0RFX0xJTkVfRkFDRSA9IDEgfTsKKwogLyogRW51bWVyYXRpb24gb2YgZ2x5cGggdHlw ZXMuICBHbHlwaCBzdHJ1Y3R1cmVzIGNvbnRhaW4gYSB0eXBlIGZpZWxkCiAgICBjb250YWlu aW5nIG9uZSBvZiB0aGUgZW51bWVyYXRvcnMgZGVmaW5lZCBoZXJlLiAgKi8KIApAQCAtMTc3 NCw2ICsxODI1LDMwIEBACiAKICNlbmRpZiAvKiBub3QgSEFWRV9XSU5ET1dfU1lTVEVNICov CiAKKy8qIFJldHVybiB0cnVlIGlmIEcgY29udGFpbnMgYSB2YWxpZCBjaGFyYWN0ZXIgY29k ZS4gICovCitESVNQRVhURVJOX0lOTElORSBib29sCitHTFlQSF9DSEFSX1ZBTElEX1AgKEdM WVBIIGcpCit7CisgIHJldHVybiBDSEFSX1ZBTElEX1AgKEdMWVBIX0NIQVIgKGcpKTsKK30K KworLyogVGhlIGdseXBoIGNvZGUgZnJvbSBhIGRpc3BsYXkgdmVjdG9yIG1heSBlaXRoZXIg YmUgYW4gaW50ZWdlciB3aGljaAorICAgZW5jb2RlcyBhIGNoYXIgY29kZSBpbiB0aGUgbG93 ZXIgQ0hBUkFDVEVSQklUUyBiaXRzIGFuZCBhICh2ZXJ5IHNtYWxsKQorICAgZmFjZS1pZCBp biB0aGUgdXBwZXIgYml0cywgb3IgaXQgbWF5IGJlIGEgY29ucyAoQ0hBUiAuIEZBQ0UtSUQp LiAgKi8KKworRElTUEVYVEVSTl9JTkxJTkUgYm9vbAorR0xZUEhfQ09ERV9QIChMaXNwX09i amVjdCBnYykKK3sKKyAgcmV0dXJuIChDT05TUCAoZ2MpCisJICA/IChDSEFSQUNURVJQIChY Q0FSIChnYykpCisJICAgICAmJiBSQU5HRURfSU5URUdFUlAgKDAsIFhDRFIgKGdjKSwgTUFY X0ZBQ0VfSUQpKQorCSAgOiAoUkFOR0VEX0lOVEVHRVJQCisJICAgICAoMCwgZ2MsCisJICAg ICAgKE1BWF9GQUNFX0lEIDwgVFlQRV9NQVhJTVVNIChFTUFDU19JTlQpID4+IENIQVJBQ1RF UkJJVFMKKwkgICAgICAgPyAoKEVNQUNTX0lOVCkgTUFYX0ZBQ0VfSUQgPDwgQ0hBUkFDVEVS QklUUykgfCBNQVhfQ0hBUgorCSAgICAgICA6IFRZUEVfTUFYSU1VTSAoRU1BQ1NfSU5UKSkp KSk7Cit9CisKIC8qIE5vbi16ZXJvIG1lYW5zIGZhY2UgYXR0cmlidXRlcyBoYXZlIGJlZW4g Y2hhbmdlZCBzaW5jZSB0aGUgbGFzdAogICAgcmVkaXNwbGF5LiAgVXNlZCBpbiByZWRpc3Bs YXlfaW50ZXJuYWwuICAqLwogCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2Zucy5jJwotLS0g c3JjL2Zucy5jCTIwMTMtMDQtMDggMTg6MDQ6NTggKzAwMDAKKysrIHNyYy9mbnMuYwkyMDEz LTA2LTA1IDA0OjM4OjA0ICswMDAwCkBAIC0zMzM1LDcgKzMzMzUsOCBAQAogCiAvKiBWYXJp b3VzIHN5bWJvbHMuICAqLwogCi1zdGF0aWMgTGlzcF9PYmplY3QgUWhhc2hfdGFibGVfcCwg UWtleSwgUXZhbHVlLCBRZXFsOworTGlzcF9PYmplY3QgUWhhc2hfdGFibGVfcDsKK3N0YXRp YyBMaXNwX09iamVjdCBRa2V5LCBRdmFsdWUsIFFlcWw7CiBMaXNwX09iamVjdCBRZXEsIFFl cXVhbDsKIExpc3BfT2JqZWN0IFFDdGVzdCwgUUNzaXplLCBRQ3JlaGFzaF9zaXplLCBRQ3Jl aGFzaF90aHJlc2hvbGQsIFFDd2Vha25lc3M7CiBzdGF0aWMgTGlzcF9PYmplY3QgUWhhc2hf dGFibGVfdGVzdCwgUWtleV9vcl92YWx1ZSwgUWtleV9hbmRfdmFsdWU7Cgo9PT0gbW9kaWZp ZWQgZmlsZSAnc3JjL2xpc3AuaCcKLS0tIHNyYy9saXNwLmgJMjAxMy0wNi0wNSAxMjoxNzow MiArMDAwMAorKysgc3JjL2xpc3AuaAkyMDEzLTA2LTA2IDE1OjQ5OjI3ICswMDAwCkBAIC0y MjAsNiArMjIwLDY1IEBACiAjZW5kaWYKIAogCisvKiBXaGVuIGNvbXBpbGluZyB2aWEgR0ND IHdpdGhvdXQgb3B0aW1pemF0aW9uLCBpbmxpbmUgYSBmZXcgZnVuY3Rpb25zCisgICBtYW51 YWxseSwgYXMgRW1hY3MgaXMgdG9vIHNsb3cgb3RoZXJ3aXNlLiAgVGhlcmUncyBubyBuZWVk IHRvCisgICBpbmxpbmUgZXZlcnl0aGluZywganVzdCB0aGUgZnVuY3Rpb25zIHRoYXQgd291 bGQgY2F1c2UgYSBzZXJpb3VzCisgICBwZXJmb3JtYW5jZSBwcm9ibGVtIHdoZW4gZGVidWdn aW5nLiAgVG8gZGlzYWJsZSB0aGlzIGhhbmQtb3B0aW1pemF0aW9uLAorICAgY29tcGlsZSB3 aXRoIC1ESU5MSU5JTkc9MC4KKworICAgQ29tbWVudGFyeSBmb3IgdGhlc2UgbWFjcm9zIGNh biBiZSBmb3VuZCBuZWFyIHRoZWlyIGNvcnJlc3BvbmRpbmcKKyAgIGZ1bmN0aW9ucywgYmVs b3cuICAqLworI2lmIChkZWZpbmVkIF9fTk9fSU5MSU5FX18gXAorICAgICAmJiAhIGRlZmlu ZWQgX19PUFRJTUlaRV9fICYmICEgZGVmaW5lZCBfX09QVElNSVpFX1NJWkVfXyBcCisgICAg ICYmICEgKGRlZmluZWQgSU5MSU5JTkcgJiYgISBJTkxJTklORykpCisjIGlmIENIRUNLX0xJ U1BfT0JKRUNUX1RZUEUKKyMgIGRlZmluZSBYTEkobykgKG8pLmkKKyMgIGRlZmluZSBYSUwo aSkgKExpc3BfT2JqZWN0KSB7IGkgfQorIyBlbHNlCisjICBkZWZpbmUgWExJKG8pIChvKQor IyAgZGVmaW5lIFhJTChpKSAoaSkKKyMgZW5kaWYKKyMgZGVmaW5lIENIRUNLX0xJU1RfQ09O Uyh4LCB5KSBDSEVDS19UWVBFIChDT05TUCAoeCksIFFsaXN0cCwgeSkKKyMgZGVmaW5lIENI RUNLX05VTUJFUih4KSBDSEVDS19UWVBFIChJTlRFR0VSUCAoeCksIFFpbnRlZ2VycCwgeCkK KyMgZGVmaW5lIENIRUNLX1NZTUJPTCh4KSBDSEVDS19UWVBFIChTWU1CT0xQICh4KSwgUXN5 bWJvbHAsIHgpCisjIGRlZmluZSBDSEVDS19UWVBFKG9rLCBReHh4cCwgeCkgXAorICAgICgo dm9pZCkgKChvaykgfHwgd3JvbmdfdHlwZV9hcmd1bWVudCAoUXh4eHAsIHgpKSkKKyMgZGVm aW5lIENPTlNQKHgpIChYVFlQRSAoeCkgPT0gTGlzcF9Db25zKQorIyBkZWZpbmUgRVEoeCwg eSkgKFhMSSAoeCkgPT0gWExJICh5KSkKKyMgZGVmaW5lIEZMT0FUUCh4KSAoWFRZUEUgKHgp ID09IExpc3BfRmxvYXQpCisjIGRlZmluZSBJTlRFR0VSUCh4KSBMSVNQX0lOVF9UQUdfUCAo WFRZUEUgKHgpKQorIyBkZWZpbmUgTElTUF9JTlRfVEFHX1AoeCkgKCgoeCkgJiB+TGlzcF9J bnQxKSA9PSAwKQorIyBkZWZpbmUgTUFSS0VSUCh4KSAoTUlTQ1AgKHgpICYmIFhNSVNDVFlQ RSAoeCkgPT0gTGlzcF9NaXNjX01hcmtlcikKKyMgZGVmaW5lIE1JU0NQKHgpIChYVFlQRSAo eCkgPT0gTGlzcF9NaXNjKQorIyBkZWZpbmUgTklMUCh4KSBFUSAoeCwgUW5pbCkKKyMgZGVm aW5lIFNFVF9TWU1CT0xfVkFMKHN5bSwgdikgXAorICAgIChlYXNzZXJ0ICgoc3ltKS0+cmVk aXJlY3QgPT0gU1lNQk9MX1BMQUlOVkFMKSwgKHN5bSktPnZhbC52YWx1ZSA9ICh2KSkKKyMg ZGVmaW5lIFNZTUJPTF9DT05TVEFOVF9QKHN5bSkgKFhTWU1CT0wgKHN5bSktPmNvbnN0YW50 KQorIyBkZWZpbmUgU1lNQk9MX1ZBTChzeW0pIFwKKyAgICAoZWFzc2VydCAoKHN5bSktPnJl ZGlyZWN0ID09IFNZTUJPTF9QTEFJTlZBTCksIChzeW0pLT52YWwudmFsdWUpKQorIyBkZWZp bmUgU1lNQk9MUCh4KSAoWFRZUEUgKHgpID09IExpc3BfU3ltYm9sKQorIyBkZWZpbmUgVkVD VE9STElLRVAoeCkgKFhUWVBFICh4KSA9PSBMaXNwX1ZlY3Rvcmxpa2UpCisjIGRlZmluZSBY Q0FSKGMpIFhDT05TIChjKS0+Y2FyCisjIGRlZmluZSBYQ0RSKGMpIFhDT05TIChjKS0+dS5j ZHIKKyMgZGVmaW5lIFhDT05TKGEpIFwKKyAgICAoZWFzc2VydCAoQ09OU1AgKGEpKSwgKHN0 cnVjdCBMaXNwX0NvbnMgKikgWFVOVEFHIChhLCBMaXNwX0NvbnMpKQorIyBkZWZpbmUgWEhB U0goYSkgWFVJTlQgKGEpCisjIGRlZmluZSBYUE5UUihhKSAoKHZvaWQgKikgKGludHB0cl90 KSAoKFhMSSAoYSkgJiBWQUxNQVNLKSB8IERBVEFfU0VHX0JJVFMpKQorIyBkZWZpbmUgWFNZ TUJPTChhKSBcCisgICAgKGVhc3NlcnQgKFNZTUJPTFAgKGEpKSwgKHN0cnVjdCBMaXNwX1N5 bWJvbCAqKSBYVU5UQUcgKGEsIExpc3BfU3ltYm9sKSkKKyMgaWZuZGVmIEdDX0NIRUNLX0NP TlNfTElTVAorIyAgZGVmaW5lIGNoZWNrX2NvbnNfbGlzdCgpICgodm9pZCkgMCkKKyMgZW5k aWYKKyMgaWYgVVNFX0xTQl9UQUcKKyMgIGRlZmluZSBtYWtlX251bWJlcihuKSBYSUwgKChF TUFDU19JTlQpIChuKSA8PCBJTlRUWVBFQklUUykKKyMgIGRlZmluZSBYRkFTVElOVChhKSBY SU5UIChhKQorIyAgZGVmaW5lIFhJTlQoYSkgKFhMSSAoYSkgPj4gSU5UVFlQRUJJVFMpCisj ICBkZWZpbmUgWFRZUEUoYSkgKChlbnVtIExpc3BfVHlwZSkgKFhMSSAoYSkgJiB+VkFMTUFT SykpCisjICBkZWZpbmUgWFVOVEFHKGEsIHR5cGUpICgodm9pZCAqKSAoWExJIChhKSAtICh0 eXBlKSkpCisjIGVuZGlmCisjZW5kaWYKKworCiAvKiBEZWZpbmUgdGhlIGZ1bmRhbWVudGFs IExpc3AgZGF0YSBzdHJ1Y3R1cmVzLiAgKi8KIAogLyogVGhpcyBpcyB0aGUgc2V0IG9mIExp c3AgZGF0YSB0eXBlcy4gIElmIHlvdSB3YW50IHRvIGRlZmluZSBhIG5ldwpAQCAtMjMwLDcg KzI4OSw2IEBACiAgICBleHRlbmRpbmcgdGhlaXIgcmFuZ2UgZnJvbSwgZS5nLiwgLTJeMjgu LjJeMjgtMSB0byAtMl4yOS4uMl4yOS0xLiAgKi8KICNkZWZpbmUgSU5UTUFTSyAoRU1BQ1Nf SU5UX01BWCA+PiAoSU5UVFlQRUJJVFMgLSAxKSkKICNkZWZpbmUgY2FzZV9MaXNwX0ludCBj YXNlIExpc3BfSW50MDogY2FzZSBMaXNwX0ludDEKLSNkZWZpbmUgTElTUF9JTlRfVEFHX1Ao eCkgKCgoeCkgJiB+TGlzcF9JbnQxKSA9PSAwKQogCiAvKiBJZGVhIHN0b2xlbiBmcm9tIEdE Qi4gIE1TVkMgZG9lc24ndCBzdXBwb3J0IGVudW1zIGluIGJpdGZpZWxkcywKICAgIGFuZCB4 bGMgY29tcGxhaW5zIHZvY2lmZXJvdXNseSBhYm91dCB0aGVtLiAgKi8KQEAgLTI3MCw2ICsz MjgsOCBAQAogICAgIExpc3BfRmxvYXQgPSA3LAogICB9OwogCitMSVNQX0lOTElORSBib29s IChMSVNQX0lOVF9UQUdfUCkgKGludCB4KSB7IHJldHVybiAoeCAmIH5MaXNwX0ludDEpID09 IDA7IH0KKwogLyogVGhpcyBpcyB0aGUgc2V0IG9mIGRhdGEgdHlwZXMgdGhhdCBzaGFyZSBh IGNvbW1vbiBzdHJ1Y3R1cmUuCiAgICBUaGUgZmlyc3QgbWVtYmVyIG9mIHRoZSBzdHJ1Y3R1 cmUgaXMgYSB0eXBlIGNvZGUgZnJvbSB0aGlzIHNldC4KICAgIFRoZSBlbnVtIHZhbHVlcyBh cmUgYXJiaXRyYXJ5LCBidXQgd2UnbGwgdXNlIGxhcmdlIG51bWJlcnMgdG8gbWFrZSBpdApA QCAtMzU5LDIwICs0MTksMTUgQEAKIAogdHlwZWRlZiBzdHJ1Y3QgeyBFTUFDU19JTlQgaTsg fSBMaXNwX09iamVjdDsKIAotI2RlZmluZSBYTEkobykgKG8pLmkKK0xJU1BfSU5MSU5FIEVN QUNTX0lOVCAoWExJKSAoTGlzcF9PYmplY3QgbykgeyByZXR1cm4gby5pOyB9CisKIExJU1Bf SU5MSU5FIExpc3BfT2JqZWN0Ci1YSUwgKEVNQUNTX0lOVCBpKQorKFhJTCkgKEVNQUNTX0lO VCBpKQogewogICBMaXNwX09iamVjdCBvID0geyBpIH07CiAgIHJldHVybiBvOwogfQogCi1M SVNQX0lOTElORSBMaXNwX09iamVjdAotTElTUF9NQUtFX1JWQUxVRSAoTGlzcF9PYmplY3Qg bykKLXsKLSAgICByZXR1cm4gbzsKLX0KLQogI2RlZmluZSBMSVNQX0lOSVRJQUxMWV9aRVJP IHswfQogCiAjdW5kZWYgQ0hFQ0tfTElTUF9PQkpFQ1RfVFlQRQpAQCAtMzgyLDkgKzQzNyw4 IEBACiAvKiBJZiBhIHN0cnVjdCB0eXBlIGlzIG5vdCB3YW50ZWQsIGRlZmluZSBMaXNwX09i amVjdCBhcyBqdXN0IGEgbnVtYmVyLiAgKi8KIAogdHlwZWRlZiBFTUFDU19JTlQgTGlzcF9P YmplY3Q7Ci0jZGVmaW5lIFhMSShvKSAobykKLSNkZWZpbmUgWElMKGkpIChpKQotI2RlZmlu ZSBMSVNQX01BS0VfUlZBTFVFKG8pICgwICsgKG8pKQorTElTUF9JTkxJTkUgRU1BQ1NfSU5U IChYTEkpIChMaXNwX09iamVjdCBvKSB7IHJldHVybiBvOyB9CitMSVNQX0lOTElORSBMaXNw X09iamVjdCAoWElMKSAoRU1BQ1NfSU5UIGkpIHsgcmV0dXJuIGk7IH0KICNkZWZpbmUgTElT UF9JTklUSUFMTFlfWkVSTyAwCiBlbnVtIENIRUNLX0xJU1BfT0JKRUNUX1RZUEUgeyBDSEVD S19MSVNQX09CSkVDVF9UWVBFID0gMCB9OwogI2VuZGlmIC8qIENIRUNLX0xJU1BfT0JKRUNU X1RZUEUgKi8KQEAgLTQ2MCw4NCArNTE0LDk2IEBACiAgICAgQk9PTF9WRUNUT1JfQklUU19Q RVJfQ0hBUiA9IDgKICAgfTsKIAwKLS8qIFRoZXNlIG1hY3JvcyBleHRyYWN0IHZhcmlvdXMg c29ydHMgb2YgdmFsdWVzIGZyb20gYSBMaXNwX09iamVjdC4KKy8qIFRoZXNlIGZ1bmN0aW9u cyBleHRyYWN0IHZhcmlvdXMgc29ydHMgb2YgdmFsdWVzIGZyb20gYSBMaXNwX09iamVjdC4K ICBGb3IgZXhhbXBsZSwgaWYgdGVtIGlzIGEgTGlzcF9PYmplY3Qgd2hvc2UgdHlwZSBpcyBM aXNwX0NvbnMsCiAgWENPTlMgKHRlbSkgaXMgdGhlIHN0cnVjdCBMaXNwX0NvbnMgKiBwb2lu dGluZyB0byB0aGUgbWVtb3J5IGZvciB0aGF0IGNvbnMuICAqLwogCi0jaWYgVVNFX0xTQl9U QUcKLQotZW51bSBsc2JfYml0cwotICB7Ci0gICAgVFlQRU1BU0sgPSAoMSA8PCBHQ1RZUEVC SVRTKSAtIDEsCi0gICAgVkFMTUFTSyA9IH4gVFlQRU1BU0sKLSAgfTsKLSNkZWZpbmUgWFRZ UEUoYSkgKChlbnVtIExpc3BfVHlwZSkgKFhMSSAoYSkgJiBUWVBFTUFTSykpCi0jZGVmaW5l IFhJTlQoYSkgKFhMSSAoYSkgPj4gSU5UVFlQRUJJVFMpCi0jZGVmaW5lIFhVSU5UKGEpICgo RU1BQ1NfVUlOVCkgWExJIChhKSA+PiBJTlRUWVBFQklUUykKLSNkZWZpbmUgbWFrZV9udW1i ZXIoTikgWElMICgoRU1BQ1NfSU5UKSAoTikgPDwgSU5UVFlQRUJJVFMpCi0jZGVmaW5lIG1h a2VfbGlzcF9wdHIocHRyLCB0eXBlKSBcCi0gIChlYXNzZXJ0IChYVFlQRSAoWElMICgoaW50 cHRyX3QpIChwdHIpKSkgPT0gMCksIC8qIENoZWNrIGFsaWdubWVudC4gICovICBcCi0gICBY SUwgKCh0eXBlKSB8IChpbnRwdHJfdCkgKHB0cikpKQotCi0jZGVmaW5lIFhQTlRSKGEpICgo aW50cHRyX3QpIChYTEkgKGEpICYgflRZUEVNQVNLKSkKLSNkZWZpbmUgWFVOVEFHKGEsIHR5 cGUpICgoaW50cHRyX3QpIChYTEkgKGEpIC0gKHR5cGUpKSkKLQotI2Vsc2UgIC8qIG5vdCBV U0VfTFNCX1RBRyAqLwotCiBzdGF0aWMgRU1BQ1NfSU5UIGNvbnN0IFZBTE1BU0sKLSNkZWZp bmUgVkFMTUFTSyBWQUxfTUFYCisjZGVmaW5lIFZBTE1BU0sgKFVTRV9MU0JfVEFHID8gLSAo MSA8PCBHQ1RZUEVCSVRTKSA6IFZBTF9NQVgpCiAgICAgICA9IFZBTE1BU0s7CiAKLSNkZWZp bmUgWFRZUEUoYSkgKChlbnVtIExpc3BfVHlwZSkgKChFTUFDU19VSU5UKSBYTEkgKGEpID4+ IFZBTEJJVFMpKQotCi0vKiBGb3IgaW50ZWdlcnMga25vd24gdG8gYmUgcG9zaXRpdmUsIFhG QVNUSU5UIHByb3ZpZGVzIGZhc3QgcmV0cmlldmFsCi0gICBhbmQgWFNFVEZBU1RJTlQgcHJv dmlkZXMgZmFzdCBzdG9yYWdlLiAgVGhpcyB0YWtlcyBhZHZhbnRhZ2Ugb2YgdGhlCi0gICBm YWN0IHRoYXQgTGlzcCBpbnRlZ2VycyBoYXZlIHplcm8tYml0cyBpbiB0aGVpciB0YWdzLiAg Ki8KLSNkZWZpbmUgWEZBU1RJTlQoYSkgKFhMSSAoYSkgKyAwKQotI2RlZmluZSBYU0VURkFT VElOVChhLCBiKSAoKGEpID0gWElMIChiKSkKLQotLyogRXh0cmFjdCB0aGUgdmFsdWUgb2Yg YSBMaXNwX09iamVjdCBhcyBhICh1bilzaWduZWQgaW50ZWdlci4gICovCi0KLSNkZWZpbmUg WElOVChhKSAoWExJIChhKSA8PCBJTlRUWVBFQklUUyA+PiBJTlRUWVBFQklUUykKLSNkZWZp bmUgWFVJTlQoYSkgKChFTUFDU19VSU5UKSAoWExJIChhKSAmIElOVE1BU0spKQotI2RlZmlu ZSBtYWtlX251bWJlcihOKSBYSUwgKChFTUFDU19JTlQpIChOKSAmIElOVE1BU0spCi0KLSNk ZWZpbmUgbWFrZV9saXNwX3B0cihwdHIsIHR5cGUpIFwKLSAgKFhJTCAoKEVNQUNTX0lOVCkg KChFTUFDU19VSU5UKSAodHlwZSkgPDwgVkFMQklUUykgIFwKLQkrICgoaW50cHRyX3QpIChw dHIpICYgVkFMTUFTSykpKQotCi0vKiBEQVRBX1NFR19CSVRTIGZvcmNlcyBleHRyYSBiaXRz IHRvIGJlIG9yJ2QgaW4gd2l0aCBhbnkgcG9pbnRlcnMKLSAgIHdoaWNoIHdlcmUgc3RvcmVk IGluIGEgTGlzcF9PYmplY3QuICAqLwotI2RlZmluZSBYUE5UUihhKSAoKHVpbnRwdHJfdCkg KChYTEkgKGEpICYgVkFMTUFTSykgfCBEQVRBX1NFR19CSVRTKSkKLQotI2VuZGlmIC8qIG5v dCBVU0VfTFNCX1RBRyAqLworLyogTGFyZ2VzdCBhbmQgc21hbGxlc3QgcmVwcmVzZW50YWJs ZSBmaXhudW0gdmFsdWVzLiAgVGhlc2UgYXJlIHRoZSBDCisgICB2YWx1ZXMuICBUaGV5IGFy ZSBtYWNyb3MgZm9yIHVzZSBpbiBzdGF0aWMgaW5pdGlhbGl6ZXJzLiAgKi8KKyNkZWZpbmUg TU9TVF9QT1NJVElWRV9GSVhOVU0gKEVNQUNTX0lOVF9NQVggPj4gSU5UVFlQRUJJVFMpCisj ZGVmaW5lIE1PU1RfTkVHQVRJVkVfRklYTlVNICgtMSAtIE1PU1RfUE9TSVRJVkVfRklYTlVN KQorCitMSVNQX0lOTElORSBlbnVtIExpc3BfVHlwZQorKFhUWVBFKSAoTGlzcF9PYmplY3Qg YSkKK3sKKyAgRU1BQ1NfVUlOVCBpID0gWExJIChhKTsKKyAgcmV0dXJuIFVTRV9MU0JfVEFH ID8gaSAmIH5WQUxNQVNLIDogaSA+PiBWQUxCSVRTOworfQorCisvKiBFeHRyYWN0IHRoZSB2 YWx1ZSBvZiBhIExpc3BfT2JqZWN0IGFzIGEgc2lnbmVkIGludGVnZXIuICAqLworTElTUF9J TkxJTkUgRU1BQ1NfSU5UCisoWElOVCkgKExpc3BfT2JqZWN0IGEpCit7CisgIEVNQUNTX0lO VCBpID0gWExJIChhKTsKKyAgcmV0dXJuIChVU0VfTFNCX1RBRyA/IGkgOiBpIDw8IElOVFRZ UEVCSVRTKSA+PiBJTlRUWVBFQklUUzsKK30KKworLyogTGlrZSBYSU5UIChBKSwgYnV0IG1h eSBiZSBmYXN0ZXIuICBBIG11c3QgYmUgbm9ubmVnYXRpdmUuICBUaGlzIHRha2VzCisgICBh ZHZhbnRhZ2Ugb2YgdGhlIGZhY3QgdGhhdCBMaXNwIGludGVnZXJzIGhhdmUgemVyby1iaXRz IGluIHRoZWlyIHRhZ3MuICAqLworTElTUF9JTkxJTkUgRU1BQ1NfSU5UCisoWEZBU1RJTlQp IChMaXNwX09iamVjdCBhKQoreworICBFTUFDU19JTlQgbiA9IFVTRV9MU0JfVEFHID8gWElO VCAoYSkgOiBYTEkgKGEpID4+IElOVFRZUEVCSVRTOworICBlYXNzZXJ0ICgwIDw9IG4pOwor ICByZXR1cm4gbjsKK30KKworLyogRXh0cmFjdCB0aGUgdmFsdWUgb2YgYSBMaXNwX09iamVj dCBhcyBhbiB1bnNpZ25lZCBpbnRlZ2VyLiAgKi8KK0xJU1BfSU5MSU5FIEVNQUNTX1VJTlQK K1hVSU5UIChMaXNwX09iamVjdCBhKQoreworICBFTUFDU19VSU5UIGkgPSBYTEkgKGEpOwor ICByZXR1cm4gVVNFX0xTQl9UQUcgPyBpID4+IElOVFRZUEVCSVRTIDogaSAmIElOVE1BU0s7 Cit9CiAKIC8qIFJldHVybiBhIChMaXNwLWludGVnZXIgc2l6ZWQpIGhhc2ggb2YgdGhlIExp c3BfT2JqZWN0IHZhbHVlLiAgSGFwcGVucyB0byBiZQogICAgbGlrZSBYVUlOVCByaWdodCBu b3csIGJ1dCBYVUlOVCBzaG91bGQgb25seSBiZSBhcHBsaWVkIHRvIG9iamVjdHMgd2Uga25v dwogICAgYXJlIGludGVnZXJzLiAgKi8KLSNkZWZpbmUgWEhBU0goYSkgWFVJTlQgKGEpCi0K LS8qIEZvciBpbnRlZ2VycyBrbm93biB0byBiZSBwb3NpdGl2ZSwgWEZBU1RJTlQgc29tZXRp bWVzIHByb3ZpZGVzCi0gICBmYXN0ZXIgcmV0cmlldmFsIGFuZCBYU0VURkFTVElOVCBwcm92 aWRlcyBmYXN0ZXIgc3RvcmFnZS4KLSAgIElmIG5vdCwgZmFsbGJhY2sgb24gdGhlIG5vbi1h Y2NlbGVyYXRlZCBwYXRoLiAgKi8KLSNpZm5kZWYgWEZBU1RJTlQKLSMgZGVmaW5lIFhGQVNU SU5UKGEpIChYSU5UIChhKSkKLSMgZGVmaW5lIFhTRVRGQVNUSU5UKGEsIGIpIChYU0VUSU5U IChhLCBiKSkKLSNlbmRpZgorTElTUF9JTkxJTkUgRU1BQ1NfSU5UIChYSEFTSCkgKExpc3Bf T2JqZWN0IGEpIHsgcmV0dXJuIFhVSU5UIChhKTsgfQorCitMSVNQX0lOTElORSBMaXNwX09i amVjdAorKG1ha2VfbnVtYmVyKSAoRU1BQ1NfSU5UIG4pCit7CisgIHJldHVybiBYSUwgKFVT RV9MU0JfVEFHID8gbiA8PCBJTlRUWVBFQklUUyA6IG4gJiBJTlRNQVNLKTsKK30KKworLyog TGlrZSBtYWtlX251bWJlciAoTiksIGJ1dCBtYXkgYmUgZmFzdGVyLiAgTiBtdXN0IGJlIGlu IG5vbm5lZ2F0aXZlIHJhbmdlLiAgKi8KK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0CittYWtl X25hdG51bSAoRU1BQ1NfSU5UIG4pCit7CisgIGVhc3NlcnQgKDAgPD0gbiAmJiBuIDw9IE1P U1RfUE9TSVRJVkVfRklYTlVNKTsKKyAgcmV0dXJuIFVTRV9MU0JfVEFHID8gbWFrZV9udW1i ZXIgKG4pIDogWElMIChuKTsKK30KKworTElTUF9JTkxJTkUgdm9pZCAqCisoWFBOVFIpIChM aXNwX09iamVjdCBhKQoreworICBpbnRwdHJfdCBpID0gKFhMSSAoYSkgJiBWQUxNQVNLKSB8 IERBVEFfU0VHX0JJVFM7CisgIHJldHVybiAodm9pZCAqKSBpOworfQogCiAvKiBFeHRyYWN0 IHRoZSBwb2ludGVyIHZhbHVlIG9mIHRoZSBMaXNwIG9iamVjdCBBLCB1bmRlciB0aGUKLSAg IGFzc3VtcHRpb24gdGhhdCBBJ3MgdHlwZSBpcyBUWVBFLiAgVGhpcyBpcyBhIGZhbGxiYWNr Ci0gICBpbXBsZW1lbnRhdGlvbiBpZiBub3RoaW5nIGZhc3RlciBpcyBhdmFpbGFibGUuICAq LwotI2lmbmRlZiBYVU5UQUcKLSMgZGVmaW5lIFhVTlRBRyhhLCB0eXBlKSBYUE5UUiAoYSkK LSNlbmRpZgotCi0jZGVmaW5lIEVRKHgsIHkpIChYTEkgKHgpID09IFhMSSAoeSkpCi0KLS8q IExhcmdlc3QgYW5kIHNtYWxsZXN0IHJlcHJlc2VudGFibGUgZml4bnVtIHZhbHVlcy4gIFRo ZXNlIGFyZSB0aGUgQwotICAgdmFsdWVzLiAgVGhleSBhcmUgbWFjcm9zIGZvciB1c2UgaW4g c3RhdGljIGluaXRpYWxpemVycy4gICovCi0jZGVmaW5lIE1PU1RfUE9TSVRJVkVfRklYTlVN IChFTUFDU19JTlRfTUFYID4+IElOVFRZUEVCSVRTKQotI2RlZmluZSBNT1NUX05FR0FUSVZF X0ZJWE5VTSAoLTEgLSBNT1NUX1BPU0lUSVZFX0ZJWE5VTSkKKyAgIGFzc3VtcHRpb24gdGhh dCBBJ3MgdHlwZSBpcyBUWVBFLiAgKi8KK0xJU1BfSU5MSU5FIHZvaWQgKgorKFhVTlRBRykg KExpc3BfT2JqZWN0IGEsIGludCB0eXBlKQoreworICBpZiAoVVNFX0xTQl9UQUcpCisgICAg eworICAgICAgaW50cHRyX3QgaSA9IFhMSSAoYSkgLSB0eXBlOworICAgICAgcmV0dXJuICh2 b2lkICopIGk7CisgICAgfQorICByZXR1cm4gWFBOVFIgKGEpOworfQorCitMSVNQX0lOTElO RSBib29sCisoRVEpIChMaXNwX09iamVjdCB4LCBMaXNwX09iamVjdCB5KQoreworICByZXR1 cm4gWExJICh4KSA9PSBYTEkgKHkpOworfQogCiAvKiBWYWx1ZSBpcyBub24temVybyBpZiBJ IGRvZXNuJ3QgZml0IGludG8gYSBMaXNwIGZpeG51bS4gIEl0IGlzCiAgICB3cml0dGVuIHRo aXMgd2F5IHNvIHRoYXQgaXQgYWxzbyB3b3JrcyBpZiBJIGlzIG9mIHVuc2lnbmVkCkBAIC01 NTEsNjYgKzYxNywxOTMgQEAKIHsKICAgcmV0dXJuIG51bSA8IGxvd2VyID8gbG93ZXIgOiBu dW0gPD0gdXBwZXIgPyBudW0gOiB1cHBlcjsKIH0KLQotDAorDAorLyogRm9yd2FyZCBkZWNs YXJhdGlvbnMuICAqLworCisvKiBEZWZpbmVkIGluIHRoaXMgZmlsZS4gICovCit1bmlvbiBM aXNwX0Z3ZDsKK0xJU1BfSU5MSU5FIGJvb2wgQk9PTEZXRFAgKHVuaW9uIExpc3BfRndkICop OworTElTUF9JTkxJTkUgYm9vbCBCT09MX1ZFQ1RPUl9QIChMaXNwX09iamVjdCk7CitMSVNQ X0lOTElORSBib29sIEJVRkZFUl9PQkpGV0RQICh1bmlvbiBMaXNwX0Z3ZCAqKTsKK0xJU1Bf SU5MSU5FIGJvb2wgQlVGRkVSUCAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCBD SEFSX1RBQkxFX1AgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0IENI QVJfVEFCTEVfUkVGX0FTQ0lJIChMaXNwX09iamVjdCwgcHRyZGlmZl90KTsKK0xJU1BfSU5M SU5FIGJvb2wgKENPTlNQKSAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCAoRkxP QVRQKSAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCBmdW5jdGlvbnAgKExpc3Bf T2JqZWN0KTsKK0xJU1BfSU5MSU5FIGJvb2wgKElOVEVHRVJQKSAoTGlzcF9PYmplY3QpOwor TElTUF9JTkxJTkUgYm9vbCBJTlRGV0RQICh1bmlvbiBMaXNwX0Z3ZCAqKTsKK0xJU1BfSU5M SU5FIGJvb2wgS0JPQVJEX09CSkZXRFAgKHVuaW9uIExpc3BfRndkICopOworTElTUF9JTkxJ TkUgYm9vbCAoTUFSS0VSUCkgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIGJvb2wgKE1J U0NQKSAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCAoTklMUCkgKExpc3BfT2Jq ZWN0KTsKK0xJU1BfSU5MSU5FIGJvb2wgT0JKRldEUCAodW5pb24gTGlzcF9Gd2QgKik7CitM SVNQX0lOTElORSBib29sIE9WRVJMQVlQIChMaXNwX09iamVjdCk7CitMSVNQX0lOTElORSBi b29sIFBST0NFU1NQIChMaXNwX09iamVjdCk7CitMSVNQX0lOTElORSBib29sIFBTRVVET1ZF Q1RPUlAgKExpc3BfT2JqZWN0LCBpbnQpOworTElTUF9JTkxJTkUgYm9vbCBTQVZFX1ZBTFVF UCAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgdm9pZCBzZXRfc3ViX2NoYXJfdGFibGVf Y29udGVudHMgKExpc3BfT2JqZWN0LCBwdHJkaWZmX3QsCisJCQkJCSAgICAgIExpc3BfT2Jq ZWN0KTsKK0xJU1BfSU5MSU5FIGJvb2wgU1RSSU5HUCAoTGlzcF9PYmplY3QpOworTElTUF9J TkxJTkUgYm9vbCBTVUJfQ0hBUl9UQUJMRV9QIChMaXNwX09iamVjdCk7CitMSVNQX0lOTElO RSBib29sIFNVQlJQIChMaXNwX09iamVjdCk7CitMSVNQX0lOTElORSBib29sIChTWU1CT0xQ KSAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCAoVkVDVE9STElLRVApIChMaXNw X09iamVjdCk7CitMSVNQX0lOTElORSBib29sIFdJTkRPV1AgKExpc3BfT2JqZWN0KTsKK0xJ U1BfSU5MSU5FIHN0cnVjdCBMaXNwX1NhdmVfVmFsdWUgKlhTQVZFX1ZBTFVFIChMaXNwX09i amVjdCk7CisKKy8qIERlZmluZWQgaW4gYnVmZmVyLmMuICAqLworZXh0ZXJuIExpc3BfT2Jq ZWN0IFFvdmVybGF5cDsKKworLyogRGVmaW5lZCBpbiBjaGFydGFiLmMuICAqLworZXh0ZXJu IExpc3BfT2JqZWN0IGNoYXJfdGFibGVfcmVmIChMaXNwX09iamVjdCwgaW50KTsKK2V4dGVy biB2b2lkIGNoYXJfdGFibGVfc2V0IChMaXNwX09iamVjdCwgaW50LCBMaXNwX09iamVjdCk7 CitleHRlcm4gaW50IGNoYXJfdGFibGVfdHJhbnNsYXRlIChMaXNwX09iamVjdCwgaW50KTsK KworLyogRGVmaW5lZCBpbiBkYXRhLmMuICAqLworZXh0ZXJuIExpc3BfT2JqZWN0IFFhcnJh eXAsIFFidWZmZXJwLCBRYnVmZmVyX29yX3N0cmluZ19wLCBRY2hhcl90YWJsZV9wOworZXh0 ZXJuIExpc3BfT2JqZWN0IFFjb25zcCwgUWZsb2F0cCwgUWludGVnZXJwLCBRbGFtYmRhLCBR bGlzdHAsIFFtYXJrZXJwLCBRbmlsOworZXh0ZXJuIExpc3BfT2JqZWN0IFFudW1iZXJwLCBR c3VicnAsIFFzdHJpbmdwLCBRc3ltYm9scCwgUXZlY3RvcnA7CitleHRlcm4gTGlzcF9PYmpl Y3QgUXZlY3Rvcl9vcl9jaGFyX3RhYmxlX3AsIFF3aG9sZW51bXA7CitleHRlcm4gTGlzcF9P YmplY3QgRmZib3VuZHAgKExpc3BfT2JqZWN0KTsKK2V4dGVybiBfTm9yZXR1cm4gTGlzcF9P YmplY3Qgd3JvbmdfdHlwZV9hcmd1bWVudCAoTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0KTsK KworLyogRGVmaW5lZCBpbiBlbWFjcy5jLiAgKi8KK2V4dGVybiBib29sIGluaXRpYWxpemVk OworCisvKiBEZWZpbmVkIGluIGV2YWwuYy4gICovCitleHRlcm4gTGlzcF9PYmplY3QgUWF1 dG9sb2FkOworCisvKiBEZWZpbmVkIGluIGZucy5jICAqLworZXh0ZXJuIExpc3BfT2JqZWN0 IFFoYXNoX3RhYmxlX3A7CisKKy8qIERlZmluZWQgaW4gZmxvYXRmbnMuYy4gICovCitleHRl cm4gZG91YmxlIGV4dHJhY3RfZmxvYXQgKExpc3BfT2JqZWN0KTsKKworLyogRGVmaW5lZCBp biBwcm9jZXNzLmMuICAqLworZXh0ZXJuIExpc3BfT2JqZWN0IFFwcm9jZXNzcDsKKworLyog RGVmaW5lZCBpbiB3aW5kb3cuYy4gICovCitleHRlcm4gTGlzcF9PYmplY3QgUXdpbmRvd3As IFF3aW5kb3dfY29uZmlndXJhdGlvbl9wOworCisvKiBEZWZpbmVkIGluIHhkaXNwLmMuICAq LworZXh0ZXJuIExpc3BfT2JqZWN0IFFpbWFnZTsKKwwKKwogLyogRXh0cmFjdCBhIHZhbHVl IG9yIGFkZHJlc3MgZnJvbSBhIExpc3BfT2JqZWN0LiAgKi8KIAotI2RlZmluZSBYQ09OUyhh KSAgIChlYXNzZXJ0IChDT05TUCAoYSkpLCBcCi0JCSAgICAoc3RydWN0IExpc3BfQ29ucyAq KSBYVU5UQUcgKGEsIExpc3BfQ29ucykpCi0jZGVmaW5lIFhWRUNUT1IoYSkgKGVhc3NlcnQg KFZFQ1RPUkxJS0VQIChhKSksIFwKLQkJICAgIChzdHJ1Y3QgTGlzcF9WZWN0b3IgKikgWFVO VEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpKQotI2RlZmluZSBYU1RSSU5HKGEpIChlYXNzZXJ0 IChTVFJJTkdQIChhKSksIFwKLQkJICAgIChzdHJ1Y3QgTGlzcF9TdHJpbmcgKikgWFVOVEFH IChhLCBMaXNwX1N0cmluZykpCi0jZGVmaW5lIFhTWU1CT0woYSkgKGVhc3NlcnQgKFNZTUJP TFAgKGEpKSwgXAotCQkgICAgKHN0cnVjdCBMaXNwX1N5bWJvbCAqKSBYVU5UQUcgKGEsIExp c3BfU3ltYm9sKSkKLSNkZWZpbmUgWEZMT0FUKGEpICAoZWFzc2VydCAoRkxPQVRQIChhKSks IFwKLQkJICAgIChzdHJ1Y3QgTGlzcF9GbG9hdCAqKSBYVU5UQUcgKGEsIExpc3BfRmxvYXQp KQotCi0vKiBNaXNjIHR5cGVzLiAgKi8KLQotI2RlZmluZSBYTUlTQyhhKQkoKHVuaW9uIExp c3BfTWlzYyAqKSBYVU5UQUcgKGEsIExpc3BfTWlzYykpCi0jZGVmaW5lIFhNSVNDQU5ZKGEp CShlYXNzZXJ0IChNSVNDUCAoYSkpLCAmKFhNSVNDIChhKS0+dV9hbnkpKQotI2RlZmluZSBY TUlTQ1RZUEUoYSkgICAoWE1JU0NBTlkgKGEpLT50eXBlKQotI2RlZmluZSBYTUFSS0VSKGEp CShlYXNzZXJ0IChNQVJLRVJQIChhKSksICYoWE1JU0MgKGEpLT51X21hcmtlcikpCi0jZGVm aW5lIFhPVkVSTEFZKGEpCShlYXNzZXJ0IChPVkVSTEFZUCAoYSkpLCAmKFhNSVNDIChhKS0+ dV9vdmVybGF5KSkKLQotLyogRm9yd2FyZGluZyBvYmplY3QgdHlwZXMuICAqLwotCi0jZGVm aW5lIFhGV0RUWVBFKGEpICAgICAoYS0+dV9pbnRmd2QudHlwZSkKLSNkZWZpbmUgWElOVEZX RChhKQkoZWFzc2VydCAoSU5URldEUCAoYSkpLCAmKChhKS0+dV9pbnRmd2QpKQotI2RlZmlu ZSBYQk9PTEZXRChhKQkoZWFzc2VydCAoQk9PTEZXRFAgKGEpKSwgJigoYSktPnVfYm9vbGZ3 ZCkpCi0jZGVmaW5lIFhPQkpGV0QoYSkJKGVhc3NlcnQgKE9CSkZXRFAgKGEpKSwgJigoYSkt PnVfb2JqZndkKSkKLSNkZWZpbmUgWEJVRkZFUl9PQkpGV0QoYSkgXAotICAoZWFzc2VydCAo QlVGRkVSX09CSkZXRFAgKGEpKSwgJigoYSktPnVfYnVmZmVyX29iamZ3ZCkpCi0jZGVmaW5l IFhLQk9BUkRfT0JKRldEKGEpIFwKLSAgKGVhc3NlcnQgKEtCT0FSRF9PQkpGV0RQIChhKSks ICYoKGEpLT51X2tib2FyZF9vYmpmd2QpKQorTElTUF9JTkxJTkUgc3RydWN0IExpc3BfQ29u cyAqCisoWENPTlMpIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChDT05TUCAoYSkp OworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX0NvbnMpOworfQorCitMSVNQX0lOTElORSBz dHJ1Y3QgTGlzcF9WZWN0b3IgKgorWFZFQ1RPUiAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFz c2VydCAoVkVDVE9STElLRVAgKGEpKTsKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlzcF9WZWN0 b3JsaWtlKTsKK30KKworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfU3RyaW5nICoKK1hTVFJJ TkcgKExpc3BfT2JqZWN0IGEpCit7CisgIGVhc3NlcnQgKFNUUklOR1AgKGEpKTsKKyAgcmV0 dXJuIFhVTlRBRyAoYSwgTGlzcF9TdHJpbmcpOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3Qg TGlzcF9TeW1ib2wgKgorKFhTWU1CT0wpIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0 IChTWU1CT0xQIChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfU3ltYm9sKTsKK30K KworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfRmxvYXQgKgorWEZMT0FUIChMaXNwX09iamVj dCBhKQoreworICBlYXNzZXJ0IChGTE9BVFAgKGEpKTsKKyAgcmV0dXJuIFhVTlRBRyAoYSwg TGlzcF9GbG9hdCk7Cit9CiAKIC8qIFBzZXVkb3ZlY3RvciB0eXBlcy4gICovCi1zdHJ1Y3Qg TGlzcF9Qcm9jZXNzOwotTElTUF9JTkxJTkUgTGlzcF9PYmplY3QgbWFrZV9saXNwX3Byb2Mg KHN0cnVjdCBMaXNwX1Byb2Nlc3MgKnApCi17IHJldHVybiBtYWtlX2xpc3BfcHRyIChwLCBM aXNwX1ZlY3Rvcmxpa2UpOyB9Ci0jZGVmaW5lIFhQUk9DRVNTKGEpIChlYXNzZXJ0IChQUk9D RVNTUCAoYSkpLCBcCi0JCSAgICAgKHN0cnVjdCBMaXNwX1Byb2Nlc3MgKikgWFVOVEFHIChh LCBMaXNwX1ZlY3Rvcmxpa2UpKQotI2RlZmluZSBYV0lORE9XKGEpIChlYXNzZXJ0IChXSU5E T1dQIChhKSksCQkJCVwKLQkJICAgIChzdHJ1Y3Qgd2luZG93ICopIFhVTlRBRyAoYSwgTGlz cF9WZWN0b3JsaWtlKSkKLSNkZWZpbmUgWFRFUk1JTkFMKGEpIChlYXNzZXJ0IChURVJNSU5B TFAgKGEpKSwgXAotCQkgICAgICAoc3RydWN0IHRlcm1pbmFsICopIFhVTlRBRyAoYSwgTGlz cF9WZWN0b3JsaWtlKSkKLSNkZWZpbmUgWFNVQlIoYSkgKGVhc3NlcnQgKFNVQlJQIChhKSks IFwKLQkJICAoc3RydWN0IExpc3BfU3ViciAqKSBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlr ZSkpCi0jZGVmaW5lIFhCVUZGRVIoYSkgKGVhc3NlcnQgKEJVRkZFUlAgKGEpKSwgXAotCQkg ICAgKHN0cnVjdCBidWZmZXIgKikgWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpKQotI2Rl ZmluZSBYQ0hBUl9UQUJMRShhKSAoZWFzc2VydCAoQ0hBUl9UQUJMRV9QIChhKSksIFwKLQkJ CShzdHJ1Y3QgTGlzcF9DaGFyX1RhYmxlICopIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtl KSkKLSNkZWZpbmUgWFNVQl9DSEFSX1RBQkxFKGEpIChlYXNzZXJ0IChTVUJfQ0hBUl9UQUJM RV9QIChhKSksIFwKLQkJCSAgICAoKHN0cnVjdCBMaXNwX1N1Yl9DaGFyX1RhYmxlICopIFwK LQkJCSAgICAgWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpKSkKLSNkZWZpbmUgWEJPT0xf VkVDVE9SKGEpIChlYXNzZXJ0IChCT09MX1ZFQ1RPUl9QIChhKSksIFwKLQkJCSAoKHN0cnVj dCBMaXNwX0Jvb2xfVmVjdG9yICopIFwKLQkJCSAgWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxp a2UpKSkKKworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfUHJvY2VzcyAqCitYUFJPQ0VTUyAo TGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoUFJPQ0VTU1AgKGEpKTsKKyAgcmV0dXJu IFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKTsKK30KKworTElTUF9JTkxJTkUgc3RydWN0 IHdpbmRvdyAqCitYV0lORE9XIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChXSU5E T1dQIChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSk7Cit9CisK K0xJU1BfSU5MSU5FIHN0cnVjdCB0ZXJtaW5hbCAqCitYVEVSTUlOQUwgKExpc3BfT2JqZWN0 IGEpCit7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSk7Cit9CisKK0xJ U1BfSU5MSU5FIHN0cnVjdCBMaXNwX1N1YnIgKgorWFNVQlIgKExpc3BfT2JqZWN0IGEpCit7 CisgIGVhc3NlcnQgKFNVQlJQIChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVj dG9ybGlrZSk7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVjdCBidWZmZXIgKgorWEJVRkZFUiAo TGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoQlVGRkVSUCAoYSkpOworICByZXR1cm4g WFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3Qg TGlzcF9DaGFyX1RhYmxlICoKK1hDSEFSX1RBQkxFIChMaXNwX09iamVjdCBhKQoreworICBl YXNzZXJ0IChDSEFSX1RBQkxFX1AgKGEpKTsKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlzcF9W ZWN0b3JsaWtlKTsKK30KKworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfU3ViX0NoYXJfVGFi bGUgKgorWFNVQl9DSEFSX1RBQkxFIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChT VUJfQ0hBUl9UQUJMRV9QIChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVjdG9y bGlrZSk7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVjdCBMaXNwX0Jvb2xfVmVjdG9yICoKK1hC T09MX1ZFQ1RPUiAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoQk9PTF9WRUNUT1Jf UCAoYSkpOworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQogCiAv KiBDb25zdHJ1Y3QgYSBMaXNwX09iamVjdCBmcm9tIGEgdmFsdWUgb3IgYWRkcmVzcy4gICov CiAKK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0CittYWtlX2xpc3BfcHRyICh2b2lkICpwdHIs IGVudW0gTGlzcF9UeXBlIHR5cGUpCit7CisgIEVNQUNTX1VJTlQgdXR5cGUgPSB0eXBlOwor ICBFTUFDU19JTlQgdHlwZWJpdHMgPSBVU0VfTFNCX1RBRyA/IHR5cGUgOiB1dHlwZSA8PCBW QUxCSVRTOworICBMaXNwX09iamVjdCBhID0gWElMICh0eXBlYml0cyB8IChpbnRwdHJfdCkg cHRyKTsKKyAgZWFzc2VydCAoWFVOVEFHIChhLCB0eXBlKSA9PSBwdHIpOyAgLyogQ2hlY2sg YWxpZ25tZW50LiAgKi8KKyAgcmV0dXJuIGE7Cit9CisKK0xJU1BfSU5MSU5FIExpc3BfT2Jq ZWN0CittYWtlX2xpc3BfcHJvYyAoc3RydWN0IExpc3BfUHJvY2VzcyAqcCkKK3sKKyAgcmV0 dXJuIG1ha2VfbGlzcF9wdHIgKHAsIExpc3BfVmVjdG9ybGlrZSk7Cit9CisKICNkZWZpbmUg WFNFVElOVChhLCBiKSAoKGEpID0gbWFrZV9udW1iZXIgKGIpKQorI2RlZmluZSBYU0VURkFT VElOVChhLCBiKSAoKGEpID0gbWFrZV9uYXRudW0gKGIpKQogI2RlZmluZSBYU0VUQ09OUyhh LCBiKSAoKGEpID0gbWFrZV9saXNwX3B0ciAoYiwgTGlzcF9Db25zKSkKICNkZWZpbmUgWFNF VFZFQ1RPUihhLCBiKSAoKGEpID0gbWFrZV9saXNwX3B0ciAoYiwgTGlzcF9WZWN0b3JsaWtl KSkKICNkZWZpbmUgWFNFVFNUUklORyhhLCBiKSAoKGEpID0gbWFrZV9saXNwX3B0ciAoYiwg TGlzcF9TdHJpbmcpKQpAQCAtNjU2LDM1ICs4NDksMTQgQEAKICNkZWZpbmUgWFNFVEJPT0xf VkVDVE9SKGEsIGIpIChYU0VUUFNFVURPVkVDVE9SIChhLCBiLCBQVkVDX0JPT0xfVkVDVE9S KSkKICNkZWZpbmUgWFNFVFNVQl9DSEFSX1RBQkxFKGEsIGIpIChYU0VUUFNFVURPVkVDVE9S IChhLCBiLCBQVkVDX1NVQl9DSEFSX1RBQkxFKSkKIAotLyogQ29udmVuaWVuY2UgbWFjcm9z IGZvciBkZWFsaW5nIHdpdGggTGlzcCBhcnJheXMuICAqLwotCi0jZGVmaW5lIEFSRUYoQVJS QVksIElEWCkJWFZFQ1RPUiAoKEFSUkFZKSktPmNvbnRlbnRzW0lEWF0KLSNkZWZpbmUgQVNJ WkUoQVJSQVkpCQlYVkVDVE9SICgoQVJSQVkpKS0+aGVhZGVyLnNpemUKLSNkZWZpbmUgQVNF VChBUlJBWSwgSURYLCBWQUwpCVwKLSAgKGVhc3NlcnQgKDAgPD0gKElEWCkgJiYgKElEWCkg PCBBU0laRSAoQVJSQVkpKSwJXAotICAgWFZFQ1RPUiAoQVJSQVkpLT5jb250ZW50c1tJRFhd ID0gKFZBTCkpCi0KLS8qIENvbnZlbmllbmNlIG1hY3JvcyBmb3IgZGVhbGluZyB3aXRoIExp c3Agc3RyaW5ncy4gICovCi0KLSNkZWZpbmUgU0RBVEEoc3RyaW5nKQkJKFhTVFJJTkcgKHN0 cmluZyktPmRhdGEgKyAwKQotI2RlZmluZSBTUkVGKHN0cmluZywgaW5kZXgpCShTREFUQSAo c3RyaW5nKVtpbmRleF0gKyAwKQotI2RlZmluZSBTU0VUKHN0cmluZywgaW5kZXgsIG5ldykg KFNEQVRBIChzdHJpbmcpW2luZGV4XSA9IChuZXcpKQotI2RlZmluZSBTQ0hBUlMoc3RyaW5n KQkJKFhTVFJJTkcgKHN0cmluZyktPnNpemUgKyAwKQotI2RlZmluZSBTQllURVMoc3RyaW5n KQkJKFNUUklOR19CWVRFUyAoWFNUUklORyAoc3RyaW5nKSkgKyAwKQotCi0vKiBBdm9pZCAi ZGlmZmVyIGluIHNpZ24iIHdhcm5pbmdzLiAgKi8KLSNkZWZpbmUgU1NEQVRBKHgpICAoKGNo YXIgKikgU0RBVEEgKHgpKQotCi0jZGVmaW5lIFNUUklOR19TRVRfQ0hBUlMoc3RyaW5nLCBu ZXdzaXplKSBcCi0gICAgKFhTVFJJTkcgKHN0cmluZyktPnNpemUgPSAobmV3c2l6ZSkpCi0K LSNkZWZpbmUgU1RSSU5HX0NPUFlJTihzdHJpbmcsIGluZGV4LCBuZXcsIGNvdW50KSBcCi0g ICAgbWVtY3B5IChTREFUQSAoc3RyaW5nKSArIGluZGV4LCBuZXcsIGNvdW50KQotCiAvKiBU eXBlIGNoZWNraW5nLiAgKi8KIAotI2RlZmluZSBDSEVDS19UWVBFKG9rLCBReHh4cCwgeCkg XAotICBkbyB7IGlmICghKG9rKSkgd3JvbmdfdHlwZV9hcmd1bWVudCAoUXh4eHAsICh4KSk7 IH0gd2hpbGUgKDApCitMSVNQX0lOTElORSB2b2lkCisoQ0hFQ0tfVFlQRSkgKGludCBvaywg TGlzcF9PYmplY3QgUXh4eHAsIExpc3BfT2JqZWN0IHgpCit7CisgIGlmICghb2spCisgICAg d3JvbmdfdHlwZV9hcmd1bWVudCAoUXh4eHAsIHgpOworfQogCiAvKiBEZXByZWNhdGVkIGFu ZCB3aWxsIGJlIHJlbW92ZWQgc29vbi4gICovCiAKQEAgLTY5NSw4ICs4NjcsMTEgQEAKIHR5 cGVkZWYgc3RydWN0IGludGVydmFsICpJTlRFUlZBTDsKIAogLyogQ29tcGxhaW4gaWYgb2Jq ZWN0IGlzIG5vdCBzdHJpbmcgb3IgYnVmZmVyIHR5cGUuICAqLwotI2RlZmluZSBDSEVDS19T VFJJTkdfT1JfQlVGRkVSKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoU1RSSU5HUCAoeCkgfHwgQlVG RkVSUCAoeCksIFFidWZmZXJfb3Jfc3RyaW5nX3AsIHgpCitMSVNQX0lOTElORSB2b2lkCitD SEVDS19TVFJJTkdfT1JfQlVGRkVSIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBF IChTVFJJTkdQICh4KSB8fCBCVUZGRVJQICh4KSwgUWJ1ZmZlcl9vcl9zdHJpbmdfcCwgeCk7 Cit9CiAKIHN0cnVjdCBMaXNwX0NvbnMKICAgewpAQCAtNzE0LDY0ICs4ODksNzggQEAKICAg fTsKIAogLyogVGFrZSB0aGUgY2FyIG9yIGNkciBvZiBzb21ldGhpbmcga25vd24gdG8gYmUg YSBjb25zIGNlbGwuICAqLwotLyogVGhlIF9BU19MVkFMVUUgbWFjcm9zIHNob3VsZG4ndCBi ZSB1c2VkIG91dHNpZGUgb2YgdGhlIG1pbmltYWwgc2V0CisvKiBUaGUgX2FkZHIgZnVuY3Rp b25zIHNob3VsZG4ndCBiZSB1c2VkIG91dHNpZGUgb2YgdGhlIG1pbmltYWwgc2V0CiAgICBv ZiBjb2RlIHRoYXQgaGFzIHRvIGtub3cgd2hhdCBhIGNvbnMgY2VsbCBsb29rcyBsaWtlLiAg T3RoZXIgY29kZSBub3QKICAgIHBhcnQgb2YgdGhlIGJhc2ljIGxpc3AgaW1wbGVtZW50YXRp b24gc2hvdWxkIGFzc3VtZSB0aGF0IHRoZSBjYXIgYW5kIGNkcgotICAgZmllbGRzIGFyZSBu b3QgYWNjZXNzaWJsZSBhcyBsdmFsdWVzLiAgKFdoYXQgaWYgd2Ugd2FudCB0byBzd2l0Y2gg dG8KKyAgIGZpZWxkcyBhcmUgbm90IGFjY2Vzc2libGUuICAoV2hhdCBpZiB3ZSB3YW50IHRv IHN3aXRjaCB0bwogICAgYSBjb3B5aW5nIGNvbGxlY3RvciBzb21lZGF5PyAgQ2FjaGVkIGNv bnMgY2VsbCBmaWVsZCBhZGRyZXNzZXMgbWF5IGJlCiAgICBpbnZhbGlkYXRlZCBhdCBhcmJp dHJhcnkgcG9pbnRzLikgICovCi0jZGVmaW5lIFhDQVJfQVNfTFZBTFVFKGMpIChYQ09OUyAo YyktPmNhcikKLSNkZWZpbmUgWENEUl9BU19MVkFMVUUoYykgKFhDT05TIChjKS0+dS5jZHIp CitMSVNQX0lOTElORSBMaXNwX09iamVjdCAqeGNhcl9hZGRyIChMaXNwX09iamVjdCBjKSB7 IHJldHVybiAmWENPTlMgKGMpLT5jYXI7IH0KK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0ICp4 Y2RyX2FkZHIgKExpc3BfT2JqZWN0IGMpIHsgcmV0dXJuICZYQ09OUyAoYyktPnUuY2RyOyB9 CiAKIC8qIFVzZSB0aGVzZSBmcm9tIG5vcm1hbCBjb2RlLiAgKi8KLSNkZWZpbmUgWENBUihj KQlMSVNQX01BS0VfUlZBTFVFIChYQ0FSX0FTX0xWQUxVRSAoYykpCi0jZGVmaW5lIFhDRFIo YykgTElTUF9NQUtFX1JWQUxVRSAoWENEUl9BU19MVkFMVUUgKGMpKQorTElTUF9JTkxJTkUg TGlzcF9PYmplY3QgKFhDQVIpIChMaXNwX09iamVjdCBjKSB7IHJldHVybiAqeGNhcl9hZGRy IChjKTsgfQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QgKFhDRFIpIChMaXNwX09iamVjdCBj KSB7IHJldHVybiAqeGNkcl9hZGRyIChjKTsgfQogCiAvKiBVc2UgdGhlc2UgdG8gc2V0IHRo ZSBmaWVsZHMgb2YgYSBjb25zIGNlbGwuCiAKICAgIE5vdGUgdGhhdCBib3RoIGFyZ3VtZW50 cyBtYXkgcmVmZXIgdG8gdGhlIHNhbWUgb2JqZWN0LCBzbyAnbicKLSAgIHNob3VsZCBub3Qg YmUgcmVhZCBhZnRlciAnYycgaXMgZmlyc3QgbW9kaWZpZWQuICBBbHNvLCBuZWl0aGVyCi0g ICBhcmd1bWVudCBzaG91bGQgYmUgZXZhbHVhdGVkIG1vcmUgdGhhbiBvbmNlOyBzaWRlIGVm ZmVjdHMgYXJlCi0gICBlc3BlY2lhbGx5IGNvbW1vbiBpbiB0aGUgc2Vjb25kIGFyZ3VtZW50 LiAgKi8KLSNkZWZpbmUgWFNFVENBUihjLG4pIChYQ0FSX0FTX0xWQUxVRSAoYykgPSAobikp Ci0jZGVmaW5lIFhTRVRDRFIoYyxuKSAoWENEUl9BU19MVkFMVUUgKGMpID0gKG4pKQotCi0v KiBUYWtlIHRoZSBjYXIgb3IgY2RyIG9mIHNvbWV0aGluZyB3aG9zZSB0eXBlIGlzIG5vdCBr bm93bi4gICovCi0jZGVmaW5lIENBUihjKQkJCQkJXAotIChDT05TUCAoKGMpKSA/IFhDQVIg KChjKSkJCQlcCi0gIDogTklMUCAoKGMpKSA/IFFuaWwJCQkJXAotICA6IHdyb25nX3R5cGVf YXJndW1lbnQgKFFsaXN0cCwgKGMpKSkKLQotI2RlZmluZSBDRFIoYykJCQkJCVwKLSAoQ09O U1AgKChjKSkgPyBYQ0RSICgoYykpCQkJXAotICA6IE5JTFAgKChjKSkgPyBRbmlsCQkJCVwK LSAgOiB3cm9uZ190eXBlX2FyZ3VtZW50IChRbGlzdHAsIChjKSkpCi0KLS8qIFRha2UgdGhl IGNhciBvciBjZHIgb2Ygc29tZXRoaW5nIHdob3NlIHR5cGUgaXMgbm90IGtub3duLiAgKi8K LSNkZWZpbmUgQ0FSX1NBRkUoYykJCQkJXAotICAoQ09OU1AgKChjKSkgPyBYQ0FSICgoYykp IDogUW5pbCkKLQotI2RlZmluZSBDRFJfU0FGRShjKQkJCQlcCi0gIChDT05TUCAoKGMpKSA/ IFhDRFIgKChjKSkgOiBRbmlsKQorICAgc2hvdWxkIG5vdCBiZSByZWFkIGFmdGVyICdjJyBp cyBmaXJzdCBtb2RpZmllZC4gICovCitMSVNQX0lOTElORSB2b2lkCitYU0VUQ0FSIChMaXNw X09iamVjdCBjLCBMaXNwX09iamVjdCBuKQoreworICAqeGNhcl9hZGRyIChjKSA9IG47Cit9 CitMSVNQX0lOTElORSB2b2lkCitYU0VUQ0RSIChMaXNwX09iamVjdCBjLCBMaXNwX09iamVj dCBuKQoreworICAqeGNkcl9hZGRyIChjKSA9IG47Cit9CisKKy8qIFRha2UgdGhlIGNhciBv ciBjZHIgb2Ygc29tZXRoaW5nIHdob3NlIHR5cGUgaXMgbm90IGtub3duLiAgKi8KK0xJU1Bf SU5MSU5FIExpc3BfT2JqZWN0CitDQVIgKExpc3BfT2JqZWN0IGMpCit7CisgIHJldHVybiAo Q09OU1AgKGMpID8gWENBUiAoYykKKwkgIDogTklMUCAoYykgPyBRbmlsCisJICA6IHdyb25n X3R5cGVfYXJndW1lbnQgKFFsaXN0cCwgYykpOworfQorTElTUF9JTkxJTkUgTGlzcF9PYmpl Y3QKK0NEUiAoTGlzcF9PYmplY3QgYykKK3sKKyAgcmV0dXJuIChDT05TUCAoYykgPyBYQ0RS IChjKQorCSAgOiBOSUxQIChjKSA/IFFuaWwKKwkgIDogd3JvbmdfdHlwZV9hcmd1bWVudCAo UWxpc3RwLCBjKSk7Cit9CisKKy8qIFRha2UgdGhlIGNhciBvciBjZHIgb2Ygc29tZXRoaW5n IHdob3NlIHR5cGUgaXMgbm90IGtub3duLiAgKi8KK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0 CitDQVJfU0FGRSAoTGlzcF9PYmplY3QgYykKK3sKKyAgcmV0dXJuIENPTlNQIChjKSA/IFhD QVIgKGMpIDogUW5pbDsKK30KK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0CitDRFJfU0FGRSAo TGlzcF9PYmplY3QgYykKK3sKKyAgcmV0dXJuIENPTlNQIChjKSA/IFhDRFIgKGMpIDogUW5p bDsKK30KKworLyogSW4gYSBzdHJpbmcgb3IgdmVjdG9yLCB0aGUgc2lnbiBiaXQgb2YgdGhl IGBzaXplJyBpcyB0aGUgZ2MgbWFyayBiaXQuICAqLworCitzdHJ1Y3QgTGlzcF9TdHJpbmcK KyAgeworICAgIHB0cmRpZmZfdCBzaXplOworICAgIHB0cmRpZmZfdCBzaXplX2J5dGU7Cisg ICAgSU5URVJWQUwgaW50ZXJ2YWxzOwkJLyogVGV4dCBwcm9wZXJ0aWVzIGluIHRoaXMgc3Ry aW5nLiAgKi8KKyAgICB1bnNpZ25lZCBjaGFyICpkYXRhOworICB9OwogCiAvKiBUcnVlIGlm IFNUUiBpcyBhIG11bHRpYnl0ZSBzdHJpbmcuICAqLwotI2RlZmluZSBTVFJJTkdfTVVMVElC WVRFKFNUUikgIFwKLSAgKFhTVFJJTkcgKFNUUiktPnNpemVfYnl0ZSA+PSAwKQotCi0vKiBS ZXR1cm4gdGhlIGxlbmd0aCBpbiBieXRlcyBvZiBTVFIuICAqLwotCi0jaWZkZWYgR0NfQ0hF Q0tfU1RSSU5HX0JZVEVTCi0KLXN0cnVjdCBMaXNwX1N0cmluZzsKLWV4dGVybiBwdHJkaWZm X3Qgc3RyaW5nX2J5dGVzIChzdHJ1Y3QgTGlzcF9TdHJpbmcgKik7Ci0jZGVmaW5lIFNUUklO R19CWVRFUyhTKSBzdHJpbmdfYnl0ZXMgKChTKSkKLQotI2Vsc2UgLyogbm90IEdDX0NIRUNL X1NUUklOR19CWVRFUyAqLwotCi0jZGVmaW5lIFNUUklOR19CWVRFUyhTVFIpICBcCi0gICgo U1RSKS0+c2l6ZV9ieXRlIDwgMCA/IChTVFIpLT5zaXplIDogKFNUUiktPnNpemVfYnl0ZSkK LQotI2VuZGlmIC8qIG5vdCBHQ19DSEVDS19TVFJJTkdfQllURVMgKi8KK0xJU1BfSU5MSU5F IGJvb2wKK1NUUklOR19NVUxUSUJZVEUgKExpc3BfT2JqZWN0IHN0cikKK3sKKyAgcmV0dXJu IDAgPD0gWFNUUklORyAoc3RyKS0+c2l6ZV9ieXRlOworfQogCiAvKiBBbiB1cHBlciBib3Vu ZCBvbiB0aGUgbnVtYmVyIG9mIGJ5dGVzIGluIGEgTGlzcCBzdHJpbmcsIG5vdAogICAgY291 bnRpbmcgdGhlIHRlcm1pbmF0aW5nIG51bGwuICBUaGlzIGEgdGlnaHQgZW5vdWdoIGJvdW5k IHRvCkBAIC04MDIsMjAgKzk5MSw2NSBAQAogICAgICAgKFNUUikgPSBlbXB0eV9tdWx0aWJ5 dGVfc3RyaW5nOyAgXAogICAgIGVsc2UgWFNUUklORyAoU1RSKS0+c2l6ZV9ieXRlID0gWFNU UklORyAoU1RSKS0+c2l6ZTsgfSB3aGlsZSAoMCkKIAotLyogSW4gYSBzdHJpbmcgb3IgdmVj dG9yLCB0aGUgc2lnbiBiaXQgb2YgdGhlIGBzaXplJyBpcyB0aGUgZ2MgbWFyayBiaXQuICAq LworLyogQ29udmVuaWVuY2UgZnVuY3Rpb25zIGZvciBkZWFsaW5nIHdpdGggTGlzcCBzdHJp bmdzLiAgKi8KIAotc3RydWN0IExpc3BfU3RyaW5nCi0gIHsKLSAgICBwdHJkaWZmX3Qgc2l6 ZTsKLSAgICBwdHJkaWZmX3Qgc2l6ZV9ieXRlOwotICAgIElOVEVSVkFMIGludGVydmFsczsJ CS8qIFRleHQgcHJvcGVydGllcyBpbiB0aGlzIHN0cmluZy4gICovCi0gICAgdW5zaWduZWQg Y2hhciAqZGF0YTsKLSAgfTsKK0xJU1BfSU5MSU5FIHVuc2lnbmVkIGNoYXIgKgorU0RBVEEg KExpc3BfT2JqZWN0IHN0cmluZykKK3sKKyAgcmV0dXJuIFhTVFJJTkcgKHN0cmluZyktPmRh dGE7Cit9CitMSVNQX0lOTElORSBjaGFyICoKK1NTREFUQSAoTGlzcF9PYmplY3Qgc3RyaW5n KQoreworICAvKiBBdm9pZCAiZGlmZmVyIGluIHNpZ24iIHdhcm5pbmdzLiAgKi8KKyAgcmV0 dXJuIChjaGFyICopIFNEQVRBIChzdHJpbmcpOworfQorTElTUF9JTkxJTkUgdW5zaWduZWQg Y2hhcgorU1JFRiAoTGlzcF9PYmplY3Qgc3RyaW5nLCBwdHJkaWZmX3QgaW5kZXgpCit7Cisg IHJldHVybiBTREFUQSAoc3RyaW5nKVtpbmRleF07Cit9CitMSVNQX0lOTElORSB2b2lkCitT U0VUIChMaXNwX09iamVjdCBzdHJpbmcsIHB0cmRpZmZfdCBpbmRleCwgdW5zaWduZWQgY2hh ciBuZXcpCit7CisgIFNEQVRBIChzdHJpbmcpW2luZGV4XSA9IG5ldzsKK30KK0xJU1BfSU5M SU5FIHB0cmRpZmZfdAorU0NIQVJTIChMaXNwX09iamVjdCBzdHJpbmcpCit7CisgIHJldHVy biBYU1RSSU5HIChzdHJpbmcpLT5zaXplOworfQorTElTUF9JTkxJTkUgcHRyZGlmZl90CitT VFJJTkdfQllURVMgKHN0cnVjdCBMaXNwX1N0cmluZyAqcykKK3sKKyNpZmRlZiBHQ19DSEVD S19TVFJJTkdfQllURVMKKyAgZXh0ZXJuIHB0cmRpZmZfdCBzdHJpbmdfYnl0ZXMgKHN0cnVj dCBMaXNwX1N0cmluZyAqKTsKKyAgcmV0dXJuIHN0cmluZ19ieXRlcyAocyk7CisjZWxzZQor ICByZXR1cm4gcy0+c2l6ZV9ieXRlIDwgMCA/IHMtPnNpemUgOiBzLT5zaXplX2J5dGU7Cisj ZW5kaWYKK30KK0xJU1BfSU5MSU5FIHB0cmRpZmZfdAorU0JZVEVTIChMaXNwX09iamVjdCBz dHJpbmcpCit7CisgIHJldHVybiBTVFJJTkdfQllURVMgKFhTVFJJTkcgKHN0cmluZykpOwor fQorTElTUF9JTkxJTkUgdm9pZAorU1RSSU5HX1NFVF9DSEFSUyAoTGlzcF9PYmplY3Qgc3Ry aW5nLCBwdHJkaWZmX3QgbmV3c2l6ZSkKK3sKKyAgWFNUUklORyAoc3RyaW5nKS0+c2l6ZSA9 IG5ld3NpemU7Cit9CitMSVNQX0lOTElORSB2b2lkCitTVFJJTkdfQ09QWUlOIChMaXNwX09i amVjdCBzdHJpbmcsIHB0cmRpZmZfdCBpbmRleCwgY2hhciBjb25zdCAqbmV3LAorCSAgICAg ICBwdHJkaWZmX3QgY291bnQpCit7CisgIG1lbWNweSAoU0RBVEEgKHN0cmluZykgKyBpbmRl eCwgbmV3LCBjb3VudCk7Cit9CiAKIC8qIEhlYWRlciBvZiB2ZWN0b3ItbGlrZSBvYmplY3Rz LiAgVGhpcyBkb2N1bWVudHMgdGhlIGxheW91dCBjb25zdHJhaW50cyBvbgogICAgdmVjdG9y cyBhbmQgcHNldWRvdmVjdG9ycyAob2JqZWN0cyBvZiBQVkVDX3h4eCBzdWJ0eXBlKS4gIEl0 IGFsc28gcHJldmVudHMKLSAgIGNvbXBpbGVycyBmcm9tIGJlaW5nIGZvb2xlZCBieSBFbWFj cydzIHR5cGUgcHVubmluZzogdGhlIFhTRVRQU0VVRE9WRUNUT1IKLSAgIGFuZCBQU0VVRE9W RUNUT1JQIG1hY3JvcyBjYXN0IHRoZWlyIHBvaW50ZXJzIHRvIHN0cnVjdCB2ZWN0b3JsaWtl X2hlYWRlciAqLAorICAgY29tcGlsZXJzIGZyb20gYmVpbmcgZm9vbGVkIGJ5IEVtYWNzJ3Mg dHlwZSBwdW5uaW5nOiBYU0VUUFNFVURPVkVDVE9SCisgICBhbmQgUFNFVURPVkVDVE9SUCBj YXN0IHRoZWlyIHBvaW50ZXJzIHRvIHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRlciAqLAogICAg YmVjYXVzZSB3aGVuIHR3byBzdWNoIHBvaW50ZXJzIHBvdGVudGlhbGx5IGFsaWFzLCBhIGNv bXBpbGVyIHdvbid0CiAgICBpbmNvcnJlY3RseSByZW9yZGVyIGxvYWRzIGFuZCBzdG9yZXMg dG8gdGhlaXIgc2l6ZSBmaWVsZHMuICBTZWUKICAgIDxodHRwOi8vZGViYnVncy5nbnUub3Jn L2NnaS9idWdyZXBvcnQuY2dpP2J1Zz04NTQ2Pi4gICovCkBAIC04NzQsNiArMTEwOCw0MiBA QAogICAgIHdvcmRfc2l6ZSA9IHNpemVvZiAoTGlzcF9PYmplY3QpCiAgIH07CiAKKy8qIENv bnZlbmllbmNlcyBmb3IgZGVhbGluZyB3aXRoIExpc3AgYXJyYXlzLiAgKi8KKworTElTUF9J TkxJTkUgTGlzcF9PYmplY3QKK0FSRUYgKExpc3BfT2JqZWN0IGFycmF5LCBwdHJkaWZmX3Qg aWR4KQoreworICByZXR1cm4gWFZFQ1RPUiAoYXJyYXkpLT5jb250ZW50c1tpZHhdOworfQor CitMSVNQX0lOTElORSBMaXNwX09iamVjdCAqCithcmVmX2FkZHIgKExpc3BfT2JqZWN0IGFy cmF5LCBwdHJkaWZmX3QgaWR4KQoreworICByZXR1cm4gJiBYVkVDVE9SIChhcnJheSktPmNv bnRlbnRzW2lkeF07Cit9CisKK0xJU1BfSU5MSU5FIHB0cmRpZmZfdAorQVNJWkUgKExpc3Bf T2JqZWN0IGFycmF5KQoreworICByZXR1cm4gWFZFQ1RPUiAoYXJyYXkpLT5oZWFkZXIuc2l6 ZTsKK30KKworTElTUF9JTkxJTkUgdm9pZAorQVNFVCAoTGlzcF9PYmplY3QgYXJyYXksIHB0 cmRpZmZfdCBpZHgsIExpc3BfT2JqZWN0IHZhbCkKK3sKKyAgZWFzc2VydCAoMCA8PSBpZHgg JiYgaWR4IDwgQVNJWkUgKGFycmF5KSk7CisgIFhWRUNUT1IgKGFycmF5KS0+Y29udGVudHNb aWR4XSA9IHZhbDsKK30KKworTElTUF9JTkxJTkUgdm9pZAorZ2NfYXNldCAoTGlzcF9PYmpl Y3QgYXJyYXksIHB0cmRpZmZfdCBpZHgsIExpc3BfT2JqZWN0IHZhbCkKK3sKKyAgLyogTGlr ZSBBU0VULCBidXQgYWxzbyBjYW4gYmUgdXNlZCBpbiB0aGUgZ2FyYmFnZSBjb2xsZWN0b3I6 CisgICAgIHN3ZWVwX3dlYWtfdGFibGUgY2FsbHMgc2V0X2hhc2hfa2V5IGV0Yy4gd2hpbGUg dGhlIHRhYmxlIGlzIG1hcmtlZC4gICovCisgIGVhc3NlcnQgKDAgPD0gaWR4ICYmIGlkeCA8 IChBU0laRSAoYXJyYXkpICYgfkFSUkFZX01BUktfRkxBRykpOworICBYVkVDVE9SIChhcnJh eSktPmNvbnRlbnRzW2lkeF0gPSB2YWw7Cit9CisKIC8qIElmIGEgc3RydWN0IGlzIG1hZGUg dG8gbG9vayBsaWtlIGEgdmVjdG9yLCB0aGlzIG1hY3JvIHJldHVybnMgdGhlIGxlbmd0aAog ICAgb2YgdGhlIHNob3J0ZXN0IHZlY3RvciB0aGF0IHdvdWxkIGhvbGQgdGhhdCBzdHJ1Y3Qu ICAqLwogCkBAIC04ODcsNDMgKzExNTcsNiBAQAogI2RlZmluZSBQU0VVRE9WRUNTSVpFKHR5 cGUsIG5vbmxpc3BmaWVsZCkJCQlcCiAgICgob2Zmc2V0b2YgKHR5cGUsIG5vbmxpc3BmaWVs ZCkgLSBoZWFkZXJfc2l6ZSkgLyB3b3JkX3NpemUpCiAKLS8qIEEgY2hhci10YWJsZSBpcyBh IGtpbmQgb2YgdmVjdG9ybGlrZSwgd2l0aCBjb250ZW50cyBhcmUgbGlrZSBhCi0gICB2ZWN0 b3IgYnV0IHdpdGggYSBmZXcgb3RoZXIgc2xvdHMuICBGb3Igc29tZSBwdXJwb3NlcywgaXQg bWFrZXMKLSAgIHNlbnNlIHRvIGhhbmRsZSBhIGNoYXItdGFibGUgd2l0aCB0eXBlIHN0cnVj dCBMaXNwX1ZlY3Rvci4gIEFuCi0gICBlbGVtZW50IG9mIGEgY2hhciB0YWJsZSBjYW4gYmUg YW55IExpc3Agb2JqZWN0cywgYnV0IGlmIGl0IGlzIGEgc3ViCi0gICBjaGFyLXRhYmxlLCB3 ZSB0cmVhdCBpdCBhIHRhYmxlIHRoYXQgY29udGFpbnMgaW5mb3JtYXRpb24gb2YgYQotICAg c3BlY2lmaWMgcmFuZ2Ugb2YgY2hhcmFjdGVycy4gIEEgc3ViIGNoYXItdGFibGUgaGFzIHRo ZSBzYW1lCi0gICBzdHJ1Y3R1cmUgYXMgYSB2ZWN0b3IuICBBIHN1YiBjaGFyIHRhYmxlIGFw cGVhcnMgb25seSBpbiBhbiBlbGVtZW50Ci0gICBvZiBhIGNoYXItdGFibGUsIGFuZCB0aGVy ZSdzIG5vIHdheSB0byBhY2Nlc3MgaXQgZGlyZWN0bHkgZnJvbQotICAgRW1hY3MgTGlzcCBw cm9ncmFtLiAgKi8KLQotI2lmZGVmIF9fR05VQ19fCi0KLSNkZWZpbmUgQ0hBUl9UQUJMRV9S RUZfQVNDSUkoQ1QsIElEWCkJCQkJCVwKLSAgKHtzdHJ1Y3QgTGlzcF9DaGFyX1RhYmxlICpf dGJsID0gTlVMTDsJCQkJXAotICAgIExpc3BfT2JqZWN0IF92YWw7CQkJCQkJCVwKLSAgICBk byB7CQkJCQkJCQlcCi0gICAgICBfdGJsID0gX3RibCA/IFhDSEFSX1RBQkxFIChfdGJsLT5w YXJlbnQpIDogWENIQVJfVEFCTEUgKENUKTsJXAotICAgICAgX3ZhbCA9ICghIFNVQl9DSEFS X1RBQkxFX1AgKF90YmwtPmFzY2lpKSA/IF90YmwtPmFzY2lpCQlcCi0JICAgICAgOiBYU1VC X0NIQVJfVEFCTEUgKF90YmwtPmFzY2lpKS0+Y29udGVudHNbSURYXSk7CQlcCi0gICAgICBp ZiAoTklMUCAoX3ZhbCkpCQkJCQkJCVwKLQlfdmFsID0gX3RibC0+ZGVmYWx0OwkJCQkJCVwK LSAgICB9IHdoaWxlIChOSUxQIChfdmFsKSAmJiAhIE5JTFAgKF90YmwtPnBhcmVudCkpOwkJ CVwKLSAgICBfdmFsOyB9KQotCi0jZWxzZSAgLyogbm90IF9fR05VQ19fICovCi0KLSNkZWZp bmUgQ0hBUl9UQUJMRV9SRUZfQVNDSUkoQ1QsIElEWCkJCQkJCSAgXAotICAoISBOSUxQIChY Q0hBUl9UQUJMRSAoQ1QpLT5hc2NpaSkJCQkJCSAgXAotICAgPyAoISBTVUJfQ0hBUl9UQUJM RV9QIChYQ0hBUl9UQUJMRSAoQ1QpLT5hc2NpaSkJCQkgIFwKLSAgICAgID8gWENIQVJfVEFC TEUgKENUKS0+YXNjaWkJCQkJCQkgIFwKLSAgICAgIDogISBOSUxQIChYU1VCX0NIQVJfVEFC TEUgKFhDSEFSX1RBQkxFIChDVCktPmFzY2lpKS0+Y29udGVudHNbSURYXSkgXAotICAgICAg PyBYU1VCX0NIQVJfVEFCTEUgKFhDSEFSX1RBQkxFIChDVCktPmFzY2lpKS0+Y29udGVudHNb SURYXQkgIFwKLSAgICAgIDogY2hhcl90YWJsZV9yZWYgKChDVCksIChJRFgpKSkJCQkJCSAg XAotICAgOiAgY2hhcl90YWJsZV9yZWYgKChDVCksIChJRFgpKSkKLQotI2VuZGlmCS8qIG5v dCBfX0dOVUNfXyAqLwotCiAvKiBDb21wdXRlIEEgT1AgQiwgdXNpbmcgdGhlIHVuc2lnbmVk IGNvbXBhcmlzb24gb3BlcmF0b3IgT1AuICBBIGFuZCBCCiAgICBzaG91bGQgYmUgaW50ZWdl ciBleHByZXNzaW9ucy4gIFRoaXMgaXMgbm90IHRoZSBzYW1lIGFzCiAgICBtYXRoZW1hdGlj YWwgY29tcGFyaXNvbjsgZm9yIGV4YW1wbGUsIFVOU0lHTkVEX0NNUCAoMCwgPCwgLTEpCkBA IC05MzcsMTggKzExNzAsMTUgQEAKIC8qIE5vbnplcm8gaWZmIEMgaXMgYW4gQVNDSUkgY2hh cmFjdGVyLiAgKi8KICNkZWZpbmUgQVNDSUlfQ0hBUl9QKGMpIFVOU0lHTkVEX0NNUCAoYywg PCwgMHg4MCkKIAotLyogQWxtb3N0IGVxdWl2YWxlbnQgdG8gRmFyZWYgKENULCBJRFgpIHdp dGggb3B0aW1pemF0aW9uIGZvciBBU0NJSQotICAgY2hhcmFjdGVycy4gIERvIG5vdCBjaGVj ayB2YWxpZGl0eSBvZiBDVC4gICovCi0jZGVmaW5lIENIQVJfVEFCTEVfUkVGKENULCBJRFgp CQkJCQlcCi0gIChBU0NJSV9DSEFSX1AgKElEWCkgPyBDSEFSX1RBQkxFX1JFRl9BU0NJSSAo KENUKSwgKElEWCkpCVwKLSAgIDogY2hhcl90YWJsZV9yZWYgKChDVCksIChJRFgpKSkKLQot LyogRXF1aXZhbGVudCB0byBGYXNldCAoQ1QsIElEWCwgVkFMKSB3aXRoIG9wdGltaXphdGlv biBmb3IgQVNDSUkgYW5kCi0gICA4LWJpdCBFdXJvcGVhbiBjaGFyYWN0ZXJzLiAgRG8gbm90 IGNoZWNrIHZhbGlkaXR5IG9mIENULiAgKi8KLSNkZWZpbmUgQ0hBUl9UQUJMRV9TRVQoQ1Qs IElEWCwgVkFMKQkJCQkJXAotICAoQVNDSUlfQ0hBUl9QIChJRFgpICYmIFNVQl9DSEFSX1RB QkxFX1AgKFhDSEFSX1RBQkxFIChDVCktPmFzY2lpKQlcCi0gICA/IHNldF9zdWJfY2hhcl90 YWJsZV9jb250ZW50cyAoWENIQVJfVEFCTEUgKENUKS0+YXNjaWksIElEWCwgVkFMKQlcCi0g ICA6IGNoYXJfdGFibGVfc2V0IChDVCwgSURYLCBWQUwpKQorLyogQSBjaGFyLXRhYmxlIGlz IGEga2luZCBvZiB2ZWN0b3JsaWtlLCB3aXRoIGNvbnRlbnRzIGFyZSBsaWtlIGEKKyAgIHZl Y3RvciBidXQgd2l0aCBhIGZldyBvdGhlciBzbG90cy4gIEZvciBzb21lIHB1cnBvc2VzLCBp dCBtYWtlcworICAgc2Vuc2UgdG8gaGFuZGxlIGEgY2hhci10YWJsZSB3aXRoIHR5cGUgc3Ry dWN0IExpc3BfVmVjdG9yLiAgQW4KKyAgIGVsZW1lbnQgb2YgYSBjaGFyIHRhYmxlIGNhbiBi ZSBhbnkgTGlzcCBvYmplY3RzLCBidXQgaWYgaXQgaXMgYSBzdWIKKyAgIGNoYXItdGFibGUs IHdlIHRyZWF0IGl0IGEgdGFibGUgdGhhdCBjb250YWlucyBpbmZvcm1hdGlvbiBvZiBhCisg ICBzcGVjaWZpYyByYW5nZSBvZiBjaGFyYWN0ZXJzLiAgQSBzdWIgY2hhci10YWJsZSBoYXMg dGhlIHNhbWUKKyAgIHN0cnVjdHVyZSBhcyBhIHZlY3Rvci4gIEEgc3ViIGNoYXIgdGFibGUg YXBwZWFycyBvbmx5IGluIGFuIGVsZW1lbnQKKyAgIG9mIGEgY2hhci10YWJsZSwgYW5kIHRo ZXJlJ3Mgbm8gd2F5IHRvIGFjY2VzcyBpdCBkaXJlY3RseSBmcm9tCisgICBFbWFjcyBMaXNw IHByb2dyYW0uICAqLwogCiBlbnVtIENIQVJUQUJfU0laRV9CSVRTCiAgIHsKQEAgLTEwMTIs NiArMTI0Miw0NSBAQAogICAgIExpc3BfT2JqZWN0IGNvbnRlbnRzWzFdOwogICB9OwogCitM SVNQX0lOTElORSBMaXNwX09iamVjdAorQ0hBUl9UQUJMRV9SRUZfQVNDSUkgKExpc3BfT2Jq ZWN0IGN0LCBwdHJkaWZmX3QgaWR4KQoreworICBzdHJ1Y3QgTGlzcF9DaGFyX1RhYmxlICp0 YmwgPSBOVUxMOworICBMaXNwX09iamVjdCB2YWw7CisgIGRvCisgICAgeworICAgICAgdGJs ID0gdGJsID8gWENIQVJfVEFCTEUgKHRibC0+cGFyZW50KSA6IFhDSEFSX1RBQkxFIChjdCk7 CisgICAgICB2YWwgPSAoISBTVUJfQ0hBUl9UQUJMRV9QICh0YmwtPmFzY2lpKSA/IHRibC0+ YXNjaWkKKwkgICAgIDogWFNVQl9DSEFSX1RBQkxFICh0YmwtPmFzY2lpKS0+Y29udGVudHNb aWR4XSk7CisgICAgICBpZiAoTklMUCAodmFsKSkKKwl2YWwgPSB0YmwtPmRlZmFsdDsKKyAg ICB9CisgIHdoaWxlIChOSUxQICh2YWwpICYmICEgTklMUCAodGJsLT5wYXJlbnQpKTsKKwor ICByZXR1cm4gdmFsOworfQorCisvKiBBbG1vc3QgZXF1aXZhbGVudCB0byBGYXJlZiAoQ1Qs IElEWCkgd2l0aCBvcHRpbWl6YXRpb24gZm9yIEFTQ0lJCisgICBjaGFyYWN0ZXJzLiAgRG8g bm90IGNoZWNrIHZhbGlkaXR5IG9mIENULiAgKi8KK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0 CitDSEFSX1RBQkxFX1JFRiAoTGlzcF9PYmplY3QgY3QsIGludCBpZHgpCit7CisgIHJldHVy biAoQVNDSUlfQ0hBUl9QIChpZHgpCisJICA/IENIQVJfVEFCTEVfUkVGX0FTQ0lJIChjdCwg aWR4KQorCSAgOiBjaGFyX3RhYmxlX3JlZiAoY3QsIGlkeCkpOworfQorCisvKiBFcXVpdmFs ZW50IHRvIEZhc2V0IChDVCwgSURYLCBWQUwpIHdpdGggb3B0aW1pemF0aW9uIGZvciBBU0NJ SSBhbmQKKyAgIDgtYml0IEV1cm9wZWFuIGNoYXJhY3RlcnMuICBEbyBub3QgY2hlY2sgdmFs aWRpdHkgb2YgQ1QuICAqLworTElTUF9JTkxJTkUgdm9pZAorQ0hBUl9UQUJMRV9TRVQgKExp c3BfT2JqZWN0IGN0LCBpbnQgaWR4LCBMaXNwX09iamVjdCB2YWwpCit7CisgIGlmIChBU0NJ SV9DSEFSX1AgKGlkeCkgJiYgU1VCX0NIQVJfVEFCTEVfUCAoWENIQVJfVEFCTEUgKGN0KS0+ YXNjaWkpKQorICAgIHNldF9zdWJfY2hhcl90YWJsZV9jb250ZW50cyAoWENIQVJfVEFCTEUg KGN0KS0+YXNjaWksIGlkeCwgdmFsKTsKKyAgZWxzZQorICAgIGNoYXJfdGFibGVfc2V0IChj dCwgaWR4LCB2YWwpOworfQorCiAvKiBUaGlzIHN0cnVjdHVyZSBkZXNjcmliZXMgYSBidWls dC1pbiBmdW5jdGlvbi4KICAgIEl0IGlzIGdlbmVyYXRlZCBieSB0aGUgREVGVU4gbWFjcm8g b25seS4KICAgIGRlZnN1YnIgbWFrZXMgaXQgaW50byBhIExpc3Agb2JqZWN0LiAgKi8KQEAg LTEwNDgsOCArMTMxNywxMiBAQAogCiAvKiBSZXR1cm4gdGhlIG51bWJlciBvZiAiZXh0cmEi IHNsb3RzIGluIHRoZSBjaGFyIHRhYmxlIENULiAgKi8KIAotI2RlZmluZSBDSEFSX1RBQkxF X0VYVFJBX1NMT1RTKENUKQlcCi0gICgoKENUKS0+aGVhZGVyLnNpemUgJiBQU0VVRE9WRUNU T1JfU0laRV9NQVNLKSAtIENIQVJfVEFCTEVfU1RBTkRBUkRfU0xPVFMpCitMSVNQX0lOTElO RSBpbnQKK0NIQVJfVEFCTEVfRVhUUkFfU0xPVFMgKHN0cnVjdCBMaXNwX0NoYXJfVGFibGUg KmN0KQoreworICByZXR1cm4gKChjdC0+aGVhZGVyLnNpemUgJiBQU0VVRE9WRUNUT1JfU0la RV9NQVNLKQorCSAgLSBDSEFSX1RBQkxFX1NUQU5EQVJEX1NMT1RTKTsKK30KIAogDAogLyoq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqCkBAIC0xMTIxLDQwICsxMzk0LDg2IEBACiAKIC8qIFZhbHVlIGlz IG5hbWUgb2Ygc3ltYm9sLiAgKi8KIAotI2RlZmluZSBTWU1CT0xfVkFMKHN5bSkJCQkJCQkJ XAotICAoZWFzc2VydCAoKHN5bSktPnJlZGlyZWN0ID09IFNZTUJPTF9QTEFJTlZBTCksICBz eW0tPnZhbC52YWx1ZSkKLSNkZWZpbmUgU1lNQk9MX0FMSUFTKHN5bSkJCQkJCQlcCi0gIChl YXNzZXJ0ICgoc3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9MX1ZBUkFMSUFTKSwgIChzeW0pLT52 YWwuYWxpYXMpCi0jZGVmaW5lIFNZTUJPTF9CTFYoc3ltKQkJCQkJCQlcCi0gIChlYXNzZXJ0 ICgoc3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9MX0xPQ0FMSVpFRCksIChzeW0pLT52YWwuYmx2 KQotI2RlZmluZSBTWU1CT0xfRldEKHN5bSkJCQkJCQkJXAotICAoZWFzc2VydCAoKHN5bSkt PnJlZGlyZWN0ID09IFNZTUJPTF9GT1JXQVJERUQpLCAoc3ltKS0+dmFsLmZ3ZCkKLSNkZWZp bmUgU0VUX1NZTUJPTF9WQUwoc3ltLCB2KQkJCQkJCVwKLSAgKGVhc3NlcnQgKChzeW0pLT5y ZWRpcmVjdCA9PSBTWU1CT0xfUExBSU5WQUwpLCAgKHN5bSktPnZhbC52YWx1ZSA9ICh2KSkK LSNkZWZpbmUgU0VUX1NZTUJPTF9BTElBUyhzeW0sIHYpCQkJCQlcCi0gIChlYXNzZXJ0ICgo c3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9MX1ZBUkFMSUFTKSwgIChzeW0pLT52YWwuYWxpYXMg PSAodikpCi0jZGVmaW5lIFNFVF9TWU1CT0xfQkxWKHN5bSwgdikJCQkJCQlcCi0gIChlYXNz ZXJ0ICgoc3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9MX0xPQ0FMSVpFRCksIChzeW0pLT52YWwu Ymx2ID0gKHYpKQotI2RlZmluZSBTRVRfU1lNQk9MX0ZXRChzeW0sIHYpCQkJCQkJXAotICAo ZWFzc2VydCAoKHN5bSktPnJlZGlyZWN0ID09IFNZTUJPTF9GT1JXQVJERUQpLCAoc3ltKS0+ dmFsLmZ3ZCA9ICh2KSkKLQotI2RlZmluZSBTWU1CT0xfTkFNRShzeW0pIFhTWU1CT0wgKHN5 bSktPm5hbWUKLQotLyogVmFsdWUgaXMgbm9uLXplcm8gaWYgU1lNIGlzIGFuIGludGVybmVk IHN5bWJvbC4gICovCi0KLSNkZWZpbmUgU1lNQk9MX0lOVEVSTkVEX1Aoc3ltKQkJCQlcCi0g IChYU1lNQk9MIChzeW0pLT5pbnRlcm5lZCAhPSBTWU1CT0xfVU5JTlRFUk5FRCkKLQotLyog VmFsdWUgaXMgbm9uLXplcm8gaWYgU1lNIGlzIGludGVybmVkIGluIGluaXRpYWxfb2JhcnJh eS4gICovCi0KLSNkZWZpbmUgU1lNQk9MX0lOVEVSTkVEX0lOX0lOSVRJQUxfT0JBUlJBWV9Q KHN5bSkJCQlcCi0gIChYU1lNQk9MIChzeW0pLT5pbnRlcm5lZCA9PSBTWU1CT0xfSU5URVJO RURfSU5fSU5JVElBTF9PQkFSUkFZKQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKKyhTWU1C T0xfVkFMKSAoc3RydWN0IExpc3BfU3ltYm9sICpzeW0pCit7CisgIGVhc3NlcnQgKHN5bS0+ cmVkaXJlY3QgPT0gU1lNQk9MX1BMQUlOVkFMKTsKKyAgcmV0dXJuIHN5bS0+dmFsLnZhbHVl OworfQorTElTUF9JTkxJTkUgc3RydWN0IExpc3BfU3ltYm9sICoKK1NZTUJPTF9BTElBUyAo c3RydWN0IExpc3BfU3ltYm9sICpzeW0pCit7CisgIGVhc3NlcnQgKHN5bS0+cmVkaXJlY3Qg PT0gU1lNQk9MX1ZBUkFMSUFTKTsKKyAgcmV0dXJuIHN5bS0+dmFsLmFsaWFzOworfQorTElT UF9JTkxJTkUgc3RydWN0IExpc3BfQnVmZmVyX0xvY2FsX1ZhbHVlICoKK1NZTUJPTF9CTFYg KHN0cnVjdCBMaXNwX1N5bWJvbCAqc3ltKQoreworICBlYXNzZXJ0IChzeW0tPnJlZGlyZWN0 ID09IFNZTUJPTF9MT0NBTElaRUQpOworICByZXR1cm4gc3ltLT52YWwuYmx2OworfQorTElT UF9JTkxJTkUgdW5pb24gTGlzcF9Gd2QgKgorU1lNQk9MX0ZXRCAoc3RydWN0IExpc3BfU3lt Ym9sICpzeW0pCit7CisgIGVhc3NlcnQgKHN5bS0+cmVkaXJlY3QgPT0gU1lNQk9MX0ZPUldB UkRFRCk7CisgIHJldHVybiBzeW0tPnZhbC5md2Q7Cit9CitMSVNQX0lOTElORSB2b2lkCiso U0VUX1NZTUJPTF9WQUwpIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSwgTGlzcF9PYmplY3Qg dikKK3sKKyAgZWFzc2VydCAoc3ltLT5yZWRpcmVjdCA9PSBTWU1CT0xfUExBSU5WQUwpOwor ICBzeW0tPnZhbC52YWx1ZSA9IHY7Cit9CitMSVNQX0lOTElORSB2b2lkCitTRVRfU1lNQk9M X0FMSUFTIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSwgc3RydWN0IExpc3BfU3ltYm9sICp2 KQoreworICBlYXNzZXJ0IChzeW0tPnJlZGlyZWN0ID09IFNZTUJPTF9WQVJBTElBUyk7Cisg IHN5bS0+dmFsLmFsaWFzID0gdjsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK1NFVF9TWU1CT0xf QkxWIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSwgc3RydWN0IExpc3BfQnVmZmVyX0xvY2Fs X1ZhbHVlICp2KQoreworICBlYXNzZXJ0IChzeW0tPnJlZGlyZWN0ID09IFNZTUJPTF9MT0NB TElaRUQpOworICBzeW0tPnZhbC5ibHYgPSB2OworfQorTElTUF9JTkxJTkUgdm9pZAorU0VU X1NZTUJPTF9GV0QgKHN0cnVjdCBMaXNwX1N5bWJvbCAqc3ltLCB1bmlvbiBMaXNwX0Z3ZCAq dikKK3sKKyAgZWFzc2VydCAoc3ltLT5yZWRpcmVjdCA9PSBTWU1CT0xfRk9SV0FSREVEKTsK KyAgc3ltLT52YWwuZndkID0gdjsKK30KKworTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK1NZ TUJPTF9OQU1FIChMaXNwX09iamVjdCBzeW0pCit7CisgIHJldHVybiBYU1lNQk9MIChzeW0p LT5uYW1lOworfQorCisvKiBWYWx1ZSBpcyB0cnVlIGlmIFNZTSBpcyBhbiBpbnRlcm5lZCBz eW1ib2wuICAqLworCitMSVNQX0lOTElORSBib29sCitTWU1CT0xfSU5URVJORURfUCAoTGlz cF9PYmplY3Qgc3ltKQoreworICByZXR1cm4gWFNZTUJPTCAoc3ltKS0+aW50ZXJuZWQgIT0g U1lNQk9MX1VOSU5URVJORUQ7Cit9CisKKy8qIFZhbHVlIGlzIHRydWUgaWYgU1lNIGlzIGlu dGVybmVkIGluIGluaXRpYWxfb2JhcnJheS4gICovCisKK0xJU1BfSU5MSU5FIGJvb2wKK1NZ TUJPTF9JTlRFUk5FRF9JTl9JTklUSUFMX09CQVJSQVlfUCAoTGlzcF9PYmplY3Qgc3ltKQor eworICByZXR1cm4gWFNZTUJPTCAoc3ltKS0+aW50ZXJuZWQgPT0gU1lNQk9MX0lOVEVSTkVE X0lOX0lOSVRJQUxfT0JBUlJBWTsKK30KIAogLyogVmFsdWUgaXMgbm9uLXplcm8gaWYgc3lt Ym9sIGlzIGNvbnNpZGVyZWQgYSBjb25zdGFudCwgaS5lLiBpdHMKICAgIHZhbHVlIGNhbm5v dCBiZSBjaGFuZ2VkICh0aGVyZSBpcyBhbiBleGNlcHRpb24gZm9yIGtleXdvcmQgc3ltYm9s cywKICAgIHdob3NlIHZhbHVlIGNhbiBiZSBzZXQgdG8gdGhlIGtleXdvcmQgc3ltYm9sIGl0 c2VsZikuICAqLwogCi0jZGVmaW5lIFNZTUJPTF9DT05TVEFOVF9QKHN5bSkgWFNZTUJPTCAo c3ltKS0+Y29uc3RhbnQKK0xJU1BfSU5MSU5FIGludAorKFNZTUJPTF9DT05TVEFOVF9QKSAo TGlzcF9PYmplY3Qgc3ltKQoreworICByZXR1cm4gWFNZTUJPTCAoc3ltKS0+Y29uc3RhbnQ7 Cit9CiAKICNkZWZpbmUgREVGU1lNKHN5bSwgbmFtZSkJCQkJCQlcCiAgIGRvIHsgKHN5bSkg PSBpbnRlcm5fY19zdHJpbmcgKChuYW1lKSk7IHN0YXRpY3BybyAoJihzeW0pKTsgfSB3aGls ZSAoMCkKQEAgLTEyNDAsNDIgKzE1NTksNjkgQEAKIH07CiAKIAotI2RlZmluZSBYSEFTSF9U QUJMRShPQkopIFwKLSAgICAgKChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICopIFhVTlRBRyAo T0JKLCBMaXNwX1ZlY3Rvcmxpa2UpKQorTElTUF9JTkxJTkUgc3RydWN0IExpc3BfSGFzaF9U YWJsZSAqCitYSEFTSF9UQUJMRSAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFhVTlRB RyAoYSwgTGlzcF9WZWN0b3JsaWtlKTsKK30KIAogI2RlZmluZSBYU0VUX0hBU0hfVEFCTEUo VkFSLCBQVFIpIFwKICAgICAgKFhTRVRQU0VVRE9WRUNUT1IgKFZBUiwgUFRSLCBQVkVDX0hB U0hfVEFCTEUpKQogCi0jZGVmaW5lIEhBU0hfVEFCTEVfUChPQkopICBQU0VVRE9WRUNUT1JQ IChPQkosIFBWRUNfSEFTSF9UQUJMRSkKLQotI2RlZmluZSBDSEVDS19IQVNIX1RBQkxFKHgp IFwKLSAgQ0hFQ0tfVFlQRSAoSEFTSF9UQUJMRV9QICh4KSwgUWhhc2hfdGFibGVfcCwgeCkK K0xJU1BfSU5MSU5FIGJvb2wKK0hBU0hfVEFCTEVfUCAoTGlzcF9PYmplY3QgYSkKK3sKKyAg cmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEsIFBWRUNfSEFTSF9UQUJMRSk7Cit9CitMSVNQX0lO TElORSB2b2lkCitDSEVDS19IQVNIX1RBQkxFIChMaXNwX09iamVjdCB4KQoreworICByZXR1 cm4gQ0hFQ0tfVFlQRSAoSEFTSF9UQUJMRV9QICh4KSwgUWhhc2hfdGFibGVfcCwgeCk7Cit9 CiAKIC8qIFZhbHVlIGlzIHRoZSBrZXkgcGFydCBvZiBlbnRyeSBJRFggaW4gaGFzaCB0YWJs ZSBILiAgKi8KLQotI2RlZmluZSBIQVNIX0tFWShILCBJRFgpICAgQVJFRiAoKEgpLT5rZXlf YW5kX3ZhbHVlLCAyICogKElEWCkpCitMSVNQX0lOTElORSBMaXNwX09iamVjdAorSEFTSF9L RVkgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIHB0cmRpZmZfdCBpZHgpCit7CisgIHJl dHVybiBBUkVGIChoLT5rZXlfYW5kX3ZhbHVlLCAyICogaWR4KTsKK30KIAogLyogVmFsdWUg aXMgdGhlIHZhbHVlIHBhcnQgb2YgZW50cnkgSURYIGluIGhhc2ggdGFibGUgSC4gICovCi0K LSNkZWZpbmUgSEFTSF9WQUxVRShILCBJRFgpIEFSRUYgKChIKS0+a2V5X2FuZF92YWx1ZSwg MiAqIChJRFgpICsgMSkKK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0CitIQVNIX1ZBTFVFIChz dHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoLCBwdHJkaWZmX3QgaWR4KQoreworICByZXR1cm4g QVJFRiAoaC0+a2V5X2FuZF92YWx1ZSwgMiAqIGlkeCArIDEpOworfQogCiAvKiBWYWx1ZSBp cyB0aGUgaW5kZXggb2YgdGhlIG5leHQgZW50cnkgZm9sbG93aW5nIHRoZSBvbmUgYXQgSURY CiAgICBpbiBoYXNoIHRhYmxlIEguICAqLwotCi0jZGVmaW5lIEhBU0hfTkVYVChILCBJRFgp ICBBUkVGICgoSCktPm5leHQsIChJRFgpKQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK0hB U0hfTkVYVCAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgcHRyZGlmZl90IGlkeCkKK3sK KyAgcmV0dXJuIEFSRUYgKGgtPm5leHQsIGlkeCk7Cit9CiAKIC8qIFZhbHVlIGlzIHRoZSBo YXNoIGNvZGUgY29tcHV0ZWQgZm9yIGVudHJ5IElEWCBpbiBoYXNoIHRhYmxlIEguICAqLwot Ci0jZGVmaW5lIEhBU0hfSEFTSChILCBJRFgpICBBUkVGICgoSCktPmhhc2gsIChJRFgpKQor TElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK0hBU0hfSEFTSCAoc3RydWN0IExpc3BfSGFzaF9U YWJsZSAqaCwgcHRyZGlmZl90IGlkeCkKK3sKKyAgcmV0dXJuIEFSRUYgKGgtPmhhc2gsIGlk eCk7Cit9CiAKIC8qIFZhbHVlIGlzIHRoZSBpbmRleCBvZiB0aGUgZWxlbWVudCBpbiBoYXNo IHRhYmxlIEggdGhhdCBpcyB0aGUKICAgIHN0YXJ0IG9mIHRoZSBjb2xsaXNpb24gbGlzdCBh dCBpbmRleCBJRFggaW4gdGhlIGluZGV4IHZlY3RvciBvZiBILiAgKi8KLQotI2RlZmluZSBI QVNIX0lOREVYKEgsIElEWCkgIEFSRUYgKChIKS0+aW5kZXgsIChJRFgpKQorTElTUF9JTkxJ TkUgTGlzcF9PYmplY3QKK0hBU0hfSU5ERVggKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgs IHB0cmRpZmZfdCBpZHgpCit7CisgIHJldHVybiBBUkVGIChoLT5pbmRleCwgaWR4KTsKK30K IAogLyogVmFsdWUgaXMgdGhlIHNpemUgb2YgaGFzaCB0YWJsZSBILiAgKi8KLQotI2RlZmlu ZSBIQVNIX1RBQkxFX1NJWkUoSCkgQVNJWkUgKChIKS0+bmV4dCkKK0xJU1BfSU5MSU5FIHB0 cmRpZmZfdAorSEFTSF9UQUJMRV9TSVpFIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQor eworICByZXR1cm4gQVNJWkUgKGgtPm5leHQpOworfQogCiAvKiBEZWZhdWx0IHNpemUgZm9y IGhhc2ggdGFibGVzIGlmIG5vdCBzcGVjaWZpZWQuICAqLwogCkBAIC0xNDg1LDYgKzE4MzEs NTMgQEAKICAgICB9IGRhdGFbU0FWRV9WQUxVRV9TTE9UU107CiAgIH07CiAKKy8qIFJldHVy biB0aGUgdHlwZSBvZiBWJ3MgTnRoIHNhdmVkIHZhbHVlLiAgKi8KK0xJU1BfSU5MSU5FIGlu dAorc2F2ZV90eXBlIChzdHJ1Y3QgTGlzcF9TYXZlX1ZhbHVlICp2LCBpbnQgbikKK3sKKyAg ZWFzc2VydCAoMCA8PSBuICYmIG4gPCBTQVZFX1ZBTFVFX1NMT1RTKTsKKyAgcmV0dXJuICh2 LT5zYXZlX3R5cGUgPj4gKFNBVkVfU0xPVF9CSVRTICogbikgJiAoKDEgPDwgU0FWRV9TTE9U X0JJVFMpIC0gMSkpOworfQorCisvKiBHZXQgYW5kIHNldCB0aGUgTnRoIHNhdmVkIHBvaW50 ZXIuICAqLworCitMSVNQX0lOTElORSB2b2lkICoKK1hTQVZFX1BPSU5URVIgKExpc3BfT2Jq ZWN0IG9iaiwgaW50IG4pCit7CisgIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUg KG9iaiksIG4pID09IFNBVkVfUE9JTlRFUik7CisgIHJldHVybiBYU0FWRV9WQUxVRSAob2Jq KS0+ZGF0YVtuXS5wb2ludGVyOzsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK3NldF9zYXZlX3Bv aW50ZXIgKExpc3BfT2JqZWN0IG9iaiwgaW50IG4sIHZvaWQgKnZhbCkKK3sKKyAgZWFzc2Vy dCAoc2F2ZV90eXBlIChYU0FWRV9WQUxVRSAob2JqKSwgbikgPT0gU0FWRV9QT0lOVEVSKTsK KyAgWFNBVkVfVkFMVUUgKG9iaiktPmRhdGFbbl0ucG9pbnRlciA9IHZhbDsKK30KKworLyog TGlrZXdpc2UgZm9yIHRoZSBzYXZlZCBpbnRlZ2VyLiAgKi8KKworTElTUF9JTkxJTkUgcHRy ZGlmZl90CitYU0FWRV9JTlRFR0VSIChMaXNwX09iamVjdCBvYmosIGludCBuKQoreworICBl YXNzZXJ0IChzYXZlX3R5cGUgKFhTQVZFX1ZBTFVFIChvYmopLCBuKSA9PSBTQVZFX0lOVEVH RVIpOworICByZXR1cm4gWFNBVkVfVkFMVUUgKG9iaiktPmRhdGFbbl0uaW50ZWdlcjsKK30K K0xJU1BfSU5MSU5FIHZvaWQKK3NldF9zYXZlX2ludGVnZXIgKExpc3BfT2JqZWN0IG9iaiwg aW50IG4sIHB0cmRpZmZfdCB2YWwpCit7CisgIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVf VkFMVUUgKG9iaiksIG4pID09IFNBVkVfSU5URUdFUik7CisgIFhTQVZFX1ZBTFVFIChvYmop LT5kYXRhW25dLmludGVnZXIgPSB2YWw7Cit9CisKKy8qIEV4dHJhY3QgTnRoIHNhdmVkIG9i amVjdC4gICovCisKK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0CitYU0FWRV9PQkpFQ1QgKExp c3BfT2JqZWN0IG9iaiwgaW50IG4pCit7CisgIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVf VkFMVUUgKG9iaiksIG4pID09IFNBVkVfT0JKRUNUKTsKKyAgcmV0dXJuIFhTQVZFX1ZBTFVF IChvYmopLT5kYXRhW25dLm9iamVjdDsKK30KKwogLyogQSBtaXNjZWxsYW5lb3VzIG9iamVj dCwgd2hlbiBpdCdzIG9uIHRoZSBmcmVlIGxpc3QuICAqLwogc3RydWN0IExpc3BfRnJlZQog ICB7CkBAIC0xNTA2LDYgKzE4OTksNDYgQEAKICAgICBzdHJ1Y3QgTGlzcF9TYXZlX1ZhbHVl IHVfc2F2ZV92YWx1ZTsKICAgfTsKIAorTElTUF9JTkxJTkUgdW5pb24gTGlzcF9NaXNjICoK K1hNSVNDIChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX01p c2MpOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9NaXNjX0FueSAqCitYTUlTQ0FO WSAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoTUlTQ1AgKGEpKTsKKyAgcmV0dXJu ICYgWE1JU0MgKGEpLT51X2FueTsKK30KKworTElTUF9JTkxJTkUgZW51bSBMaXNwX01pc2Nf VHlwZQorWE1JU0NUWVBFIChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4gWE1JU0NBTlkg KGEpLT50eXBlOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9NYXJrZXIgKgorWE1B UktFUiAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoTUFSS0VSUCAoYSkpOworICBy ZXR1cm4gJiBYTUlTQyAoYSktPnVfbWFya2VyOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3Qg TGlzcF9PdmVybGF5ICoKK1hPVkVSTEFZIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0 IChPVkVSTEFZUCAoYSkpOworICByZXR1cm4gJiBYTUlTQyAoYSktPnVfb3ZlcmxheTsKK30K KworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfU2F2ZV9WYWx1ZSAqCitYU0FWRV9WQUxVRSAo TGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoU0FWRV9WQUxVRVAgKGEpKTsKKyAgcmV0 dXJuICYgWE1JU0MgKGEpLT51X3NhdmVfdmFsdWU7Cit9CisMCiAvKiBGb3J3YXJkaW5nIHBv aW50ZXIgdG8gYW4gaW50IHZhcmlhYmxlLgogICAgVGhpcyBpcyBhbGxvd2VkIG9ubHkgaW4g dGhlIHZhbHVlIGNlbGwgb2YgYSBzeW1ib2wsCiAgICBhbmQgaXQgbWVhbnMgdGhhdCB0aGUg c3ltYm9sJ3MgdmFsdWUgcmVhbGx5IGxpdmVzIGluIHRoZQpAQCAtMTYxMiw2ICsyMDQ1LDQ3 IEBACiAgICAgc3RydWN0IExpc3BfQnVmZmVyX09iamZ3ZCB1X2J1ZmZlcl9vYmpmd2Q7CiAg ICAgc3RydWN0IExpc3BfS2JvYXJkX09iamZ3ZCB1X2tib2FyZF9vYmpmd2Q7CiAgIH07CisK K0xJU1BfSU5MSU5FIGVudW0gTGlzcF9Gd2RfVHlwZQorWEZXRFRZUEUgKHVuaW9uIExpc3Bf RndkICphKQoreworICByZXR1cm4gYS0+dV9pbnRmd2QudHlwZTsKK30KKworTElTUF9JTkxJ TkUgc3RydWN0IExpc3BfSW50ZndkICoKK1hJTlRGV0QgKHVuaW9uIExpc3BfRndkICphKQor eworICBlYXNzZXJ0IChJTlRGV0RQIChhKSk7CisgIHJldHVybiAmYS0+dV9pbnRmd2Q7Cit9 CisKK0xJU1BfSU5MSU5FIHN0cnVjdCBMaXNwX0Jvb2xmd2QgKgorWEJPT0xGV0QgKHVuaW9u IExpc3BfRndkICphKQoreworICBlYXNzZXJ0IChCT09MRldEUCAoYSkpOworICByZXR1cm4g JmEtPnVfYm9vbGZ3ZDsKK30KKworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfT2JqZndkICoK K1hPQkpGV0QgKHVuaW9uIExpc3BfRndkICphKQoreworICBlYXNzZXJ0IChPQkpGV0RQIChh KSk7CisgIHJldHVybiAmYS0+dV9vYmpmd2Q7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVjdCBM aXNwX0J1ZmZlcl9PYmpmd2QgKgorWEJVRkZFUl9PQkpGV0QgKHVuaW9uIExpc3BfRndkICph KQoreworICBlYXNzZXJ0IChCVUZGRVJfT0JKRldEUCAoYSkpOworICByZXR1cm4gJmEtPnVf YnVmZmVyX29iamZ3ZDsKK30KKworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfS2JvYXJkX09i amZ3ZCAqCitYS0JPQVJEX09CSkZXRCAodW5pb24gTGlzcF9Gd2QgKmEpCit7CisgIGVhc3Nl cnQgKEtCT0FSRF9PQkpGV0RQIChhKSk7CisgIHJldHVybiAmYS0+dV9rYm9hcmRfb2JqZndk OworfQogDAogLyogTGlzcCBmbG9hdGluZyBwb2ludCB0eXBlLiAgKi8KIHN0cnVjdCBMaXNw X0Zsb2F0CkBAIC0xNjIzLDggKzIwOTcsMTcgQEAKICAgICB9IHU7CiAgIH07CiAKLSNkZWZp bmUgWEZMT0FUX0RBVEEoZikgKDAgPyBYRkxPQVQgKGYpLT51LmRhdGEgOiAgWEZMT0FUIChm KS0+dS5kYXRhKQotI2RlZmluZSBYRkxPQVRfSU5JVChmLCBuKSAoWEZMT0FUIChmKS0+dS5k YXRhID0gKG4pKQorTElTUF9JTkxJTkUgZG91YmxlCitYRkxPQVRfREFUQSAoTGlzcF9PYmpl Y3QgZikKK3sKKyAgcmV0dXJuIFhGTE9BVCAoZiktPnUuZGF0YTsKK30KKworTElTUF9JTkxJ TkUgdm9pZAorWEZMT0FUX0lOSVQgKExpc3BfT2JqZWN0IGYsIGRvdWJsZSBuKQoreworICBY RkxPQVQgKGYpLT51LmRhdGEgPSBuOworfQogCiAvKiBNb3N0IGhvc3RzIG5vd2FkYXlzIHVz ZSBJRUVFIGZsb2F0aW5nIHBvaW50LCBzbyB0aGV5IHVzZSBJRUMgNjA1NTkKICAgIHJlcHJl c2VudGF0aW9ucywgaGF2ZSBpbmZpbml0aWVzIGFuZCBOYU5zLCBhbmQgZG8gbm90IHRyYXAg b24KQEAgLTE2MzMsOCArMjExNiwxMiBAQAogICAgd2FudGVkIGhlcmUsIGJ1dCBpcyBub3Qg cXVpdGUgcmlnaHQgYmVjYXVzZSBFbWFjcyBkb2VzIG5vdCByZXF1aXJlCiAgICBhbGwgdGhl IGZlYXR1cmVzIG9mIEMxMSBBbm5leCBGIChhbmQgZG9lcyBub3QgcmVxdWlyZSBDMTEgYXQg YWxsLAogICAgZm9yIHRoYXQgbWF0dGVyKS4gICovCi0jZGVmaW5lIElFRUVfRkxPQVRJTkdf UE9JTlQgKEZMVF9SQURJWCA9PSAyICYmIEZMVF9NQU5UX0RJRyA9PSAyNCBcCi0JCQkgICAg ICYmIEZMVF9NSU5fRVhQID09IC0xMjUgJiYgRkxUX01BWF9FWFAgPT0gMTI4KQorZW51bQor ICB7CisgICAgSUVFRV9GTE9BVElOR19QT0lOVAorICAgICAgPSAoRkxUX1JBRElYID09IDIg JiYgRkxUX01BTlRfRElHID09IDI0CisJICYmIEZMVF9NSU5fRVhQID09IC0xMjUgJiYgRkxU X01BWF9FWFAgPT0gMTI4KQorICB9OwogCiAvKiBBIGNoYXJhY3RlciwgZGVjbGFyZWQgd2l0 aCB0aGUgZm9sbG93aW5nIHR5cGVkZWYsIGlzIGEgbWVtYmVyCiAgICBvZiBzb21lIGNoYXJh Y3RlciBzZXQgYXNzb2NpYXRlZCB3aXRoIHRoZSBjdXJyZW50IGJ1ZmZlci4gICovCkBAIC0x Njc1LDY0ICsyMTYyLDYgQEAKICAgICAgICBpdHNlbGYuICAqLwogICAgIENIQVJBQ1RFUkJJ VFMgPSAyMgogICB9OwotCi0KLQotDAotLyogVGhlIGdseXBoIGRhdGF0eXBlLCB1c2VkIHRv IHJlcHJlc2VudCBjaGFyYWN0ZXJzIG9uIHRoZSBkaXNwbGF5LgotICAgSXQgY29uc2lzdHMg b2YgYSBjaGFyIGNvZGUgYW5kIGEgZmFjZSBpZC4gICovCi0KLXR5cGVkZWYgc3RydWN0IHsK LSAgaW50IGNoOwotICBpbnQgZmFjZV9pZDsKLX0gR0xZUEg7Ci0KLS8qIFJldHVybiBhIGds eXBoJ3MgY2hhcmFjdGVyIGNvZGUuICAqLwotI2RlZmluZSBHTFlQSF9DSEFSKGdseXBoKSAo KGdseXBoKS5jaCkKLQotLyogUmV0dXJuIGEgZ2x5cGgncyBmYWNlIElELiAgKi8KLSNkZWZp bmUgR0xZUEhfRkFDRShnbHlwaCkgKChnbHlwaCkuZmFjZV9pZCkKLQotI2RlZmluZSBTRVRf R0xZUEhfQ0hBUihnbHlwaCwgY2hhcikgKChnbHlwaCkuY2ggPSAoY2hhcikpCi0jZGVmaW5l IFNFVF9HTFlQSF9GQUNFKGdseXBoLCBmYWNlKSAoKGdseXBoKS5mYWNlX2lkID0gKGZhY2Up KQotI2RlZmluZSBTRVRfR0xZUEgoZ2x5cGgsIGNoYXIsIGZhY2UpICgoZ2x5cGgpLmNoID0g KGNoYXIpLCAoZ2x5cGgpLmZhY2VfaWQgPSAoZmFjZSkpCi0KLS8qIFJldHVybiAxIGlmIEdM WVBIIGNvbnRhaW5zIHZhbGlkIGNoYXJhY3RlciBjb2RlLiAgKi8KLSNkZWZpbmUgR0xZUEhf Q0hBUl9WQUxJRF9QKGdseXBoKSBDSEFSX1ZBTElEX1AgKEdMWVBIX0NIQVIgKGdseXBoKSkK LQotCi0vKiBHbHlwaCBDb2RlIGZyb20gYSBkaXNwbGF5IHZlY3RvciBtYXkgZWl0aGVyIGJl IGFuIGludGVnZXIgd2hpY2gKLSAgIGVuY29kZXMgYSBjaGFyIGNvZGUgaW4gdGhlIGxvd2Vy IENIQVJBQ1RFUkJJVFMgYml0cyBhbmQgYSAodmVyeSBzbWFsbCkKLSAgIGZhY2UtaWQgaW4g dGhlIHVwcGVyIGJpdHMsIG9yIGl0IG1heSBiZSBhIGNvbnMgKENIQVIgLiBGQUNFLUlEKS4g ICovCi0KLSNkZWZpbmUgR0xZUEhfQ09ERV9QKGdjKQkJCQkJCVwKLSAgKENPTlNQIChnYykJ CQkJCQkJCVwKLSAgID8gKENIQVJBQ1RFUlAgKFhDQVIgKGdjKSkJCQkJCQlcCi0gICAgICAm JiBSQU5HRURfSU5URUdFUlAgKDAsIFhDRFIgKGdjKSwgTUFYX0ZBQ0VfSUQpKQkJCVwKLSAg IDogKFJBTkdFRF9JTlRFR0VSUAkJCQkJCQlcCi0gICAgICAoMCwgZ2MsCQkJCQkJCQlcCi0g ICAgICAgKE1BWF9GQUNFX0lEIDwgVFlQRV9NQVhJTVVNIChFTUFDU19JTlQpID4+IENIQVJB Q1RFUkJJVFMJCVwKLQk/ICgoRU1BQ1NfSU5UKSBNQVhfRkFDRV9JRCA8PCBDSEFSQUNURVJC SVRTKSB8IE1BWF9DSEFSCQlcCi0JOiBUWVBFX01BWElNVU0gKEVNQUNTX0lOVCkpKSkpCi0K LS8qIFRoZSBmb2xsb3dpbmcgYXJlIHZhbGlkIG9ubHkgaWYgR0xZUEhfQ09ERV9QIChnYyku ICAqLwotCi0jZGVmaW5lIEdMWVBIX0NPREVfQ0hBUihnYykgXAotICAoQ09OU1AgKGdjKSA/ IFhJTlQgKFhDQVIgKGdjKSkgOiBYSU5UIChnYykgJiAoKDEgPDwgQ0hBUkFDVEVSQklUUykg LSAxKSkKLQotI2RlZmluZSBHTFlQSF9DT0RFX0ZBQ0UoZ2MpIFwKLSAgKENPTlNQIChnYykg PyBYSU5UIChYQ0RSIChnYykpIDogWElOVCAoZ2MpID4+IENIQVJBQ1RFUkJJVFMpCi0KLSNk ZWZpbmUgU0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERShnbHlwaCwgZ2MpCQkJCVwKLSAgZG8J CQkJCQkJCQlcCi0gICAgewkJCQkJCQkJCVwKLSAgICAgIGlmIChDT05TUCAoZ2MpKQkJCQkJ CQlcCi0JU0VUX0dMWVBIIChnbHlwaCwgWElOVCAoWENBUiAoZ2MpKSwgWElOVCAoWENEUiAo Z2MpKSk7CQlcCi0gICAgICBlbHNlCQkJCQkJCQlcCi0JU0VUX0dMWVBIIChnbHlwaCwgKFhJ TlQgKGdjKSAmICgoMSA8PCBDSEFSQUNURVJCSVRTKS0xKSksCVwKLQkJICAgKFhJTlQgKGdj KSA+PiBDSEFSQUNURVJCSVRTKSk7CQkJXAotICAgIH0JCQkJCQkJCQlcCi0gIHdoaWxlICgw KQogDAogLyogU3RydWN0dXJlIHRvIGhvbGQgbW91c2UgaGlnaGxpZ2h0IGRhdGEuICBUaGlz IGlzIGhlcmUgYmVjYXVzZSBvdGhlcgogICAgaGVhZGVyIGZpbGVzIG5lZWQgaXQgZm9yIGRl ZmluaW5nIHN0cnVjdCB4X291dHB1dCBldGMuICAqLwpAQCAtMTc2OCwxOTAgKzIxOTcsMzA1 IEBACiAMCiAvKiBEYXRhIHR5cGUgY2hlY2tpbmcuICAqLwogCi0jZGVmaW5lIE5JTFAoeCkg IEVRICh4LCBRbmlsKQotCi0jZGVmaW5lIE5VTUJFUlAoeCkgKElOVEVHRVJQICh4KSB8fCBG TE9BVFAgKHgpKQotI2RlZmluZSBOQVROVU1QKHgpIChJTlRFR0VSUCAoeCkgJiYgWElOVCAo eCkgPj0gMCkKLQotI2RlZmluZSBSQU5HRURfSU5URUdFUlAobG8sIHgsIGhpKSBcCi0gIChJ TlRFR0VSUCAoeCkgJiYgKGxvKSA8PSBYSU5UICh4KSAmJiBYSU5UICh4KSA8PSAoaGkpKQor TElTUF9JTkxJTkUgYm9vbAorKE5JTFApIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4g RVEgKHgsIFFuaWwpOworfQorCitMSVNQX0lOTElORSBib29sCitOVU1CRVJQIChMaXNwX09i amVjdCB4KQoreworICByZXR1cm4gSU5URUdFUlAgKHgpIHx8IEZMT0FUUCAoeCk7Cit9CitM SVNQX0lOTElORSBib29sCitOQVROVU1QIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4g SU5URUdFUlAgKHgpICYmIDAgPD0gWElOVCAoeCk7Cit9CisKK0xJU1BfSU5MSU5FIGJvb2wK K1JBTkdFRF9JTlRFR0VSUCAoaW50bWF4X3QgbG8sIExpc3BfT2JqZWN0IHgsIGludG1heF90 IGhpKQoreworICByZXR1cm4gSU5URUdFUlAgKHgpICYmIGxvIDw9IFhJTlQgKHgpICYmIFhJ TlQgKHgpIDw9IGhpOworfQorCiAjZGVmaW5lIFRZUEVfUkFOR0VEX0lOVEVHRVJQKHR5cGUs IHgpIFwKLSAgKFRZUEVfU0lHTkVEICh0eXBlKQkJCQkJCQlcCi0gICA/IFJBTkdFRF9JTlRF R0VSUCAoVFlQRV9NSU5JTVVNICh0eXBlKSwgeCwgVFlQRV9NQVhJTVVNICh0eXBlKSkJXAot ICAgOiBSQU5HRURfSU5URUdFUlAgKDAsIHgsIFRZUEVfTUFYSU1VTSAodHlwZSkpKQotCi0j ZGVmaW5lIElOVEVHRVJQKHgpIChMSVNQX0lOVF9UQUdfUCAoWFRZUEUgKCh4KSkpKQotI2Rl ZmluZSBTWU1CT0xQKHgpIChYVFlQRSAoKHgpKSA9PSBMaXNwX1N5bWJvbCkKLSNkZWZpbmUg TUlTQ1AoeCkgKFhUWVBFICgoeCkpID09IExpc3BfTWlzYykKLSNkZWZpbmUgVkVDVE9STElL RVAoeCkgKFhUWVBFICgoeCkpID09IExpc3BfVmVjdG9ybGlrZSkKLSNkZWZpbmUgU1RSSU5H UCh4KSAoWFRZUEUgKCh4KSkgPT0gTGlzcF9TdHJpbmcpCi0jZGVmaW5lIENPTlNQKHgpIChY VFlQRSAoKHgpKSA9PSBMaXNwX0NvbnMpCi0KLSNkZWZpbmUgRkxPQVRQKHgpIChYVFlQRSAo KHgpKSA9PSBMaXNwX0Zsb2F0KQotI2RlZmluZSBWRUNUT1JQKHgpIChWRUNUT1JMSUtFUCAo eCkgJiYgIShBU0laRSAoeCkgJiBQU0VVRE9WRUNUT1JfRkxBRykpCi0jZGVmaW5lIE9WRVJM QVlQKHgpIChNSVNDUCAoeCkgJiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01pc2NfT3Zlcmxh eSkKLSNkZWZpbmUgTUFSS0VSUCh4KSAoTUlTQ1AgKHgpICYmIFhNSVNDVFlQRSAoeCkgPT0g TGlzcF9NaXNjX01hcmtlcikKLQorICAoSU5URUdFUlAgKHgpCQkJICAgICAgXAorICAgJiYg KFRZUEVfU0lHTkVEICh0eXBlKSA/IFRZUEVfTUlOSU1VTSAodHlwZSkgPD0gWElOVCAoeCkg OiAwIDw9IFhJTlQgKHgpKSBcCisgICAmJiBYSU5UICh4KSA8PSBUWVBFX01BWElNVU0gKHR5 cGUpKQorCitMSVNQX0lOTElORSBib29sIChDT05TUCkgKExpc3BfT2JqZWN0IHgpIHsgcmV0 dXJuIFhUWVBFICh4KSA9PSBMaXNwX0NvbnM7IH0KK0xJU1BfSU5MSU5FIGJvb2wgKEZMT0FU UCkgKExpc3BfT2JqZWN0IHgpIHsgcmV0dXJuIFhUWVBFICh4KSA9PSBMaXNwX0Zsb2F0OyB9 CitMSVNQX0lOTElORSBib29sIChNSVNDUCkgKExpc3BfT2JqZWN0IHgpIHsgcmV0dXJuIFhU WVBFICh4KSA9PSBMaXNwX01pc2M7IH0KK0xJU1BfSU5MSU5FIGJvb2wgU1RSSU5HUCAoTGlz cF9PYmplY3QgeCkgeyByZXR1cm4gWFRZUEUgKHgpID09IExpc3BfU3RyaW5nOyB9CitMSVNQ X0lOTElORSBib29sCisoU1lNQk9MUCkgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBY VFlQRSAoeCkgPT0gTGlzcF9TeW1ib2w7Cit9CitMSVNQX0lOTElORSBib29sCisoSU5URUdF UlApIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4gTElTUF9JTlRfVEFHX1AgKFhUWVBF ICh4KSk7Cit9CitMSVNQX0lOTElORSBib29sCisoVkVDVE9STElLRVApIChMaXNwX09iamVj dCB4KQoreworICByZXR1cm4gWFRZUEUgKHgpID09IExpc3BfVmVjdG9ybGlrZTsKK30KK0xJ U1BfSU5MSU5FIGJvb2wKK1ZFQ1RPUlAgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBW RUNUT1JMSUtFUCAoeCkgJiYgISAoQVNJWkUgKHgpICYgUFNFVURPVkVDVE9SX0ZMQUcpOwor fQorTElTUF9JTkxJTkUgYm9vbAorT1ZFUkxBWVAgKExpc3BfT2JqZWN0IHgpCit7CisgIHJl dHVybiBNSVNDUCAoeCkgJiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01pc2NfT3ZlcmxheTsK K30KK0xJU1BfSU5MSU5FIGJvb2wKKyhNQVJLRVJQKSAoTGlzcF9PYmplY3QgeCkKK3sKKyAg cmV0dXJuIE1JU0NQICh4KSAmJiBYTUlTQ1RZUEUgKHgpID09IExpc3BfTWlzY19NYXJrZXI7 Cit9CiBMSVNQX0lOTElORSBib29sCiBTQVZFX1ZBTFVFUCAoTGlzcF9PYmplY3QgeCkKIHsK ICAgcmV0dXJuIE1JU0NQICh4KSAmJiBYTUlTQ1RZUEUgKHgpID09IExpc3BfTWlzY19TYXZl X1ZhbHVlOwogfQogCi1MSVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9TYXZlX1ZhbHVlICoKLVhT QVZFX1ZBTFVFIChMaXNwX09iamVjdCBhKQotewotICBlYXNzZXJ0IChTQVZFX1ZBTFVFUCAo YSkpOwotICByZXR1cm4gJiBYTUlTQyAoYSktPnVfc2F2ZV92YWx1ZTsKLX0KLQotLyogUmV0 dXJuIHRoZSB0eXBlIG9mIFYncyBOdGggc2F2ZWQgdmFsdWUuICAqLwotTElTUF9JTkxJTkUg aW50Ci1zYXZlX3R5cGUgKHN0cnVjdCBMaXNwX1NhdmVfVmFsdWUgKnYsIGludCBuKQotewot ICBlYXNzZXJ0ICgwIDw9IG4gJiYgbiA8IFNBVkVfVkFMVUVfU0xPVFMpOwotICByZXR1cm4g KHYtPnNhdmVfdHlwZSA+PiAoU0FWRV9TTE9UX0JJVFMgKiBuKSAmICgoMSA8PCBTQVZFX1NM T1RfQklUUykgLSAxKSk7Ci19Ci0KLS8qIEdldCBhbmQgc2V0IHRoZSBOdGggc2F2ZWQgcG9p bnRlci4gICovCi0KLUxJU1BfSU5MSU5FIHZvaWQgKgotWFNBVkVfUE9JTlRFUiAoTGlzcF9P YmplY3Qgb2JqLCBpbnQgbikKLXsKLSAgZWFzc2VydCAoc2F2ZV90eXBlIChYU0FWRV9WQUxV RSAob2JqKSwgbikgPT0gU0FWRV9QT0lOVEVSKTsKLSAgcmV0dXJuIFhTQVZFX1ZBTFVFIChv YmopLT5kYXRhW25dLnBvaW50ZXI7OwotfQotTElTUF9JTkxJTkUgdm9pZAotc2V0X3NhdmVf cG9pbnRlciAoTGlzcF9PYmplY3Qgb2JqLCBpbnQgbiwgdm9pZCAqdmFsKQotewotICBlYXNz ZXJ0IChzYXZlX3R5cGUgKFhTQVZFX1ZBTFVFIChvYmopLCBuKSA9PSBTQVZFX1BPSU5URVIp OwotICBYU0FWRV9WQUxVRSAob2JqKS0+ZGF0YVtuXS5wb2ludGVyID0gdmFsOwotfQotCi0v KiBMaWtld2lzZSBmb3IgdGhlIHNhdmVkIGludGVnZXIuICAqLwotCi1MSVNQX0lOTElORSBw dHJkaWZmX3QKLVhTQVZFX0lOVEVHRVIgKExpc3BfT2JqZWN0IG9iaiwgaW50IG4pCi17Ci0g IGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUgKG9iaiksIG4pID09IFNBVkVfSU5U RUdFUik7Ci0gIHJldHVybiBYU0FWRV9WQUxVRSAob2JqKS0+ZGF0YVtuXS5pbnRlZ2VyOwot fQotTElTUF9JTkxJTkUgdm9pZAotc2V0X3NhdmVfaW50ZWdlciAoTGlzcF9PYmplY3Qgb2Jq LCBpbnQgbiwgcHRyZGlmZl90IHZhbCkKLXsKLSAgZWFzc2VydCAoc2F2ZV90eXBlIChYU0FW RV9WQUxVRSAob2JqKSwgbikgPT0gU0FWRV9JTlRFR0VSKTsKLSAgWFNBVkVfVkFMVUUgKG9i aiktPmRhdGFbbl0uaW50ZWdlciA9IHZhbDsKLX0KLQotLyogRXh0cmFjdCBOdGggc2F2ZWQg b2JqZWN0LiAgKi8KLQotTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKLVhTQVZFX09CSkVDVCAo TGlzcF9PYmplY3Qgb2JqLCBpbnQgbikKLXsKLSAgZWFzc2VydCAoc2F2ZV90eXBlIChYU0FW RV9WQUxVRSAob2JqKSwgbikgPT0gU0FWRV9PQkpFQ1QpOwotICByZXR1cm4gWFNBVkVfVkFM VUUgKG9iaiktPmRhdGFbbl0ub2JqZWN0OwotfQotCi0jZGVmaW5lIEFVVE9MT0FEUCh4KSAo Q09OU1AgKHgpICYmIEVRIChRYXV0b2xvYWQsIFhDQVIgKHgpKSkKLQotI2RlZmluZSBJTlRG V0RQKHgpIChYRldEVFlQRSAoeCkgPT0gTGlzcF9Gd2RfSW50KQotI2RlZmluZSBCT09MRldE UCh4KSAoWEZXRFRZUEUgKHgpID09IExpc3BfRndkX0Jvb2wpCi0jZGVmaW5lIE9CSkZXRFAo eCkgKFhGV0RUWVBFICh4KSA9PSBMaXNwX0Z3ZF9PYmopCi0jZGVmaW5lIEJVRkZFUl9PQkpG V0RQKHgpIChYRldEVFlQRSAoeCkgPT0gTGlzcF9Gd2RfQnVmZmVyX09iaikKLSNkZWZpbmUg S0JPQVJEX09CSkZXRFAoeCkgKFhGV0RUWVBFICh4KSA9PSBMaXNwX0Z3ZF9LYm9hcmRfT2Jq KQotCi0vKiBUcnVlIGlmIG9iamVjdCBYIGlzIGEgcHNldWRvdmVjdG9yIHdob3NlIGNvZGUg aXMgQ09ERS4gIFRoZSBjYXN0IHRvIHN0cnVjdAotICAgdmVjdG9ybGlrZV9oZWFkZXIgKiBh dm9pZHMgYWxpYXNpbmcgaXNzdWVzLiAgKi8KLSNkZWZpbmUgUFNFVURPVkVDVE9SUCh4LCBj b2RlKQkJCQkJXAotICBUWVBFRF9QU0VVRE9WRUNUT1JQICh4LCB2ZWN0b3JsaWtlX2hlYWRl ciwgY29kZSkKLQotI2RlZmluZSBQU0VVRE9WRUNUT1JfVFlQRVAodiwgY29kZSkJCQkJCVwK LSAgKCgodiktPnNpemUgJiAoUFNFVURPVkVDVE9SX0ZMQUcgfCBQVkVDX1RZUEVfTUFTSykp CQkJXAotICAgPT0gKFBTRVVET1ZFQ1RPUl9GTEFHIHwgKChjb2RlKSA8PCBQU0VVRE9WRUNU T1JfQVJFQV9CSVRTKSkpCi0KLS8qIFRydWUgaWYgb2JqZWN0IFgsIHdpdGggaW50ZXJuYWwg dHlwZSBzdHJ1Y3QgVCAqLCBpcyBhIHBzZXVkb3ZlY3RvciB3aG9zZQotICAgY29kZSBpcyBD T0RFLiAgKi8KLSNkZWZpbmUgVFlQRURfUFNFVURPVkVDVE9SUCh4LCB0LCBjb2RlKQkJCQlc Ci0gIChWRUNUT1JMSUtFUCAoeCkJCQkJCQlcCi0gICAmJiBQU0VVRE9WRUNUT1JfVFlQRVAg KChzdHJ1Y3QgdCAqKSBYVU5UQUcgKHgsIExpc3BfVmVjdG9ybGlrZSksIGNvZGUpKQorTElT UF9JTkxJTkUgYm9vbAorQVVUT0xPQURQIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4g Q09OU1AgKHgpICYmIEVRIChRYXV0b2xvYWQsIFhDQVIgKHgpKTsKK30KKworTElTUF9JTkxJ TkUgYm9vbAorSU5URldEUCAodW5pb24gTGlzcF9Gd2QgKmEpCit7CisgIHJldHVybiBYRldE VFlQRSAoYSkgPT0gTGlzcF9Gd2RfSW50OworfQorTElTUF9JTkxJTkUgYm9vbAorQk9PTEZX RFAgKHVuaW9uIExpc3BfRndkICphKQoreworICByZXR1cm4gWEZXRFRZUEUgKGEpID09IExp c3BfRndkX0Jvb2w7Cit9CitMSVNQX0lOTElORSBib29sCitPQkpGV0RQICh1bmlvbiBMaXNw X0Z3ZCAqYSkKK3sKKyAgcmV0dXJuIFhGV0RUWVBFIChhKSA9PSBMaXNwX0Z3ZF9PYmo7Cit9 CitMSVNQX0lOTElORSBib29sCitCVUZGRVJfT0JKRldEUCAodW5pb24gTGlzcF9Gd2QgKmEp Cit7CisgIHJldHVybiBYRldEVFlQRSAoYSkgPT0gTGlzcF9Gd2RfQnVmZmVyX09iajsKK30K K0xJU1BfSU5MSU5FIGJvb2wKK0tCT0FSRF9PQkpGV0RQICh1bmlvbiBMaXNwX0Z3ZCAqYSkK K3sKKyAgcmV0dXJuIFhGV0RUWVBFIChhKSA9PSBMaXNwX0Z3ZF9LYm9hcmRfT2JqOworfQor CitMSVNQX0lOTElORSBib29sCitQU0VVRE9WRUNUT1JfVFlQRVAgKHN0cnVjdCB2ZWN0b3Js aWtlX2hlYWRlciAqYSwgaW50IGNvZGUpCit7CisgIHJldHVybiAoKGEtPnNpemUgJiAoUFNF VURPVkVDVE9SX0ZMQUcgfCBQVkVDX1RZUEVfTUFTSykpCisJICA9PSAoUFNFVURPVkVDVE9S X0ZMQUcgfCAoY29kZSA8PCBQU0VVRE9WRUNUT1JfQVJFQV9CSVRTKSkpOworfQorCisvKiBU cnVlIGlmIEEgaXMgYSBwc2V1ZG92ZWN0b3Igd2hvc2UgY29kZSBpcyBDT0RFLiAgKi8KK0xJ U1BfSU5MSU5FIGJvb2wKK1BTRVVET1ZFQ1RPUlAgKExpc3BfT2JqZWN0IGEsIGludCBjb2Rl KQoreworICBpZiAoISBWRUNUT1JMSUtFUCAoYSkpCisgICAgcmV0dXJuIDA7CisgIGVsc2UK KyAgICB7CisgICAgICAvKiBDb252ZXJ0aW5nIHRvIHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRl ciAqIGF2b2lkcyBhbGlhc2luZyBpc3N1ZXMuICAqLworICAgICAgc3RydWN0IHZlY3Rvcmxp a2VfaGVhZGVyICpoID0gWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworICAgICAgcmV0 dXJuIFBTRVVET1ZFQ1RPUl9UWVBFUCAoaCwgY29kZSk7CisgICAgfQorfQorCiAKIC8qIFRl c3QgZm9yIHNwZWNpZmljIHBzZXVkb3ZlY3RvciB0eXBlcy4gICovCi0jZGVmaW5lIFdJTkRP V19DT05GSUdVUkFUSU9OUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX1dJTkRPV19DT05G SUdVUkFUSU9OKQotI2RlZmluZSBQUk9DRVNTUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVD X1BST0NFU1MpCi0jZGVmaW5lIFdJTkRPV1AoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19X SU5ET1cpCi0jZGVmaW5lIFRFUk1JTkFMUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX1RF Uk1JTkFMKQotI2RlZmluZSBTVUJSUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX1NVQlIp Ci0jZGVmaW5lIENPTVBJTEVEUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX0NPTVBJTEVE KQotI2RlZmluZSBCVUZGRVJQKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfQlVGRkVSKQot I2RlZmluZSBDSEFSX1RBQkxFX1AoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19DSEFSX1RB QkxFKQotI2RlZmluZSBTVUJfQ0hBUl9UQUJMRV9QKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBW RUNfU1VCX0NIQVJfVEFCTEUpCi0jZGVmaW5lIEJPT0xfVkVDVE9SX1AoeCkgUFNFVURPVkVD VE9SUCAoeCwgUFZFQ19CT09MX1ZFQ1RPUikKLSNkZWZpbmUgRlJBTUVQKHgpIFBTRVVET1ZF Q1RPUlAgKHgsIFBWRUNfRlJBTUUpCisKK0xJU1BfSU5MSU5FIGJvb2wKK1dJTkRPV19DT05G SUdVUkFUSU9OUCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAg KGEsIFBWRUNfV0lORE9XX0NPTkZJR1VSQVRJT04pOworfQorCitMSVNQX0lOTElORSBib29s CitQUk9DRVNTUCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAg KGEsIFBWRUNfUFJPQ0VTUyk7Cit9CisKK0xJU1BfSU5MSU5FIGJvb2wKK1dJTkRPV1AgKExp c3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVDX1dJTkRP Vyk7Cit9CisKK0xJU1BfSU5MSU5FIGJvb2wKK1RFUk1JTkFMUCAoTGlzcF9PYmplY3QgYSkK K3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEsIFBWRUNfVEVSTUlOQUwpOworfQorCitM SVNQX0lOTElORSBib29sCitTVUJSUCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFBT RVVET1ZFQ1RPUlAgKGEsIFBWRUNfU1VCUik7Cit9CisKK0xJU1BfSU5MSU5FIGJvb2wKK0NP TVBJTEVEUCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEs IFBWRUNfQ09NUElMRUQpOworfQorCitMSVNQX0lOTElORSBib29sCitCVUZGRVJQIChMaXNw X09iamVjdCBhKQoreworICByZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZFQ19CVUZGRVIp OworfQorCitMSVNQX0lOTElORSBib29sCitDSEFSX1RBQkxFX1AgKExpc3BfT2JqZWN0IGEp Cit7CisgIHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVDX0NIQVJfVEFCTEUpOworfQor CitMSVNQX0lOTElORSBib29sCitTVUJfQ0hBUl9UQUJMRV9QIChMaXNwX09iamVjdCBhKQor eworICByZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZFQ19TVUJfQ0hBUl9UQUJMRSk7Cit9 CisKK0xJU1BfSU5MSU5FIGJvb2wKK0JPT0xfVkVDVE9SX1AgKExpc3BfT2JqZWN0IGEpCit7 CisgIHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVDX0JPT0xfVkVDVE9SKTsKK30KKwor TElTUF9JTkxJTkUgYm9vbAorRlJBTUVQIChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4g UFNFVURPVkVDVE9SUCAoYSwgUFZFQ19GUkFNRSk7Cit9CiAKIC8qIFRlc3QgZm9yIGltYWdl IChpbWFnZSAuIHNwZWMpICAqLwotI2RlZmluZSBJTUFHRVAoeCkgKENPTlNQICh4KSAmJiBF USAoWENBUiAoeCksIFFpbWFnZSkpCitMSVNQX0lOTElORSBib29sCitJTUFHRVAgKExpc3Bf T2JqZWN0IHgpCit7CisgIHJldHVybiBDT05TUCAoeCkgJiYgRVEgKFhDQVIgKHgpLCBRaW1h Z2UpOworfQogCiAvKiBBcnJheSB0eXBlcy4gICovCi0KLSNkZWZpbmUgQVJSQVlQKHgpIFwK LSAgKFZFQ1RPUlAgKHgpIHx8IFNUUklOR1AgKHgpIHx8IENIQVJfVEFCTEVfUCAoeCkgfHwg Qk9PTF9WRUNUT1JfUCAoeCkpCitMSVNQX0lOTElORSBib29sCitBUlJBWVAgKExpc3BfT2Jq ZWN0IHgpCit7CisgIHJldHVybiBWRUNUT1JQICh4KSB8fCBTVFJJTkdQICh4KSB8fCBDSEFS X1RBQkxFX1AgKHgpIHx8IEJPT0xfVkVDVE9SX1AgKHgpOworfQogDAotI2RlZmluZSBDSEVD S19MSVNUKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoQ09OU1AgKHgpIHx8IE5JTFAgKHgpLCBRbGlz dHAsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfTElTVF9DT05TKHgsIHkpIFwKLSAgQ0hFQ0tfVFlQ RSAoQ09OU1AgKHgpLCBRbGlzdHAsIHkpCi0KLSNkZWZpbmUgQ0hFQ0tfTElTVF9FTkQoeCwg eSkgXAotICBDSEVDS19UWVBFIChOSUxQICh4KSwgUWxpc3RwLCB5KQotCi0jZGVmaW5lIENI RUNLX1NUUklORyh4KSBcCi0gIENIRUNLX1RZUEUgKFNUUklOR1AgKHgpLCBRc3RyaW5ncCwg eCkKLQotI2RlZmluZSBDSEVDS19TVFJJTkdfQ0FSKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoU1RS SU5HUCAoWENBUiAoeCkpLCBRc3RyaW5ncCwgWENBUiAoeCkpCi0KLSNkZWZpbmUgQ0hFQ0tf Q09OUyh4KSBcCi0gIENIRUNLX1RZUEUgKENPTlNQICh4KSwgUWNvbnNwLCB4KQotCi0jZGVm aW5lIENIRUNLX1NZTUJPTCh4KSBcCi0gIENIRUNLX1RZUEUgKFNZTUJPTFAgKHgpLCBRc3lt Ym9scCwgeCkKLQotI2RlZmluZSBDSEVDS19DSEFSX1RBQkxFKHgpIFwKLSAgQ0hFQ0tfVFlQ RSAoQ0hBUl9UQUJMRV9QICh4KSwgUWNoYXJfdGFibGVfcCwgeCkKLQotI2RlZmluZSBDSEVD S19WRUNUT1IoeCkgXAotICBDSEVDS19UWVBFIChWRUNUT1JQICh4KSwgUXZlY3RvcnAsIHgp Ci0KLSNkZWZpbmUgQ0hFQ0tfVkVDVE9SX09SX1NUUklORyh4KSBcCi0gIENIRUNLX1RZUEUg KFZFQ1RPUlAgKHgpIHx8IFNUUklOR1AgKHgpLCBRYXJyYXlwLCB4KQotCi0jZGVmaW5lIENI RUNLX0FSUkFZKHgsIFF4eHhwKSBcCi0gIENIRUNLX1RZUEUgKEFSUkFZUCAoeCksIFF4eHhw LCB4KQotCi0jZGVmaW5lIENIRUNLX1ZFQ1RPUl9PUl9DSEFSX1RBQkxFKHgpIFwKLSAgQ0hF Q0tfVFlQRSAoVkVDVE9SUCAoeCkgfHwgQ0hBUl9UQUJMRV9QICh4KSwgUXZlY3Rvcl9vcl9j aGFyX3RhYmxlX3AsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfQlVGRkVSKHgpIFwKLSAgQ0hFQ0tf VFlQRSAoQlVGRkVSUCAoeCksIFFidWZmZXJwLCB4KQotCi0jZGVmaW5lIENIRUNLX1dJTkRP Vyh4KSBcCi0gIENIRUNLX1RZUEUgKFdJTkRPV1AgKHgpLCBRd2luZG93cCwgeCkKLQotI2Rl ZmluZSBDSEVDS19XSU5ET1dfQ09ORklHVVJBVElPTih4KSBcCi0gIENIRUNLX1RZUEUgKFdJ TkRPV19DT05GSUdVUkFUSU9OUCAoeCksIFF3aW5kb3dfY29uZmlndXJhdGlvbl9wLCB4KQot Ci0jZGVmaW5lIENIRUNLX1BST0NFU1MoeCkgXAotICBDSEVDS19UWVBFIChQUk9DRVNTUCAo eCksIFFwcm9jZXNzcCwgeCkKLQotI2RlZmluZSBDSEVDS19TVUJSKHgpIFwKLSAgQ0hFQ0tf VFlQRSAoU1VCUlAgKHgpLCBRc3VicnAsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfTlVNQkVSKHgp IFwKLSAgQ0hFQ0tfVFlQRSAoSU5URUdFUlAgKHgpLCBRaW50ZWdlcnAsIHgpCi0KLSNkZWZp bmUgQ0hFQ0tfTkFUTlVNKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoTkFUTlVNUCAoeCksIFF3aG9s ZW51bXAsIHgpCitMSVNQX0lOTElORSB2b2lkCitDSEVDS19MSVNUIChMaXNwX09iamVjdCB4 KQoreworICBDSEVDS19UWVBFIChDT05TUCAoeCkgfHwgTklMUCAoeCksIFFsaXN0cCwgeCk7 Cit9CitMSVNQX0lOTElORSB2b2lkCisoQ0hFQ0tfTElTVF9DT05TKSAoTGlzcF9PYmplY3Qg eCwgTGlzcF9PYmplY3QgeSkKK3sKKyAgQ0hFQ0tfVFlQRSAoQ09OU1AgKHgpLCBRbGlzdHAs IHkpOworfQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTElTVF9FTkQgKExpc3BfT2JqZWN0 IHgsIExpc3BfT2JqZWN0IHkpCit7CisgIENIRUNLX1RZUEUgKE5JTFAgKHgpLCBRbGlzdHAs IHkpOworfQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfU1RSSU5HIChMaXNwX09iamVjdCB4 KQoreworICBDSEVDS19UWVBFIChTVFJJTkdQICh4KSwgUXN0cmluZ3AsIHgpOworfQorTElT UF9JTkxJTkUgdm9pZAorQ0hFQ0tfU1RSSU5HX0NBUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAg Q0hFQ0tfVFlQRSAoU1RSSU5HUCAoWENBUiAoeCkpLCBRc3RyaW5ncCwgWENBUiAoeCkpOwor fQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfQ09OUyAoTGlzcF9PYmplY3QgeCkKK3sKKyAg Q0hFQ0tfVFlQRSAoQ09OU1AgKHgpLCBRY29uc3AsIHgpOworfQorTElTUF9JTkxJTkUgdm9p ZAorKENIRUNLX1NZTUJPTCkgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKFNZ TUJPTFAgKHgpLCBRc3ltYm9scCwgeCk7Cit9CitMSVNQX0lOTElORSB2b2lkCitDSEVDS19D SEFSX1RBQkxFIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChDSEFSX1RBQkxF X1AgKHgpLCBRY2hhcl90YWJsZV9wLCB4KTsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK0NIRUNL X1ZFQ1RPUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQRSAoVkVDVE9SUCAoeCks IFF2ZWN0b3JwLCB4KTsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK0NIRUNLX1ZFQ1RPUl9PUl9T VFJJTkcgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKFZFQ1RPUlAgKHgpIHx8 IFNUUklOR1AgKHgpLCBRYXJyYXlwLCB4KTsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK0NIRUNL X0FSUkFZIChMaXNwX09iamVjdCB4LCBMaXNwX09iamVjdCBReHh4cCkKK3sKKyAgQ0hFQ0tf VFlQRSAoQVJSQVlQICh4KSwgUXh4eHAsIHgpOworfQorTElTUF9JTkxJTkUgdm9pZAorQ0hF Q0tfVkVDVE9SX09SX0NIQVJfVEFCTEUgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZ UEUgKFZFQ1RPUlAgKHgpIHx8IENIQVJfVEFCTEVfUCAoeCksIFF2ZWN0b3Jfb3JfY2hhcl90 YWJsZV9wLCB4KTsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK0NIRUNLX0JVRkZFUiAoTGlzcF9P YmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQRSAoQlVGRkVSUCAoeCksIFFidWZmZXJwLCB4KTsK K30KK0xJU1BfSU5MSU5FIHZvaWQKK0NIRUNLX1dJTkRPVyAoTGlzcF9PYmplY3QgeCkKK3sK KyAgQ0hFQ0tfVFlQRSAoV0lORE9XUCAoeCksIFF3aW5kb3dwLCB4KTsKK30KK0xJU1BfSU5M SU5FIHZvaWQKK0NIRUNLX1dJTkRPV19DT05GSUdVUkFUSU9OIChMaXNwX09iamVjdCB4KQor eworICBDSEVDS19UWVBFIChXSU5ET1dfQ09ORklHVVJBVElPTlAgKHgpLCBRd2luZG93X2Nv bmZpZ3VyYXRpb25fcCwgeCk7Cit9CitMSVNQX0lOTElORSB2b2lkCitDSEVDS19QUk9DRVNT IChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChQUk9DRVNTUCAoeCksIFFwcm9j ZXNzcCwgeCk7Cit9CitMSVNQX0lOTElORSB2b2lkCitDSEVDS19TVUJSIChMaXNwX09iamVj dCB4KQoreworICBDSEVDS19UWVBFIChTVUJSUCAoeCksIFFzdWJycCwgeCk7Cit9CitMSVNQ X0lOTElORSB2b2lkCisoQ0hFQ0tfTlVNQkVSKSAoTGlzcF9PYmplY3QgeCkKK3sKKyAgQ0hF Q0tfVFlQRSAoSU5URUdFUlAgKHgpLCBRaW50ZWdlcnAsIHgpOworfQorTElTUF9JTkxJTkUg dm9pZAorQ0hFQ0tfTkFUTlVNIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChO QVROVU1QICh4KSwgUXdob2xlbnVtcCwgeCk7Cit9CiAKICNkZWZpbmUgQ0hFQ0tfUkFOR0VE X0lOVEVHRVIoeCwgbG8sIGhpKQkJCQkJXAogICBkbyB7CQkJCQkJCQkJXApAQCAtMTk3Miw1 NyArMjUxNiw3NiBAQAogICAgICAgQ0hFQ0tfUkFOR0VEX0lOVEVHRVIgKHgsIDAsIFRZUEVf TUFYSU1VTSAodHlwZSkpOwkJCVwKICAgfSB3aGlsZSAoMCkKIAotI2RlZmluZSBDSEVDS19N QVJLRVIoeCkgXAotICBDSEVDS19UWVBFIChNQVJLRVJQICh4KSwgUW1hcmtlcnAsIHgpCitM SVNQX0lOTElORSB2b2lkCitDSEVDS19NQVJLRVIgKExpc3BfT2JqZWN0IHgpCit7CisgIENI RUNLX1RZUEUgKE1BUktFUlAgKHgpLCBRbWFya2VycCwgeCk7Cit9CiAKICNkZWZpbmUgQ0hF Q0tfTlVNQkVSX0NPRVJDRV9NQVJLRVIoeCkgXAogICBkbyB7IGlmIChNQVJLRVJQICgoeCkp KSBYU0VURkFTVElOVCAoeCwgbWFya2VyX3Bvc2l0aW9uICh4KSk7IFwKICAgICBlbHNlIENI RUNLX1RZUEUgKElOVEVHRVJQICh4KSwgUWludGVnZXJfb3JfbWFya2VyX3AsIHgpOyB9IHdo aWxlICgwKQogCi0jZGVmaW5lIFhGTE9BVElOVChuKSBleHRyYWN0X2Zsb2F0KChuKSkKLQot I2RlZmluZSBDSEVDS19GTE9BVCh4KSBcCi0gIENIRUNLX1RZUEUgKEZMT0FUUCAoeCksIFFm bG9hdHAsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfTlVNQkVSX09SX0ZMT0FUKHgpIFwKLSAgQ0hF Q0tfVFlQRSAoRkxPQVRQICh4KSB8fCBJTlRFR0VSUCAoeCksIFFudW1iZXJwLCB4KQorTElT UF9JTkxJTkUgZG91YmxlCitYRkxPQVRJTlQgKExpc3BfT2JqZWN0IG4pCit7CisgIHJldHVy biBleHRyYWN0X2Zsb2F0IChuKTsKK30KKworTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfRkxP QVQgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKEZMT0FUUCAoeCksIFFmbG9h dHAsIHgpOworfQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTlVNQkVSX09SX0ZMT0FUIChM aXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChGTE9BVFAgKHgpIHx8IElOVEVHRVJQ ICh4KSwgUW51bWJlcnAsIHgpOworfQogCiAjZGVmaW5lIENIRUNLX05VTUJFUl9PUl9GTE9B VF9DT0VSQ0VfTUFSS0VSKHgpIFwKICAgZG8geyBpZiAoTUFSS0VSUCAoeCkpIFhTRVRGQVNU SU5UICh4LCBtYXJrZXJfcG9zaXRpb24gKHgpKTsgXAogICAgIGVsc2UgQ0hFQ0tfVFlQRSAo SU5URUdFUlAgKHgpIHx8IEZMT0FUUCAoeCksIFFudW1iZXJfb3JfbWFya2VyX3AsIHgpOyB9 IHdoaWxlICgwKQogCi0jZGVmaW5lIENIRUNLX09WRVJMQVkoeCkgXAotICBDSEVDS19UWVBF IChPVkVSTEFZUCAoeCksIFFvdmVybGF5cCwgeCkKK0xJU1BfSU5MSU5FIHZvaWQKK0NIRUNL X09WRVJMQVkgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKE9WRVJMQVlQICh4 KSwgUW92ZXJsYXlwLCB4KTsKK30KIAogLyogU2luY2Ugd2UgY2FuJ3QgYXNzaWduIGRpcmVj dGx5IHRvIHRoZSBDQVIgb3IgQ0RSIGZpZWxkcyBvZiBhIGNvbnMKICAgIGNlbGwsIHVzZSB0 aGVzZSB3aGVuIGNoZWNraW5nIHRoYXQgdGhvc2UgZmllbGRzIGNvbnRhaW4gbnVtYmVycy4g ICovCi0jZGVmaW5lIENIRUNLX05VTUJFUl9DQVIoeCkgXAotICBkbyB7CQkJCQlcCi0gICAg TGlzcF9PYmplY3QgdG1wID0gWENBUiAoeCk7CQlcCi0gICAgQ0hFQ0tfTlVNQkVSICh0bXAp OwkJCVwKLSAgICBYU0VUQ0FSICgoeCksIHRtcCk7CQkJXAotICB9IHdoaWxlICgwKQotCi0j ZGVmaW5lIENIRUNLX05VTUJFUl9DRFIoeCkgXAotICBkbyB7CQkJCQlcCi0gICAgTGlzcF9P YmplY3QgdG1wID0gWENEUiAoeCk7CQlcCi0gICAgQ0hFQ0tfTlVNQkVSICh0bXApOwkJCVwK LSAgICBYU0VUQ0RSICgoeCksIHRtcCk7CQkJXAotICB9IHdoaWxlICgwKQotCi0jZGVmaW5l IENIRUNLX05BVE5VTV9DQVIoeCkgXAotICBkbyB7CQkJCQlcCi0gICAgTGlzcF9PYmplY3Qg dG1wID0gWENBUiAoeCk7CQlcCi0gICAgQ0hFQ0tfTkFUTlVNICh0bXApOwkJCVwKLSAgICBY U0VUQ0FSICgoeCksIHRtcCk7CQkJXAotICB9IHdoaWxlICgwKQotCi0jZGVmaW5lIENIRUNL X05BVE5VTV9DRFIoeCkgXAotICBkbyB7CQkJCQlcCi0gICAgTGlzcF9PYmplY3QgdG1wID0g WENEUiAoeCk7CQlcCi0gICAgQ0hFQ0tfTkFUTlVNICh0bXApOwkJCVwKLSAgICBYU0VUQ0RS ICgoeCksIHRtcCk7CQkJXAotICB9IHdoaWxlICgwKQorTElTUF9JTkxJTkUgdm9pZAorQ0hF Q0tfTlVNQkVSX0NBUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgTGlzcF9PYmplY3QgdG1wID0g WENBUiAoeCk7CisgIENIRUNLX05VTUJFUiAodG1wKTsKKyAgWFNFVENBUiAoeCwgdG1wKTsK K30KKworTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTlVNQkVSX0NEUiAoTGlzcF9PYmplY3Qg eCkKK3sKKyAgTGlzcF9PYmplY3QgdG1wID0gWENEUiAoeCk7CisgIENIRUNLX05VTUJFUiAo dG1wKTsKKyAgWFNFVENEUiAoeCwgdG1wKTsKK30KKworTElTUF9JTkxJTkUgdm9pZAorQ0hF Q0tfTkFUTlVNX0NBUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgTGlzcF9PYmplY3QgdG1wID0g WENBUiAoeCk7CisgIENIRUNLX05BVE5VTSAodG1wKTsKKyAgWFNFVENBUiAoeCwgdG1wKTsK K30KKworTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTkFUTlVNX0NEUiAoTGlzcF9PYmplY3Qg eCkKK3sKKyAgTGlzcF9PYmplY3QgdG1wID0gWENEUiAoeCk7CisgIENIRUNLX05BVE5VTSAo dG1wKTsKKyAgWFNFVENEUiAoeCwgdG1wKTsKK30KIAwKIC8qIERlZmluZSBhIGJ1aWx0LWlu IGZ1bmN0aW9uIGZvciBjYWxsaW5nIGZyb20gTGlzcC4KICBgbG5hbWUnIHNob3VsZCBiZSB0 aGUgbmFtZSB0byBnaXZlIHRoZSBmdW5jdGlvbiBpbiBMaXNwLApAQCAtMjA4OCw4ICsyNjUx LDEyIEBACiAjZGVmaW5lIERFRlVOX0FSR1NfOAkoTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0 LCBMaXNwX09iamVjdCwgTGlzcF9PYmplY3QsIFwKIAkJCSBMaXNwX09iamVjdCwgTGlzcF9P YmplY3QsIExpc3BfT2JqZWN0LCBMaXNwX09iamVjdCkKIAotLyogTm9uLXplcm8gaWYgT0JK IGlzIGEgTGlzcCBmdW5jdGlvbi4gICovCi0jZGVmaW5lIEZVTkNUSU9OUChPQkopIGZ1bmN0 aW9ucChPQkopCisvKiBUcnVlIGlmIE9CSiBpcyBhIExpc3AgZnVuY3Rpb24uICAqLworTElT UF9JTkxJTkUgYm9vbAorRlVOQ1RJT05QIChMaXNwX09iamVjdCBvYmopCit7CisgIHJldHVy biBmdW5jdGlvbnAgKG9iaik7Cit9CiAKIC8qIGRlZnN1YnIgKFNuYW1lKTsKICAgIGlzIGhv dyB3ZSBkZWZpbmUgdGhlIHN5bWJvbCBmb3IgZnVuY3Rpb24gYG5hbWUnIGF0IHN0YXJ0LXVw IHRpbWUuICAqLwpAQCAtMjI3Niw3ICsyODQzLDExIEBACiBleHRlcm4gc3RydWN0IHNwZWNi aW5kaW5nICpzcGVjcGRsX3B0cjsKIGV4dGVybiBwdHJkaWZmX3Qgc3BlY3BkbF9zaXplOwog Ci0jZGVmaW5lIFNQRUNQRExfSU5ERVgoKQkoc3BlY3BkbF9wdHIgLSBzcGVjcGRsKQorTElT UF9JTkxJTkUgcHRyZGlmZl90CitTUEVDUERMX0lOREVYICh2b2lkKQoreworICByZXR1cm4g c3BlY3BkbF9wdHIgLSBzcGVjcGRsOworfQogCiAvKiBFdmVyeXRoaW5nIG5lZWRlZCB0byBk ZXNjcmliZSBhbiBhY3RpdmUgY29uZGl0aW9uIGNhc2UuCiAKQEAgLTI1OTIsMjcgKzMxNjMs MTIgQEAKICNkZWZpbmUgRVhGVU4oZm5uYW1lLCBtYXhhcmdzKSBcCiAgIGV4dGVybiBMaXNw X09iamVjdCBmbm5hbWUgREVGVU5fQVJHU18gIyMgbWF4YXJncwogCisjaW5jbHVkZSAiZ2xv YmFscy5oIgorCiAvKiBGb3J3YXJkIGRlY2xhcmF0aW9ucyBmb3IgcHJvdG90eXBlcy4gICov CiBzdHJ1Y3Qgd2luZG93Owogc3RydWN0IGZyYW1lOwogCi0vKiBTaW1wbGUgYWNjZXNzIGZ1 bmN0aW9ucy4gICovCi0KLUxJU1BfSU5MSU5FIExpc3BfT2JqZWN0ICoKLWFyZWZfYWRkciAo TGlzcF9PYmplY3QgYXJyYXksIHB0cmRpZmZfdCBpZHgpCi17Ci0gIHJldHVybiAmIFhWRUNU T1IgKGFycmF5KS0+Y29udGVudHNbaWR4XTsKLX0KLQotTElTUF9JTkxJTkUgdm9pZAotZ2Nf YXNldCAoTGlzcF9PYmplY3QgYXJyYXksIHB0cmRpZmZfdCBpZHgsIExpc3BfT2JqZWN0IHZh bCkKLXsKLSAgLyogTGlrZSBBU0VULCBidXQgYWxzbyBjYW4gYmUgdXNlZCBpbiB0aGUgZ2Fy YmFnZSBjb2xsZWN0b3I6Ci0gICAgIHN3ZWVwX3dlYWtfdGFibGUgY2FsbHMgc2V0X2hhc2hf a2V5IGV0Yy4gd2hpbGUgdGhlIHRhYmxlIGlzIG1hcmtlZC4gICovCi0gIGVhc3NlcnQgKDAg PD0gaWR4ICYmIGlkeCA8IChBU0laRSAoYXJyYXkpICYgfkFSUkFZX01BUktfRkxBRykpOwot ICBYVkVDVE9SIChhcnJheSktPmNvbnRlbnRzW2lkeF0gPSB2YWw7Ci19Ci0KIC8qIENvcHkg Q09VTlQgTGlzcF9PYmplY3RzIGZyb20gQVJHUyB0byBjb250ZW50cyBvZiBWIHN0YXJ0aW5n IGZyb20gT0ZGU0VULiAgKi8KIAogTElTUF9JTkxJTkUgdm9pZApAQCAtMjg0OSw2ICszNDA1 LDcgQEAKIAogZXh0ZXJuIExpc3BfT2JqZWN0IFFidWZmZXIsIFFpbnRlZ2VyLCBRc3ltYm9s OwogCitleHRlcm4gTGlzcF9PYmplY3QgUXN1YnJwOwogZXh0ZXJuIExpc3BfT2JqZWN0IFFm b250X3NwZWMsIFFmb250X2VudGl0eSwgUWZvbnRfb2JqZWN0OwogCiBFWEZVTiAoRmJ5dGVv cmRlciwgMCkgQVRUUklCVVRFX0NPTlNUOwpAQCAtMzIzNyw3ICszNzk0LDcgQEAKICNpZmRl ZiBHQ19DSEVDS19DT05TX0xJU1QKIGV4dGVybiB2b2lkIGNoZWNrX2NvbnNfbGlzdCAodm9p ZCk7CiAjZWxzZQotI2RlZmluZSBjaGVja19jb25zX2xpc3QoKSAoKHZvaWQpIDApCitMSVNQ X0lOTElORSB2b2lkIChjaGVja19jb25zX2xpc3QpICh2b2lkKSB7fQogI2VuZGlmCiAKICNp ZmRlZiBSRUxfQUxMT0MKQEAgLTMzMDUsMTAgKzM4NjIsMTIgQEAKIGV4dGVybiBMaXNwX09i amVjdCBpbnRlcm5fMSAoY29uc3QgY2hhciAqLCBwdHJkaWZmX3QpOwogZXh0ZXJuIExpc3Bf T2JqZWN0IGludGVybl9jX3N0cmluZ18xIChjb25zdCBjaGFyICosIHB0cmRpZmZfdCk7CiBl eHRlcm4gTGlzcF9PYmplY3Qgb2Jsb29rdXAgKExpc3BfT2JqZWN0LCBjb25zdCBjaGFyICos IHB0cmRpZmZfdCwgcHRyZGlmZl90KTsKLSNkZWZpbmUgTE9BREhJU1RfQVRUQUNIKHgpIFwK LSAgZG8gewkJCQkJCQkJCVwKLSAgICBpZiAoaW5pdGlhbGl6ZWQpIFZjdXJyZW50X2xvYWRf bGlzdCA9IEZjb25zICh4LCBWY3VycmVudF9sb2FkX2xpc3QpOyBcCi0gIH0gd2hpbGUgKDAp CitMSVNQX0lOTElORSB2b2lkCitMT0FESElTVF9BVFRBQ0ggKExpc3BfT2JqZWN0IHgpCit7 CisgIGlmIChpbml0aWFsaXplZCkKKyAgICBWY3VycmVudF9sb2FkX2xpc3QgPSBGY29ucyAo eCwgVmN1cnJlbnRfbG9hZF9saXN0KTsKK30KIGV4dGVybiBpbnQgb3BlbnAgKExpc3BfT2Jq ZWN0LCBMaXNwX09iamVjdCwgTGlzcF9PYmplY3QsCiAgICAgICAgICAgICAgICAgICBMaXNw X09iamVjdCAqLCBMaXNwX09iamVjdCk7CiBleHRlcm4gTGlzcF9PYmplY3Qgc3RyaW5nX3Rv X251bWJlciAoY2hhciBjb25zdCAqLCBpbnQsIGJvb2wpOwpAQCAtMzQzMSw2ICszOTkwLDcg QEAKIGV4dGVybiBMaXNwX09iamVjdCBWYnVmZmVyX2FsaXN0OwogZXh0ZXJuIExpc3BfT2Jq ZWN0IHNldF9idWZmZXJfaWZfbGl2ZSAoTGlzcF9PYmplY3QpOwogZXh0ZXJuIExpc3BfT2Jq ZWN0IG90aGVyX2J1ZmZlcl9zYWZlbHkgKExpc3BfT2JqZWN0KTsKK2V4dGVybiBMaXNwX09i amVjdCBRb3ZlcmxheXA7CiBleHRlcm4gTGlzcF9PYmplY3QgUXByaW9yaXR5LCBRd2luZG93 LCBRYmVmb3JlX3N0cmluZywgUWFmdGVyX3N0cmluZzsKIGV4dGVybiBMaXNwX09iamVjdCBn ZXRfdHJ1ZW5hbWVfYnVmZmVyIChMaXNwX09iamVjdCk7CiBleHRlcm4gdm9pZCBpbml0X2J1 ZmZlcl9vbmNlICh2b2lkKTsKQEAgLTM1OTQsMTAgKzQxNTQsMTAgQEAKIHZvaWQgc3luY2hy b25pemVfc3lzdGVtX21lc3NhZ2VzX2xvY2FsZSAodm9pZCk7CiB2b2lkIHN5bmNocm9uaXpl X3N5c3RlbV90aW1lX2xvY2FsZSAodm9pZCk7CiAjZWxzZQotI2RlZmluZSBzZXRsb2NhbGUo Y2F0ZWdvcnksIGxvY2FsZSkKLSNkZWZpbmUgZml4dXBfbG9jYWxlKCkKLSNkZWZpbmUgc3lu Y2hyb25pemVfc3lzdGVtX21lc3NhZ2VzX2xvY2FsZSgpCi0jZGVmaW5lIHN5bmNocm9uaXpl X3N5c3RlbV90aW1lX2xvY2FsZSgpCitMSVNQX0lOTElORSBjaGFyICpzZXRsb2NhbGUgKGlu dCBjYXQsIGNoYXIgY29uc3QgKmxvY2FsZSkgeyByZXR1cm4gMDsgfQorTElTUF9JTkxJTkUg dm9pZCBmaXh1cF9sb2NhbGUgKHZvaWQpIHt9CitMSVNQX0lOTElORSB2b2lkIHN5bmNocm9u aXplX3N5c3RlbV9tZXNzYWdlc19sb2NhbGUgKHZvaWQpIHt9CitMSVNQX0lOTElORSB2b2lk IHN5bmNocm9uaXplX3N5c3RlbV90aW1lX2xvY2FsZSAodm9pZCkge30KICNlbmRpZgogZXh0 ZXJuIHZvaWQgc2h1dF9kb3duX2VtYWNzIChpbnQsIExpc3BfT2JqZWN0KTsKIApAQCAtMzk1 Niw4ICs0NTE2LDYgQEAKICAgfSB3aGlsZSAoMCkKIAogCi0jaW5jbHVkZSAiZ2xvYmFscy5o IgotCiAvKiBDaGVjayB3aGV0aGVyIGl0J3MgdGltZSBmb3IgR0MsIGFuZCBydW4gaXQgaWYg c28uICAqLwogCiBMSVNQX0lOTElORSB2b2lkCkBAIC0zOTcwLDcgKzQ1MjgsNyBAQAogICAg IEZnYXJiYWdlX2NvbGxlY3QgKCk7CiB9CiAKLUxJU1BfSU5MSU5FIGludAorTElTUF9JTkxJ TkUgYm9vbAogZnVuY3Rpb25wIChMaXNwX09iamVjdCBvYmplY3QpCiB7CiAgIGlmIChTWU1C T0xQIChvYmplY3QpICYmICFOSUxQIChGZmJvdW5kcCAob2JqZWN0KSkpCgo9PT0gbW9kaWZp ZWQgZmlsZSAnc3JjL3dpbmRvdy5jJwotLS0gc3JjL3dpbmRvdy5jCTIwMTMtMDYtMDQgMTY6 MzM6NDYgKzAwMDAKKysrIHNyYy93aW5kb3cuYwkyMDEzLTA2LTA1IDA0OjM4OjA0ICswMDAw CkBAIC01NSw3ICs1NSw4IEBACiAKIExpc3BfT2JqZWN0IFF3aW5kb3dwLCBRd2luZG93X2xp dmVfcDsKIHN0YXRpYyBMaXNwX09iamVjdCBRd2luZG93X3ZhbGlkX3A7Ci1zdGF0aWMgTGlz cF9PYmplY3QgUXdpbmRvd19jb25maWd1cmF0aW9uX3AsIFFyZWNvcmRfd2luZG93X2J1ZmZl cjsKK0xpc3BfT2JqZWN0IFF3aW5kb3dfY29uZmlndXJhdGlvbl9wOworc3RhdGljIExpc3Bf T2JqZWN0IFFyZWNvcmRfd2luZG93X2J1ZmZlcjsKIHN0YXRpYyBMaXNwX09iamVjdCBRd2lu ZG93X2RlbGV0YWJsZV9wLCBRZGVsZXRlX3dpbmRvdywgUWRpc3BsYXlfYnVmZmVyOwogc3Rh dGljIExpc3BfT2JqZWN0IFFyZXBsYWNlX2J1ZmZlcl9pbl93aW5kb3dzLCBRZ2V0X21ydV93 aW5kb3c7CiBzdGF0aWMgTGlzcF9PYmplY3QgUXdpbmRvd19yZXNpemVfcm9vdF93aW5kb3cs IFF3aW5kb3dfcmVzaXplX3Jvb3Rfd2luZG93X3ZlcnRpY2FsbHk7Cgo9PT0gbW9kaWZpZWQg ZmlsZSAnc3JjL3dpbmRvdy5oJwotLS0gc3JjL3dpbmRvdy5oCTIwMTMtMDMtMjggMTQ6MDQ6 NDkgKzAwMDAKKysrIHNyYy93aW5kb3cuaAkyMDEzLTA0LTAzIDE3OjIzOjA2ICswMDAwCkBA IC05NTgsNyArOTU4LDcgQEAKIAogLyogVGhlc2UgdXNlZCB0byBiZSBpbiBsaXNwLmguICAq LwogCi1leHRlcm4gTGlzcF9PYmplY3QgUXdpbmRvd3AsIFF3aW5kb3dfbGl2ZV9wOworZXh0 ZXJuIExpc3BfT2JqZWN0IFF3aW5kb3dfbGl2ZV9wOwogZXh0ZXJuIExpc3BfT2JqZWN0IFZ3 aW5kb3dfbGlzdDsKIAogZXh0ZXJuIHN0cnVjdCB3aW5kb3cgKmRlY29kZV9saXZlX3dpbmRv dyAoTGlzcF9PYmplY3QpOwo= --------------050709090604060200090702-- From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 06 12:38:26 2013 Received: (at 11935) by debbugs.gnu.org; 6 Jun 2013 16:38:26 +0000 Received: from localhost ([127.0.0.1]:54608 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1UkdCg-0007nS-5V for submit@debbugs.gnu.org; Thu, 06 Jun 2013 12:38:26 -0400 Received: from mail-out.m-online.net ([212.18.0.10]:47411) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1UkdCZ-0007nF-Qi for 11935@debbugs.gnu.org; Thu, 06 Jun 2013 12:38:20 -0400 Received: from frontend1.mail.m-online.net (frontend1.mail.intern.m-online.net [192.168.8.180]) by mail-out.m-online.net (Postfix) with ESMTP id 3bRCDN1Wt5z3hhV6; Thu, 6 Jun 2013 18:36:02 +0200 (CEST) Received: from localhost (dynscan1.mnet-online.de [192.168.6.68]) by mail.m-online.net (Postfix) with ESMTP id 3bRCDL385szbc02; Thu, 6 Jun 2013 18:36:02 +0200 (CEST) X-Virus-Scanned: amavisd-new at mnet-online.de Received: from mail.mnet-online.de ([192.168.8.180]) by localhost (dynscan1.mail.m-online.net [192.168.6.68]) (amavisd-new, port 10024) with ESMTP id lYaom57bEiRV; Thu, 6 Jun 2013 18:36:01 +0200 (CEST) X-Auth-Info: a4s6Hz4MpJ1MzCC5Aby0okK1Od3mie2+LuJNkg3mvY8= Received: from igel.home (ppp-88-217-111-4.dynamic.mnet-online.de [88.217.111.4]) by mail.mnet-online.de (Postfix) with ESMTPA; Thu, 6 Jun 2013 18:36:01 +0200 (CEST) Received: by igel.home (Postfix, from userid 1000) id 75685E42B8; Thu, 6 Jun 2013 18:36:00 +0200 (CEST) From: Andreas Schwab To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> X-Yow: I'm receiving a coded message from EUBIE BLAKE!! Date: Thu, 06 Jun 2013 18:36:00 +0200 In-Reply-To: <51B0B137.5020705@cs.ucla.edu> (Paul Eggert's message of "Thu, 06 Jun 2013 08:56:39 -0700") Message-ID: <87k3m7qjrj.fsf@igel.home> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Score: -0.0 (/) X-Debbugs-Envelope-To: 11935 Cc: 11935@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 (-) Paul Eggert writes: > -#define CHECK_OVERLAY(x) \ > - CHECK_TYPE (OVERLAYP (x), Qoverlayp, x) > +LISP_INLINE void > +CHECK_OVERLAY (Lisp_Object x) > +{ > + CHECK_TYPE (OVERLAYP (x), Qoverlayp, x); > +} Since it's only used in buffer.c it should be moved there. Andreas. -- Andreas Schwab, schwab@linux-m68k.org GPG Key fingerprint = 58CA 54C7 6D53 942B 1756 01D3 44D5 214B 8276 4ED5 "And now for something completely different." From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 06 12:44:32 2013 Received: (at 11935) by debbugs.gnu.org; 6 Jun 2013 16:44:32 +0000 Received: from localhost ([127.0.0.1]:54623 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1UkdId-00084A-Ps for submit@debbugs.gnu.org; Thu, 06 Jun 2013 12:44:32 -0400 Received: from pruche.dit.umontreal.ca ([132.204.246.22]:49848) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1UkdIZ-00083r-AF for 11935@debbugs.gnu.org; Thu, 06 Jun 2013 12:44:27 -0400 Received: from pastel.home (lechon.iro.umontreal.ca [132.204.27.242]) by pruche.dit.umontreal.ca (8.14.1/8.14.1) with ESMTP id r56Gg6jn028891; Thu, 6 Jun 2013 12:42:06 -0400 Received: by pastel.home (Postfix, from userid 20848) id CC07169DA7; Thu, 6 Jun 2013 12:42:05 -0400 (EDT) From: Stefan Monnier To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions Message-ID: References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> Date: Thu, 06 Jun 2013 12:42:05 -0400 In-Reply-To: <51B0B137.5020705@cs.ucla.edu> (Paul Eggert's message of "Thu, 06 Jun 2013 08:56:39 -0700") User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-NAI-Spam-Flag: NO X-NAI-Spam-Level: X-NAI-Spam-Threshold: 5 X-NAI-Spam-Score: 0.7 X-NAI-Spam-Rules: 3 Rules triggered SUBJ_END_DOT_WORDS=0.5, GEN_SPAM_FEATRE=0.2, RV4601=0 X-NAI-Spam-Version: 2.3.0.9362 : core <4601> : streams <975100> : uri <1440180> X-Spam-Score: -4.1 (----) X-Debbugs-Envelope-To: 11935 Cc: 11935@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: -4.1 (----) > Attached is an updated version of this patch, > relative to the current trunk (bzr 112869). Having XCONS and friends duplicated into a macro version and a function version is a non-starter for me. Stefan From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 08 20:52:27 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 00:52:27 +0000 Received: from localhost ([127.0.0.1]:52323 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlTrq-0007Nq-Eg for submit@debbugs.gnu.org; Sat, 08 Jun 2013 20:52:27 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:51639) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlTrh-0007N2-72 for 11935@debbugs.gnu.org; Sat, 08 Jun 2013 20:52:18 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 9933F39E8105; Sat, 8 Jun 2013 17:52:06 -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 W89SchyTi2yp; Sat, 8 Jun 2013 17:52:06 -0700 (PDT) Received: from [192.168.1.9] (pool-71-108-49-126.lsanca.fios.verizon.net [71.108.49.126]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 014E839E8100; Sat, 8 Jun 2013 17:52:05 -0700 (PDT) Message-ID: <51B3D1B5.8020807@cs.ucla.edu> Date: Sat, 08 Jun 2013 17:52:05 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130510 Thunderbird/17.0.6 MIME-Version: 1.0 To: Stefan Monnier Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> In-Reply-To: Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.3 (--) On 06/06/13 09:42, Stefan Monnier wrote: > Having XCONS and friends duplicated into a macro version and a function > version is a non-starter for me. Yes, I didn't like those macros either. I'll remove them; they're no longer needed now that GCC has the -Og option. In case you haven't run into it yet, -Og means "optimize for debugging", and causes GCC to generate code that's easy to debug, without having the big runtime performance penalty of -O0. Like -O2 but unlike -O0, with -Og the CPU time for my little Lisp nthcdr benchmark is unaffected by the proposed patch (assuming those macros are removed). C compilation time is considerably faster for -Og than for -O2; it's not as fast as -O0, but for the common case of changing one C source file and then typing "make emacs", -Og is faster than -O0 (because bootstrap-emacs runs faster) and is a tad faster than -O2 (because the C compiler runs faster). Here are the detailed times, if you're curious. I got these on a Fedora 17 x86-64 (AMD Phenom II X4 910e) that was otherwise unloaded. I used plain 'make' without parallelism. Everything was built with GCC 4.8.1 and with Texinfo 5.1. All times are user+system CPU times; the low-order digits of the times aren't that reliable. (benchmark make \ rm fns.o; rm *.o; make \ 100000) xdisp.o make emacs make emacs bootstrap -O0 unpatched 2.89 3.1 12.4 57 1099 -O0 patched 21.66 3.0 20.0 63 2442 -Og unpatched 1.15 5.9 9.2 80 860 -Og patched 1.15 6.4 9.5 87 879 -O2 unpatched 1.57 11.3 9.6 110 843 -O2 patched 1.57 11.1 9.9 119 847 In (benchmark 100000) the -Og code runs faster than -O2, which is surprising, but I think it's an anomaly; I may find the time to fire off a performance bug-report to the GCC developers. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 08 23:05:05 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 03:05:05 +0000 Received: from localhost ([127.0.0.1]:52446 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlVwB-0004cl-LP for submit@debbugs.gnu.org; Sat, 08 Jun 2013 23:05:05 -0400 Received: from ironport2-out.teksavvy.com ([206.248.154.182]:50153) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlVw5-0004cN-3m for 11935@debbugs.gnu.org; Sat, 08 Jun 2013 23:04:58 -0400 X-IronPort-Anti-Spam-Filtered: true X-IronPort-Anti-Spam-Result: Av8EABK/CFFFpYtM/2dsb2JhbABEDrsng1kXc4IeAQEEAVYjEAs0EhQYDSSIHgbBLZEKA6R6gV6COVo X-IPAS-Result: Av8EABK/CFFFpYtM/2dsb2JhbABEDrsng1kXc4IeAQEEAVYjEAs0EhQYDSSIHgbBLZEKA6R6gV6COVo X-IronPort-AV: E=Sophos;i="4.84,565,1355115600"; d="scan'208";a="15958130" Received: from 69-165-139-76.dsl.teksavvy.com (HELO pastel.home) ([69.165.139.76]) by ironport2-out.teksavvy.com with ESMTP/TLS/ADH-AES256-SHA; 08 Jun 2013 23:04:41 -0400 Received: by pastel.home (Postfix, from userid 20848) id DC9DD62EE3; Sat, 8 Jun 2013 23:04:45 -0400 (EDT) From: Stefan Monnier To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions Message-ID: References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> Date: Sat, 08 Jun 2013 23:04:45 -0400 In-Reply-To: <51B3D1B5.8020807@cs.ucla.edu> (Paul Eggert's message of "Sat, 08 Jun 2013 17:52:05 -0700") User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Score: 0.3 (/) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: 0.3 (/) >> Having XCONS and friends duplicated into a macro version and a function >> version is a non-starter for me. > Yes, I didn't like those macros either. I'll remove them; they're no > longer needed now that GCC has the -Og option. Sadly, I don't live in the same era as you do: my gcc doesn't take -Og yet. > -O0 unpatched 2.89 3.1 12.4 57 1099 > -O0 patched 21.66 3.0 20.0 63 2442 An almost 10 times slowdown for the -O0 case is really problematic. IOW I think it'll be a fine idea but only when -Og is supported in Debian stable. Stefan From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 09 00:43:24 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 04:43:24 +0000 Received: from localhost ([127.0.0.1]:52526 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlXTM-0000L4-2Q for submit@debbugs.gnu.org; Sun, 09 Jun 2013 00:43:24 -0400 Received: from ore.jhcloos.com ([198.147.23.85]:47359) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlXTG-0000KV-0k for 11935@debbugs.gnu.org; Sun, 09 Jun 2013 00:43:17 -0400 Received: by ore.jhcloos.com (Postfix, from userid 10) id D326A1F9C1; Sun, 9 Jun 2013 00:43:10 -0400 (EDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=jhcloos.com; s=ore13; t=1370752990; bh=Jn7df9VUwVfHstAngMPHIYN+bG8gf8LzhSv43/89ne8=; h=From:To:Cc:Subject:In-Reply-To:References:Date:From; b=BWQypAe0huJa8xBHx9/A4ivJ5KReL7L2mhVxQ+mjRPF9Sb/XlKz2wLGkcZyCuO+1d AGUC83NeiG52hu9Ptw/3EwpMo+Nzb6EG9O/1JIAN58DiEP1tRL3O4b+TBOMlPoOBwW NpaK72sP6mEWajq8B+jn4Oibc+FPzXnLhs4SV4wL4ug== Received: by carbon.jhcloos.org (Postfix, from userid 500) id E12747342E; Sun, 9 Jun 2013 04:37:52 +0000 (UTC) From: James Cloos To: Stefan Monnier Subject: Re: bug#11935: XINT etc. should be functions In-Reply-To: (Stefan Monnier's message of "Sat, 08 Jun 2013 23:04:45 -0400") References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> User-Agent: Gnus/5.130008 (Ma Gnus v0.8) Emacs/24.3.50 (gnu/linux) Face: iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAgMAAABinRfyAAAACVBMVEX///8ZGXBQKKnCrDQ3 AAAAJElEQVQImWNgQAAXzwQg4SKASgAlXIEEiwsSIYBEcLaAtMEAADJnB+kKcKioAAAAAElFTkSu QmCC Copyright: Copyright 2013 James Cloos OpenPGP: ED7DAEA6; url=http://jhcloos.com/public_key/0xED7DAEA6.asc OpenPGP-Fingerprint: E9E9 F828 61A4 6EA9 0F2B 63E7 997A 9F17 ED7D AEA6 Date: Sun, 09 Jun 2013 00:37:52 -0400 Message-ID: Lines: 13 MIME-Version: 1.0 Content-Type: text/plain X-Hashcash: 1:28:130609:monnier@iro.umontreal.ca::v83ISWuIe6kdSbYA:0000000000000000000000000000000000001Z8yD X-Hashcash: 1:28:130609:eggert@cs.ucla.edu::S28D3sRYr77DIg/x:000000000000000000000000000000000000000000SKvC7 X-Hashcash: 1:28:130609:11935@debbugs.gnu.org::sIpPoqrE0FiSBhTK:000000000000000000000000000000000000000Ucjlp X-Spam-Score: -0.0 (/) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, Paul Eggert X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.0 (/) >>>>> "SM" == Stefan Monnier writes: SM> An almost 10 times slowdown for the -O0 case is really problematic. SM> IOW I think it'll be a fine idea but only when -Og is supported in SM> Debian stable. Jessie has gcc-4.8, so that is just one more freeze/thaw cycle. However long that takes. :^) -JimC -- James Cloos OpenPGP: 1024D/ED7DAEA6 From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 09 02:57:14 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 06:57:14 +0000 Received: from localhost ([127.0.0.1]:52666 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlZYr-0006bB-Uv for submit@debbugs.gnu.org; Sun, 09 Jun 2013 02:57:14 -0400 Received: from mailout.melmac.se ([62.20.26.67]:37756) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlZYl-0006a9-OS for 11935@debbugs.gnu.org; Sun, 09 Jun 2013 02:57:08 -0400 Received: from mail01.melmac.se (mail01.melmac.se [62.20.26.80]) by mailout.melmac.se (Postfix) with ESMTP id 1D480C55D for <11935@debbugs.gnu.org>; Sun, 9 Jun 2013 08:56:55 +0200 (CEST) Received: (qmail 26280 invoked by uid 89); 9 Jun 2013 06:56:55 -0000 Received: from h-46-59-42-57.na.cust.bahnhof.se (HELO coolsville.localdomain) (boel.djarv@bdtv.se@46.59.42.57) by mail01.melmac.se with ESMTPA; 9 Jun 2013 06:56:55 -0000 Received: from [172.20.199.13] (unknown [172.20.199.13]) by coolsville.localdomain (Postfix) with ESMTPSA id C125F1A1B8C; Sun, 9 Jun 2013 06:56:54 +0000 (UTC) Content-Type: text/plain; charset=us-ascii Mime-Version: 1.0 (Mac OS X Mail 6.3 \(1503\)) Subject: Re: bug#11935: XINT etc. should be functions From: =?iso-8859-1?Q?Jan_Dj=E4rv?= In-Reply-To: <51B3D1B5.8020807@cs.ucla.edu> Date: Sun, 9 Jun 2013 08:56:55 +0200 Content-Transfer-Encoding: quoted-printable Message-Id: <1EB810C4-5B0D-4564-A914-E203B6DFD7BB@swipnet.se> References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> To: Paul Eggert X-Mailer: Apple Mail (2.1503) X-Spam-Score: 1.0 (+) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, Stefan Monnier X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: 1.0 (+) Hello. 9 jun 2013 kl. 02:52 skrev Paul Eggert : > On 06/06/13 09:42, Stefan Monnier wrote: >=20 >> Having XCONS and friends duplicated into a macro version and a = function >> version is a non-starter for me. >=20 > Yes, I didn't like those macros either. I'll remove them; they're no > longer needed now that GCC has the -Og option. In case you haven't > run into it yet, -Og means "optimize for debugging", and causes GCC to > generate code that's easy to debug, without having the big runtime > performance penalty of -O0. Which version of gcc has this? Note that most people does not have the = latest gcc version. Jan D. From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 09 02:59:52 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 06:59:52 +0000 Received: from localhost ([127.0.0.1]:52673 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlZbQ-0006hg-1B for submit@debbugs.gnu.org; Sun, 09 Jun 2013 02:59:52 -0400 Received: from mailout.melmac.se ([62.20.26.67]:37768) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlZbK-0006gt-4S for 11935@debbugs.gnu.org; Sun, 09 Jun 2013 02:59:46 -0400 Received: from mail01.melmac.se (mail01.melmac.se [62.20.26.80]) by mailout.melmac.se (Postfix) with ESMTP id 9685FC568 for <11935@debbugs.gnu.org>; Sun, 9 Jun 2013 08:59:34 +0200 (CEST) Received: (qmail 27524 invoked by uid 89); 9 Jun 2013 06:59:34 -0000 Received: from h-46-59-42-57.na.cust.bahnhof.se (HELO coolsville.localdomain) (boel.djarv@bdtv.se@46.59.42.57) by mail01.melmac.se with ESMTPA; 9 Jun 2013 06:59:34 -0000 Received: from [172.20.199.13] (unknown [172.20.199.13]) by coolsville.localdomain (Postfix) with ESMTPSA id 2998C1A1B8C; Sun, 9 Jun 2013 06:59:34 +0000 (UTC) Content-Type: text/plain; charset=us-ascii Mime-Version: 1.0 (Mac OS X Mail 6.3 \(1503\)) Subject: Re: bug#11935: XINT etc. should be functions From: =?iso-8859-1?Q?Jan_Dj=E4rv?= In-Reply-To: Date: Sun, 9 Jun 2013 08:59:34 +0200 Content-Transfer-Encoding: quoted-printable Message-Id: <6D69C5C3-5B4E-4D50-84A7-73553C072F42@swipnet.se> References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> To: James Cloos X-Mailer: Apple Mail (2.1503) X-Spam-Score: 1.0 (+) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, Paul Eggert , Stefan Monnier X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: 1.0 (+) 9 jun 2013 kl. 06:37 skrev James Cloos : >>>>>> "SM" =3D=3D Stefan Monnier writes: >=20 > SM> An almost 10 times slowdown for the -O0 case is really = problematic. > SM> IOW I think it'll be a fine idea but only when -Og is supported in > SM> Debian stable. >=20 > Jessie has gcc-4.8, so that is just one more freeze/thaw cycle. >=20 > However long that takes. :^) Some distibutions will never get gcc 4.8. Not everybody upgrades to the = latest version. I think it would be a big mistake to introduce a x10 slowdown for pre = 4.8 gcc users. Jan D. From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 09 03:13:32 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 07:13:32 +0000 Received: from localhost ([127.0.0.1]:52679 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlZoc-0007Qd-Mf for submit@debbugs.gnu.org; Sun, 09 Jun 2013 03:13:31 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:60810) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlZoV-0007Pn-VW for 11935@debbugs.gnu.org; Sun, 09 Jun 2013 03:13:25 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 1A0C739E8106; Sun, 9 Jun 2013 00:13:12 -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 FbX5sde967co; Sun, 9 Jun 2013 00:13:11 -0700 (PDT) Received: from [192.168.1.9] (pool-71-108-49-126.lsanca.fios.verizon.net [71.108.49.126]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id B54CC39E8008; Sun, 9 Jun 2013 00:13:11 -0700 (PDT) Message-ID: <51B42B07.5090209@cs.ucla.edu> Date: Sun, 09 Jun 2013 00:13:11 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130510 Thunderbird/17.0.6 MIME-Version: 1.0 To: Stefan Monnier Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> In-Reply-To: Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.3 (--) On 06/08/2013 08:04 PM, Stefan Monnier wrote: > I think it'll be a fine idea but only when -Og is supported in > Debian stable. I'd rather not wait three (or five!) more years to install helpful changes like this. I might not live that long. If it's unacceptable to maintain both a macro and a function implementation for a few primitives, we can simply have the latter invoke the former -- that way, there's only one actual implementation. Or if you prefer, we can omit the functions entirely. We can leave in a FIXME reminding us to change the macros to functions after the three years or so. Another option is that you could download and install GCC 4.8.x on your Debian stable host. That should work. That might be better for Emacs development, though it'd be a bit more of an effort for you. From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 09 03:23:43 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 07:23:43 +0000 Received: from localhost ([127.0.0.1]:52687 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlZyT-0007v3-Mc for submit@debbugs.gnu.org; Sun, 09 Jun 2013 03:23:43 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:32880) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlZyL-0007uH-Ve for 11935@debbugs.gnu.org; Sun, 09 Jun 2013 03:23:35 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 58F1F39E8106; Sun, 9 Jun 2013 00:23:22 -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 yi547YdqkN0k; Sun, 9 Jun 2013 00:23:22 -0700 (PDT) Received: from [192.168.1.9] (pool-71-108-49-126.lsanca.fios.verizon.net [71.108.49.126]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id ECB4C39E8008; Sun, 9 Jun 2013 00:23:21 -0700 (PDT) Message-ID: <51B42D69.7040800@cs.ucla.edu> Date: Sun, 09 Jun 2013 00:23:21 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130510 Thunderbird/17.0.6 MIME-Version: 1.0 To: =?UTF-8?B?SmFuIERqw6Rydg==?= Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <1EB810C4-5B0D-4564-A914-E203B6DFD7BB@swipnet.se> In-Reply-To: <1EB810C4-5B0D-4564-A914-E203B6DFD7BB@swipnet.se> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, Stefan Monnier X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.3 (--) On 06/08/2013 11:56 PM, Jan Djärv wrote: > most people does not have the latest gcc version. Most people can use older GCC versions just fine, since by default Emacs builds with optimization flags that will generate pretty much the same machine code regardless of whether the patch is used. The only problem is with developers who are using older GCC versions and who wish to compile without optimization, to make Emacs easier to debug. These folks can't use -Og (available in GCC 4.8 and later), so they have to make do with -O0. -Og is better for debugging than -O0 is, and the proposed patch caters to -Og. Eventually the -Og approach will win out; the only question is when and how to start the ball rolling. From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 09 05:19:05 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 09:19:05 +0000 Received: from localhost ([127.0.0.1]:52770 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Ulbm8-0004Vo-Ei for submit@debbugs.gnu.org; Sun, 09 Jun 2013 05:19:05 -0400 Received: from mailout.melmac.se ([62.20.26.67]:62169) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Ulbm3-0004VK-3q for 11935@debbugs.gnu.org; Sun, 09 Jun 2013 05:18:59 -0400 Received: from mail01.melmac.se (mail01.melmac.se [62.20.26.80]) by mailout.melmac.se (Postfix) with ESMTP id 97045CA65 for <11935@debbugs.gnu.org>; Sun, 9 Jun 2013 11:18:45 +0200 (CEST) Received: (qmail 9267 invoked by uid 89); 9 Jun 2013 09:18:45 -0000 Received: from h-46-59-42-57.na.cust.bahnhof.se (HELO coolsville.localdomain) (boel.djarv@bdtv.se@46.59.42.57) by mail01.melmac.se with ESMTPA; 9 Jun 2013 09:18:45 -0000 Received: from [172.20.199.13] (unknown [172.20.199.13]) by coolsville.localdomain (Postfix) with ESMTPSA id 2874E1A1D0F; Sun, 9 Jun 2013 09:18:45 +0000 (UTC) Content-Type: text/plain; charset=iso-8859-1 Mime-Version: 1.0 (Mac OS X Mail 6.3 \(1503\)) Subject: Re: bug#11935: XINT etc. should be functions From: =?iso-8859-1?Q?Jan_Dj=E4rv?= In-Reply-To: <51B42D69.7040800@cs.ucla.edu> Date: Sun, 9 Jun 2013 11:18:45 +0200 Content-Transfer-Encoding: quoted-printable Message-Id: References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <1EB810C4-5B0D-4564-A914-E203B6DFD7BB@swipnet.se> <51B42D69.7040800@cs.ucla.edu> To: Paul Eggert X-Mailer: Apple Mail (2.1503) X-Spam-Score: 1.0 (+) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, Stefan Monnier X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: 1.0 (+) Hello. 9 jun 2013 kl. 09:23 skrev Paul Eggert : > On 06/08/2013 11:56 PM, Jan Dj=E4rv wrote: >> most people does not have the latest gcc version. >=20 > Most people can use older GCC versions just fine, > since by default Emacs builds with optimization flags > that will generate pretty much the same machine code > regardless of whether the patch is used. >=20 > The only problem is with developers who are using older > GCC versions and who wish to compile without optimization, > to make Emacs easier to debug. These folks can't use -Og > (available in GCC 4.8 and later), so they have to make do > with -O0. >=20 That is not the only problem. etc/DEBUG recommends to build with no = optimization when reporting errors. > -Og is better for debugging than -O0 is, and the > proposed patch caters to -Og. Eventually the -Og > approach will win out; the only question is when > and how to start the ball rolling. If you can make it detect when to use macros and when to use functions = so -O0 doesn't suffer, that is starting the ball rolling. Otherwise it = is setting up a brick wall for users/developers with older gcc. Jan D. From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 09 10:26:44 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 14:26:44 +0000 Received: from localhost ([127.0.0.1]:53333 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlgZv-0002Hn-GQ for submit@debbugs.gnu.org; Sun, 09 Jun 2013 10:26:43 -0400 Received: from mail-ee0-f45.google.com ([74.125.83.45]:55460) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UlgZs-0002H5-SK for 11935@debbugs.gnu.org; Sun, 09 Jun 2013 10:26:41 -0400 Received: by mail-ee0-f45.google.com with SMTP id c1so2180228eek.32 for <11935@debbugs.gnu.org>; Sun, 09 Jun 2013 07:26:31 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:in-reply-to:references:from:date:message-id:subject:to :cc:content-type:content-transfer-encoding; bh=27ZGQkNDtH0RVY6yUhOZI+ihOwPA9TNIa0W6l1fGX4I=; b=EYS1w1TST6BOQxan2sN/sbpUDVhL1jvs6tGvgxwaCUfwVVhDzudxyKGLdtX2w2yNID Gf8Y3QMbcO4aJbAhX7uUWBesAFRPz1hxj8JpCWfjX6uPIz91v4i7ldSsApjxmSwMhu0+ 6ku6Va+deV8B+aSK1tGytAqEIEqi5TsuXCyvx529MylVU92pE7G7b4MxFeNlEuMXtupI bxUAwGiux88hZhpCgx+uN1iO6+PMSAJ9/NCdZhdqZQrrNSysS5Y+HeeBU4boNRiKBZxR AAnAhfKKxv7IN8KPSb2pw3u28wPQkCKTIS6mqrArmAwTzNDwx45+fnDAhTLWYClQ/JND EInw== X-Received: by 10.14.216.201 with SMTP id g49mr6765192eep.42.1370787991219; Sun, 09 Jun 2013 07:26:31 -0700 (PDT) MIME-Version: 1.0 Received: by 10.14.142.4 with HTTP; Sun, 9 Jun 2013 07:25:50 -0700 (PDT) In-Reply-To: References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <1EB810C4-5B0D-4564-A914-E203B6DFD7BB@swipnet.se> <51B42D69.7040800@cs.ucla.edu> From: Juanma Barranquero Date: Sun, 9 Jun 2013 16:25:50 +0200 Message-ID: Subject: Re: bug#11935: XINT etc. should be functions To: =?UTF-8?Q?Jan_Dj=C3=A4rv?= Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable X-Spam-Score: -0.7 (/) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, Paul Eggert X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -0.7 (/) On Sun, Jun 9, 2013 at 11:18 AM, Jan Dj=C3=A4rv wrote: > If you can make it detect when to use macros and when to use functions so > -O0 doesn't suffer, that is starting the ball rolling. Otherwise it is s= etting up > a brick wall for users/developers with older gcc. Also, in some environments updating to newer GCC isn't that easy. There's no MinGW GCC 4.8.1, and I wouldn't bet there will be one for many months. J From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 09 11:57:43 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 15:57:43 +0000 Received: from localhost ([127.0.0.1]:53418 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Ulhzy-0006N8-QK for submit@debbugs.gnu.org; Sun, 09 Jun 2013 11:57:43 -0400 Received: from ironport2-out.teksavvy.com ([206.248.154.182]:19397) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Ulhzv-0006MZ-7s for 11935@debbugs.gnu.org; Sun, 09 Jun 2013 11:57:40 -0400 X-IronPort-Anti-Spam-Filtered: true X-IronPort-Anti-Spam-Result: Av4EABK/CFFFpYtM/2dsb2JhbABEDr8AF3OCHgEBBAFWIwULCzQSFBgNJIgeBsEtkQoDpHqBXoI5Wg X-IPAS-Result: Av4EABK/CFFFpYtM/2dsb2JhbABEDr8AF3OCHgEBBAFWIwULCzQSFBgNJIgeBsEtkQoDpHqBXoI5Wg X-IronPort-AV: E=Sophos;i="4.84,565,1355115600"; d="scan'208";a="15980472" Received: from 69-165-139-76.dsl.teksavvy.com (HELO pastel.home) ([69.165.139.76]) by ironport2-out.teksavvy.com with ESMTP/TLS/ADH-AES256-SHA; 09 Jun 2013 11:57:24 -0400 Received: by pastel.home (Postfix, from userid 20848) id EB2CD62EE3; Sun, 9 Jun 2013 11:57:23 -0400 (EDT) From: Stefan Monnier To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions Message-ID: References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <51B42B07.5090209@cs.ucla.edu> Date: Sun, 09 Jun 2013 11:57:23 -0400 In-Reply-To: <51B42B07.5090209@cs.ucla.edu> (Paul Eggert's message of "Sun, 09 Jun 2013 00:13:11 -0700") User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Score: 0.3 (/) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: 0.3 (/) >> I think it'll be a fine idea but only when -Og is supported in >> Debian stable. > I'd rather not wait three (or five!) more years to install helpful > changes like this. I might not live that long. OTOH we've been using the current macros for so many years that the change is not exactly urgent. > If it's unacceptable to maintain both a macro and a function > implementation for a few primitives, we can simply have the > latter invoke the former -- that way, there's only one actual > implementation. I could live with that. > Or if you prefer, we can omit the functions entirely. Sounds even better. > We can leave in a FIXME reminding us to > change the macros to functions after the three years or so. Sure. > Another option is that you could download and install > GCC 4.8.x on your Debian stable host. I'm running Debian testing on most of my machines, so it should get to 4.8 pretty soon, but as others have pointed out, Debian is not the only problem. I generally take "Debian stable" as a reference, not because I use Debian but because it seems that if something is in Debian stable you can mostly assume it's also available in most other contexts. Stefan From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 09 12:05:48 2013 Received: (at 11935) by debbugs.gnu.org; 9 Jun 2013 16:05:48 +0000 Received: from localhost ([127.0.0.1]:53431 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Uli7m-0006ic-7w for submit@debbugs.gnu.org; Sun, 09 Jun 2013 12:05:47 -0400 Received: from mailout.melmac.se ([62.20.26.67]:36813) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Uli7j-0006hm-06 for 11935@debbugs.gnu.org; Sun, 09 Jun 2013 12:05:45 -0400 Received: from mail01.melmac.se (mail01.melmac.se [62.20.26.80]) by mailout.melmac.se (Postfix) with ESMTP id 9FA869863 for <11935@debbugs.gnu.org>; Sun, 9 Jun 2013 18:05:31 +0200 (CEST) Received: (qmail 5654 invoked by uid 89); 9 Jun 2013 16:05:31 -0000 Received: from h-46-59-42-57.na.cust.bahnhof.se (HELO coolsville.localdomain) (boel.djarv@bdtv.se@46.59.42.57) by mail01.melmac.se with ESMTPA; 9 Jun 2013 16:05:31 -0000 Received: from [172.20.199.13] (unknown [172.20.199.13]) by coolsville.localdomain (Postfix) with ESMTPSA id 03CAF1A0074; Sun, 9 Jun 2013 16:05:31 +0000 (UTC) Content-Type: text/plain; charset=iso-8859-1 Mime-Version: 1.0 (Mac OS X Mail 6.3 \(1503\)) Subject: Re: bug#11935: XINT etc. should be functions From: =?iso-8859-1?Q?Jan_Dj=E4rv?= In-Reply-To: Date: Sun, 9 Jun 2013 18:05:31 +0200 Content-Transfer-Encoding: quoted-printable Message-Id: <217FA2AC-198B-44B2-8E2D-533D3048C28F@swipnet.se> References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <1EB810C4-5B0D-4564-A914-E203B6DFD7BB@swipnet.se> <51B42D69.7040800@cs.ucla.edu> To: Juanma Barranquero X-Mailer: Apple Mail (2.1503) X-Spam-Score: 1.0 (+) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org, Paul Eggert X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: 1.0 (+) Hello. 9 jun 2013 kl. 16:25 skrev Juanma Barranquero : > On Sun, Jun 9, 2013 at 11:18 AM, Jan Dj=E4rv = wrote: >=20 >> If you can make it detect when to use macros and when to use = functions so >> -O0 doesn't suffer, that is starting the ball rolling. Otherwise it = is setting up >> a brick wall for users/developers with older gcc. >=20 > Also, in some environments updating to newer GCC isn't that easy. > There's no MinGW GCC 4.8.1, and I wouldn't bet there will be one for > many months. Another thing to consider are other compilers. Clang is becoming more = common, and is available on all supported platforms (maybe not DOS). = How does it handle -g -O0? AFAIK, it does not have -Og. Jan D. From debbugs-submit-bounces@debbugs.gnu.org Mon Jun 10 09:41:07 2013 Received: (at submit) by debbugs.gnu.org; 10 Jun 2013 13:41:07 +0000 Received: from localhost ([127.0.0.1]:54584 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Um2LJ-0003Mf-A1 for submit@debbugs.gnu.org; Mon, 10 Jun 2013 09:41:06 -0400 Received: from eggs.gnu.org ([208.118.235.92]:46613) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Um2LE-0003Lg-Ab for submit@debbugs.gnu.org; Mon, 10 Jun 2013 09:41:01 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1Um2Ky-00030O-BN for submit@debbugs.gnu.org; Mon, 10 Jun 2013 09:40:45 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.2 (2011-06-06) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=-101.9 required=5.0 tests=BAYES_00,FREEMAIL_FROM, HTML_MESSAGE, T_DKIM_INVALID, USER_IN_WHITELIST autolearn=disabled version=3.3.2 Received: from lists.gnu.org ([2001:4830:134:3::11]:36281) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Um2Ky-00030J-8Q for submit@debbugs.gnu.org; Mon, 10 Jun 2013 09:40:44 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:48330) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Um2Kw-00033v-SZ for bug-gnu-emacs@gnu.org; Mon, 10 Jun 2013 09:40:44 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1Um2Ks-0002zI-CD for bug-gnu-emacs@gnu.org; Mon, 10 Jun 2013 09:40:42 -0400 Received: from mail-ob0-x22d.google.com ([2607:f8b0:4003:c01::22d]:39652) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Um2Ks-0002yw-6j for bug-gnu-emacs@gnu.org; Mon, 10 Jun 2013 09:40:38 -0400 Received: by mail-ob0-f173.google.com with SMTP id wc20so9891224obb.4 for ; Mon, 10 Jun 2013 06:40:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:date:message-id:subject:from:to:content-type; bh=4UdrC14aj/XpB7NV2i6kmnJBEOks7qYhZz5mXzdTsTA=; b=Hudoj+4gsMS0HEcW+BL2eAOjGx+pdUqK+5Cb624Yy2PWOrYGYinOxHvNXDv7+xh9qQ GduEDgFJYNHktazSvCJ+JPf750+0A1fN7Fz66zRuRR7DfapM6y3BCw8wOETIdxtnmlwQ aX3/+Se+xCwz1h6w5Hp5FdveYVYs+hzzxPSNZjUjTXahAYY3SEYDRJvR+ueO5+vTPTeV tOLRwEFbuWTBbUE/eaOc7Wb0jMsiaifUZz98QCfrwG7kYM9e6EyLDo865hK0sYHoUi5K uv3uD5XIlolPD51sHgBcMsmdbdpVpPUlGYQvvCXCNUALmTknfBtS2Em0n1V2GM4kD7TA +pew== MIME-Version: 1.0 X-Received: by 10.60.119.65 with SMTP id ks1mr8306988oeb.43.1370871637378; Mon, 10 Jun 2013 06:40:37 -0700 (PDT) Received: by 10.76.69.234 with HTTP; Mon, 10 Jun 2013 06:40:37 -0700 (PDT) Date: Mon, 10 Jun 2013 09:40:37 -0400 Message-ID: Subject: bug#11935: XINT etc. should be functions From: Barry OReilly To: bug-gnu-emacs@gnu.org Content-Type: multipart/alternative; boundary=047d7b3a9792fa8a2d04deccec17 X-detected-operating-system: by eggs.gnu.org: Error: Malformed IPv6 address (bad octet value). X-detected-operating-system: by eggs.gnu.org: Error: Malformed IPv6 address (bad octet value). X-Received-From: 2001:4830:134:3::11 X-Spam-Score: -4.3 (----) X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -4.3 (----) --047d7b3a9792fa8a2d04deccec17 Content-Type: text/plain; charset=ISO-8859-1 Man gcc indicates -O* flags are selected sets of finer grained optimizations. Perhaps if this is so for -Og, it is possible to build an efficient and debug-friendly Emacs with older versions of GCC by specifying the right set of finer grained optimization flags. --047d7b3a9792fa8a2d04deccec17 Content-Type: text/html; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Man gcc indicates -O* flags are selected sets of finer grained optimization= s. Perhaps if this is so for -Og, it is possible to build an efficient and = debug-friendly Emacs with older versions of GCC by specifying the right set= of finer grained optimization flags.

--047d7b3a9792fa8a2d04deccec17-- From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 13 10:45:50 2013 Received: (at 11935) by debbugs.gnu.org; 13 Jun 2013 14:45:51 +0000 Received: from localhost ([127.0.0.1]:41541 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Un8mc-0008Fg-Is for submit@debbugs.gnu.org; Thu, 13 Jun 2013 10:45:50 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:37943) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1Un8mY-0008FJ-UI for 11935@debbugs.gnu.org; Thu, 13 Jun 2013 10:45:48 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 2E7E339E8008; Thu, 13 Jun 2013 07:45:40 -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 K6EOcBHA6fqt; Thu, 13 Jun 2013 07:45:36 -0700 (PDT) Received: from penguin.cs.ucla.edu (Penguin.CS.UCLA.EDU [131.179.64.200]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 80588A60038; Thu, 13 Jun 2013 07:45:21 -0700 (PDT) Message-ID: <51B9DAFC.3010502@cs.ucla.edu> Date: Thu, 13 Jun 2013 07:45:16 -0700 From: Paul Eggert User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130514 Thunderbird/17.0.6 MIME-Version: 1.0 To: Stefan Monnier Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <51B42B07.5090209@cs.ucla.edu> In-Reply-To: Content-Type: multipart/mixed; boundary="------------080600040104060500050802" X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" This is a multi-part message in MIME format. --------------080600040104060500050802 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 06/09/13 08:57, Stefan Monnier wrote: >> > If it's unacceptable to maintain both a macro and a function >> > implementation for a few primitives, we can simply have the >> > latter invoke the former -- that way, there's only one actual >> > implementation. > I could live with that. OK, attached is a patch to do that. I think this is a bit better than a macro-only implementation as it makes the way forward clearer for a few years from now, when we can assume GCC 4.8 or later. This fixes the -O0 performance problem, so developers using pre-4.8 GCC (or clang) won't suffer. Here are the measurements, where "old patch" refers to the previous version of the patch with the XINT etc. macros removed, and "new patch" refers to the attached. The benchmark is the same as before. As before, the low-order digits probably aren't that significant. Fedora 17 x86-64, AMD Phenom II X4 910e Clang 3.0 (Fedora 17) GCC 4.8.1 (I built it) single-process make (no -j) (benchmark make \ rm fns.o; rm *.o; make \ 100000) xdisp.o make emacs make emacs bootstrap GCC -O2 unpatched 1.57 11.3 9.6 110 843 GCC -O2 old patch 1.57 11.1 9.9 119 847 GCC -O2 new patch 1.38 10.9 9.9 118 850 GCC -Og unpatched 1.15 5.9 9.2 80 860 GCC -Og old patch 1.15 6.4 9.5 87 879 GCC -Og new patch 1.15 6.4 9.5 86 874 GCC -O0 unpatched 2.89 3.1 12.4 57 1099 GCC -O0 old patch 21.66 3.0 20.0 63 2442 GCC -O0 new patch 2.89 2.9 13.2 56 1265 Clang -O2 unpatched 1.57 6.3 8.3 65 818 Clang -O2 old patch 1.34 6.8 8.5 70 826 Clang -O2 new patch 1.34 6.8 8.5 70 830 Clang -O0 unpatched 3.72 1.5 10.9 34 1159 Clang -O0 old patch 17.89 1.4 17.0 39 2309 Clang -O0 new patch 3.92 1.4 11.8 34 1332 --------------080600040104060500050802 Content-Type: text/plain; charset=us-ascii; name="inline4n.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="inline4n.txt" PT09IG1vZGlmaWVkIGZpbGUgJ0NoYW5nZUxvZycKLS0tIENoYW5nZUxvZwkyMDEzLTA2LTEx IDE4OjA1OjA1ICswMDAwCisrKyBDaGFuZ2VMb2cJMjAxMy0wNi0xMyAxNDoxNzowMSArMDAw MApAQCAtMSwzICsxLDkgQEAKKzIwMTMtMDYtMTMgIFBhdWwgRWdnZXJ0ICA8ZWdnZXJ0QGNz LnVjbGEuZWR1PgorCisJVXNlIGZ1bmN0aW9ucywgbm90IG1hY3JvcywgZm9yIFhJTlQgZXRj LiAoQnVnIzExOTM1KS4KKwkqIGNvbmZpZ3VyZS5hYyAoV0FSTl9DRkxBR1MpOiBSZW1vdmUg LVdiYWQtZnVuY3Rpb24tY2FzdCwKKwlhcyBpdCBnZW5lcmF0ZXMgYm9ndXMgd2FybmluZ3Mg YWJvdXQgcmVhc29uYWJsZSBjYXN0cyBvZiBjYWxscy4KKwogMjAxMy0wNi0xMSAgUGF1bCBF Z2dlcnQgIDxlZ2dlcnRAY3MudWNsYS5lZHU+CiAKIAktLXdpdGhvdXQtYWxsIHNob3VsZCBp bXBseSAtLXdpdGgtZmlsZS1ub3RpZmljYXRpb249bm8uICAoQnVnIzE0NTY5KQoKPT09IG1v ZGlmaWVkIGZpbGUgJ2NvbmZpZ3VyZS5hYycKLS0tIGNvbmZpZ3VyZS5hYwkyMDEzLTA2LTEz IDA2OjI4OjA1ICswMDAwCisrKyBjb25maWd1cmUuYWMJMjAxMy0wNi0xMyAxNDoxNzowMSAr MDAwMApAQCAtNzc2LDYgKzc3Niw3IEBACiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAjIHNpZ25lZCBvdmVyZmxvdyBoYXMgdW5kZWZpbmVkIGJlaGF2aW9yCiAgIG53 PSIkbncgLVdzeW5jLW5hbmQiICAgICAgICAgICAgICAjIGlycmVsZXZhbnQgaGVyZSwgYW5k IHByb3Zva2VzIE9iakMgd2FybmluZwogICBudz0iJG53IC1XdW5zYWZlLWxvb3Atb3B0aW1p emF0aW9ucyIgIyBPSyB0byBzdXBwcmVzcyB1bnNhZmUgb3B0aW1pemF0aW9ucworICBudz0i JG53IC1XYmFkLWZ1bmN0aW9uLWNhc3QiICAgICAgIyBUaGVzZSBjYXN0cyBhcmUgbm8gd29y c2UgdGhhbiBvdGhlcnMuCiAKICAgIyBFbWFjcyBkb2Vzbid0IGNhcmUgYWJvdXQgc2hhZG93 aW5nOyBzZWUKICAgIyA8aHR0cDovL2xpc3RzLmdudS5vcmcvYXJjaGl2ZS9odG1sL2VtYWNz LWRpZmZzLzIwMTEtMTEvbXNnMDAyNjUuaHRtbD4uCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3Jj L0NoYW5nZUxvZycKLS0tIHNyYy9DaGFuZ2VMb2cJMjAxMy0wNi0xMyAwNToxMzowNSArMDAw MAorKysgc3JjL0NoYW5nZUxvZwkyMDEzLTA2LTEzIDE0OjE3OjAxICswMDAwCkBAIC0xLDMg KzEsMTI4IEBACisyMDEzLTA2LTEzICBQYXVsIEVnZ2VydCAgPGVnZ2VydEBjcy51Y2xhLmVk dT4KKworCVVzZSBmdW5jdGlvbnMsIG5vdCBtYWNyb3MsIGZvciBYSU5UIGV0Yy4gKEJ1ZyMx MTkzNSkuCisJSW4gbGlzcC5oLCBwcmVmZXIgZnVuY3Rpb25zIHRvIGZ1bmN0aW9uLWxpa2Ug bWFjcm9zLCBhbmQKKwljb25zdGFudHMgdG8gb2JqZWN0LWxpa2UgbWFjcm9zLCB3aGVuIGVp dGhlciB3aWxsIGRvLiAgVGhpczoKKwkgLiBzaW1wbGlmaWVzIHVzZSwgYXMgdGhlcmUncyBu byBtb3JlIG5lZWQgdG8gd29ycnkgYWJvdXQKKwkgICBhcmd1bWVudHMnIHNpZGUgZWZmZWN0 cyBiZWluZyBldmFsdWF0ZWQgbXVsdGlwbGUgdGltZXMuCisJIC4gbWFrZXMgdGhlIGNvZGUg ZWFzaWVyIHRvIGRlYnVnIG9uIHNvbWUgcGxhdGZvcm1zLgorCUhvd2V2ZXIsIHdoZW4gdXNp bmcgZ2NjIC1PMCwga2VlcCB1c2luZyBmdW5jdGlvbi1saWtlIG1hY3JvcworCWZvciBhIGZl dyBjcml0aWNhbCBvcGVyYXRpb25zLCBmb3IgcGVyZm9ybWFuY2UgcmVhc29ucy4KKwlUaGlz IHNvcnQgb2YgdGhpbmcgaXNuJ3QgbmVlZGVkIHdpdGggZ2NjIC1PZywgYnV0IC1PZworCWlz IGEgR0NDIDQuOCBmZWF0dXJlIGFuZCBpc24ndCB3aWRlbHktZW5vdWdoIGF2YWlsYWJsZSB5 ZXQuCisJKiBhbGxvYy5jIChnZGJfbWFrZV9lbnVtc192aXNpYmxlKSBbVVNFX0xTQl9UQUdd OgorCVJlbW92ZSBlbnVtIGxzYl9iaXRzOyBubyBsb25nZXIgbmVlZGVkLgorCShhbGxvY2F0 ZV9taXNjLCBmcmVlX21pc2MpOiBEb24ndCB1c2UgWE1JU0NUWVBFIGFzIGFuIGx2YWx1ZS4K KwkqIGJ1ZmZlci5jIChRb3ZlcmxhcCk6CisJKiBkYXRhLmMgKFFzdWJycCk6CisJKiBmbnMu YyAoUWhhc2hfdGFibGVfcCk6CisJTm93IGV4dGVybiwgc28gbGlzcC5oIGNhbiB1c2UgdGhl c2Ugc3ltYm9scy4KKwkqIGRpc3BleHRlcm4uaDogSW5jbHVkZSBjaGFyYWN0ZXIuaCwgZm9y IE1BWF9DSEFSIGV0Yy4KKwkoR0xZUEgsIEdMWVBIX0NIQVIsIEdMWVBIX0ZBQ0UsIFNFVF9H TFlQSF9DSEFSLCBTRVRfR0xZUEhfRkFDRSkKKwkoU0VUX0dMWVBILCBHTFlQSF9DT0RFX0NI QVIsIEdMWVBIX0NPREVfRkFDRSkKKwkoU0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERSwgR0xZ UEhfTU9ERV9MSU5FX0ZBQ0UsIEdMWVBIX0NIQVJfVkFMSURfUCkKKwkoR0xZUEhfQ09ERV9Q KTogTW92ZSBoZXJlIGZyb20gbGlzcC5oLgorCShHTFlQSF9DSEFSLCBHTFlQSF9GQUNFLCBH TFlQSF9DT0RFX0NIQVIsIEdMWVBIX0NPREVfRkFDRSkKKwkoR0xZUEhfQ0hBUl9WQUxJRF9Q LCBHTFlQSF9DT0RFX1ApOiBOb3cgZnVuY3Rpb25zLCBub3QgbWFjcm9zLgorCShHTFlQSF9N T0RFX0xJTkVfRkFDRSk6IE5vdyBlbnVtcywgbm90IG1hY3Jvcy4KKwkqIGV2YWwuYyAoRmF1 dG9sb2FkKTogQ2FzdCBYVU5UQUcgb3V0cHV0IHRvIGludHB0cl90LCBzaW5jZQorCVhVTlRB RyBub3cgcmV0dXJucyB2b2lkICouCisJKiBsaXNwLmggKGxpc3BfaF9YTEksIGxpc3BfaF9Y SUwsIGxpc3BfaF9DSEVDS19MSVNUX0NPTlMpCisJKGxpc3BfaF9DSEVDS19OVU1CRVIgQ0hF Q0tfU1lNQk9MLCBsaXNwX2hfQ0hFQ0tfVFlQRSkKKwkobGlzcF9oX0NPTlNQLCBsaXNwX2hf RVEsIGxpc3BfaF9GTE9BVFAsIGxpc3BfaF9JTlRFR0VSUCkKKwkobGlzcF9oX0xJU1BfSU5U X1RBR19QLCBsaXNwX2hfTUFSS0VSUCwgbGlzcF9oX01JU0NQLCBsaXNwX2hfTklMUCkKKwko bGlzcF9oX1NFVF9TWU1CT0xfVkFMLCBsaXNwX2hfU1lNQk9MX0NPTlNUQU5UX1ApCisJKGxp c3BfaF9TWU1CT0xfVkFMLCBsaXNwX2hfU1lNQk9MUCwgbGlzcF9oX1ZFQ1RPUkxJS0VQKQor CShsaXNwX2hfWENBUiwgbGlzcF9oX1hDRFIsIGxpc3BfaF9YQ09OUywgbGlzcF9oX1hIQVNI KQorCShsaXNwX2hfWFBOVFIsIGxpc3BfaF9YU1lNQk9MKToKKwlOZXcgbWFjcm9zLCByZW5h bWVkIGZyb20gdGhlaXIgc2Fucy1saXNwX2hfIGNvdW50ZXJwYXJ0cy4KKwkoWExJLCBYSUws IENIRUNLX0xJU1RfQ09OUywgQ0hFQ0tfTlVNQkVSIENIRUNLX1NZTUJPTCkKKwkoQ0hFQ0tf VFlQRSwgQ09OU1AsIEVRLCBGTE9BVFAsIElOVEVHRVJQLCBMSVNQX0lOVF9UQUdfUCwgTUFS S0VSUCkKKwkoTUlTQ1AsIE5JTFAsIFNFVF9TWU1CT0xfVkFMLCBTWU1CT0xfQ09OU1RBTlRf UCwgU1lNQk9MX1ZBTCwgU1lNQk9MUCkKKwkoVkVDVE9STElLRVAsIFhDQVIsIFhDRFIsIFhD T05TLCBYSEFTSCwgWFBOVFIsIFhTWU1CT0wpOgorCUlmIGNvbXBpbGluZyB2aWEgR0NDIHdp dGhvdXQgb3B0aW1pemF0aW9uLCBkZWZpbmUgdGhlc2UgYXMgbWFjcm9zCisJaW4gYWRkaXRp b24gdG8gaW5saW5lIGZ1bmN0aW9ucy4KKwlUbyBkaXNhYmxlIHRoaXMsIGNvbXBpbGUgd2l0 aCAtRElOTElOSU5HPTAuCisJKGNoZWNrX2NvbnNfbGlzdCkgWyFHQ19DSEVDS19DT05TX0xJ U1RdOiBMaWtld2lzZS4KKwkobWFrZV9udW1iZXIsIFhGQVNUSU5ULCBYSU5ULCBYVFlQRSwg WFVOVEFHKTogTGlrZXdpc2UsIGJ1dAorCWhhbmQtb3B0aW1pemUgb25seSBpbiB0aGUgVVNF X0xTQl9UQUcgY2FzZSwgYXMgR05VaXNoIGhvc3RzIGRvIHRoYXQuCisJKElOVE1BU0ssIFZB TE1BU0spOiBOb3cgbWFjcm9zLCBzaW5jZSBzdGF0aWMgdmFsdWVzIGNhbm5vdCBiZQorCWFj Y2Vzc2VkIGZyb20gZXh0ZXJuIGlubGluZSBmdW5jdGlvbnMuCisJKFZBTE1BU0spOiBBbHNv IGEgY29uc3RhbnQsIGZvciBiZW5lZml0IG9mIG9sZCBHREIuCisJKExJU1BfSU5UX1RBR19Q LCBYTEksIFhJTCwgWEhBU0gsIFhUWVBFLFhJTlQsIFhGQVNUSU5ULCBYVUlOVCkKKwkobWFr ZV9udW1iZXIsIFhQTlRSLCBYVU5UQUcsIEVRLCBYQ09OUywgWFZFQ1RPUiwgWFNUUklORywg WFNZTUJPTCkKKwkoWEZMT0FULCBYUFJPQ0VTUywgWFdJTkRPVywgWFRFUk1JTkFMLCBYU1VC UiwgWEJVRkZFUiwgWENIQVJfVEFCTEUpCisJKFhTVUJfQ0hBUl9UQUJMRSwgWEJPT0xfVkVD VE9SLCBtYWtlX2xpc3BfcHRyLCBDSEVDS19UWVBFKQorCShDSEVDS19TVFJJTkdfT1JfQlVG RkVSLCBYQ0FSLCBYQ0RSLCBYU0VUQ0FSLCBYU0VUQ0RSLCBDQVIsIENEUikKKwkoQ0FSX1NB RkUsIENEUl9TQUZFLCBTVFJJTkdfTVVMVElCWVRFLCBTREFUQSwgU1NEQVRBLCBTUkVGLCBT U0VUKQorCShTQ0hBUlMsIFNUUklOR19CWVRFUywgU0JZVEVTLCBTVFJJTkdfU0VUX0NIQVJT LCBTVFJJTkdfQ09QWUlOLCBBUkVGKQorCShBU0laRSwgQVNFVCwgQ0hBUl9UQUJMRV9SRUZf QVNDSUksIENIQVJfVEFCTEVfUkVGKQorCShDSEFSX1RBQkxFX1NFVCwgQ0hBUl9UQUJMRV9F WFRSQV9TTE9UUywgU1lNQk9MX1ZBTCwgU1lNQk9MX0FMSUFTKQorCShTWU1CT0xfQkxWLCBT WU1CT0xfRldELCBTRVRfU1lNQk9MX1ZBTCwgU0VUX1NZTUJPTF9BTElBUykKKwkoU0VUX1NZ TUJPTF9CTFYsIFNFVF9TWU1CT0xfRldELCBTWU1CT0xfTkFNRSwgU1lNQk9MX0lOVEVSTkVE X1ApCisJKFNZTUJPTF9JTlRFUk5FRF9JTl9JTklUSUFMX09CQVJSQVlfUCwgU1lNQk9MX0NP TlNUQU5UX1ApCisJKFhIQVNIX1RBQkxFLCBIQVNIX1RBQkxFX1AsIENIRUNLX0hBU0hfVEFC TEUsIEhBU0hfS0VZLCBIQVNIX1ZBTFVFKQorCShIQVNIX05FWFQsIEhBU0hfSEFTSCwgSEFT SF9JTkRFWCwgSEFTSF9UQUJMRV9TSVpFKQorCShYTUlTQywgWE1JU0NBTlksIFhNQVJLRVIs IFhPVkVSTEFZLCBYU0FWRV9WQUxVRSwgWEZXRFRZUEUpCisJKFhJTlRGV0QsIFhCT09MRldE LCBYT0JKRldELCBYQlVGRkVSX09CSkZXRCwgWEtCT0FSRF9PQkpGV0QpCisJKFhGTE9BVF9E QVRBLCBYRkxPQVRfSU5JVCwgTklMUCwgTlVNQkVSUCwgTkFUTlVNUCkKKwkoUkFOR0VEX0lO VEVHRVJQLCBDT05TUCwgRkxPQVRQLCBNSVNDUCwgU1RSSU5HUCwgU1lNQk9MUCkKKwkoSU5U RUdFUlAsIFZFQ1RPUkxJS0VQLCBWRUNUT1JQLCBPVkVSTEFZUCkKKwkoTUFSS0VSUCwgU0FW RV9WQUxVRVAsIEFVVE9MT0FEUCwgSU5URldEUCwgQk9PTEZXRFAsIE9CSkZXRFApCisJKEJV RkZFUl9PQkpGV0RQLCBLQk9BUkRfT0JKRldEUCwgUFNFVURPVkVDVE9SX1RZUEVQKQorCShQ U0VVRE9WRUNUT1JQLCBXSU5ET1dfQ09ORklHVVJBVElPTlAsIFBST0NFU1NQLCBXSU5ET1dQ KQorCShURVJNSU5BTFAsIFNVQlJQLCBDT01QSUxFRFAsIEJVRkZFUlAsIENIQVJfVEFCTEVf UCkKKwkoU1VCX0NIQVJfVEFCTEVfUCwgQk9PTF9WRUNUT1JfUCwgRlJBTUVQLCBJTUFHRVAs IEFSUkFZUCkKKwkoQ0hFQ0tfTElTVCwgQ0hFQ0tfTElTVF9DT05TLCBDSEVDS19MSVNUX0VO RCwgQ0hFQ0tfU1RSSU5HKQorCShDSEVDS19TVFJJTkdfQ0FSLCBDSEVDS19DT05TLCBDSEVD S19TWU1CT0wsIENIRUNLX0NIQVJfVEFCTEUpCisJKENIRUNLX1ZFQ1RPUiwgQ0hFQ0tfVkVD VE9SX09SX1NUUklORywgQ0hFQ0tfQVJSQVkpCisJKENIRUNLX1ZFQ1RPUl9PUl9DSEFSX1RB QkxFLCBDSEVDS19CVUZGRVIsIENIRUNLX1dJTkRPVykKKwkoQ0hFQ0tfV0lORE9XX0NPTkZJ R1VSQVRJT04sIENIRUNLX1BST0NFU1MsIENIRUNLX1NVQlIpCisJKENIRUNLX05VTUJFUiwg Q0hFQ0tfTkFUTlVNLCBDSEVDS19NQVJLRVIsIFhGTE9BVElOVCkKKwkoQ0hFQ0tfRkxPQVQs IENIRUNLX05VTUJFUl9PUl9GTE9BVCwgQ0hFQ0tfT1ZFUkxBWSkKKwkoQ0hFQ0tfTlVNQkVS X0NBUiwgQ0hFQ0tfTlVNQkVSX0NEUiwgQ0hFQ0tfTkFUTlVNX0NBUikKKwkoQ0hFQ0tfTkFU TlVNX0NEUiwgRlVOQ1RJT05QLCBTUEVDUERMX0lOREVYLCBMT0FESElTVF9BVFRBQ0gpCisJ Tm93IGZ1bmN0aW9ucy4KKwkoY2hlY2tfY29uc19saXN0KSBbIUdDX0NIRUNLX0NPTlNfTElT VF06IE5ldyBlbXB0eSBmdW5jdGlvbi4KKwkoTElTUF9NQUtFX1JWQUxVRSwgVFlQRU1BU0sp OiBSZW1vdmU7IG5vIGxvbmdlciBuZWVkZWQuCisJKFZBTE1BU0spOiBEZWZpbmUgaW4gb25l IHBsYWNlIHJhdGhlciB0aGFuIGluIHR3bywgbWVyZ2luZyB0aGUKKwlVU0VfTFNCX1RBRyBw YXJ0czsgdGhpcyBpcyBzaW1wbGVyLgorCShhcmVmX2FkZHIsIGdjX2FzZXQsIE1PU1RfUE9T SVRJVkVfRklYTlVNLCBNT1NUX05FR0FUSVZFX0ZJWE5VTSkKKwkobWF4LCBtaW4sIHN0cnVj dCBMaXNwX1N0cmluZywgVU5TSUdORURfQ01QLCBBU0NJSV9DSEFSX1ApOgorCU1vdmUgdXAs IHRvIGF2b2lkIHVzZSBiZWZvcmUgZGVmaW5pdGlvbi4KKwlBbHNvIGluY2x1ZGUgImdsb2Jh bHMuaCIgZWFybGllciwgZm9yIHRoZSBzYW1lIHJlYXNvbi4KKwkobWFrZV9uYXRudW0pOiBO ZXcgZnVuY3Rpb24uCisJKFhVTlRBRyk6IE5vdyByZXR1cm5zIHZvaWQgKiwgbm90IGludHB0 cl90LCBhcyB0aGlzIG1lYW5zIGZld2VyIGNhc3RzLgorCSh1bmlvbiBMaXNwX0Z3ZCwgQk9P TEZXRFAsIEJPT0xfVkVDVE9SX1AsIEJVRkZFUl9PQkpGV0RQLCBCVUZGRVJQKQorCShDSEFS X1RBQkxFX1AsIENIQVJfVEFCTEVfUkVGX0FTQ0lJLCBDT05TUCwgRkxPQVRQLCBJTlRFR0VS UCwgSU5URldEUCkKKwkoS0JPQVJEX09CSkZXRFAsIE1BUktFUlAsIE1JU0NQLCBOSUxQLCBP QkpGV0RQLCBPVkVSTEFZUCwgUFJPQ0VTU1ApCisJKFBTRVVET1ZFQ1RPUlAsIFNBVkVfVkFM VUVQLCBTVFJJTkdQLCBTVUJfQ0hBUl9UQUJMRV9QLCBTVUJSUCwgU1lNQk9MUCkKKwkoVkVD VE9STElLRVAsIFdJTkRPV1AsIFFvdmVybGF5cCwgY2hhcl90YWJsZV9yZWYsIGNoYXJfdGFi bGVfc2V0KQorCShjaGFyX3RhYmxlX3RyYW5zbGF0ZSwgUWFycmF5cCwgUWJ1ZmZlcnAsIFFi dWZmZXJfb3Jfc3RyaW5nX3ApCisJKFFjaGFyX3RhYmxlX3AsIFFjb25zcCwgUWZsb2F0cCwg UWludGVnZXJwLCBRbGFtYmRhLCBRbGlzdHAsIFFtYXJrZXJwKQorCShRbmlsLCBRbnVtYmVy cCwgUXN1YnJwLCBRc3RyaW5ncCwgUXN5bWJvbHAsIFF2ZWN0b3JwKQorCShRdmVjdG9yX29y X2NoYXJfdGFibGVfcCwgUXdob2xlbnVtcCwgRmZib3VuZHAsIHdyb25nX3R5cGVfYXJndW1l bnQpCisJKGluaXRpYWxpemVkLCBRaGFzaF90YWJsZV9wLCBleHRyYWN0X2Zsb2F0LCBRcHJv Y2Vzc3AsIFF3aW5kb3dwKQorCShRd2luZG93X2NvbmZpZ3VyYXRpb25fcCwgUWltYWdlKTog TmV3IGZvcndhcmQgZGVjbGFyYXRpb25zLgorCShYU0VURkFTVElOVCk6IFNpbXBsaWZ5IGJ5 IHJld3JpdGluZyBpbiB0ZXJtcyBvZiBtYWtlX25hdG51bS4KKwkoU1RSSU5HX0NPUFlJTik6 IFJlbW92ZTsgdW51c2VkLgorCShYQ0FSX0FTX0xWQUxVRSwgWENEUl9BU19MVkFMVUUpOiBS ZW1vdmUgdGhlc2UgbWFjcm9zLCByZXBsYWNpbmcgd2l0aCAuLi4KKwkoeGNhcl9hZGRyLCB4 Y2RyX2FkZHIpOiBOZXcgZnVuY3Rpb25zLiAgQWxsIHVzZXMgY2hhbmdlZC4KKwkoSUVFRV9G TE9BVElOR19QT0lOVCk6IE5vdyBhIGNvbnN0YW50LCBub3QgYSBtYWNyby4KKwkoR0xZUEgs IEdMWVBIX0NIQVIsIEdMWVBIX0ZBQ0UsIFNFVF9HTFlQSF9DSEFSLCBTRVRfR0xZUEhfRkFD RSkKKwkoU0VUX0dMWVBILCBHTFlQSF9DT0RFX0NIQVIsIEdMWVBIX0NPREVfRkFDRSkKKwko U0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERSwgR0xZUEhfTU9ERV9MSU5FX0ZBQ0UsIEdMWVBI X0NIQVJfVkFMSURfUCkKKwkoR0xZUEhfQ09ERV9QKTogTW92ZSB0byBkaXNwZXh0ZXJuLmgs IHRvIGF2b2lkIGRlZmluZS1iZWZvcmUtdXNlLgorCShUWVBFX1JBTkdFRF9JTlRFR0VSUCk6 IFNpbXBsaWZ5LgorCShRc3VicnAsIFFoYXNoX3RhYmxlX3AsIFFvdmVybGF5cCk6IE5ldyBl eHRlcm4gZGVjbHMuCisJKHNldGxvY2FsZSwgZml4dXBfbG9jYWxlLCBzeW5jaHJvbml6ZV9z eXN0ZW1fbWVzc2FnZXNfbG9jYWxlKQorCShzeW5jaHJvbml6ZV9zeXN0ZW1fdGltZV9sb2Nh bGUpIFshSEFWRV9TRVRMT0NBTEVdOgorCU5vdyBlbXB0eSBmdW5jdGlvbnMsIG5vdCBtYWNy b3MuCisJKGZ1bmN0aW9ucCk6IFJldHVybiBib29sLCBub3QgaW50LgorCSogd2luZG93LmMg KFF3aW5kb3dfY29uZmlndXJhdGlvbl9wKTogTm93IGV4dGVybiwKKwlzbyB3aW5kb3cuaCBj YW4gdXNlIGl0LgorCSogd2luZG93LmggKFF3aW5kb3dwKTogTW92ZSBkZWNsIGJhY2sgdG8g bGlzcC5oLgorCiAyMDEzLTA2LTEzICBLZWxseSBEZWFuICA8a2VsbHlkZWFuY2hAeWFob28u Y29tPiAgKHRpbnkgY2hhbmdlKQogCiAJKiBmaWxlaW8uYyAoRmRvX2F1dG9fc2F2ZSk6IFRy YXAgZXJyb3JzIGluIGF1dG8tc2F2ZS1ob29rLiAgKEJ1ZyMxNDQ3OSkKCj09PSBtb2RpZmll ZCBmaWxlICdzcmMvYWxsb2MuYycKLS0tIHNyYy9hbGxvYy5jCTIwMTMtMDYtMDMgMDk6MDE6 NTMgKzAwMDAKKysrIHNyYy9hbGxvYy5jCTIwMTMtMDYtMDkgMTk6NDI6NTMgKzAwMDAKQEAg LTMzMDksNyArMzMwOSw3IEBACiAgIC0tdG90YWxfZnJlZV9tYXJrZXJzOwogICBjb25zaW5n X3NpbmNlX2djICs9IHNpemVvZiAodW5pb24gTGlzcF9NaXNjKTsKICAgbWlzY19vYmplY3Rz X2NvbnNlZCsrOwotICBYTUlTQ1RZUEUgKHZhbCkgPSB0eXBlOworICBYTUlTQ0FOWSAodmFs KS0+dHlwZSA9IHR5cGU7CiAgIFhNSVNDQU5ZICh2YWwpLT5nY21hcmtiaXQgPSAwOwogICBy ZXR1cm4gdmFsOwogfQpAQCAtMzMxOSw3ICszMzE5LDcgQEAKIHZvaWQKIGZyZWVfbWlzYyAo TGlzcF9PYmplY3QgbWlzYykKIHsKLSAgWE1JU0NUWVBFIChtaXNjKSA9IExpc3BfTWlzY19G cmVlOworICBYTUlTQ0FOWSAobWlzYyktPnR5cGUgPSBMaXNwX01pc2NfRnJlZTsKICAgWE1J U0MgKG1pc2MpLT51X2ZyZWUuY2hhaW4gPSBtYXJrZXJfZnJlZV9saXN0OwogICBtYXJrZXJf ZnJlZV9saXN0ID0gWE1JU0MgKG1pc2MpOwogICBjb25zaW5nX3NpbmNlX2djIC09IHNpemVv ZiAodW5pb24gTGlzcF9NaXNjKTsKQEAgLTU2NDcsNyArNTY0Nyw3IEBACiAJewogCSAgQ09O U19NQVJLIChYQ09OUyAodGFpbCkpOwogCSAgbWFya19vYmplY3QgKFhDQVIgKHRhaWwpKTsK LQkgIHByZXYgPSAmWENEUl9BU19MVkFMVUUgKHRhaWwpOworCSAgcHJldiA9IHhjZHJfYWRk ciAodGFpbCk7CiAJfQogICAgIH0KICAgbWFya19vYmplY3QgKHRhaWwpOwpAQCAtNjY4OSw4 ICs2Njg5LDUgQEAKICAgZW51bSBNQVhfQUxMT0NBIE1BWF9BTExPQ0E7CiAgIGVudW0gTW9y ZV9MaXNwX0JpdHMgTW9yZV9MaXNwX0JpdHM7CiAgIGVudW0gcHZlY190eXBlIHB2ZWNfdHlw ZTsKLSNpZiBVU0VfTFNCX1RBRwotICBlbnVtIGxzYl9iaXRzIGxzYl9iaXRzOwotI2VuZGlm CiB9IGNvbnN0IEVYVEVSTkFMTFlfVklTSUJMRSBnZGJfbWFrZV9lbnVtc192aXNpYmxlID0g ezB9OwogI2VuZGlmCS8qIF9fR05VQ19fICovCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2J1 ZmZlci5jJwotLS0gc3JjL2J1ZmZlci5jCTIwMTMtMDUtMDcgMTQ6MTI6NTcgKzAwMDAKKysr IHNyYy9idWZmZXIuYwkyMDEzLTA2LTA5IDE5OjQyOjUzICswMDAwCkBAIC0xMzQsNyArMTM0 LDcgQEAKIAogc3RhdGljIExpc3BfT2JqZWN0IFFnZXRfZmlsZV9idWZmZXI7CiAKLXN0YXRp YyBMaXNwX09iamVjdCBRb3ZlcmxheXA7CitMaXNwX09iamVjdCBRb3ZlcmxheXA7CiAKIExp c3BfT2JqZWN0IFFwcmlvcml0eSwgUWJlZm9yZV9zdHJpbmcsIFFhZnRlcl9zdHJpbmc7CiAK Cj09PSBtb2RpZmllZCBmaWxlICdzcmMvZGF0YS5jJwotLS0gc3JjL2RhdGEuYwkyMDEzLTA2 LTAzIDE4OjI5OjMwICswMDAwCisrKyBzcmMvZGF0YS5jCTIwMTMtMDYtMTIgMjM6NDE6NTQg KzAwMDAKQEAgLTc2LDcgKzc2LDggQEAKIHN0YXRpYyBMaXNwX09iamVjdCBRY29tcGlsZWRf ZnVuY3Rpb24sIFFmcmFtZTsKIExpc3BfT2JqZWN0IFFidWZmZXI7CiBzdGF0aWMgTGlzcF9P YmplY3QgUWNoYXJfdGFibGUsIFFib29sX3ZlY3RvciwgUWhhc2hfdGFibGU7Ci1zdGF0aWMg TGlzcF9PYmplY3QgUXN1YnJwLCBRbWFueSwgUXVuZXZhbGxlZDsKK0xpc3BfT2JqZWN0IFFz dWJycDsKK3N0YXRpYyBMaXNwX09iamVjdCBRbWFueSwgUXVuZXZhbGxlZDsKIExpc3BfT2Jq ZWN0IFFmb250X3NwZWMsIFFmb250X2VudGl0eSwgUWZvbnRfb2JqZWN0Owogc3RhdGljIExp c3BfT2JqZWN0IFFkZWZ1bjsKIAoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9kaXNwZXh0ZXJu LmgnCi0tLSBzcmMvZGlzcGV4dGVybi5oCTIwMTMtMDYtMDggMTg6Mjg6MzYgKzAwMDAKKysr IHNyYy9kaXNwZXh0ZXJuLmgJMjAxMy0wNi0wOSAxOTo0Mjo1MyArMDAwMApAQCAtMjIsNiAr MjIsOCBAQAogI2lmbmRlZiBESVNQRVhURVJOX0hfSU5DTFVERUQKICNkZWZpbmUgRElTUEVY VEVSTl9IX0lOQ0xVREVECiAKKyNpbmNsdWRlICJjaGFyYWN0ZXIuaCIKKwogI2lmZGVmIEhB VkVfWF9XSU5ET1dTCiAKICNpbmNsdWRlIDxYMTEvWGxpYi5oPgpAQCAtMjcwLDYgKzI3Miw1 NSBAQAogCQkJCUdseXBocwogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCisvKiBUaGUgZ2x5cGgg ZGF0YXR5cGUsIHVzZWQgdG8gcmVwcmVzZW50IGNoYXJhY3RlcnMgb24gdGhlIGRpc3BsYXku CisgICBJdCBjb25zaXN0cyBvZiBhIGNoYXIgY29kZSBhbmQgYSBmYWNlIGlkLiAgKi8KKwor dHlwZWRlZiBzdHJ1Y3QgeworICBpbnQgY2g7CisgIGludCBmYWNlX2lkOworfSBHTFlQSDsK KworLyogUmV0dXJuIGEgZ2x5cGgncyBjaGFyYWN0ZXIgY29kZS4gICovCitESVNQRVhURVJO X0lOTElORSBpbnQgR0xZUEhfQ0hBUiAoR0xZUEggZ2x5cGgpIHsgcmV0dXJuIGdseXBoLmNo OyB9CisKKy8qIFJldHVybiBhIGdseXBoJ3MgZmFjZSBJRC4gICovCitESVNQRVhURVJOX0lO TElORSBpbnQgR0xZUEhfRkFDRSAoR0xZUEggZ2x5cGgpIHsgcmV0dXJuIGdseXBoLmZhY2Vf aWQ7IH0KKworI2RlZmluZSBTRVRfR0xZUEhfQ0hBUihnbHlwaCwgY2hhcikgKChnbHlwaCku Y2ggPSAoY2hhcikpCisjZGVmaW5lIFNFVF9HTFlQSF9GQUNFKGdseXBoLCBmYWNlKSAoKGds eXBoKS5mYWNlX2lkID0gKGZhY2UpKQorI2RlZmluZSBTRVRfR0xZUEgoZ2x5cGgsIGNoYXIs IGZhY2UpIFwKKyAgKChnbHlwaCkuY2ggPSAoY2hhciksIChnbHlwaCkuZmFjZV9pZCA9IChm YWNlKSkKKworLyogVGhlIGZvbGxvd2luZyBhcmUgdmFsaWQgb25seSBpZiBHTFlQSF9DT0RF X1AgKGdjKS4gICovCisKK0RJU1BFWFRFUk5fSU5MSU5FIGludAorR0xZUEhfQ09ERV9DSEFS IChMaXNwX09iamVjdCBnYykKK3sKKyAgcmV0dXJuIChDT05TUCAoZ2MpCisJICA/IFhJTlQg KFhDQVIgKGdjKSkKKwkgIDogWElOVCAoZ2MpICYgTUFYX0NIQVIpOworfQorCitESVNQRVhU RVJOX0lOTElORSBpbnQKK0dMWVBIX0NPREVfRkFDRSAoTGlzcF9PYmplY3QgZ2MpCit7Cisg IHJldHVybiBDT05TUCAoZ2MpID8gWElOVCAoWENEUiAoZ2MpKSA6IFhJTlQgKGdjKSA+PiBD SEFSQUNURVJCSVRTOworfQorCisjZGVmaW5lIFNFVF9HTFlQSF9GUk9NX0dMWVBIX0NPREUo Z2x5cGgsIGdjKQkJCQlcCisgIGRvCQkJCQkJCQkJXAorICAgIHsJCQkJCQkJCQlcCisgICAg ICBpZiAoQ09OU1AgKGdjKSkJCQkJCQkJXAorCVNFVF9HTFlQSCAoZ2x5cGgsIFhJTlQgKFhD QVIgKGdjKSksIFhJTlQgKFhDRFIgKGdjKSkpOwkJXAorICAgICAgZWxzZQkJCQkJCQkJXAor CVNFVF9HTFlQSCAoZ2x5cGgsIChYSU5UIChnYykgJiAoKDEgPDwgQ0hBUkFDVEVSQklUUykt MSkpLAlcCisJCSAgIChYSU5UIChnYykgPj4gQ0hBUkFDVEVSQklUUykpOwkJCVwKKyAgICB9 CQkJCQkJCQkJXAorICB3aGlsZSAoMCkKKworLyogVGhlIElEIG9mIHRoZSBtb2RlIGxpbmUg aGlnaGxpZ2h0aW5nIGZhY2UuICAqLworZW51bSB7IEdMWVBIX01PREVfTElORV9GQUNFID0g MSB9OworCiAvKiBFbnVtZXJhdGlvbiBvZiBnbHlwaCB0eXBlcy4gIEdseXBoIHN0cnVjdHVy ZXMgY29udGFpbiBhIHR5cGUgZmllbGQKICAgIGNvbnRhaW5pbmcgb25lIG9mIHRoZSBlbnVt ZXJhdG9ycyBkZWZpbmVkIGhlcmUuICAqLwogCkBAIC0xNzc0LDYgKzE4MjUsMzAgQEAKIAog I2VuZGlmIC8qIG5vdCBIQVZFX1dJTkRPV19TWVNURU0gKi8KIAorLyogUmV0dXJuIHRydWUg aWYgRyBjb250YWlucyBhIHZhbGlkIGNoYXJhY3RlciBjb2RlLiAgKi8KK0RJU1BFWFRFUk5f SU5MSU5FIGJvb2wKK0dMWVBIX0NIQVJfVkFMSURfUCAoR0xZUEggZykKK3sKKyAgcmV0dXJu IENIQVJfVkFMSURfUCAoR0xZUEhfQ0hBUiAoZykpOworfQorCisvKiBUaGUgZ2x5cGggY29k ZSBmcm9tIGEgZGlzcGxheSB2ZWN0b3IgbWF5IGVpdGhlciBiZSBhbiBpbnRlZ2VyIHdoaWNo CisgICBlbmNvZGVzIGEgY2hhciBjb2RlIGluIHRoZSBsb3dlciBDSEFSQUNURVJCSVRTIGJp dHMgYW5kIGEgKHZlcnkgc21hbGwpCisgICBmYWNlLWlkIGluIHRoZSB1cHBlciBiaXRzLCBv ciBpdCBtYXkgYmUgYSBjb25zIChDSEFSIC4gRkFDRS1JRCkuICAqLworCitESVNQRVhURVJO X0lOTElORSBib29sCitHTFlQSF9DT0RFX1AgKExpc3BfT2JqZWN0IGdjKQoreworICByZXR1 cm4gKENPTlNQIChnYykKKwkgID8gKENIQVJBQ1RFUlAgKFhDQVIgKGdjKSkKKwkgICAgICYm IFJBTkdFRF9JTlRFR0VSUCAoMCwgWENEUiAoZ2MpLCBNQVhfRkFDRV9JRCkpCisJICA6IChS QU5HRURfSU5URUdFUlAKKwkgICAgICgwLCBnYywKKwkgICAgICAoTUFYX0ZBQ0VfSUQgPCBU WVBFX01BWElNVU0gKEVNQUNTX0lOVCkgPj4gQ0hBUkFDVEVSQklUUworCSAgICAgICA/ICgo RU1BQ1NfSU5UKSBNQVhfRkFDRV9JRCA8PCBDSEFSQUNURVJCSVRTKSB8IE1BWF9DSEFSCisJ ICAgICAgIDogVFlQRV9NQVhJTVVNIChFTUFDU19JTlQpKSkpKTsKK30KKwogLyogTm9uLXpl cm8gbWVhbnMgZmFjZSBhdHRyaWJ1dGVzIGhhdmUgYmVlbiBjaGFuZ2VkIHNpbmNlIHRoZSBs YXN0CiAgICByZWRpc3BsYXkuICBVc2VkIGluIHJlZGlzcGxheV9pbnRlcm5hbC4gICovCiAK Cj09PSBtb2RpZmllZCBmaWxlICdzcmMvZm5zLmMnCi0tLSBzcmMvZm5zLmMJMjAxMy0wNC0w OCAxODowNDo1OCArMDAwMAorKysgc3JjL2Zucy5jCTIwMTMtMDYtMTIgMjM6NDI6MTAgKzAw MDAKQEAgLTMzMzUsNyArMzMzNSw4IEBACiAKIC8qIFZhcmlvdXMgc3ltYm9scy4gICovCiAK LXN0YXRpYyBMaXNwX09iamVjdCBRaGFzaF90YWJsZV9wLCBRa2V5LCBRdmFsdWUsIFFlcWw7 CitMaXNwX09iamVjdCBRaGFzaF90YWJsZV9wOworc3RhdGljIExpc3BfT2JqZWN0IFFrZXks IFF2YWx1ZSwgUWVxbDsKIExpc3BfT2JqZWN0IFFlcSwgUWVxdWFsOwogTGlzcF9PYmplY3Qg UUN0ZXN0LCBRQ3NpemUsIFFDcmVoYXNoX3NpemUsIFFDcmVoYXNoX3RocmVzaG9sZCwgUUN3 ZWFrbmVzczsKIHN0YXRpYyBMaXNwX09iamVjdCBRaGFzaF90YWJsZV90ZXN0LCBRa2V5X29y X3ZhbHVlLCBRa2V5X2FuZF92YWx1ZTsKCj09PSBtb2RpZmllZCBmaWxlICdzcmMvbGlzcC5o JwotLS0gc3JjL2xpc3AuaAkyMDEzLTA2LTA1IDEyOjE3OjAyICswMDAwCisrKyBzcmMvbGlz cC5oCTIwMTMtMDYtMTMgMDA6MDY6NTMgKzAwMDAKQEAgLTIyMCw2ICsyMjAsMTMwIEBACiAj ZW5kaWYKIAogCisvKiBTb21lIG9wZXJhdGlvbnMgYXJlIHNvIGNvbW1vbmx5IGV4ZWN1dGVk IHRoYXQgdGhleSBhcmUgaW1wbGVtZW50ZWQKKyAgIGFzIG1hY3Jvcywgbm90IGZ1bmN0aW9u cywgYmVjYXVzZSBvdGhlcndpc2UgcnVudGltZSBwZXJmb3JtYW5jZSB3b3VsZAorICAgc3Vm ZmVyIHRvbyBtdWNoIHdoZW4gY29tcGlsaW5nIHdpdGggR0NDIHdpdGhvdXQgb3B0aW1pemF0 aW9uLgorICAgVGhlcmUncyBubyBuZWVkIHRvIGlubGluZSBldmVyeXRoaW5nLCBqdXN0IHRo ZSBvcGVyYXRpb25zIHRoYXQKKyAgIHdvdWxkIG90aGVyd2lzZSBjYXVzZSBhIHNlcmlvdXMg cGVyZm9ybWFuY2UgcHJvYmxlbS4KKworICAgRm9yIGVhY2ggc3VjaCBvcGVyYXRpb24gT1As IGRlZmluZSBhIG1hY3JvIGxpc3BfaF9PUCB0aGF0IGNvbnRhaW5zCisgICB0aGUgb3BlcmF0 aW9uJ3MgaW1wbGVtZW50YXRpb24uICBUaGF0IHdheSwgT1AgY2FuIGJlIGltcGxlbWVudGF0 ZWQKKyAgIHZpYSBhIG1hY3JvIGRlZmluaXRpb24gbGlrZSB0aGlzOgorCisgICAgICNkZWZp bmUgT1AoeCkgbGlzcF9oX09QICh4KQorCisgICBhbmQvb3IgdmlhIGEgZnVuY3Rpb24gZGVm aW5pdGlvbiBsaWtlIHRoaXM6CisKKyAgICAgTGlzcF9PYmplY3QKKyAgICAgKE9QKSAoTGlz cF9PYmplY3QgeCkKKyAgICAgeworICAgICAgIHJldHVybiBsaXNwX2hfT1AgKHgpOworICAg ICB9CisKKyAgIHdpdGhvdXQgd29ycnlpbmcgYWJvdXQgdGhlIGltcGxlbWVudGF0aW9ucyBk aXZlcmdpbmcsIHNpbmNlCisgICBsaXNwX2hfT1AgZGVmaW5lcyB0aGUgYWN0dWFsIGltcGxl bWVudGF0aW9uLiAgVGhlIGxpc3BfaF9PUCBtYWNyb3MKKyAgIGFyZSBpbnRlbmRlZCB0byBi ZSBwcml2YXRlIHRvIHRoaXMgaW5jbHVkZSBmaWxlLCBhbmQgc2hvdWxkIG5vdCBiZQorICAg dXNlZCBlbHNld2hlcmUuCisKKyAgIEZJWE1FOiBSZW1vdmUgdGhlIGxpc3BfaF9PUCBtYWNy b3MsIGFuZCBkZWZpbmUganVzdCB0aGUgaW5saW5lIE9QCisgICBmdW5jdGlvbnMsIG9uY2Ug bW9zdCBkZXZlbG9wZXJzIGhhdmUgYWNjZXNzIHRvIEdDQyA0Ljggb3IgbGF0ZXIgYW5kCisg ICBjYW4gdXNlICJnY2MgLU9nIiB0byBkZWJ1Zy4gIE1heWJlIGluIHRoZSB5ZWFyIDIwMTYu ICBTZWUKKyAgIEJ1ZyMxMTkzNS4KKworICAgQ29tbWVudGFyeSBmb3IgdGhlc2UgbWFjcm9z IGNhbiBiZSBmb3VuZCBuZWFyIHRoZWlyIGNvcnJlc3BvbmRpbmcKKyAgIGZ1bmN0aW9ucywg YmVsb3cuICAqLworCisjaWYgQ0hFQ0tfTElTUF9PQkpFQ1RfVFlQRQorIyBkZWZpbmUgbGlz cF9oX1hMSShvKSAoKG8pLmkpCisjIGRlZmluZSBsaXNwX2hfWElMKGkpICgoTGlzcF9PYmpl Y3QpIHsgaSB9KQorI2Vsc2UKKyMgZGVmaW5lIGxpc3BfaF9YTEkobykgKG8pCisjIGRlZmlu ZSBsaXNwX2hfWElMKGkpIChpKQorI2VuZGlmCisjZGVmaW5lIGxpc3BfaF9DSEVDS19MSVNU X0NPTlMoeCwgeSkgQ0hFQ0tfVFlQRSAoQ09OU1AgKHgpLCBRbGlzdHAsIHkpCisjZGVmaW5l IGxpc3BfaF9DSEVDS19OVU1CRVIoeCkgQ0hFQ0tfVFlQRSAoSU5URUdFUlAgKHgpLCBRaW50 ZWdlcnAsIHgpCisjZGVmaW5lIGxpc3BfaF9DSEVDS19TWU1CT0woeCkgQ0hFQ0tfVFlQRSAo U1lNQk9MUCAoeCksIFFzeW1ib2xwLCB4KQorI2RlZmluZSBsaXNwX2hfQ0hFQ0tfVFlQRShv aywgUXh4eHAsIHgpIFwKKyAgICgodm9pZCkgKChvaykgfHwgd3JvbmdfdHlwZV9hcmd1bWVu dCAoUXh4eHAsIHgpKSkKKyNkZWZpbmUgbGlzcF9oX0NPTlNQKHgpIChYVFlQRSAoeCkgPT0g TGlzcF9Db25zKQorI2RlZmluZSBsaXNwX2hfRVEoeCwgeSkgKFhMSSAoeCkgPT0gWExJICh5 KSkKKyNkZWZpbmUgbGlzcF9oX0ZMT0FUUCh4KSAoWFRZUEUgKHgpID09IExpc3BfRmxvYXQp CisjZGVmaW5lIGxpc3BfaF9JTlRFR0VSUCh4KSBMSVNQX0lOVF9UQUdfUCAoWFRZUEUgKHgp KQorI2RlZmluZSBsaXNwX2hfTElTUF9JTlRfVEFHX1AoeCkgKCgoeCkgJiB+TGlzcF9JbnQx KSA9PSAwKQorI2RlZmluZSBsaXNwX2hfTUFSS0VSUCh4KSAoTUlTQ1AgKHgpICYmIFhNSVND VFlQRSAoeCkgPT0gTGlzcF9NaXNjX01hcmtlcikKKyNkZWZpbmUgbGlzcF9oX01JU0NQKHgp IChYVFlQRSAoeCkgPT0gTGlzcF9NaXNjKQorI2RlZmluZSBsaXNwX2hfTklMUCh4KSBFUSAo eCwgUW5pbCkKKyNkZWZpbmUgbGlzcF9oX1NFVF9TWU1CT0xfVkFMKHN5bSwgdikgXAorICAg KGVhc3NlcnQgKChzeW0pLT5yZWRpcmVjdCA9PSBTWU1CT0xfUExBSU5WQUwpLCAoc3ltKS0+ dmFsLnZhbHVlID0gKHYpKQorI2RlZmluZSBsaXNwX2hfU1lNQk9MX0NPTlNUQU5UX1Aoc3lt KSAoWFNZTUJPTCAoc3ltKS0+Y29uc3RhbnQpCisjZGVmaW5lIGxpc3BfaF9TWU1CT0xfVkFM KHN5bSkgXAorICAgKGVhc3NlcnQgKChzeW0pLT5yZWRpcmVjdCA9PSBTWU1CT0xfUExBSU5W QUwpLCAoc3ltKS0+dmFsLnZhbHVlKQorI2RlZmluZSBsaXNwX2hfU1lNQk9MUCh4KSAoWFRZ UEUgKHgpID09IExpc3BfU3ltYm9sKQorI2RlZmluZSBsaXNwX2hfVkVDVE9STElLRVAoeCkg KFhUWVBFICh4KSA9PSBMaXNwX1ZlY3Rvcmxpa2UpCisjZGVmaW5lIGxpc3BfaF9YQ0FSKGMp IFhDT05TIChjKS0+Y2FyCisjZGVmaW5lIGxpc3BfaF9YQ0RSKGMpIFhDT05TIChjKS0+dS5j ZHIKKyNkZWZpbmUgbGlzcF9oX1hDT05TKGEpIFwKKyAgIChlYXNzZXJ0IChDT05TUCAoYSkp LCAoc3RydWN0IExpc3BfQ29ucyAqKSBYVU5UQUcgKGEsIExpc3BfQ29ucykpCisjZGVmaW5l IGxpc3BfaF9YSEFTSChhKSBYVUlOVCAoYSkKKyNkZWZpbmUgbGlzcF9oX1hQTlRSKGEpIFwK KyAgICgodm9pZCAqKSAoaW50cHRyX3QpICgoWExJIChhKSAmIFZBTE1BU0spIHwgREFUQV9T RUdfQklUUykpCisjZGVmaW5lIGxpc3BfaF9YU1lNQk9MKGEpIFwKKyAgIChlYXNzZXJ0IChT WU1CT0xQIChhKSksIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKikgWFVOVEFHIChhLCBMaXNwX1N5 bWJvbCkpCisjaWZuZGVmIEdDX0NIRUNLX0NPTlNfTElTVAorIyBkZWZpbmUgbGlzcF9oX2No ZWNrX2NvbnNfbGlzdCgpICgodm9pZCkgMCkKKyNlbmRpZgorI2lmIFVTRV9MU0JfVEFHCisj IGRlZmluZSBsaXNwX2hfbWFrZV9udW1iZXIobikgWElMICgoRU1BQ1NfSU5UKSAobikgPDwg SU5UVFlQRUJJVFMpCisjIGRlZmluZSBsaXNwX2hfWEZBU1RJTlQoYSkgWElOVCAoYSkKKyMg ZGVmaW5lIGxpc3BfaF9YSU5UKGEpIChYTEkgKGEpID4+IElOVFRZUEVCSVRTKQorIyBkZWZp bmUgbGlzcF9oX1hUWVBFKGEpICgoZW51bSBMaXNwX1R5cGUpIChYTEkgKGEpICYgflZBTE1B U0spKQorIyBkZWZpbmUgbGlzcF9oX1hVTlRBRyhhLCB0eXBlKSAoKHZvaWQgKikgKFhMSSAo YSkgLSAodHlwZSkpKQorI2VuZGlmCisKKy8qIFdoZW4gY29tcGlsaW5nIHZpYSBnY2MgLU8w LCBkZWZpbmUgdGhlIGtleSBvcGVyYXRpb25zIGFzIG1hY3JvcywgYXMKKyAgIEVtYWNzIGlz IHRvbyBzbG93IG90aGVyd2lzZS4gIFRvIGRpc2FibGUgdGhpcyBvcHRpbWl6YXRpb24sIGNv bXBpbGUKKyAgIHdpdGggLURJTkxJTklORz0wLiAgKi8KKyNpZiAoZGVmaW5lZCBfX05PX0lO TElORV9fIFwKKyAgICAgJiYgISBkZWZpbmVkIF9fT1BUSU1JWkVfXyAmJiAhIGRlZmluZWQg X19PUFRJTUlaRV9TSVpFX18gXAorICAgICAmJiAhIChkZWZpbmVkIElOTElOSU5HICYmICEg SU5MSU5JTkcpKQorIyBkZWZpbmUgWExJKG8pIGxpc3BfaF9YTEkgKG8pCisjIGRlZmluZSBY SUwoaSkgbGlzcF9oX1hJTCAoaSkKKyMgZGVmaW5lIENIRUNLX0xJU1RfQ09OUyh4LCB5KSBs aXNwX2hfQ0hFQ0tfTElTVF9DT05TICh4LCB5KQorIyBkZWZpbmUgQ0hFQ0tfTlVNQkVSKHgp IGxpc3BfaF9DSEVDS19OVU1CRVIgKHgpCisjIGRlZmluZSBDSEVDS19TWU1CT0woeCkgbGlz cF9oX0NIRUNLX1NZTUJPTCAoeCkKKyMgZGVmaW5lIENIRUNLX1RZUEUob2ssIFF4eHhwLCB4 KSBsaXNwX2hfQ0hFQ0tfVFlQRSAob2ssIFF4eHhwLCB4KQorIyBkZWZpbmUgQ09OU1AoeCkg bGlzcF9oX0NPTlNQICh4KQorIyBkZWZpbmUgRVEoeCwgeSkgbGlzcF9oX0VRICh4LCB5KQor IyBkZWZpbmUgRkxPQVRQKHgpIGxpc3BfaF9GTE9BVFAgKHgpCisjIGRlZmluZSBJTlRFR0VS UCh4KSBsaXNwX2hfSU5URUdFUlAgKHgpCisjIGRlZmluZSBMSVNQX0lOVF9UQUdfUCh4KSBs aXNwX2hfTElTUF9JTlRfVEFHX1AgKHgpCisjIGRlZmluZSBNQVJLRVJQKHgpIGxpc3BfaF9N QVJLRVJQICh4KQorIyBkZWZpbmUgTUlTQ1AoeCkgbGlzcF9oX01JU0NQICh4KQorIyBkZWZp bmUgTklMUCh4KSBsaXNwX2hfTklMUCAoeCkKKyMgZGVmaW5lIFNFVF9TWU1CT0xfVkFMKHN5 bSwgdikgbGlzcF9oX1NFVF9TWU1CT0xfVkFMIChzeW0sIHYpCisjIGRlZmluZSBTWU1CT0xf Q09OU1RBTlRfUChzeW0pIGxpc3BfaF9TWU1CT0xfQ09OU1RBTlRfUCAoc3ltKQorIyBkZWZp bmUgU1lNQk9MX1ZBTChzeW0pIGxpc3BfaF9TWU1CT0xfVkFMIChzeW0pCisjIGRlZmluZSBT WU1CT0xQKHgpIGxpc3BfaF9TWU1CT0xQICh4KQorIyBkZWZpbmUgVkVDVE9STElLRVAoeCkg bGlzcF9oX1ZFQ1RPUkxJS0VQICh4KQorIyBkZWZpbmUgWENBUihjKSBsaXNwX2hfWENBUiAo YykKKyMgZGVmaW5lIFhDRFIoYykgbGlzcF9oX1hDRFIgKGMpCisjIGRlZmluZSBYQ09OUyhh KSBsaXNwX2hfWENPTlMgKGEpCisjIGRlZmluZSBYSEFTSChhKSBsaXNwX2hfWEhBU0ggKGEp CisjIGRlZmluZSBYUE5UUihhKSBsaXNwX2hfWFBOVFIgKGEpCisjIGRlZmluZSBYU1lNQk9M KGEpIGxpc3BfaF9YU1lNQk9MIChhKQorIyBpZm5kZWYgR0NfQ0hFQ0tfQ09OU19MSVNUCisj ICBkZWZpbmUgY2hlY2tfY29uc19saXN0KCkgbGlzcF9oX2NoZWNrX2NvbnNfbGlzdCAoKQor IyBlbmRpZgorIyBpZiBVU0VfTFNCX1RBRworIyAgZGVmaW5lIG1ha2VfbnVtYmVyKG4pIGxp c3BfaF9tYWtlX251bWJlciAobikKKyMgIGRlZmluZSBYRkFTVElOVChhKSBsaXNwX2hfWEZB U1RJTlQgKGEpCisjICBkZWZpbmUgWElOVChhKSBsaXNwX2hfWElOVCAoYSkKKyMgIGRlZmlu ZSBYVFlQRShhKSBsaXNwX2hfWFRZUEUgKGEpCisjICBkZWZpbmUgWFVOVEFHKGEsIHR5cGUp IGxpc3BfaF9YVU5UQUcgKGEsIHR5cGUpCisjIGVuZGlmCisjZW5kaWYKKworCiAvKiBEZWZp bmUgdGhlIGZ1bmRhbWVudGFsIExpc3AgZGF0YSBzdHJ1Y3R1cmVzLiAgKi8KIAogLyogVGhp cyBpcyB0aGUgc2V0IG9mIExpc3AgZGF0YSB0eXBlcy4gIElmIHlvdSB3YW50IHRvIGRlZmlu ZSBhIG5ldwpAQCAtMjMwLDcgKzM1NCw2IEBACiAgICBleHRlbmRpbmcgdGhlaXIgcmFuZ2Ug ZnJvbSwgZS5nLiwgLTJeMjguLjJeMjgtMSB0byAtMl4yOS4uMl4yOS0xLiAgKi8KICNkZWZp bmUgSU5UTUFTSyAoRU1BQ1NfSU5UX01BWCA+PiAoSU5UVFlQRUJJVFMgLSAxKSkKICNkZWZp bmUgY2FzZV9MaXNwX0ludCBjYXNlIExpc3BfSW50MDogY2FzZSBMaXNwX0ludDEKLSNkZWZp bmUgTElTUF9JTlRfVEFHX1AoeCkgKCgoeCkgJiB+TGlzcF9JbnQxKSA9PSAwKQogCiAvKiBJ ZGVhIHN0b2xlbiBmcm9tIEdEQi4gIE1TVkMgZG9lc24ndCBzdXBwb3J0IGVudW1zIGluIGJp dGZpZWxkcywKICAgIGFuZCB4bGMgY29tcGxhaW5zIHZvY2lmZXJvdXNseSBhYm91dCB0aGVt LiAgKi8KQEAgLTI3MCw2ICszOTMsMTIgQEAKICAgICBMaXNwX0Zsb2F0ID0gNywKICAgfTsK IAorTElTUF9JTkxJTkUgYm9vbAorKExJU1BfSU5UX1RBR19QKSAoaW50IHgpCit7CisgIHJl dHVybiBsaXNwX2hfTElTUF9JTlRfVEFHX1AgKHgpOworfQorCiAvKiBUaGlzIGlzIHRoZSBz ZXQgb2YgZGF0YSB0eXBlcyB0aGF0IHNoYXJlIGEgY29tbW9uIHN0cnVjdHVyZS4KICAgIFRo ZSBmaXJzdCBtZW1iZXIgb2YgdGhlIHN0cnVjdHVyZSBpcyBhIHR5cGUgY29kZSBmcm9tIHRo aXMgc2V0LgogICAgVGhlIGVudW0gdmFsdWVzIGFyZSBhcmJpdHJhcnksIGJ1dCB3ZSdsbCB1 c2UgbGFyZ2UgbnVtYmVycyB0byBtYWtlIGl0CkBAIC0zNTksMjAgKzQ4OCw2IEBACiAKIHR5 cGVkZWYgc3RydWN0IHsgRU1BQ1NfSU5UIGk7IH0gTGlzcF9PYmplY3Q7CiAKLSNkZWZpbmUg WExJKG8pIChvKS5pCi1MSVNQX0lOTElORSBMaXNwX09iamVjdAotWElMIChFTUFDU19JTlQg aSkKLXsKLSAgTGlzcF9PYmplY3QgbyA9IHsgaSB9OwotICByZXR1cm4gbzsKLX0KLQotTElT UF9JTkxJTkUgTGlzcF9PYmplY3QKLUxJU1BfTUFLRV9SVkFMVUUgKExpc3BfT2JqZWN0IG8p Ci17Ci0gICAgcmV0dXJuIG87Ci19Ci0KICNkZWZpbmUgTElTUF9JTklUSUFMTFlfWkVSTyB7 MH0KIAogI3VuZGVmIENIRUNLX0xJU1BfT0JKRUNUX1RZUEUKQEAgLTM4MiwxMyArNDk3LDIy IEBACiAvKiBJZiBhIHN0cnVjdCB0eXBlIGlzIG5vdCB3YW50ZWQsIGRlZmluZSBMaXNwX09i amVjdCBhcyBqdXN0IGEgbnVtYmVyLiAgKi8KIAogdHlwZWRlZiBFTUFDU19JTlQgTGlzcF9P YmplY3Q7Ci0jZGVmaW5lIFhMSShvKSAobykKLSNkZWZpbmUgWElMKGkpIChpKQotI2RlZmlu ZSBMSVNQX01BS0VfUlZBTFVFKG8pICgwICsgKG8pKQogI2RlZmluZSBMSVNQX0lOSVRJQUxM WV9aRVJPIDAKIGVudW0gQ0hFQ0tfTElTUF9PQkpFQ1RfVFlQRSB7IENIRUNLX0xJU1BfT0JK RUNUX1RZUEUgPSAwIH07CiAjZW5kaWYgLyogQ0hFQ0tfTElTUF9PQkpFQ1RfVFlQRSAqLwog CitMSVNQX0lOTElORSBFTUFDU19JTlQKKyhYTEkpIChMaXNwX09iamVjdCBvKQoreworICBy ZXR1cm4gbGlzcF9oX1hMSSAobyk7Cit9CisKK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0Ciso WElMKSAoRU1BQ1NfSU5UIGkpCit7CisgIHJldHVybiBsaXNwX2hfWElMIChpKTsKK30KKwog LyogSW4gdGhlIHNpemUgd29yZCBvZiBhIHZlY3RvciwgdGhpcyBiaXQgbWVhbnMgdGhlIHZl Y3RvciBoYXMgYmVlbiBtYXJrZWQuICAqLwogCiBzdGF0aWMgcHRyZGlmZl90IGNvbnN0IEFS UkFZX01BUktfRkxBRwpAQCAtNDYwLDg0ICs1ODQsMTE5IEBACiAgICAgQk9PTF9WRUNUT1Jf QklUU19QRVJfQ0hBUiA9IDgKICAgfTsKIAwKLS8qIFRoZXNlIG1hY3JvcyBleHRyYWN0IHZh cmlvdXMgc29ydHMgb2YgdmFsdWVzIGZyb20gYSBMaXNwX09iamVjdC4KKy8qIFRoZXNlIGZ1 bmN0aW9ucyBleHRyYWN0IHZhcmlvdXMgc29ydHMgb2YgdmFsdWVzIGZyb20gYSBMaXNwX09i amVjdC4KICBGb3IgZXhhbXBsZSwgaWYgdGVtIGlzIGEgTGlzcF9PYmplY3Qgd2hvc2UgdHlw ZSBpcyBMaXNwX0NvbnMsCiAgWENPTlMgKHRlbSkgaXMgdGhlIHN0cnVjdCBMaXNwX0NvbnMg KiBwb2ludGluZyB0byB0aGUgbWVtb3J5IGZvciB0aGF0IGNvbnMuICAqLwogCi0jaWYgVVNF X0xTQl9UQUcKLQotZW51bSBsc2JfYml0cwotICB7Ci0gICAgVFlQRU1BU0sgPSAoMSA8PCBH Q1RZUEVCSVRTKSAtIDEsCi0gICAgVkFMTUFTSyA9IH4gVFlQRU1BU0sKLSAgfTsKLSNkZWZp bmUgWFRZUEUoYSkgKChlbnVtIExpc3BfVHlwZSkgKFhMSSAoYSkgJiBUWVBFTUFTSykpCi0j ZGVmaW5lIFhJTlQoYSkgKFhMSSAoYSkgPj4gSU5UVFlQRUJJVFMpCi0jZGVmaW5lIFhVSU5U KGEpICgoRU1BQ1NfVUlOVCkgWExJIChhKSA+PiBJTlRUWVBFQklUUykKLSNkZWZpbmUgbWFr ZV9udW1iZXIoTikgWElMICgoRU1BQ1NfSU5UKSAoTikgPDwgSU5UVFlQRUJJVFMpCi0jZGVm aW5lIG1ha2VfbGlzcF9wdHIocHRyLCB0eXBlKSBcCi0gIChlYXNzZXJ0IChYVFlQRSAoWElM ICgoaW50cHRyX3QpIChwdHIpKSkgPT0gMCksIC8qIENoZWNrIGFsaWdubWVudC4gICovICBc Ci0gICBYSUwgKCh0eXBlKSB8IChpbnRwdHJfdCkgKHB0cikpKQotCi0jZGVmaW5lIFhQTlRS KGEpICgoaW50cHRyX3QpIChYTEkgKGEpICYgflRZUEVNQVNLKSkKLSNkZWZpbmUgWFVOVEFH KGEsIHR5cGUpICgoaW50cHRyX3QpIChYTEkgKGEpIC0gKHR5cGUpKSkKLQotI2Vsc2UgIC8q IG5vdCBVU0VfTFNCX1RBRyAqLwotCiBzdGF0aWMgRU1BQ1NfSU5UIGNvbnN0IFZBTE1BU0sK LSNkZWZpbmUgVkFMTUFTSyBWQUxfTUFYCisjZGVmaW5lIFZBTE1BU0sgKFVTRV9MU0JfVEFH ID8gLSAoMSA8PCBHQ1RZUEVCSVRTKSA6IFZBTF9NQVgpCiAgICAgICA9IFZBTE1BU0s7CiAK LSNkZWZpbmUgWFRZUEUoYSkgKChlbnVtIExpc3BfVHlwZSkgKChFTUFDU19VSU5UKSBYTEkg KGEpID4+IFZBTEJJVFMpKQotCi0vKiBGb3IgaW50ZWdlcnMga25vd24gdG8gYmUgcG9zaXRp dmUsIFhGQVNUSU5UIHByb3ZpZGVzIGZhc3QgcmV0cmlldmFsCi0gICBhbmQgWFNFVEZBU1RJ TlQgcHJvdmlkZXMgZmFzdCBzdG9yYWdlLiAgVGhpcyB0YWtlcyBhZHZhbnRhZ2Ugb2YgdGhl Ci0gICBmYWN0IHRoYXQgTGlzcCBpbnRlZ2VycyBoYXZlIHplcm8tYml0cyBpbiB0aGVpciB0 YWdzLiAgKi8KLSNkZWZpbmUgWEZBU1RJTlQoYSkgKFhMSSAoYSkgKyAwKQotI2RlZmluZSBY U0VURkFTVElOVChhLCBiKSAoKGEpID0gWElMIChiKSkKLQotLyogRXh0cmFjdCB0aGUgdmFs dWUgb2YgYSBMaXNwX09iamVjdCBhcyBhICh1bilzaWduZWQgaW50ZWdlci4gICovCi0KLSNk ZWZpbmUgWElOVChhKSAoWExJIChhKSA8PCBJTlRUWVBFQklUUyA+PiBJTlRUWVBFQklUUykK LSNkZWZpbmUgWFVJTlQoYSkgKChFTUFDU19VSU5UKSAoWExJIChhKSAmIElOVE1BU0spKQot I2RlZmluZSBtYWtlX251bWJlcihOKSBYSUwgKChFTUFDU19JTlQpIChOKSAmIElOVE1BU0sp Ci0KLSNkZWZpbmUgbWFrZV9saXNwX3B0cihwdHIsIHR5cGUpIFwKLSAgKFhJTCAoKEVNQUNT X0lOVCkgKChFTUFDU19VSU5UKSAodHlwZSkgPDwgVkFMQklUUykgIFwKLQkrICgoaW50cHRy X3QpIChwdHIpICYgVkFMTUFTSykpKQotCi0vKiBEQVRBX1NFR19CSVRTIGZvcmNlcyBleHRy YSBiaXRzIHRvIGJlIG9yJ2QgaW4gd2l0aCBhbnkgcG9pbnRlcnMKLSAgIHdoaWNoIHdlcmUg c3RvcmVkIGluIGEgTGlzcF9PYmplY3QuICAqLwotI2RlZmluZSBYUE5UUihhKSAoKHVpbnRw dHJfdCkgKChYTEkgKGEpICYgVkFMTUFTSykgfCBEQVRBX1NFR19CSVRTKSkKLQotI2VuZGlm IC8qIG5vdCBVU0VfTFNCX1RBRyAqLworLyogTGFyZ2VzdCBhbmQgc21hbGxlc3QgcmVwcmVz ZW50YWJsZSBmaXhudW0gdmFsdWVzLiAgVGhlc2UgYXJlIHRoZSBDCisgICB2YWx1ZXMuICBU aGV5IGFyZSBtYWNyb3MgZm9yIHVzZSBpbiBzdGF0aWMgaW5pdGlhbGl6ZXJzLiAgKi8KKyNk ZWZpbmUgTU9TVF9QT1NJVElWRV9GSVhOVU0gKEVNQUNTX0lOVF9NQVggPj4gSU5UVFlQRUJJ VFMpCisjZGVmaW5lIE1PU1RfTkVHQVRJVkVfRklYTlVNICgtMSAtIE1PU1RfUE9TSVRJVkVf RklYTlVNKQorCitMSVNQX0lOTElORSBlbnVtIExpc3BfVHlwZQorKFhUWVBFKSAoTGlzcF9P YmplY3QgYSkKK3sKKyNpZiBVU0VfTFNCX1RBRworICByZXR1cm4gbGlzcF9oX1hUWVBFIChh KTsKKyNlbHNlCisgIEVNQUNTX1VJTlQgaSA9IFhMSSAoYSk7CisgIHJldHVybiBVU0VfTFNC X1RBRyA/IGkgJiB+VkFMTUFTSyA6IGkgPj4gVkFMQklUUzsKKyNlbmRpZgorfQorCisvKiBF eHRyYWN0IHRoZSB2YWx1ZSBvZiBhIExpc3BfT2JqZWN0IGFzIGEgc2lnbmVkIGludGVnZXIu ICAqLworTElTUF9JTkxJTkUgRU1BQ1NfSU5UCisoWElOVCkgKExpc3BfT2JqZWN0IGEpCit7 CisjaWYgVVNFX0xTQl9UQUcKKyAgcmV0dXJuIGxpc3BfaF9YSU5UIChhKTsKKyNlbHNlCisg IEVNQUNTX0lOVCBpID0gWExJIChhKTsKKyAgcmV0dXJuIChVU0VfTFNCX1RBRyA/IGkgOiBp IDw8IElOVFRZUEVCSVRTKSA+PiBJTlRUWVBFQklUUzsKKyNlbmRpZgorfQorCisvKiBMaWtl IFhJTlQgKEEpLCBidXQgbWF5IGJlIGZhc3Rlci4gIEEgbXVzdCBiZSBub25uZWdhdGl2ZS4g IFRoaXMgdGFrZXMKKyAgIGFkdmFudGFnZSBvZiB0aGUgZmFjdCB0aGF0IExpc3AgaW50ZWdl cnMgaGF2ZSB6ZXJvLWJpdHMgaW4gdGhlaXIgdGFncy4gICovCitMSVNQX0lOTElORSBFTUFD U19JTlQKKyhYRkFTVElOVCkgKExpc3BfT2JqZWN0IGEpCit7CisjaWYgVVNFX0xTQl9UQUcK KyAgcmV0dXJuIGxpc3BfaF9YRkFTVElOVCAoYSk7CisjZWxzZQorICBFTUFDU19JTlQgbiA9 IFVTRV9MU0JfVEFHID8gWElOVCAoYSkgOiBYTEkgKGEpOworICBlYXNzZXJ0ICgwIDw9IG4p OworICByZXR1cm4gbjsKKyNlbmRpZgorfQorCisvKiBFeHRyYWN0IHRoZSB2YWx1ZSBvZiBh IExpc3BfT2JqZWN0IGFzIGFuIHVuc2lnbmVkIGludGVnZXIuICAqLworTElTUF9JTkxJTkUg RU1BQ1NfVUlOVAorWFVJTlQgKExpc3BfT2JqZWN0IGEpCit7CisgIEVNQUNTX1VJTlQgaSA9 IFhMSSAoYSk7CisgIHJldHVybiBVU0VfTFNCX1RBRyA/IGkgPj4gSU5UVFlQRUJJVFMgOiBp ICYgSU5UTUFTSzsKK30KIAogLyogUmV0dXJuIGEgKExpc3AtaW50ZWdlciBzaXplZCkgaGFz aCBvZiB0aGUgTGlzcF9PYmplY3QgdmFsdWUuICBIYXBwZW5zIHRvIGJlCiAgICBsaWtlIFhV SU5UIHJpZ2h0IG5vdywgYnV0IFhVSU5UIHNob3VsZCBvbmx5IGJlIGFwcGxpZWQgdG8gb2Jq ZWN0cyB3ZSBrbm93CiAgICBhcmUgaW50ZWdlcnMuICAqLwotI2RlZmluZSBYSEFTSChhKSBY VUlOVCAoYSkKK0xJU1BfSU5MSU5FIEVNQUNTX0lOVAorKFhIQVNIKSAoTGlzcF9PYmplY3Qg YSkKK3sKKyAgcmV0dXJuIGxpc3BfaF9YSEFTSCAoYSk7Cit9CiAKLS8qIEZvciBpbnRlZ2Vy cyBrbm93biB0byBiZSBwb3NpdGl2ZSwgWEZBU1RJTlQgc29tZXRpbWVzIHByb3ZpZGVzCi0g ICBmYXN0ZXIgcmV0cmlldmFsIGFuZCBYU0VURkFTVElOVCBwcm92aWRlcyBmYXN0ZXIgc3Rv cmFnZS4KLSAgIElmIG5vdCwgZmFsbGJhY2sgb24gdGhlIG5vbi1hY2NlbGVyYXRlZCBwYXRo LiAgKi8KLSNpZm5kZWYgWEZBU1RJTlQKLSMgZGVmaW5lIFhGQVNUSU5UKGEpIChYSU5UIChh KSkKLSMgZGVmaW5lIFhTRVRGQVNUSU5UKGEsIGIpIChYU0VUSU5UIChhLCBiKSkKK0xJU1Bf SU5MSU5FIExpc3BfT2JqZWN0CisobWFrZV9udW1iZXIpIChFTUFDU19JTlQgbikKK3sKKyNp ZiBVU0VfTFNCX1RBRworICByZXR1cm4gbGlzcF9oX21ha2VfbnVtYmVyIChuKTsKKyNlbHNl CisgIHJldHVybiBYSUwgKFVTRV9MU0JfVEFHID8gbiA8PCBJTlRUWVBFQklUUyA6IG4gJiBJ TlRNQVNLKTsKICNlbmRpZgorfQorCisvKiBMaWtlIG1ha2VfbnVtYmVyIChOKSwgYnV0IG1h eSBiZSBmYXN0ZXIuICBOIG11c3QgYmUgaW4gbm9ubmVnYXRpdmUgcmFuZ2UuICAqLworTElT UF9JTkxJTkUgTGlzcF9PYmplY3QKK21ha2VfbmF0bnVtIChFTUFDU19JTlQgbikKK3sKKyAg ZWFzc2VydCAoMCA8PSBuICYmIG4gPD0gTU9TVF9QT1NJVElWRV9GSVhOVU0pOworICByZXR1 cm4gVVNFX0xTQl9UQUcgPyBtYWtlX251bWJlciAobikgOiBYSUwgKG4pOworfQorCitMSVNQ X0lOTElORSB2b2lkICoKKyhYUE5UUikgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBs aXNwX2hfWFBOVFIgKGEpOworfQogCiAvKiBFeHRyYWN0IHRoZSBwb2ludGVyIHZhbHVlIG9m IHRoZSBMaXNwIG9iamVjdCBBLCB1bmRlciB0aGUKLSAgIGFzc3VtcHRpb24gdGhhdCBBJ3Mg dHlwZSBpcyBUWVBFLiAgVGhpcyBpcyBhIGZhbGxiYWNrCi0gICBpbXBsZW1lbnRhdGlvbiBp ZiBub3RoaW5nIGZhc3RlciBpcyBhdmFpbGFibGUuICAqLwotI2lmbmRlZiBYVU5UQUcKLSMg ZGVmaW5lIFhVTlRBRyhhLCB0eXBlKSBYUE5UUiAoYSkKKyAgIGFzc3VtcHRpb24gdGhhdCBB J3MgdHlwZSBpcyBUWVBFLiAgKi8KK0xJU1BfSU5MSU5FIHZvaWQgKgorKFhVTlRBRykgKExp c3BfT2JqZWN0IGEsIGludCB0eXBlKQoreworI2lmIFVTRV9MU0JfVEFHCisgIHJldHVybiBs aXNwX2hfWFVOVEFHIChhLCB0eXBlKTsKKyNlbHNlCisgIGlmIChVU0VfTFNCX1RBRykKKyAg ICB7CisgICAgICBpbnRwdHJfdCBpID0gWExJIChhKSAtIHR5cGU7CisgICAgICByZXR1cm4g KHZvaWQgKikgaTsKKyAgICB9CisgIHJldHVybiBYUE5UUiAoYSk7CiAjZW5kaWYKLQotI2Rl ZmluZSBFUSh4LCB5KSAoWExJICh4KSA9PSBYTEkgKHkpKQotCi0vKiBMYXJnZXN0IGFuZCBz bWFsbGVzdCByZXByZXNlbnRhYmxlIGZpeG51bSB2YWx1ZXMuICBUaGVzZSBhcmUgdGhlIEMK LSAgIHZhbHVlcy4gIFRoZXkgYXJlIG1hY3JvcyBmb3IgdXNlIGluIHN0YXRpYyBpbml0aWFs aXplcnMuICAqLwotI2RlZmluZSBNT1NUX1BPU0lUSVZFX0ZJWE5VTSAoRU1BQ1NfSU5UX01B WCA+PiBJTlRUWVBFQklUUykKLSNkZWZpbmUgTU9TVF9ORUdBVElWRV9GSVhOVU0gKC0xIC0g TU9TVF9QT1NJVElWRV9GSVhOVU0pCit9CisKK0xJU1BfSU5MSU5FIGJvb2wKKyhFUSkgKExp c3BfT2JqZWN0IHgsIExpc3BfT2JqZWN0IHkpCit7CisgIHJldHVybiBsaXNwX2hfRVEgKHgs IHkpOworfQogCiAvKiBWYWx1ZSBpcyBub24temVybyBpZiBJIGRvZXNuJ3QgZml0IGludG8g YSBMaXNwIGZpeG51bS4gIEl0IGlzCiAgICB3cml0dGVuIHRoaXMgd2F5IHNvIHRoYXQgaXQg YWxzbyB3b3JrcyBpZiBJIGlzIG9mIHVuc2lnbmVkCkBAIC01NTEsNjYgKzcxMCwxOTEgQEAK IHsKICAgcmV0dXJuIG51bSA8IGxvd2VyID8gbG93ZXIgOiBudW0gPD0gdXBwZXIgPyBudW0g OiB1cHBlcjsKIH0KLQotDAorDAorLyogRm9yd2FyZCBkZWNsYXJhdGlvbnMuICAqLworCisv KiBEZWZpbmVkIGluIHRoaXMgZmlsZS4gICovCit1bmlvbiBMaXNwX0Z3ZDsKK0xJU1BfSU5M SU5FIGJvb2wgQk9PTEZXRFAgKHVuaW9uIExpc3BfRndkICopOworTElTUF9JTkxJTkUgYm9v bCBCT09MX1ZFQ1RPUl9QIChMaXNwX09iamVjdCk7CitMSVNQX0lOTElORSBib29sIEJVRkZF Ul9PQkpGV0RQICh1bmlvbiBMaXNwX0Z3ZCAqKTsKK0xJU1BfSU5MSU5FIGJvb2wgQlVGRkVS UCAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCBDSEFSX1RBQkxFX1AgKExpc3Bf T2JqZWN0KTsKK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0IENIQVJfVEFCTEVfUkVGX0FTQ0lJ IChMaXNwX09iamVjdCwgcHRyZGlmZl90KTsKK0xJU1BfSU5MSU5FIGJvb2wgKENPTlNQKSAo TGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCAoRkxPQVRQKSAoTGlzcF9PYmplY3Qp OworTElTUF9JTkxJTkUgYm9vbCBmdW5jdGlvbnAgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5M SU5FIGJvb2wgKElOVEVHRVJQKSAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCBJ TlRGV0RQICh1bmlvbiBMaXNwX0Z3ZCAqKTsKK0xJU1BfSU5MSU5FIGJvb2wgS0JPQVJEX09C SkZXRFAgKHVuaW9uIExpc3BfRndkICopOworTElTUF9JTkxJTkUgYm9vbCAoTUFSS0VSUCkg KExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIGJvb2wgKE1JU0NQKSAoTGlzcF9PYmplY3Qp OworTElTUF9JTkxJTkUgYm9vbCAoTklMUCkgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5F IGJvb2wgT0JKRldEUCAodW5pb24gTGlzcF9Gd2QgKik7CitMSVNQX0lOTElORSBib29sIE9W RVJMQVlQIChMaXNwX09iamVjdCk7CitMSVNQX0lOTElORSBib29sIFBST0NFU1NQIChMaXNw X09iamVjdCk7CitMSVNQX0lOTElORSBib29sIFBTRVVET1ZFQ1RPUlAgKExpc3BfT2JqZWN0 LCBpbnQpOworTElTUF9JTkxJTkUgYm9vbCBTQVZFX1ZBTFVFUCAoTGlzcF9PYmplY3QpOwor TElTUF9JTkxJTkUgdm9pZCBzZXRfc3ViX2NoYXJfdGFibGVfY29udGVudHMgKExpc3BfT2Jq ZWN0LCBwdHJkaWZmX3QsCisJCQkJCSAgICAgIExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5F IGJvb2wgU1RSSU5HUCAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCBTVUJfQ0hB Ul9UQUJMRV9QIChMaXNwX09iamVjdCk7CitMSVNQX0lOTElORSBib29sIFNVQlJQIChMaXNw X09iamVjdCk7CitMSVNQX0lOTElORSBib29sIChTWU1CT0xQKSAoTGlzcF9PYmplY3QpOwor TElTUF9JTkxJTkUgYm9vbCAoVkVDVE9STElLRVApIChMaXNwX09iamVjdCk7CitMSVNQX0lO TElORSBib29sIFdJTkRPV1AgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIHN0cnVjdCBM aXNwX1NhdmVfVmFsdWUgKlhTQVZFX1ZBTFVFIChMaXNwX09iamVjdCk7CisKKy8qIERlZmlu ZWQgaW4gYnVmZmVyLmMuICAqLworZXh0ZXJuIExpc3BfT2JqZWN0IFFvdmVybGF5cDsKKwor LyogRGVmaW5lZCBpbiBjaGFydGFiLmMuICAqLworZXh0ZXJuIExpc3BfT2JqZWN0IGNoYXJf dGFibGVfcmVmIChMaXNwX09iamVjdCwgaW50KTsKK2V4dGVybiB2b2lkIGNoYXJfdGFibGVf c2V0IChMaXNwX09iamVjdCwgaW50LCBMaXNwX09iamVjdCk7CitleHRlcm4gaW50IGNoYXJf dGFibGVfdHJhbnNsYXRlIChMaXNwX09iamVjdCwgaW50KTsKKworLyogRGVmaW5lZCBpbiBk YXRhLmMuICAqLworZXh0ZXJuIExpc3BfT2JqZWN0IFFhcnJheXAsIFFidWZmZXJwLCBRYnVm ZmVyX29yX3N0cmluZ19wLCBRY2hhcl90YWJsZV9wOworZXh0ZXJuIExpc3BfT2JqZWN0IFFj b25zcCwgUWZsb2F0cCwgUWludGVnZXJwLCBRbGFtYmRhLCBRbGlzdHAsIFFtYXJrZXJwLCBR bmlsOworZXh0ZXJuIExpc3BfT2JqZWN0IFFudW1iZXJwLCBRc3VicnAsIFFzdHJpbmdwLCBR c3ltYm9scCwgUXZlY3RvcnA7CitleHRlcm4gTGlzcF9PYmplY3QgUXZlY3Rvcl9vcl9jaGFy X3RhYmxlX3AsIFF3aG9sZW51bXA7CitleHRlcm4gTGlzcF9PYmplY3QgRmZib3VuZHAgKExp c3BfT2JqZWN0KTsKK2V4dGVybiBfTm9yZXR1cm4gTGlzcF9PYmplY3Qgd3JvbmdfdHlwZV9h cmd1bWVudCAoTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0KTsKKworLyogRGVmaW5lZCBpbiBl bWFjcy5jLiAgKi8KK2V4dGVybiBib29sIGluaXRpYWxpemVkOworCisvKiBEZWZpbmVkIGlu IGV2YWwuYy4gICovCitleHRlcm4gTGlzcF9PYmplY3QgUWF1dG9sb2FkOworCisvKiBEZWZp bmVkIGluIGZucy5jICAqLworZXh0ZXJuIExpc3BfT2JqZWN0IFFoYXNoX3RhYmxlX3A7CisK Ky8qIERlZmluZWQgaW4gZmxvYXRmbnMuYy4gICovCitleHRlcm4gZG91YmxlIGV4dHJhY3Rf ZmxvYXQgKExpc3BfT2JqZWN0KTsKKworLyogRGVmaW5lZCBpbiBwcm9jZXNzLmMuICAqLwor ZXh0ZXJuIExpc3BfT2JqZWN0IFFwcm9jZXNzcDsKKworLyogRGVmaW5lZCBpbiB3aW5kb3cu Yy4gICovCitleHRlcm4gTGlzcF9PYmplY3QgUXdpbmRvd3AsIFF3aW5kb3dfY29uZmlndXJh dGlvbl9wOworCisvKiBEZWZpbmVkIGluIHhkaXNwLmMuICAqLworZXh0ZXJuIExpc3BfT2Jq ZWN0IFFpbWFnZTsKKwwKKwogLyogRXh0cmFjdCBhIHZhbHVlIG9yIGFkZHJlc3MgZnJvbSBh IExpc3BfT2JqZWN0LiAgKi8KIAotI2RlZmluZSBYQ09OUyhhKSAgIChlYXNzZXJ0IChDT05T UCAoYSkpLCBcCi0JCSAgICAoc3RydWN0IExpc3BfQ29ucyAqKSBYVU5UQUcgKGEsIExpc3Bf Q29ucykpCi0jZGVmaW5lIFhWRUNUT1IoYSkgKGVhc3NlcnQgKFZFQ1RPUkxJS0VQIChhKSks IFwKLQkJICAgIChzdHJ1Y3QgTGlzcF9WZWN0b3IgKikgWFVOVEFHIChhLCBMaXNwX1ZlY3Rv cmxpa2UpKQotI2RlZmluZSBYU1RSSU5HKGEpIChlYXNzZXJ0IChTVFJJTkdQIChhKSksIFwK LQkJICAgIChzdHJ1Y3QgTGlzcF9TdHJpbmcgKikgWFVOVEFHIChhLCBMaXNwX1N0cmluZykp Ci0jZGVmaW5lIFhTWU1CT0woYSkgKGVhc3NlcnQgKFNZTUJPTFAgKGEpKSwgXAotCQkgICAg KHN0cnVjdCBMaXNwX1N5bWJvbCAqKSBYVU5UQUcgKGEsIExpc3BfU3ltYm9sKSkKLSNkZWZp bmUgWEZMT0FUKGEpICAoZWFzc2VydCAoRkxPQVRQIChhKSksIFwKLQkJICAgIChzdHJ1Y3Qg TGlzcF9GbG9hdCAqKSBYVU5UQUcgKGEsIExpc3BfRmxvYXQpKQotCi0vKiBNaXNjIHR5cGVz LiAgKi8KLQotI2RlZmluZSBYTUlTQyhhKQkoKHVuaW9uIExpc3BfTWlzYyAqKSBYVU5UQUcg KGEsIExpc3BfTWlzYykpCi0jZGVmaW5lIFhNSVNDQU5ZKGEpCShlYXNzZXJ0IChNSVNDUCAo YSkpLCAmKFhNSVNDIChhKS0+dV9hbnkpKQotI2RlZmluZSBYTUlTQ1RZUEUoYSkgICAoWE1J U0NBTlkgKGEpLT50eXBlKQotI2RlZmluZSBYTUFSS0VSKGEpCShlYXNzZXJ0IChNQVJLRVJQ IChhKSksICYoWE1JU0MgKGEpLT51X21hcmtlcikpCi0jZGVmaW5lIFhPVkVSTEFZKGEpCShl YXNzZXJ0IChPVkVSTEFZUCAoYSkpLCAmKFhNSVNDIChhKS0+dV9vdmVybGF5KSkKLQotLyog Rm9yd2FyZGluZyBvYmplY3QgdHlwZXMuICAqLwotCi0jZGVmaW5lIFhGV0RUWVBFKGEpICAg ICAoYS0+dV9pbnRmd2QudHlwZSkKLSNkZWZpbmUgWElOVEZXRChhKQkoZWFzc2VydCAoSU5U RldEUCAoYSkpLCAmKChhKS0+dV9pbnRmd2QpKQotI2RlZmluZSBYQk9PTEZXRChhKQkoZWFz c2VydCAoQk9PTEZXRFAgKGEpKSwgJigoYSktPnVfYm9vbGZ3ZCkpCi0jZGVmaW5lIFhPQkpG V0QoYSkJKGVhc3NlcnQgKE9CSkZXRFAgKGEpKSwgJigoYSktPnVfb2JqZndkKSkKLSNkZWZp bmUgWEJVRkZFUl9PQkpGV0QoYSkgXAotICAoZWFzc2VydCAoQlVGRkVSX09CSkZXRFAgKGEp KSwgJigoYSktPnVfYnVmZmVyX29iamZ3ZCkpCi0jZGVmaW5lIFhLQk9BUkRfT0JKRldEKGEp IFwKLSAgKGVhc3NlcnQgKEtCT0FSRF9PQkpGV0RQIChhKSksICYoKGEpLT51X2tib2FyZF9v Ympmd2QpKQorTElTUF9JTkxJTkUgc3RydWN0IExpc3BfQ29ucyAqCisoWENPTlMpIChMaXNw X09iamVjdCBhKQoreworICByZXR1cm4gbGlzcF9oX1hDT05TIChhKTsKK30KKworTElTUF9J TkxJTkUgc3RydWN0IExpc3BfVmVjdG9yICoKK1hWRUNUT1IgKExpc3BfT2JqZWN0IGEpCit7 CisgIGVhc3NlcnQgKFZFQ1RPUkxJS0VQIChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExp c3BfVmVjdG9ybGlrZSk7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVjdCBMaXNwX1N0cmluZyAq CitYU1RSSU5HIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChTVFJJTkdQIChhKSk7 CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfU3RyaW5nKTsKK30KKworTElTUF9JTkxJTkUg c3RydWN0IExpc3BfU3ltYm9sICoKKyhYU1lNQk9MKSAoTGlzcF9PYmplY3QgYSkKK3sKKyAg cmV0dXJuIGxpc3BfaF9YU1lNQk9MIChhKTsKK30KKworTElTUF9JTkxJTkUgc3RydWN0IExp c3BfRmxvYXQgKgorWEZMT0FUIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChGTE9B VFAgKGEpKTsKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlzcF9GbG9hdCk7Cit9CiAKIC8qIFBz ZXVkb3ZlY3RvciB0eXBlcy4gICovCi1zdHJ1Y3QgTGlzcF9Qcm9jZXNzOwotTElTUF9JTkxJ TkUgTGlzcF9PYmplY3QgbWFrZV9saXNwX3Byb2MgKHN0cnVjdCBMaXNwX1Byb2Nlc3MgKnAp Ci17IHJldHVybiBtYWtlX2xpc3BfcHRyIChwLCBMaXNwX1ZlY3Rvcmxpa2UpOyB9Ci0jZGVm aW5lIFhQUk9DRVNTKGEpIChlYXNzZXJ0IChQUk9DRVNTUCAoYSkpLCBcCi0JCSAgICAgKHN0 cnVjdCBMaXNwX1Byb2Nlc3MgKikgWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpKQotI2Rl ZmluZSBYV0lORE9XKGEpIChlYXNzZXJ0IChXSU5ET1dQIChhKSksCQkJCVwKLQkJICAgIChz dHJ1Y3Qgd2luZG93ICopIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKSkKLSNkZWZpbmUg WFRFUk1JTkFMKGEpIChlYXNzZXJ0IChURVJNSU5BTFAgKGEpKSwgXAotCQkgICAgICAoc3Ry dWN0IHRlcm1pbmFsICopIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKSkKLSNkZWZpbmUg WFNVQlIoYSkgKGVhc3NlcnQgKFNVQlJQIChhKSksIFwKLQkJICAoc3RydWN0IExpc3BfU3Vi ciAqKSBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSkpCi0jZGVmaW5lIFhCVUZGRVIoYSkg KGVhc3NlcnQgKEJVRkZFUlAgKGEpKSwgXAotCQkgICAgKHN0cnVjdCBidWZmZXIgKikgWFVO VEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpKQotI2RlZmluZSBYQ0hBUl9UQUJMRShhKSAoZWFz c2VydCAoQ0hBUl9UQUJMRV9QIChhKSksIFwKLQkJCShzdHJ1Y3QgTGlzcF9DaGFyX1RhYmxl ICopIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKSkKLSNkZWZpbmUgWFNVQl9DSEFSX1RB QkxFKGEpIChlYXNzZXJ0IChTVUJfQ0hBUl9UQUJMRV9QIChhKSksIFwKLQkJCSAgICAoKHN0 cnVjdCBMaXNwX1N1Yl9DaGFyX1RhYmxlICopIFwKLQkJCSAgICAgWFVOVEFHIChhLCBMaXNw X1ZlY3Rvcmxpa2UpKSkKLSNkZWZpbmUgWEJPT0xfVkVDVE9SKGEpIChlYXNzZXJ0IChCT09M X1ZFQ1RPUl9QIChhKSksIFwKLQkJCSAoKHN0cnVjdCBMaXNwX0Jvb2xfVmVjdG9yICopIFwK LQkJCSAgWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpKSkKKworTElTUF9JTkxJTkUgc3Ry dWN0IExpc3BfUHJvY2VzcyAqCitYUFJPQ0VTUyAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFz c2VydCAoUFJPQ0VTU1AgKGEpKTsKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3Js aWtlKTsKK30KKworTElTUF9JTkxJTkUgc3RydWN0IHdpbmRvdyAqCitYV0lORE9XIChMaXNw X09iamVjdCBhKQoreworICBlYXNzZXJ0IChXSU5ET1dQIChhKSk7CisgIHJldHVybiBYVU5U QUcgKGEsIExpc3BfVmVjdG9ybGlrZSk7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVjdCB0ZXJt aW5hbCAqCitYVEVSTUlOQUwgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBYVU5UQUcg KGEsIExpc3BfVmVjdG9ybGlrZSk7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVjdCBMaXNwX1N1 YnIgKgorWFNVQlIgKExpc3BfT2JqZWN0IGEpCit7CisgIGVhc3NlcnQgKFNVQlJQIChhKSk7 CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSk7Cit9CisKK0xJU1BfSU5M SU5FIHN0cnVjdCBidWZmZXIgKgorWEJVRkZFUiAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFz c2VydCAoQlVGRkVSUCAoYSkpOworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxp a2UpOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9DaGFyX1RhYmxlICoKK1hDSEFS X1RBQkxFIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChDSEFSX1RBQkxFX1AgKGEp KTsKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKTsKK30KKworTElTUF9J TkxJTkUgc3RydWN0IExpc3BfU3ViX0NoYXJfVGFibGUgKgorWFNVQl9DSEFSX1RBQkxFIChM aXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChTVUJfQ0hBUl9UQUJMRV9QIChhKSk7Cisg IHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSk7Cit9CisKK0xJU1BfSU5MSU5F IHN0cnVjdCBMaXNwX0Jvb2xfVmVjdG9yICoKK1hCT09MX1ZFQ1RPUiAoTGlzcF9PYmplY3Qg YSkKK3sKKyAgZWFzc2VydCAoQk9PTF9WRUNUT1JfUCAoYSkpOworICByZXR1cm4gWFVOVEFH IChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQogCiAvKiBDb25zdHJ1Y3QgYSBMaXNwX09iamVj dCBmcm9tIGEgdmFsdWUgb3IgYWRkcmVzcy4gICovCiAKK0xJU1BfSU5MSU5FIExpc3BfT2Jq ZWN0CittYWtlX2xpc3BfcHRyICh2b2lkICpwdHIsIGVudW0gTGlzcF9UeXBlIHR5cGUpCit7 CisgIEVNQUNTX1VJTlQgdXR5cGUgPSB0eXBlOworICBFTUFDU19VSU5UIHR5cGViaXRzID0g VVNFX0xTQl9UQUcgPyB0eXBlIDogdXR5cGUgPDwgVkFMQklUUzsKKyAgTGlzcF9PYmplY3Qg YSA9IFhJTCAodHlwZWJpdHMgfCAodWludHB0cl90KSBwdHIpOworICBlYXNzZXJ0IChYVFlQ RSAoYSkgPT0gdHlwZSAmJiBYVU5UQUcgKGEsIHR5cGUpID09IHB0cik7CisgIHJldHVybiBh OworfQorCitMSVNQX0lOTElORSBMaXNwX09iamVjdAorbWFrZV9saXNwX3Byb2MgKHN0cnVj dCBMaXNwX1Byb2Nlc3MgKnApCit7CisgIHJldHVybiBtYWtlX2xpc3BfcHRyIChwLCBMaXNw X1ZlY3Rvcmxpa2UpOworfQorCiAjZGVmaW5lIFhTRVRJTlQoYSwgYikgKChhKSA9IG1ha2Vf bnVtYmVyIChiKSkKKyNkZWZpbmUgWFNFVEZBU1RJTlQoYSwgYikgKChhKSA9IG1ha2VfbmF0 bnVtIChiKSkKICNkZWZpbmUgWFNFVENPTlMoYSwgYikgKChhKSA9IG1ha2VfbGlzcF9wdHIg KGIsIExpc3BfQ29ucykpCiAjZGVmaW5lIFhTRVRWRUNUT1IoYSwgYikgKChhKSA9IG1ha2Vf bGlzcF9wdHIgKGIsIExpc3BfVmVjdG9ybGlrZSkpCiAjZGVmaW5lIFhTRVRTVFJJTkcoYSwg YikgKChhKSA9IG1ha2VfbGlzcF9wdHIgKGIsIExpc3BfU3RyaW5nKSkKQEAgLTY1NiwzNSAr OTQwLDEzIEBACiAjZGVmaW5lIFhTRVRCT09MX1ZFQ1RPUihhLCBiKSAoWFNFVFBTRVVET1ZF Q1RPUiAoYSwgYiwgUFZFQ19CT09MX1ZFQ1RPUikpCiAjZGVmaW5lIFhTRVRTVUJfQ0hBUl9U QUJMRShhLCBiKSAoWFNFVFBTRVVET1ZFQ1RPUiAoYSwgYiwgUFZFQ19TVUJfQ0hBUl9UQUJM RSkpCiAKLS8qIENvbnZlbmllbmNlIG1hY3JvcyBmb3IgZGVhbGluZyB3aXRoIExpc3AgYXJy YXlzLiAgKi8KLQotI2RlZmluZSBBUkVGKEFSUkFZLCBJRFgpCVhWRUNUT1IgKChBUlJBWSkp LT5jb250ZW50c1tJRFhdCi0jZGVmaW5lIEFTSVpFKEFSUkFZKQkJWFZFQ1RPUiAoKEFSUkFZ KSktPmhlYWRlci5zaXplCi0jZGVmaW5lIEFTRVQoQVJSQVksIElEWCwgVkFMKQlcCi0gIChl YXNzZXJ0ICgwIDw9IChJRFgpICYmIChJRFgpIDwgQVNJWkUgKEFSUkFZKSksCVwKLSAgIFhW RUNUT1IgKEFSUkFZKS0+Y29udGVudHNbSURYXSA9IChWQUwpKQotCi0vKiBDb252ZW5pZW5j ZSBtYWNyb3MgZm9yIGRlYWxpbmcgd2l0aCBMaXNwIHN0cmluZ3MuICAqLwotCi0jZGVmaW5l IFNEQVRBKHN0cmluZykJCShYU1RSSU5HIChzdHJpbmcpLT5kYXRhICsgMCkKLSNkZWZpbmUg U1JFRihzdHJpbmcsIGluZGV4KQkoU0RBVEEgKHN0cmluZylbaW5kZXhdICsgMCkKLSNkZWZp bmUgU1NFVChzdHJpbmcsIGluZGV4LCBuZXcpIChTREFUQSAoc3RyaW5nKVtpbmRleF0gPSAo bmV3KSkKLSNkZWZpbmUgU0NIQVJTKHN0cmluZykJCShYU1RSSU5HIChzdHJpbmcpLT5zaXpl ICsgMCkKLSNkZWZpbmUgU0JZVEVTKHN0cmluZykJCShTVFJJTkdfQllURVMgKFhTVFJJTkcg KHN0cmluZykpICsgMCkKLQotLyogQXZvaWQgImRpZmZlciBpbiBzaWduIiB3YXJuaW5ncy4g ICovCi0jZGVmaW5lIFNTREFUQSh4KSAgKChjaGFyICopIFNEQVRBICh4KSkKLQotI2RlZmlu ZSBTVFJJTkdfU0VUX0NIQVJTKHN0cmluZywgbmV3c2l6ZSkgXAotICAgIChYU1RSSU5HIChz dHJpbmcpLT5zaXplID0gKG5ld3NpemUpKQotCi0jZGVmaW5lIFNUUklOR19DT1BZSU4oc3Ry aW5nLCBpbmRleCwgbmV3LCBjb3VudCkgXAotICAgIG1lbWNweSAoU0RBVEEgKHN0cmluZykg KyBpbmRleCwgbmV3LCBjb3VudCkKLQogLyogVHlwZSBjaGVja2luZy4gICovCiAKLSNkZWZp bmUgQ0hFQ0tfVFlQRShvaywgUXh4eHAsIHgpIFwKLSAgZG8geyBpZiAoIShvaykpIHdyb25n X3R5cGVfYXJndW1lbnQgKFF4eHhwLCAoeCkpOyB9IHdoaWxlICgwKQorTElTUF9JTkxJTkUg dm9pZAorKENIRUNLX1RZUEUpIChpbnQgb2ssIExpc3BfT2JqZWN0IFF4eHhwLCBMaXNwX09i amVjdCB4KQoreworICBsaXNwX2hfQ0hFQ0tfVFlQRSAob2ssIFF4eHhwLCB4KTsKK30KIAog LyogRGVwcmVjYXRlZCBhbmQgd2lsbCBiZSByZW1vdmVkIHNvb24uICAqLwogCkBAIC02OTUs OCArOTU3LDExIEBACiB0eXBlZGVmIHN0cnVjdCBpbnRlcnZhbCAqSU5URVJWQUw7CiAKIC8q IENvbXBsYWluIGlmIG9iamVjdCBpcyBub3Qgc3RyaW5nIG9yIGJ1ZmZlciB0eXBlLiAgKi8K LSNkZWZpbmUgQ0hFQ0tfU1RSSU5HX09SX0JVRkZFUih4KSBcCi0gIENIRUNLX1RZUEUgKFNU UklOR1AgKHgpIHx8IEJVRkZFUlAgKHgpLCBRYnVmZmVyX29yX3N0cmluZ19wLCB4KQorTElT UF9JTkxJTkUgdm9pZAorQ0hFQ0tfU1RSSU5HX09SX0JVRkZFUiAoTGlzcF9PYmplY3QgeCkK K3sKKyAgQ0hFQ0tfVFlQRSAoU1RSSU5HUCAoeCkgfHwgQlVGRkVSUCAoeCksIFFidWZmZXJf b3Jfc3RyaW5nX3AsIHgpOworfQogCiBzdHJ1Y3QgTGlzcF9Db25zCiAgIHsKQEAgLTcxNCw2 NCArOTc5LDk0IEBACiAgIH07CiAKIC8qIFRha2UgdGhlIGNhciBvciBjZHIgb2Ygc29tZXRo aW5nIGtub3duIHRvIGJlIGEgY29ucyBjZWxsLiAgKi8KLS8qIFRoZSBfQVNfTFZBTFVFIG1h Y3JvcyBzaG91bGRuJ3QgYmUgdXNlZCBvdXRzaWRlIG9mIHRoZSBtaW5pbWFsIHNldAorLyog VGhlIF9hZGRyIGZ1bmN0aW9ucyBzaG91bGRuJ3QgYmUgdXNlZCBvdXRzaWRlIG9mIHRoZSBt aW5pbWFsIHNldAogICAgb2YgY29kZSB0aGF0IGhhcyB0byBrbm93IHdoYXQgYSBjb25zIGNl bGwgbG9va3MgbGlrZS4gIE90aGVyIGNvZGUgbm90CiAgICBwYXJ0IG9mIHRoZSBiYXNpYyBs aXNwIGltcGxlbWVudGF0aW9uIHNob3VsZCBhc3N1bWUgdGhhdCB0aGUgY2FyIGFuZCBjZHIK LSAgIGZpZWxkcyBhcmUgbm90IGFjY2Vzc2libGUgYXMgbHZhbHVlcy4gIChXaGF0IGlmIHdl IHdhbnQgdG8gc3dpdGNoIHRvCisgICBmaWVsZHMgYXJlIG5vdCBhY2Nlc3NpYmxlLiAgKFdo YXQgaWYgd2Ugd2FudCB0byBzd2l0Y2ggdG8KICAgIGEgY29weWluZyBjb2xsZWN0b3Igc29t ZWRheT8gIENhY2hlZCBjb25zIGNlbGwgZmllbGQgYWRkcmVzc2VzIG1heSBiZQogICAgaW52 YWxpZGF0ZWQgYXQgYXJiaXRyYXJ5IHBvaW50cy4pICAqLwotI2RlZmluZSBYQ0FSX0FTX0xW QUxVRShjKSAoWENPTlMgKGMpLT5jYXIpCi0jZGVmaW5lIFhDRFJfQVNfTFZBTFVFKGMpIChY Q09OUyAoYyktPnUuY2RyKQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QgKgoreGNhcl9hZGRy IChMaXNwX09iamVjdCBjKQoreworICByZXR1cm4gJlhDT05TIChjKS0+Y2FyOworfQorTElT UF9JTkxJTkUgTGlzcF9PYmplY3QgKgoreGNkcl9hZGRyIChMaXNwX09iamVjdCBjKQorewor ICByZXR1cm4gJlhDT05TIChjKS0+dS5jZHI7Cit9CiAKIC8qIFVzZSB0aGVzZSBmcm9tIG5v cm1hbCBjb2RlLiAgKi8KLSNkZWZpbmUgWENBUihjKQlMSVNQX01BS0VfUlZBTFVFIChYQ0FS X0FTX0xWQUxVRSAoYykpCi0jZGVmaW5lIFhDRFIoYykgTElTUF9NQUtFX1JWQUxVRSAoWENE Ul9BU19MVkFMVUUgKGMpKQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKKyhYQ0FSKSAoTGlz cF9PYmplY3QgYykKK3sKKyAgcmV0dXJuIGxpc3BfaF9YQ0FSIChjKTsKK30KK0xJU1BfSU5M SU5FIExpc3BfT2JqZWN0CisoWENEUikgKExpc3BfT2JqZWN0IGMpCit7CisgIHJldHVybiBs aXNwX2hfWENEUiAoYyk7Cit9CiAKIC8qIFVzZSB0aGVzZSB0byBzZXQgdGhlIGZpZWxkcyBv ZiBhIGNvbnMgY2VsbC4KIAogICAgTm90ZSB0aGF0IGJvdGggYXJndW1lbnRzIG1heSByZWZl ciB0byB0aGUgc2FtZSBvYmplY3QsIHNvICduJwotICAgc2hvdWxkIG5vdCBiZSByZWFkIGFm dGVyICdjJyBpcyBmaXJzdCBtb2RpZmllZC4gIEFsc28sIG5laXRoZXIKLSAgIGFyZ3VtZW50 IHNob3VsZCBiZSBldmFsdWF0ZWQgbW9yZSB0aGFuIG9uY2U7IHNpZGUgZWZmZWN0cyBhcmUK LSAgIGVzcGVjaWFsbHkgY29tbW9uIGluIHRoZSBzZWNvbmQgYXJndW1lbnQuICAqLwotI2Rl ZmluZSBYU0VUQ0FSKGMsbikgKFhDQVJfQVNfTFZBTFVFIChjKSA9IChuKSkKLSNkZWZpbmUg WFNFVENEUihjLG4pIChYQ0RSX0FTX0xWQUxVRSAoYykgPSAobikpCi0KLS8qIFRha2UgdGhl IGNhciBvciBjZHIgb2Ygc29tZXRoaW5nIHdob3NlIHR5cGUgaXMgbm90IGtub3duLiAgKi8K LSNkZWZpbmUgQ0FSKGMpCQkJCQlcCi0gKENPTlNQICgoYykpID8gWENBUiAoKGMpKQkJCVwK LSAgOiBOSUxQICgoYykpID8gUW5pbAkJCQlcCi0gIDogd3JvbmdfdHlwZV9hcmd1bWVudCAo UWxpc3RwLCAoYykpKQotCi0jZGVmaW5lIENEUihjKQkJCQkJXAotIChDT05TUCAoKGMpKSA/ IFhDRFIgKChjKSkJCQlcCi0gIDogTklMUCAoKGMpKSA/IFFuaWwJCQkJXAotICA6IHdyb25n X3R5cGVfYXJndW1lbnQgKFFsaXN0cCwgKGMpKSkKLQotLyogVGFrZSB0aGUgY2FyIG9yIGNk ciBvZiBzb21ldGhpbmcgd2hvc2UgdHlwZSBpcyBub3Qga25vd24uICAqLwotI2RlZmluZSBD QVJfU0FGRShjKQkJCQlcCi0gIChDT05TUCAoKGMpKSA/IFhDQVIgKChjKSkgOiBRbmlsKQot Ci0jZGVmaW5lIENEUl9TQUZFKGMpCQkJCVwKLSAgKENPTlNQICgoYykpID8gWENEUiAoKGMp KSA6IFFuaWwpCisgICBzaG91bGQgbm90IGJlIHJlYWQgYWZ0ZXIgJ2MnIGlzIGZpcnN0IG1v ZGlmaWVkLiAgKi8KK0xJU1BfSU5MSU5FIHZvaWQKK1hTRVRDQVIgKExpc3BfT2JqZWN0IGMs IExpc3BfT2JqZWN0IG4pCit7CisgICp4Y2FyX2FkZHIgKGMpID0gbjsKK30KK0xJU1BfSU5M SU5FIHZvaWQKK1hTRVRDRFIgKExpc3BfT2JqZWN0IGMsIExpc3BfT2JqZWN0IG4pCit7Cisg ICp4Y2RyX2FkZHIgKGMpID0gbjsKK30KKworLyogVGFrZSB0aGUgY2FyIG9yIGNkciBvZiBz b21ldGhpbmcgd2hvc2UgdHlwZSBpcyBub3Qga25vd24uICAqLworTElTUF9JTkxJTkUgTGlz cF9PYmplY3QKK0NBUiAoTGlzcF9PYmplY3QgYykKK3sKKyAgcmV0dXJuIChDT05TUCAoYykg PyBYQ0FSIChjKQorCSAgOiBOSUxQIChjKSA/IFFuaWwKKwkgIDogd3JvbmdfdHlwZV9hcmd1 bWVudCAoUWxpc3RwLCBjKSk7Cit9CitMSVNQX0lOTElORSBMaXNwX09iamVjdAorQ0RSIChM aXNwX09iamVjdCBjKQoreworICByZXR1cm4gKENPTlNQIChjKSA/IFhDRFIgKGMpCisJICA6 IE5JTFAgKGMpID8gUW5pbAorCSAgOiB3cm9uZ190eXBlX2FyZ3VtZW50IChRbGlzdHAsIGMp KTsKK30KKworLyogVGFrZSB0aGUgY2FyIG9yIGNkciBvZiBzb21ldGhpbmcgd2hvc2UgdHlw ZSBpcyBub3Qga25vd24uICAqLworTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK0NBUl9TQUZF IChMaXNwX09iamVjdCBjKQoreworICByZXR1cm4gQ09OU1AgKGMpID8gWENBUiAoYykgOiBR bmlsOworfQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK0NEUl9TQUZFIChMaXNwX09iamVj dCBjKQoreworICByZXR1cm4gQ09OU1AgKGMpID8gWENEUiAoYykgOiBRbmlsOworfQorCisv KiBJbiBhIHN0cmluZyBvciB2ZWN0b3IsIHRoZSBzaWduIGJpdCBvZiB0aGUgYHNpemUnIGlz IHRoZSBnYyBtYXJrIGJpdC4gICovCisKK3N0cnVjdCBMaXNwX1N0cmluZworICB7CisgICAg cHRyZGlmZl90IHNpemU7CisgICAgcHRyZGlmZl90IHNpemVfYnl0ZTsKKyAgICBJTlRFUlZB TCBpbnRlcnZhbHM7CQkvKiBUZXh0IHByb3BlcnRpZXMgaW4gdGhpcyBzdHJpbmcuICAqLwor ICAgIHVuc2lnbmVkIGNoYXIgKmRhdGE7CisgIH07CiAKIC8qIFRydWUgaWYgU1RSIGlzIGEg bXVsdGlieXRlIHN0cmluZy4gICovCi0jZGVmaW5lIFNUUklOR19NVUxUSUJZVEUoU1RSKSAg XAotICAoWFNUUklORyAoU1RSKS0+c2l6ZV9ieXRlID49IDApCi0KLS8qIFJldHVybiB0aGUg bGVuZ3RoIGluIGJ5dGVzIG9mIFNUUi4gICovCi0KLSNpZmRlZiBHQ19DSEVDS19TVFJJTkdf QllURVMKLQotc3RydWN0IExpc3BfU3RyaW5nOwotZXh0ZXJuIHB0cmRpZmZfdCBzdHJpbmdf Ynl0ZXMgKHN0cnVjdCBMaXNwX1N0cmluZyAqKTsKLSNkZWZpbmUgU1RSSU5HX0JZVEVTKFMp IHN0cmluZ19ieXRlcyAoKFMpKQotCi0jZWxzZSAvKiBub3QgR0NfQ0hFQ0tfU1RSSU5HX0JZ VEVTICovCi0KLSNkZWZpbmUgU1RSSU5HX0JZVEVTKFNUUikgIFwKLSAgKChTVFIpLT5zaXpl X2J5dGUgPCAwID8gKFNUUiktPnNpemUgOiAoU1RSKS0+c2l6ZV9ieXRlKQotCi0jZW5kaWYg Lyogbm90IEdDX0NIRUNLX1NUUklOR19CWVRFUyAqLworTElTUF9JTkxJTkUgYm9vbAorU1RS SU5HX01VTFRJQllURSAoTGlzcF9PYmplY3Qgc3RyKQoreworICByZXR1cm4gMCA8PSBYU1RS SU5HIChzdHIpLT5zaXplX2J5dGU7Cit9CiAKIC8qIEFuIHVwcGVyIGJvdW5kIG9uIHRoZSBu dW1iZXIgb2YgYnl0ZXMgaW4gYSBMaXNwIHN0cmluZywgbm90CiAgICBjb3VudGluZyB0aGUg dGVybWluYXRpbmcgbnVsbC4gIFRoaXMgYSB0aWdodCBlbm91Z2ggYm91bmQgdG8KQEAgLTgw MiwyMCArMTA5Nyw2NSBAQAogICAgICAgKFNUUikgPSBlbXB0eV9tdWx0aWJ5dGVfc3RyaW5n OyAgXAogICAgIGVsc2UgWFNUUklORyAoU1RSKS0+c2l6ZV9ieXRlID0gWFNUUklORyAoU1RS KS0+c2l6ZTsgfSB3aGlsZSAoMCkKIAotLyogSW4gYSBzdHJpbmcgb3IgdmVjdG9yLCB0aGUg c2lnbiBiaXQgb2YgdGhlIGBzaXplJyBpcyB0aGUgZ2MgbWFyayBiaXQuICAqLworLyogQ29u dmVuaWVuY2UgZnVuY3Rpb25zIGZvciBkZWFsaW5nIHdpdGggTGlzcCBzdHJpbmdzLiAgKi8K IAotc3RydWN0IExpc3BfU3RyaW5nCi0gIHsKLSAgICBwdHJkaWZmX3Qgc2l6ZTsKLSAgICBw dHJkaWZmX3Qgc2l6ZV9ieXRlOwotICAgIElOVEVSVkFMIGludGVydmFsczsJCS8qIFRleHQg cHJvcGVydGllcyBpbiB0aGlzIHN0cmluZy4gICovCi0gICAgdW5zaWduZWQgY2hhciAqZGF0 YTsKLSAgfTsKK0xJU1BfSU5MSU5FIHVuc2lnbmVkIGNoYXIgKgorU0RBVEEgKExpc3BfT2Jq ZWN0IHN0cmluZykKK3sKKyAgcmV0dXJuIFhTVFJJTkcgKHN0cmluZyktPmRhdGE7Cit9CitM SVNQX0lOTElORSBjaGFyICoKK1NTREFUQSAoTGlzcF9PYmplY3Qgc3RyaW5nKQoreworICAv KiBBdm9pZCAiZGlmZmVyIGluIHNpZ24iIHdhcm5pbmdzLiAgKi8KKyAgcmV0dXJuIChjaGFy ICopIFNEQVRBIChzdHJpbmcpOworfQorTElTUF9JTkxJTkUgdW5zaWduZWQgY2hhcgorU1JF RiAoTGlzcF9PYmplY3Qgc3RyaW5nLCBwdHJkaWZmX3QgaW5kZXgpCit7CisgIHJldHVybiBT REFUQSAoc3RyaW5nKVtpbmRleF07Cit9CitMSVNQX0lOTElORSB2b2lkCitTU0VUIChMaXNw X09iamVjdCBzdHJpbmcsIHB0cmRpZmZfdCBpbmRleCwgdW5zaWduZWQgY2hhciBuZXcpCit7 CisgIFNEQVRBIChzdHJpbmcpW2luZGV4XSA9IG5ldzsKK30KK0xJU1BfSU5MSU5FIHB0cmRp ZmZfdAorU0NIQVJTIChMaXNwX09iamVjdCBzdHJpbmcpCit7CisgIHJldHVybiBYU1RSSU5H IChzdHJpbmcpLT5zaXplOworfQorTElTUF9JTkxJTkUgcHRyZGlmZl90CitTVFJJTkdfQllU RVMgKHN0cnVjdCBMaXNwX1N0cmluZyAqcykKK3sKKyNpZmRlZiBHQ19DSEVDS19TVFJJTkdf QllURVMKKyAgZXh0ZXJuIHB0cmRpZmZfdCBzdHJpbmdfYnl0ZXMgKHN0cnVjdCBMaXNwX1N0 cmluZyAqKTsKKyAgcmV0dXJuIHN0cmluZ19ieXRlcyAocyk7CisjZWxzZQorICByZXR1cm4g cy0+c2l6ZV9ieXRlIDwgMCA/IHMtPnNpemUgOiBzLT5zaXplX2J5dGU7CisjZW5kaWYKK30K K0xJU1BfSU5MSU5FIHB0cmRpZmZfdAorU0JZVEVTIChMaXNwX09iamVjdCBzdHJpbmcpCit7 CisgIHJldHVybiBTVFJJTkdfQllURVMgKFhTVFJJTkcgKHN0cmluZykpOworfQorTElTUF9J TkxJTkUgdm9pZAorU1RSSU5HX1NFVF9DSEFSUyAoTGlzcF9PYmplY3Qgc3RyaW5nLCBwdHJk aWZmX3QgbmV3c2l6ZSkKK3sKKyAgWFNUUklORyAoc3RyaW5nKS0+c2l6ZSA9IG5ld3NpemU7 Cit9CitMSVNQX0lOTElORSB2b2lkCitTVFJJTkdfQ09QWUlOIChMaXNwX09iamVjdCBzdHJp bmcsIHB0cmRpZmZfdCBpbmRleCwgY2hhciBjb25zdCAqbmV3LAorCSAgICAgICBwdHJkaWZm X3QgY291bnQpCit7CisgIG1lbWNweSAoU0RBVEEgKHN0cmluZykgKyBpbmRleCwgbmV3LCBj b3VudCk7Cit9CiAKIC8qIEhlYWRlciBvZiB2ZWN0b3ItbGlrZSBvYmplY3RzLiAgVGhpcyBk b2N1bWVudHMgdGhlIGxheW91dCBjb25zdHJhaW50cyBvbgogICAgdmVjdG9ycyBhbmQgcHNl dWRvdmVjdG9ycyAob2JqZWN0cyBvZiBQVkVDX3h4eCBzdWJ0eXBlKS4gIEl0IGFsc28gcHJl dmVudHMKLSAgIGNvbXBpbGVycyBmcm9tIGJlaW5nIGZvb2xlZCBieSBFbWFjcydzIHR5cGUg cHVubmluZzogdGhlIFhTRVRQU0VVRE9WRUNUT1IKLSAgIGFuZCBQU0VVRE9WRUNUT1JQIG1h Y3JvcyBjYXN0IHRoZWlyIHBvaW50ZXJzIHRvIHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRlciAq LAorICAgY29tcGlsZXJzIGZyb20gYmVpbmcgZm9vbGVkIGJ5IEVtYWNzJ3MgdHlwZSBwdW5u aW5nOiBYU0VUUFNFVURPVkVDVE9SCisgICBhbmQgUFNFVURPVkVDVE9SUCBjYXN0IHRoZWly IHBvaW50ZXJzIHRvIHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRlciAqLAogICAgYmVjYXVzZSB3 aGVuIHR3byBzdWNoIHBvaW50ZXJzIHBvdGVudGlhbGx5IGFsaWFzLCBhIGNvbXBpbGVyIHdv bid0CiAgICBpbmNvcnJlY3RseSByZW9yZGVyIGxvYWRzIGFuZCBzdG9yZXMgdG8gdGhlaXIg c2l6ZSBmaWVsZHMuICBTZWUKICAgIDxodHRwOi8vZGViYnVncy5nbnUub3JnL2NnaS9idWdy ZXBvcnQuY2dpP2J1Zz04NTQ2Pi4gICovCkBAIC04NzQsNiArMTIxNCw0MiBAQAogICAgIHdv cmRfc2l6ZSA9IHNpemVvZiAoTGlzcF9PYmplY3QpCiAgIH07CiAKKy8qIENvbnZlbmllbmNl cyBmb3IgZGVhbGluZyB3aXRoIExpc3AgYXJyYXlzLiAgKi8KKworTElTUF9JTkxJTkUgTGlz cF9PYmplY3QKK0FSRUYgKExpc3BfT2JqZWN0IGFycmF5LCBwdHJkaWZmX3QgaWR4KQorewor ICByZXR1cm4gWFZFQ1RPUiAoYXJyYXkpLT5jb250ZW50c1tpZHhdOworfQorCitMSVNQX0lO TElORSBMaXNwX09iamVjdCAqCithcmVmX2FkZHIgKExpc3BfT2JqZWN0IGFycmF5LCBwdHJk aWZmX3QgaWR4KQoreworICByZXR1cm4gJiBYVkVDVE9SIChhcnJheSktPmNvbnRlbnRzW2lk eF07Cit9CisKK0xJU1BfSU5MSU5FIHB0cmRpZmZfdAorQVNJWkUgKExpc3BfT2JqZWN0IGFy cmF5KQoreworICByZXR1cm4gWFZFQ1RPUiAoYXJyYXkpLT5oZWFkZXIuc2l6ZTsKK30KKwor TElTUF9JTkxJTkUgdm9pZAorQVNFVCAoTGlzcF9PYmplY3QgYXJyYXksIHB0cmRpZmZfdCBp ZHgsIExpc3BfT2JqZWN0IHZhbCkKK3sKKyAgZWFzc2VydCAoMCA8PSBpZHggJiYgaWR4IDwg QVNJWkUgKGFycmF5KSk7CisgIFhWRUNUT1IgKGFycmF5KS0+Y29udGVudHNbaWR4XSA9IHZh bDsKK30KKworTElTUF9JTkxJTkUgdm9pZAorZ2NfYXNldCAoTGlzcF9PYmplY3QgYXJyYXks IHB0cmRpZmZfdCBpZHgsIExpc3BfT2JqZWN0IHZhbCkKK3sKKyAgLyogTGlrZSBBU0VULCBi dXQgYWxzbyBjYW4gYmUgdXNlZCBpbiB0aGUgZ2FyYmFnZSBjb2xsZWN0b3I6CisgICAgIHN3 ZWVwX3dlYWtfdGFibGUgY2FsbHMgc2V0X2hhc2hfa2V5IGV0Yy4gd2hpbGUgdGhlIHRhYmxl IGlzIG1hcmtlZC4gICovCisgIGVhc3NlcnQgKDAgPD0gaWR4ICYmIGlkeCA8IChBU0laRSAo YXJyYXkpICYgfkFSUkFZX01BUktfRkxBRykpOworICBYVkVDVE9SIChhcnJheSktPmNvbnRl bnRzW2lkeF0gPSB2YWw7Cit9CisKIC8qIElmIGEgc3RydWN0IGlzIG1hZGUgdG8gbG9vayBs aWtlIGEgdmVjdG9yLCB0aGlzIG1hY3JvIHJldHVybnMgdGhlIGxlbmd0aAogICAgb2YgdGhl IHNob3J0ZXN0IHZlY3RvciB0aGF0IHdvdWxkIGhvbGQgdGhhdCBzdHJ1Y3QuICAqLwogCkBA IC04ODcsNDMgKzEyNjMsNiBAQAogI2RlZmluZSBQU0VVRE9WRUNTSVpFKHR5cGUsIG5vbmxp c3BmaWVsZCkJCQlcCiAgICgob2Zmc2V0b2YgKHR5cGUsIG5vbmxpc3BmaWVsZCkgLSBoZWFk ZXJfc2l6ZSkgLyB3b3JkX3NpemUpCiAKLS8qIEEgY2hhci10YWJsZSBpcyBhIGtpbmQgb2Yg dmVjdG9ybGlrZSwgd2l0aCBjb250ZW50cyBhcmUgbGlrZSBhCi0gICB2ZWN0b3IgYnV0IHdp dGggYSBmZXcgb3RoZXIgc2xvdHMuICBGb3Igc29tZSBwdXJwb3NlcywgaXQgbWFrZXMKLSAg IHNlbnNlIHRvIGhhbmRsZSBhIGNoYXItdGFibGUgd2l0aCB0eXBlIHN0cnVjdCBMaXNwX1Zl Y3Rvci4gIEFuCi0gICBlbGVtZW50IG9mIGEgY2hhciB0YWJsZSBjYW4gYmUgYW55IExpc3Ag b2JqZWN0cywgYnV0IGlmIGl0IGlzIGEgc3ViCi0gICBjaGFyLXRhYmxlLCB3ZSB0cmVhdCBp dCBhIHRhYmxlIHRoYXQgY29udGFpbnMgaW5mb3JtYXRpb24gb2YgYQotICAgc3BlY2lmaWMg cmFuZ2Ugb2YgY2hhcmFjdGVycy4gIEEgc3ViIGNoYXItdGFibGUgaGFzIHRoZSBzYW1lCi0g ICBzdHJ1Y3R1cmUgYXMgYSB2ZWN0b3IuICBBIHN1YiBjaGFyIHRhYmxlIGFwcGVhcnMgb25s eSBpbiBhbiBlbGVtZW50Ci0gICBvZiBhIGNoYXItdGFibGUsIGFuZCB0aGVyZSdzIG5vIHdh eSB0byBhY2Nlc3MgaXQgZGlyZWN0bHkgZnJvbQotICAgRW1hY3MgTGlzcCBwcm9ncmFtLiAg Ki8KLQotI2lmZGVmIF9fR05VQ19fCi0KLSNkZWZpbmUgQ0hBUl9UQUJMRV9SRUZfQVNDSUko Q1QsIElEWCkJCQkJCVwKLSAgKHtzdHJ1Y3QgTGlzcF9DaGFyX1RhYmxlICpfdGJsID0gTlVM TDsJCQkJXAotICAgIExpc3BfT2JqZWN0IF92YWw7CQkJCQkJCVwKLSAgICBkbyB7CQkJCQkJ CQlcCi0gICAgICBfdGJsID0gX3RibCA/IFhDSEFSX1RBQkxFIChfdGJsLT5wYXJlbnQpIDog WENIQVJfVEFCTEUgKENUKTsJXAotICAgICAgX3ZhbCA9ICghIFNVQl9DSEFSX1RBQkxFX1Ag KF90YmwtPmFzY2lpKSA/IF90YmwtPmFzY2lpCQlcCi0JICAgICAgOiBYU1VCX0NIQVJfVEFC TEUgKF90YmwtPmFzY2lpKS0+Y29udGVudHNbSURYXSk7CQlcCi0gICAgICBpZiAoTklMUCAo X3ZhbCkpCQkJCQkJCVwKLQlfdmFsID0gX3RibC0+ZGVmYWx0OwkJCQkJCVwKLSAgICB9IHdo aWxlIChOSUxQIChfdmFsKSAmJiAhIE5JTFAgKF90YmwtPnBhcmVudCkpOwkJCVwKLSAgICBf dmFsOyB9KQotCi0jZWxzZSAgLyogbm90IF9fR05VQ19fICovCi0KLSNkZWZpbmUgQ0hBUl9U QUJMRV9SRUZfQVNDSUkoQ1QsIElEWCkJCQkJCSAgXAotICAoISBOSUxQIChYQ0hBUl9UQUJM RSAoQ1QpLT5hc2NpaSkJCQkJCSAgXAotICAgPyAoISBTVUJfQ0hBUl9UQUJMRV9QIChYQ0hB Ul9UQUJMRSAoQ1QpLT5hc2NpaSkJCQkgIFwKLSAgICAgID8gWENIQVJfVEFCTEUgKENUKS0+ YXNjaWkJCQkJCQkgIFwKLSAgICAgIDogISBOSUxQIChYU1VCX0NIQVJfVEFCTEUgKFhDSEFS X1RBQkxFIChDVCktPmFzY2lpKS0+Y29udGVudHNbSURYXSkgXAotICAgICAgPyBYU1VCX0NI QVJfVEFCTEUgKFhDSEFSX1RBQkxFIChDVCktPmFzY2lpKS0+Y29udGVudHNbSURYXQkgIFwK LSAgICAgIDogY2hhcl90YWJsZV9yZWYgKChDVCksIChJRFgpKSkJCQkJCSAgXAotICAgOiAg Y2hhcl90YWJsZV9yZWYgKChDVCksIChJRFgpKSkKLQotI2VuZGlmCS8qIG5vdCBfX0dOVUNf XyAqLwotCiAvKiBDb21wdXRlIEEgT1AgQiwgdXNpbmcgdGhlIHVuc2lnbmVkIGNvbXBhcmlz b24gb3BlcmF0b3IgT1AuICBBIGFuZCBCCiAgICBzaG91bGQgYmUgaW50ZWdlciBleHByZXNz aW9ucy4gIFRoaXMgaXMgbm90IHRoZSBzYW1lIGFzCiAgICBtYXRoZW1hdGljYWwgY29tcGFy aXNvbjsgZm9yIGV4YW1wbGUsIFVOU0lHTkVEX0NNUCAoMCwgPCwgLTEpCkBAIC05MzcsMTgg KzEyNzYsMTUgQEAKIC8qIE5vbnplcm8gaWZmIEMgaXMgYW4gQVNDSUkgY2hhcmFjdGVyLiAg Ki8KICNkZWZpbmUgQVNDSUlfQ0hBUl9QKGMpIFVOU0lHTkVEX0NNUCAoYywgPCwgMHg4MCkK IAotLyogQWxtb3N0IGVxdWl2YWxlbnQgdG8gRmFyZWYgKENULCBJRFgpIHdpdGggb3B0aW1p emF0aW9uIGZvciBBU0NJSQotICAgY2hhcmFjdGVycy4gIERvIG5vdCBjaGVjayB2YWxpZGl0 eSBvZiBDVC4gICovCi0jZGVmaW5lIENIQVJfVEFCTEVfUkVGKENULCBJRFgpCQkJCQlcCi0g IChBU0NJSV9DSEFSX1AgKElEWCkgPyBDSEFSX1RBQkxFX1JFRl9BU0NJSSAoKENUKSwgKElE WCkpCVwKLSAgIDogY2hhcl90YWJsZV9yZWYgKChDVCksIChJRFgpKSkKLQotLyogRXF1aXZh bGVudCB0byBGYXNldCAoQ1QsIElEWCwgVkFMKSB3aXRoIG9wdGltaXphdGlvbiBmb3IgQVND SUkgYW5kCi0gICA4LWJpdCBFdXJvcGVhbiBjaGFyYWN0ZXJzLiAgRG8gbm90IGNoZWNrIHZh bGlkaXR5IG9mIENULiAgKi8KLSNkZWZpbmUgQ0hBUl9UQUJMRV9TRVQoQ1QsIElEWCwgVkFM KQkJCQkJXAotICAoQVNDSUlfQ0hBUl9QIChJRFgpICYmIFNVQl9DSEFSX1RBQkxFX1AgKFhD SEFSX1RBQkxFIChDVCktPmFzY2lpKQlcCi0gICA/IHNldF9zdWJfY2hhcl90YWJsZV9jb250 ZW50cyAoWENIQVJfVEFCTEUgKENUKS0+YXNjaWksIElEWCwgVkFMKQlcCi0gICA6IGNoYXJf dGFibGVfc2V0IChDVCwgSURYLCBWQUwpKQorLyogQSBjaGFyLXRhYmxlIGlzIGEga2luZCBv ZiB2ZWN0b3JsaWtlLCB3aXRoIGNvbnRlbnRzIGFyZSBsaWtlIGEKKyAgIHZlY3RvciBidXQg d2l0aCBhIGZldyBvdGhlciBzbG90cy4gIEZvciBzb21lIHB1cnBvc2VzLCBpdCBtYWtlcwor ICAgc2Vuc2UgdG8gaGFuZGxlIGEgY2hhci10YWJsZSB3aXRoIHR5cGUgc3RydWN0IExpc3Bf VmVjdG9yLiAgQW4KKyAgIGVsZW1lbnQgb2YgYSBjaGFyIHRhYmxlIGNhbiBiZSBhbnkgTGlz cCBvYmplY3RzLCBidXQgaWYgaXQgaXMgYSBzdWIKKyAgIGNoYXItdGFibGUsIHdlIHRyZWF0 IGl0IGEgdGFibGUgdGhhdCBjb250YWlucyBpbmZvcm1hdGlvbiBvZiBhCisgICBzcGVjaWZp YyByYW5nZSBvZiBjaGFyYWN0ZXJzLiAgQSBzdWIgY2hhci10YWJsZSBoYXMgdGhlIHNhbWUK KyAgIHN0cnVjdHVyZSBhcyBhIHZlY3Rvci4gIEEgc3ViIGNoYXIgdGFibGUgYXBwZWFycyBv bmx5IGluIGFuIGVsZW1lbnQKKyAgIG9mIGEgY2hhci10YWJsZSwgYW5kIHRoZXJlJ3Mgbm8g d2F5IHRvIGFjY2VzcyBpdCBkaXJlY3RseSBmcm9tCisgICBFbWFjcyBMaXNwIHByb2dyYW0u ICAqLwogCiBlbnVtIENIQVJUQUJfU0laRV9CSVRTCiAgIHsKQEAgLTEwMTIsNiArMTM0OCw0 NSBAQAogICAgIExpc3BfT2JqZWN0IGNvbnRlbnRzWzFdOwogICB9OwogCitMSVNQX0lOTElO RSBMaXNwX09iamVjdAorQ0hBUl9UQUJMRV9SRUZfQVNDSUkgKExpc3BfT2JqZWN0IGN0LCBw dHJkaWZmX3QgaWR4KQoreworICBzdHJ1Y3QgTGlzcF9DaGFyX1RhYmxlICp0YmwgPSBOVUxM OworICBMaXNwX09iamVjdCB2YWw7CisgIGRvCisgICAgeworICAgICAgdGJsID0gdGJsID8g WENIQVJfVEFCTEUgKHRibC0+cGFyZW50KSA6IFhDSEFSX1RBQkxFIChjdCk7CisgICAgICB2 YWwgPSAoISBTVUJfQ0hBUl9UQUJMRV9QICh0YmwtPmFzY2lpKSA/IHRibC0+YXNjaWkKKwkg ICAgIDogWFNVQl9DSEFSX1RBQkxFICh0YmwtPmFzY2lpKS0+Y29udGVudHNbaWR4XSk7Cisg ICAgICBpZiAoTklMUCAodmFsKSkKKwl2YWwgPSB0YmwtPmRlZmFsdDsKKyAgICB9CisgIHdo aWxlIChOSUxQICh2YWwpICYmICEgTklMUCAodGJsLT5wYXJlbnQpKTsKKworICByZXR1cm4g dmFsOworfQorCisvKiBBbG1vc3QgZXF1aXZhbGVudCB0byBGYXJlZiAoQ1QsIElEWCkgd2l0 aCBvcHRpbWl6YXRpb24gZm9yIEFTQ0lJCisgICBjaGFyYWN0ZXJzLiAgRG8gbm90IGNoZWNr IHZhbGlkaXR5IG9mIENULiAgKi8KK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0CitDSEFSX1RB QkxFX1JFRiAoTGlzcF9PYmplY3QgY3QsIGludCBpZHgpCit7CisgIHJldHVybiAoQVNDSUlf Q0hBUl9QIChpZHgpCisJICA/IENIQVJfVEFCTEVfUkVGX0FTQ0lJIChjdCwgaWR4KQorCSAg OiBjaGFyX3RhYmxlX3JlZiAoY3QsIGlkeCkpOworfQorCisvKiBFcXVpdmFsZW50IHRvIEZh c2V0IChDVCwgSURYLCBWQUwpIHdpdGggb3B0aW1pemF0aW9uIGZvciBBU0NJSSBhbmQKKyAg IDgtYml0IEV1cm9wZWFuIGNoYXJhY3RlcnMuICBEbyBub3QgY2hlY2sgdmFsaWRpdHkgb2Yg Q1QuICAqLworTElTUF9JTkxJTkUgdm9pZAorQ0hBUl9UQUJMRV9TRVQgKExpc3BfT2JqZWN0 IGN0LCBpbnQgaWR4LCBMaXNwX09iamVjdCB2YWwpCit7CisgIGlmIChBU0NJSV9DSEFSX1Ag KGlkeCkgJiYgU1VCX0NIQVJfVEFCTEVfUCAoWENIQVJfVEFCTEUgKGN0KS0+YXNjaWkpKQor ICAgIHNldF9zdWJfY2hhcl90YWJsZV9jb250ZW50cyAoWENIQVJfVEFCTEUgKGN0KS0+YXNj aWksIGlkeCwgdmFsKTsKKyAgZWxzZQorICAgIGNoYXJfdGFibGVfc2V0IChjdCwgaWR4LCB2 YWwpOworfQorCiAvKiBUaGlzIHN0cnVjdHVyZSBkZXNjcmliZXMgYSBidWlsdC1pbiBmdW5j dGlvbi4KICAgIEl0IGlzIGdlbmVyYXRlZCBieSB0aGUgREVGVU4gbWFjcm8gb25seS4KICAg IGRlZnN1YnIgbWFrZXMgaXQgaW50byBhIExpc3Agb2JqZWN0LiAgKi8KQEAgLTEwNDgsOCAr MTQyMywxMiBAQAogCiAvKiBSZXR1cm4gdGhlIG51bWJlciBvZiAiZXh0cmEiIHNsb3RzIGlu IHRoZSBjaGFyIHRhYmxlIENULiAgKi8KIAotI2RlZmluZSBDSEFSX1RBQkxFX0VYVFJBX1NM T1RTKENUKQlcCi0gICgoKENUKS0+aGVhZGVyLnNpemUgJiBQU0VVRE9WRUNUT1JfU0laRV9N QVNLKSAtIENIQVJfVEFCTEVfU1RBTkRBUkRfU0xPVFMpCitMSVNQX0lOTElORSBpbnQKK0NI QVJfVEFCTEVfRVhUUkFfU0xPVFMgKHN0cnVjdCBMaXNwX0NoYXJfVGFibGUgKmN0KQorewor ICByZXR1cm4gKChjdC0+aGVhZGVyLnNpemUgJiBQU0VVRE9WRUNUT1JfU0laRV9NQVNLKQor CSAgLSBDSEFSX1RBQkxFX1NUQU5EQVJEX1NMT1RTKTsKK30KIAogDAogLyoqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqCkBAIC0xMTIxLDQwICsxNTAwLDg0IEBACiAKIC8qIFZhbHVlIGlzIG5hbWUgb2Yg c3ltYm9sLiAgKi8KIAotI2RlZmluZSBTWU1CT0xfVkFMKHN5bSkJCQkJCQkJXAotICAoZWFz c2VydCAoKHN5bSktPnJlZGlyZWN0ID09IFNZTUJPTF9QTEFJTlZBTCksICBzeW0tPnZhbC52 YWx1ZSkKLSNkZWZpbmUgU1lNQk9MX0FMSUFTKHN5bSkJCQkJCQlcCi0gIChlYXNzZXJ0ICgo c3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9MX1ZBUkFMSUFTKSwgIChzeW0pLT52YWwuYWxpYXMp Ci0jZGVmaW5lIFNZTUJPTF9CTFYoc3ltKQkJCQkJCQlcCi0gIChlYXNzZXJ0ICgoc3ltKS0+ cmVkaXJlY3QgPT0gU1lNQk9MX0xPQ0FMSVpFRCksIChzeW0pLT52YWwuYmx2KQotI2RlZmlu ZSBTWU1CT0xfRldEKHN5bSkJCQkJCQkJXAotICAoZWFzc2VydCAoKHN5bSktPnJlZGlyZWN0 ID09IFNZTUJPTF9GT1JXQVJERUQpLCAoc3ltKS0+dmFsLmZ3ZCkKLSNkZWZpbmUgU0VUX1NZ TUJPTF9WQUwoc3ltLCB2KQkJCQkJCVwKLSAgKGVhc3NlcnQgKChzeW0pLT5yZWRpcmVjdCA9 PSBTWU1CT0xfUExBSU5WQUwpLCAgKHN5bSktPnZhbC52YWx1ZSA9ICh2KSkKLSNkZWZpbmUg U0VUX1NZTUJPTF9BTElBUyhzeW0sIHYpCQkJCQlcCi0gIChlYXNzZXJ0ICgoc3ltKS0+cmVk aXJlY3QgPT0gU1lNQk9MX1ZBUkFMSUFTKSwgIChzeW0pLT52YWwuYWxpYXMgPSAodikpCi0j ZGVmaW5lIFNFVF9TWU1CT0xfQkxWKHN5bSwgdikJCQkJCQlcCi0gIChlYXNzZXJ0ICgoc3lt KS0+cmVkaXJlY3QgPT0gU1lNQk9MX0xPQ0FMSVpFRCksIChzeW0pLT52YWwuYmx2ID0gKHYp KQotI2RlZmluZSBTRVRfU1lNQk9MX0ZXRChzeW0sIHYpCQkJCQkJXAotICAoZWFzc2VydCAo KHN5bSktPnJlZGlyZWN0ID09IFNZTUJPTF9GT1JXQVJERUQpLCAoc3ltKS0+dmFsLmZ3ZCA9 ICh2KSkKLQotI2RlZmluZSBTWU1CT0xfTkFNRShzeW0pIFhTWU1CT0wgKHN5bSktPm5hbWUK LQotLyogVmFsdWUgaXMgbm9uLXplcm8gaWYgU1lNIGlzIGFuIGludGVybmVkIHN5bWJvbC4g ICovCi0KLSNkZWZpbmUgU1lNQk9MX0lOVEVSTkVEX1Aoc3ltKQkJCQlcCi0gIChYU1lNQk9M IChzeW0pLT5pbnRlcm5lZCAhPSBTWU1CT0xfVU5JTlRFUk5FRCkKLQotLyogVmFsdWUgaXMg bm9uLXplcm8gaWYgU1lNIGlzIGludGVybmVkIGluIGluaXRpYWxfb2JhcnJheS4gICovCi0K LSNkZWZpbmUgU1lNQk9MX0lOVEVSTkVEX0lOX0lOSVRJQUxfT0JBUlJBWV9QKHN5bSkJCQlc Ci0gIChYU1lNQk9MIChzeW0pLT5pbnRlcm5lZCA9PSBTWU1CT0xfSU5URVJORURfSU5fSU5J VElBTF9PQkFSUkFZKQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKKyhTWU1CT0xfVkFMKSAo c3RydWN0IExpc3BfU3ltYm9sICpzeW0pCit7CisgIHJldHVybiBsaXNwX2hfU1lNQk9MX1ZB TCAoc3ltKTsKK30KK0xJU1BfSU5MSU5FIHN0cnVjdCBMaXNwX1N5bWJvbCAqCitTWU1CT0xf QUxJQVMgKHN0cnVjdCBMaXNwX1N5bWJvbCAqc3ltKQoreworICBlYXNzZXJ0IChzeW0tPnJl ZGlyZWN0ID09IFNZTUJPTF9WQVJBTElBUyk7CisgIHJldHVybiBzeW0tPnZhbC5hbGlhczsK K30KK0xJU1BfSU5MSU5FIHN0cnVjdCBMaXNwX0J1ZmZlcl9Mb2NhbF9WYWx1ZSAqCitTWU1C T0xfQkxWIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSkKK3sKKyAgZWFzc2VydCAoc3ltLT5y ZWRpcmVjdCA9PSBTWU1CT0xfTE9DQUxJWkVEKTsKKyAgcmV0dXJuIHN5bS0+dmFsLmJsdjsK K30KK0xJU1BfSU5MSU5FIHVuaW9uIExpc3BfRndkICoKK1NZTUJPTF9GV0QgKHN0cnVjdCBM aXNwX1N5bWJvbCAqc3ltKQoreworICBlYXNzZXJ0IChzeW0tPnJlZGlyZWN0ID09IFNZTUJP TF9GT1JXQVJERUQpOworICByZXR1cm4gc3ltLT52YWwuZndkOworfQorTElTUF9JTkxJTkUg dm9pZAorKFNFVF9TWU1CT0xfVkFMKSAoc3RydWN0IExpc3BfU3ltYm9sICpzeW0sIExpc3Bf T2JqZWN0IHYpCit7CisgIGxpc3BfaF9TRVRfU1lNQk9MX1ZBTCAoc3ltLCB2KTsKK30KK0xJ U1BfSU5MSU5FIHZvaWQKK1NFVF9TWU1CT0xfQUxJQVMgKHN0cnVjdCBMaXNwX1N5bWJvbCAq c3ltLCBzdHJ1Y3QgTGlzcF9TeW1ib2wgKnYpCit7CisgIGVhc3NlcnQgKHN5bS0+cmVkaXJl Y3QgPT0gU1lNQk9MX1ZBUkFMSUFTKTsKKyAgc3ltLT52YWwuYWxpYXMgPSB2OworfQorTElT UF9JTkxJTkUgdm9pZAorU0VUX1NZTUJPTF9CTFYgKHN0cnVjdCBMaXNwX1N5bWJvbCAqc3lt LCBzdHJ1Y3QgTGlzcF9CdWZmZXJfTG9jYWxfVmFsdWUgKnYpCit7CisgIGVhc3NlcnQgKHN5 bS0+cmVkaXJlY3QgPT0gU1lNQk9MX0xPQ0FMSVpFRCk7CisgIHN5bS0+dmFsLmJsdiA9IHY7 Cit9CitMSVNQX0lOTElORSB2b2lkCitTRVRfU1lNQk9MX0ZXRCAoc3RydWN0IExpc3BfU3lt Ym9sICpzeW0sIHVuaW9uIExpc3BfRndkICp2KQoreworICBlYXNzZXJ0IChzeW0tPnJlZGly ZWN0ID09IFNZTUJPTF9GT1JXQVJERUQpOworICBzeW0tPnZhbC5md2QgPSB2OworfQorCitM SVNQX0lOTElORSBMaXNwX09iamVjdAorU1lNQk9MX05BTUUgKExpc3BfT2JqZWN0IHN5bSkK K3sKKyAgcmV0dXJuIFhTWU1CT0wgKHN5bSktPm5hbWU7Cit9CisKKy8qIFZhbHVlIGlzIHRy dWUgaWYgU1lNIGlzIGFuIGludGVybmVkIHN5bWJvbC4gICovCisKK0xJU1BfSU5MSU5FIGJv b2wKK1NZTUJPTF9JTlRFUk5FRF9QIChMaXNwX09iamVjdCBzeW0pCit7CisgIHJldHVybiBY U1lNQk9MIChzeW0pLT5pbnRlcm5lZCAhPSBTWU1CT0xfVU5JTlRFUk5FRDsKK30KKworLyog VmFsdWUgaXMgdHJ1ZSBpZiBTWU0gaXMgaW50ZXJuZWQgaW4gaW5pdGlhbF9vYmFycmF5LiAg Ki8KKworTElTUF9JTkxJTkUgYm9vbAorU1lNQk9MX0lOVEVSTkVEX0lOX0lOSVRJQUxfT0JB UlJBWV9QIChMaXNwX09iamVjdCBzeW0pCit7CisgIHJldHVybiBYU1lNQk9MIChzeW0pLT5p bnRlcm5lZCA9PSBTWU1CT0xfSU5URVJORURfSU5fSU5JVElBTF9PQkFSUkFZOworfQogCiAv KiBWYWx1ZSBpcyBub24temVybyBpZiBzeW1ib2wgaXMgY29uc2lkZXJlZCBhIGNvbnN0YW50 LCBpLmUuIGl0cwogICAgdmFsdWUgY2Fubm90IGJlIGNoYW5nZWQgKHRoZXJlIGlzIGFuIGV4 Y2VwdGlvbiBmb3Iga2V5d29yZCBzeW1ib2xzLAogICAgd2hvc2UgdmFsdWUgY2FuIGJlIHNl dCB0byB0aGUga2V5d29yZCBzeW1ib2wgaXRzZWxmKS4gICovCiAKLSNkZWZpbmUgU1lNQk9M X0NPTlNUQU5UX1Aoc3ltKSBYU1lNQk9MIChzeW0pLT5jb25zdGFudAorTElTUF9JTkxJTkUg aW50CisoU1lNQk9MX0NPTlNUQU5UX1ApIChMaXNwX09iamVjdCBzeW0pCit7CisgIHJldHVy biBsaXNwX2hfU1lNQk9MX0NPTlNUQU5UX1AgKHN5bSk7Cit9CiAKICNkZWZpbmUgREVGU1lN KHN5bSwgbmFtZSkJCQkJCQlcCiAgIGRvIHsgKHN5bSkgPSBpbnRlcm5fY19zdHJpbmcgKChu YW1lKSk7IHN0YXRpY3BybyAoJihzeW0pKTsgfSB3aGlsZSAoMCkKQEAgLTEyNDAsNDIgKzE2 NjMsNjkgQEAKIH07CiAKIAotI2RlZmluZSBYSEFTSF9UQUJMRShPQkopIFwKLSAgICAgKChz dHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICopIFhVTlRBRyAoT0JKLCBMaXNwX1ZlY3Rvcmxpa2Up KQorTElTUF9JTkxJTkUgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqCitYSEFTSF9UQUJMRSAo TGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtl KTsKK30KIAogI2RlZmluZSBYU0VUX0hBU0hfVEFCTEUoVkFSLCBQVFIpIFwKICAgICAgKFhT RVRQU0VVRE9WRUNUT1IgKFZBUiwgUFRSLCBQVkVDX0hBU0hfVEFCTEUpKQogCi0jZGVmaW5l IEhBU0hfVEFCTEVfUChPQkopICBQU0VVRE9WRUNUT1JQIChPQkosIFBWRUNfSEFTSF9UQUJM RSkKLQotI2RlZmluZSBDSEVDS19IQVNIX1RBQkxFKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoSEFT SF9UQUJMRV9QICh4KSwgUWhhc2hfdGFibGVfcCwgeCkKK0xJU1BfSU5MSU5FIGJvb2wKK0hB U0hfVEFCTEVfUCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAg KGEsIFBWRUNfSEFTSF9UQUJMRSk7Cit9CitMSVNQX0lOTElORSB2b2lkCitDSEVDS19IQVNI X1RBQkxFIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4gQ0hFQ0tfVFlQRSAoSEFTSF9U QUJMRV9QICh4KSwgUWhhc2hfdGFibGVfcCwgeCk7Cit9CiAKIC8qIFZhbHVlIGlzIHRoZSBr ZXkgcGFydCBvZiBlbnRyeSBJRFggaW4gaGFzaCB0YWJsZSBILiAgKi8KLQotI2RlZmluZSBI QVNIX0tFWShILCBJRFgpICAgQVJFRiAoKEgpLT5rZXlfYW5kX3ZhbHVlLCAyICogKElEWCkp CitMSVNQX0lOTElORSBMaXNwX09iamVjdAorSEFTSF9LRVkgKHN0cnVjdCBMaXNwX0hhc2hf VGFibGUgKmgsIHB0cmRpZmZfdCBpZHgpCit7CisgIHJldHVybiBBUkVGIChoLT5rZXlfYW5k X3ZhbHVlLCAyICogaWR4KTsKK30KIAogLyogVmFsdWUgaXMgdGhlIHZhbHVlIHBhcnQgb2Yg ZW50cnkgSURYIGluIGhhc2ggdGFibGUgSC4gICovCi0KLSNkZWZpbmUgSEFTSF9WQUxVRShI LCBJRFgpIEFSRUYgKChIKS0+a2V5X2FuZF92YWx1ZSwgMiAqIChJRFgpICsgMSkKK0xJU1Bf SU5MSU5FIExpc3BfT2JqZWN0CitIQVNIX1ZBTFVFIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxl ICpoLCBwdHJkaWZmX3QgaWR4KQoreworICByZXR1cm4gQVJFRiAoaC0+a2V5X2FuZF92YWx1 ZSwgMiAqIGlkeCArIDEpOworfQogCiAvKiBWYWx1ZSBpcyB0aGUgaW5kZXggb2YgdGhlIG5l eHQgZW50cnkgZm9sbG93aW5nIHRoZSBvbmUgYXQgSURYCiAgICBpbiBoYXNoIHRhYmxlIEgu ICAqLwotCi0jZGVmaW5lIEhBU0hfTkVYVChILCBJRFgpICBBUkVGICgoSCktPm5leHQsIChJ RFgpKQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK0hBU0hfTkVYVCAoc3RydWN0IExpc3Bf SGFzaF9UYWJsZSAqaCwgcHRyZGlmZl90IGlkeCkKK3sKKyAgcmV0dXJuIEFSRUYgKGgtPm5l eHQsIGlkeCk7Cit9CiAKIC8qIFZhbHVlIGlzIHRoZSBoYXNoIGNvZGUgY29tcHV0ZWQgZm9y IGVudHJ5IElEWCBpbiBoYXNoIHRhYmxlIEguICAqLwotCi0jZGVmaW5lIEhBU0hfSEFTSChI LCBJRFgpICBBUkVGICgoSCktPmhhc2gsIChJRFgpKQorTElTUF9JTkxJTkUgTGlzcF9PYmpl Y3QKK0hBU0hfSEFTSCAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgcHRyZGlmZl90IGlk eCkKK3sKKyAgcmV0dXJuIEFSRUYgKGgtPmhhc2gsIGlkeCk7Cit9CiAKIC8qIFZhbHVlIGlz IHRoZSBpbmRleCBvZiB0aGUgZWxlbWVudCBpbiBoYXNoIHRhYmxlIEggdGhhdCBpcyB0aGUK ICAgIHN0YXJ0IG9mIHRoZSBjb2xsaXNpb24gbGlzdCBhdCBpbmRleCBJRFggaW4gdGhlIGlu ZGV4IHZlY3RvciBvZiBILiAgKi8KLQotI2RlZmluZSBIQVNIX0lOREVYKEgsIElEWCkgIEFS RUYgKChIKS0+aW5kZXgsIChJRFgpKQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK0hBU0hf SU5ERVggKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIHB0cmRpZmZfdCBpZHgpCit7Cisg IHJldHVybiBBUkVGIChoLT5pbmRleCwgaWR4KTsKK30KIAogLyogVmFsdWUgaXMgdGhlIHNp emUgb2YgaGFzaCB0YWJsZSBILiAgKi8KLQotI2RlZmluZSBIQVNIX1RBQkxFX1NJWkUoSCkg QVNJWkUgKChIKS0+bmV4dCkKK0xJU1BfSU5MSU5FIHB0cmRpZmZfdAorSEFTSF9UQUJMRV9T SVpFIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoKQoreworICByZXR1cm4gQVNJWkUgKGgt Pm5leHQpOworfQogCiAvKiBEZWZhdWx0IHNpemUgZm9yIGhhc2ggdGFibGVzIGlmIG5vdCBz cGVjaWZpZWQuICAqLwogCkBAIC0xNDg1LDYgKzE5MzUsNTMgQEAKICAgICB9IGRhdGFbU0FW RV9WQUxVRV9TTE9UU107CiAgIH07CiAKKy8qIFJldHVybiB0aGUgdHlwZSBvZiBWJ3MgTnRo IHNhdmVkIHZhbHVlLiAgKi8KK0xJU1BfSU5MSU5FIGludAorc2F2ZV90eXBlIChzdHJ1Y3Qg TGlzcF9TYXZlX1ZhbHVlICp2LCBpbnQgbikKK3sKKyAgZWFzc2VydCAoMCA8PSBuICYmIG4g PCBTQVZFX1ZBTFVFX1NMT1RTKTsKKyAgcmV0dXJuICh2LT5zYXZlX3R5cGUgPj4gKFNBVkVf U0xPVF9CSVRTICogbikgJiAoKDEgPDwgU0FWRV9TTE9UX0JJVFMpIC0gMSkpOworfQorCisv KiBHZXQgYW5kIHNldCB0aGUgTnRoIHNhdmVkIHBvaW50ZXIuICAqLworCitMSVNQX0lOTElO RSB2b2lkICoKK1hTQVZFX1BPSU5URVIgKExpc3BfT2JqZWN0IG9iaiwgaW50IG4pCit7Cisg IGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUgKG9iaiksIG4pID09IFNBVkVfUE9J TlRFUik7CisgIHJldHVybiBYU0FWRV9WQUxVRSAob2JqKS0+ZGF0YVtuXS5wb2ludGVyOzsK K30KK0xJU1BfSU5MSU5FIHZvaWQKK3NldF9zYXZlX3BvaW50ZXIgKExpc3BfT2JqZWN0IG9i aiwgaW50IG4sIHZvaWQgKnZhbCkKK3sKKyAgZWFzc2VydCAoc2F2ZV90eXBlIChYU0FWRV9W QUxVRSAob2JqKSwgbikgPT0gU0FWRV9QT0lOVEVSKTsKKyAgWFNBVkVfVkFMVUUgKG9iaikt PmRhdGFbbl0ucG9pbnRlciA9IHZhbDsKK30KKworLyogTGlrZXdpc2UgZm9yIHRoZSBzYXZl ZCBpbnRlZ2VyLiAgKi8KKworTElTUF9JTkxJTkUgcHRyZGlmZl90CitYU0FWRV9JTlRFR0VS IChMaXNwX09iamVjdCBvYmosIGludCBuKQoreworICBlYXNzZXJ0IChzYXZlX3R5cGUgKFhT QVZFX1ZBTFVFIChvYmopLCBuKSA9PSBTQVZFX0lOVEVHRVIpOworICByZXR1cm4gWFNBVkVf VkFMVUUgKG9iaiktPmRhdGFbbl0uaW50ZWdlcjsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK3Nl dF9zYXZlX2ludGVnZXIgKExpc3BfT2JqZWN0IG9iaiwgaW50IG4sIHB0cmRpZmZfdCB2YWwp Cit7CisgIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUgKG9iaiksIG4pID09IFNB VkVfSU5URUdFUik7CisgIFhTQVZFX1ZBTFVFIChvYmopLT5kYXRhW25dLmludGVnZXIgPSB2 YWw7Cit9CisKKy8qIEV4dHJhY3QgTnRoIHNhdmVkIG9iamVjdC4gICovCisKK0xJU1BfSU5M SU5FIExpc3BfT2JqZWN0CitYU0FWRV9PQkpFQ1QgKExpc3BfT2JqZWN0IG9iaiwgaW50IG4p Cit7CisgIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUgKG9iaiksIG4pID09IFNB VkVfT0JKRUNUKTsKKyAgcmV0dXJuIFhTQVZFX1ZBTFVFIChvYmopLT5kYXRhW25dLm9iamVj dDsKK30KKwogLyogQSBtaXNjZWxsYW5lb3VzIG9iamVjdCwgd2hlbiBpdCdzIG9uIHRoZSBm cmVlIGxpc3QuICAqLwogc3RydWN0IExpc3BfRnJlZQogICB7CkBAIC0xNTA2LDYgKzIwMDMs NDYgQEAKICAgICBzdHJ1Y3QgTGlzcF9TYXZlX1ZhbHVlIHVfc2F2ZV92YWx1ZTsKICAgfTsK IAorTElTUF9JTkxJTkUgdW5pb24gTGlzcF9NaXNjICoKK1hNSVNDIChMaXNwX09iamVjdCBh KQoreworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX01pc2MpOworfQorCitMSVNQX0lOTElO RSBzdHJ1Y3QgTGlzcF9NaXNjX0FueSAqCitYTUlTQ0FOWSAoTGlzcF9PYmplY3QgYSkKK3sK KyAgZWFzc2VydCAoTUlTQ1AgKGEpKTsKKyAgcmV0dXJuICYgWE1JU0MgKGEpLT51X2FueTsK K30KKworTElTUF9JTkxJTkUgZW51bSBMaXNwX01pc2NfVHlwZQorWE1JU0NUWVBFIChMaXNw X09iamVjdCBhKQoreworICByZXR1cm4gWE1JU0NBTlkgKGEpLT50eXBlOworfQorCitMSVNQ X0lOTElORSBzdHJ1Y3QgTGlzcF9NYXJrZXIgKgorWE1BUktFUiAoTGlzcF9PYmplY3QgYSkK K3sKKyAgZWFzc2VydCAoTUFSS0VSUCAoYSkpOworICByZXR1cm4gJiBYTUlTQyAoYSktPnVf bWFya2VyOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9PdmVybGF5ICoKK1hPVkVS TEFZIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChPVkVSTEFZUCAoYSkpOworICBy ZXR1cm4gJiBYTUlTQyAoYSktPnVfb3ZlcmxheTsKK30KKworTElTUF9JTkxJTkUgc3RydWN0 IExpc3BfU2F2ZV9WYWx1ZSAqCitYU0FWRV9WQUxVRSAoTGlzcF9PYmplY3QgYSkKK3sKKyAg ZWFzc2VydCAoU0FWRV9WQUxVRVAgKGEpKTsKKyAgcmV0dXJuICYgWE1JU0MgKGEpLT51X3Nh dmVfdmFsdWU7Cit9CisMCiAvKiBGb3J3YXJkaW5nIHBvaW50ZXIgdG8gYW4gaW50IHZhcmlh YmxlLgogICAgVGhpcyBpcyBhbGxvd2VkIG9ubHkgaW4gdGhlIHZhbHVlIGNlbGwgb2YgYSBz eW1ib2wsCiAgICBhbmQgaXQgbWVhbnMgdGhhdCB0aGUgc3ltYm9sJ3MgdmFsdWUgcmVhbGx5 IGxpdmVzIGluIHRoZQpAQCAtMTYxMiw2ICsyMTQ5LDQ3IEBACiAgICAgc3RydWN0IExpc3Bf QnVmZmVyX09iamZ3ZCB1X2J1ZmZlcl9vYmpmd2Q7CiAgICAgc3RydWN0IExpc3BfS2JvYXJk X09iamZ3ZCB1X2tib2FyZF9vYmpmd2Q7CiAgIH07CisKK0xJU1BfSU5MSU5FIGVudW0gTGlz cF9Gd2RfVHlwZQorWEZXRFRZUEUgKHVuaW9uIExpc3BfRndkICphKQoreworICByZXR1cm4g YS0+dV9pbnRmd2QudHlwZTsKK30KKworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfSW50Zndk ICoKK1hJTlRGV0QgKHVuaW9uIExpc3BfRndkICphKQoreworICBlYXNzZXJ0IChJTlRGV0RQ IChhKSk7CisgIHJldHVybiAmYS0+dV9pbnRmd2Q7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVj dCBMaXNwX0Jvb2xmd2QgKgorWEJPT0xGV0QgKHVuaW9uIExpc3BfRndkICphKQoreworICBl YXNzZXJ0IChCT09MRldEUCAoYSkpOworICByZXR1cm4gJmEtPnVfYm9vbGZ3ZDsKK30KKwor TElTUF9JTkxJTkUgc3RydWN0IExpc3BfT2JqZndkICoKK1hPQkpGV0QgKHVuaW9uIExpc3Bf RndkICphKQoreworICBlYXNzZXJ0IChPQkpGV0RQIChhKSk7CisgIHJldHVybiAmYS0+dV9v Ympmd2Q7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVjdCBMaXNwX0J1ZmZlcl9PYmpmd2QgKgor WEJVRkZFUl9PQkpGV0QgKHVuaW9uIExpc3BfRndkICphKQoreworICBlYXNzZXJ0IChCVUZG RVJfT0JKRldEUCAoYSkpOworICByZXR1cm4gJmEtPnVfYnVmZmVyX29iamZ3ZDsKK30KKwor TElTUF9JTkxJTkUgc3RydWN0IExpc3BfS2JvYXJkX09iamZ3ZCAqCitYS0JPQVJEX09CSkZX RCAodW5pb24gTGlzcF9Gd2QgKmEpCit7CisgIGVhc3NlcnQgKEtCT0FSRF9PQkpGV0RQIChh KSk7CisgIHJldHVybiAmYS0+dV9rYm9hcmRfb2JqZndkOworfQogDAogLyogTGlzcCBmbG9h dGluZyBwb2ludCB0eXBlLiAgKi8KIHN0cnVjdCBMaXNwX0Zsb2F0CkBAIC0xNjIzLDggKzIy MDEsMTcgQEAKICAgICB9IHU7CiAgIH07CiAKLSNkZWZpbmUgWEZMT0FUX0RBVEEoZikgKDAg PyBYRkxPQVQgKGYpLT51LmRhdGEgOiAgWEZMT0FUIChmKS0+dS5kYXRhKQotI2RlZmluZSBY RkxPQVRfSU5JVChmLCBuKSAoWEZMT0FUIChmKS0+dS5kYXRhID0gKG4pKQorTElTUF9JTkxJ TkUgZG91YmxlCitYRkxPQVRfREFUQSAoTGlzcF9PYmplY3QgZikKK3sKKyAgcmV0dXJuIFhG TE9BVCAoZiktPnUuZGF0YTsKK30KKworTElTUF9JTkxJTkUgdm9pZAorWEZMT0FUX0lOSVQg KExpc3BfT2JqZWN0IGYsIGRvdWJsZSBuKQoreworICBYRkxPQVQgKGYpLT51LmRhdGEgPSBu OworfQogCiAvKiBNb3N0IGhvc3RzIG5vd2FkYXlzIHVzZSBJRUVFIGZsb2F0aW5nIHBvaW50 LCBzbyB0aGV5IHVzZSBJRUMgNjA1NTkKICAgIHJlcHJlc2VudGF0aW9ucywgaGF2ZSBpbmZp bml0aWVzIGFuZCBOYU5zLCBhbmQgZG8gbm90IHRyYXAgb24KQEAgLTE2MzMsOCArMjIyMCwx MiBAQAogICAgd2FudGVkIGhlcmUsIGJ1dCBpcyBub3QgcXVpdGUgcmlnaHQgYmVjYXVzZSBF bWFjcyBkb2VzIG5vdCByZXF1aXJlCiAgICBhbGwgdGhlIGZlYXR1cmVzIG9mIEMxMSBBbm5l eCBGIChhbmQgZG9lcyBub3QgcmVxdWlyZSBDMTEgYXQgYWxsLAogICAgZm9yIHRoYXQgbWF0 dGVyKS4gICovCi0jZGVmaW5lIElFRUVfRkxPQVRJTkdfUE9JTlQgKEZMVF9SQURJWCA9PSAy ICYmIEZMVF9NQU5UX0RJRyA9PSAyNCBcCi0JCQkgICAgICYmIEZMVF9NSU5fRVhQID09IC0x MjUgJiYgRkxUX01BWF9FWFAgPT0gMTI4KQorZW51bQorICB7CisgICAgSUVFRV9GTE9BVElO R19QT0lOVAorICAgICAgPSAoRkxUX1JBRElYID09IDIgJiYgRkxUX01BTlRfRElHID09IDI0 CisJICYmIEZMVF9NSU5fRVhQID09IC0xMjUgJiYgRkxUX01BWF9FWFAgPT0gMTI4KQorICB9 OwogCiAvKiBBIGNoYXJhY3RlciwgZGVjbGFyZWQgd2l0aCB0aGUgZm9sbG93aW5nIHR5cGVk ZWYsIGlzIGEgbWVtYmVyCiAgICBvZiBzb21lIGNoYXJhY3RlciBzZXQgYXNzb2NpYXRlZCB3 aXRoIHRoZSBjdXJyZW50IGJ1ZmZlci4gICovCkBAIC0xNjc1LDY0ICsyMjY2LDYgQEAKICAg ICAgICBpdHNlbGYuICAqLwogICAgIENIQVJBQ1RFUkJJVFMgPSAyMgogICB9OwotCi0KLQot DAotLyogVGhlIGdseXBoIGRhdGF0eXBlLCB1c2VkIHRvIHJlcHJlc2VudCBjaGFyYWN0ZXJz IG9uIHRoZSBkaXNwbGF5LgotICAgSXQgY29uc2lzdHMgb2YgYSBjaGFyIGNvZGUgYW5kIGEg ZmFjZSBpZC4gICovCi0KLXR5cGVkZWYgc3RydWN0IHsKLSAgaW50IGNoOwotICBpbnQgZmFj ZV9pZDsKLX0gR0xZUEg7Ci0KLS8qIFJldHVybiBhIGdseXBoJ3MgY2hhcmFjdGVyIGNvZGUu ICAqLwotI2RlZmluZSBHTFlQSF9DSEFSKGdseXBoKSAoKGdseXBoKS5jaCkKLQotLyogUmV0 dXJuIGEgZ2x5cGgncyBmYWNlIElELiAgKi8KLSNkZWZpbmUgR0xZUEhfRkFDRShnbHlwaCkg KChnbHlwaCkuZmFjZV9pZCkKLQotI2RlZmluZSBTRVRfR0xZUEhfQ0hBUihnbHlwaCwgY2hh cikgKChnbHlwaCkuY2ggPSAoY2hhcikpCi0jZGVmaW5lIFNFVF9HTFlQSF9GQUNFKGdseXBo LCBmYWNlKSAoKGdseXBoKS5mYWNlX2lkID0gKGZhY2UpKQotI2RlZmluZSBTRVRfR0xZUEgo Z2x5cGgsIGNoYXIsIGZhY2UpICgoZ2x5cGgpLmNoID0gKGNoYXIpLCAoZ2x5cGgpLmZhY2Vf aWQgPSAoZmFjZSkpCi0KLS8qIFJldHVybiAxIGlmIEdMWVBIIGNvbnRhaW5zIHZhbGlkIGNo YXJhY3RlciBjb2RlLiAgKi8KLSNkZWZpbmUgR0xZUEhfQ0hBUl9WQUxJRF9QKGdseXBoKSBD SEFSX1ZBTElEX1AgKEdMWVBIX0NIQVIgKGdseXBoKSkKLQotCi0vKiBHbHlwaCBDb2RlIGZy b20gYSBkaXNwbGF5IHZlY3RvciBtYXkgZWl0aGVyIGJlIGFuIGludGVnZXIgd2hpY2gKLSAg IGVuY29kZXMgYSBjaGFyIGNvZGUgaW4gdGhlIGxvd2VyIENIQVJBQ1RFUkJJVFMgYml0cyBh bmQgYSAodmVyeSBzbWFsbCkKLSAgIGZhY2UtaWQgaW4gdGhlIHVwcGVyIGJpdHMsIG9yIGl0 IG1heSBiZSBhIGNvbnMgKENIQVIgLiBGQUNFLUlEKS4gICovCi0KLSNkZWZpbmUgR0xZUEhf Q09ERV9QKGdjKQkJCQkJCVwKLSAgKENPTlNQIChnYykJCQkJCQkJCVwKLSAgID8gKENIQVJB Q1RFUlAgKFhDQVIgKGdjKSkJCQkJCQlcCi0gICAgICAmJiBSQU5HRURfSU5URUdFUlAgKDAs IFhDRFIgKGdjKSwgTUFYX0ZBQ0VfSUQpKQkJCVwKLSAgIDogKFJBTkdFRF9JTlRFR0VSUAkJ CQkJCQlcCi0gICAgICAoMCwgZ2MsCQkJCQkJCQlcCi0gICAgICAgKE1BWF9GQUNFX0lEIDwg VFlQRV9NQVhJTVVNIChFTUFDU19JTlQpID4+IENIQVJBQ1RFUkJJVFMJCVwKLQk/ICgoRU1B Q1NfSU5UKSBNQVhfRkFDRV9JRCA8PCBDSEFSQUNURVJCSVRTKSB8IE1BWF9DSEFSCQlcCi0J OiBUWVBFX01BWElNVU0gKEVNQUNTX0lOVCkpKSkpCi0KLS8qIFRoZSBmb2xsb3dpbmcgYXJl IHZhbGlkIG9ubHkgaWYgR0xZUEhfQ09ERV9QIChnYykuICAqLwotCi0jZGVmaW5lIEdMWVBI X0NPREVfQ0hBUihnYykgXAotICAoQ09OU1AgKGdjKSA/IFhJTlQgKFhDQVIgKGdjKSkgOiBY SU5UIChnYykgJiAoKDEgPDwgQ0hBUkFDVEVSQklUUykgLSAxKSkKLQotI2RlZmluZSBHTFlQ SF9DT0RFX0ZBQ0UoZ2MpIFwKLSAgKENPTlNQIChnYykgPyBYSU5UIChYQ0RSIChnYykpIDog WElOVCAoZ2MpID4+IENIQVJBQ1RFUkJJVFMpCi0KLSNkZWZpbmUgU0VUX0dMWVBIX0ZST01f R0xZUEhfQ09ERShnbHlwaCwgZ2MpCQkJCVwKLSAgZG8JCQkJCQkJCQlcCi0gICAgewkJCQkJ CQkJCVwKLSAgICAgIGlmIChDT05TUCAoZ2MpKQkJCQkJCQlcCi0JU0VUX0dMWVBIIChnbHlw aCwgWElOVCAoWENBUiAoZ2MpKSwgWElOVCAoWENEUiAoZ2MpKSk7CQlcCi0gICAgICBlbHNl CQkJCQkJCQlcCi0JU0VUX0dMWVBIIChnbHlwaCwgKFhJTlQgKGdjKSAmICgoMSA8PCBDSEFS QUNURVJCSVRTKS0xKSksCVwKLQkJICAgKFhJTlQgKGdjKSA+PiBDSEFSQUNURVJCSVRTKSk7 CQkJXAotICAgIH0JCQkJCQkJCQlcCi0gIHdoaWxlICgwKQogDAogLyogU3RydWN0dXJlIHRv IGhvbGQgbW91c2UgaGlnaGxpZ2h0IGRhdGEuICBUaGlzIGlzIGhlcmUgYmVjYXVzZSBvdGhl cgogICAgaGVhZGVyIGZpbGVzIG5lZWQgaXQgZm9yIGRlZmluaW5nIHN0cnVjdCB4X291dHB1 dCBldGMuICAqLwpAQCAtMTc2OCwxOTAgKzIzMDEsMzIxIEBACiAMCiAvKiBEYXRhIHR5cGUg Y2hlY2tpbmcuICAqLwogCi0jZGVmaW5lIE5JTFAoeCkgIEVRICh4LCBRbmlsKQotCi0jZGVm aW5lIE5VTUJFUlAoeCkgKElOVEVHRVJQICh4KSB8fCBGTE9BVFAgKHgpKQotI2RlZmluZSBO QVROVU1QKHgpIChJTlRFR0VSUCAoeCkgJiYgWElOVCAoeCkgPj0gMCkKLQotI2RlZmluZSBS QU5HRURfSU5URUdFUlAobG8sIHgsIGhpKSBcCi0gIChJTlRFR0VSUCAoeCkgJiYgKGxvKSA8 PSBYSU5UICh4KSAmJiBYSU5UICh4KSA8PSAoaGkpKQorTElTUF9JTkxJTkUgYm9vbAorKE5J TFApIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4gbGlzcF9oX05JTFAgKHgpOworfQor CitMSVNQX0lOTElORSBib29sCitOVU1CRVJQIChMaXNwX09iamVjdCB4KQoreworICByZXR1 cm4gSU5URUdFUlAgKHgpIHx8IEZMT0FUUCAoeCk7Cit9CitMSVNQX0lOTElORSBib29sCitO QVROVU1QIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4gSU5URUdFUlAgKHgpICYmIDAg PD0gWElOVCAoeCk7Cit9CisKK0xJU1BfSU5MSU5FIGJvb2wKK1JBTkdFRF9JTlRFR0VSUCAo aW50bWF4X3QgbG8sIExpc3BfT2JqZWN0IHgsIGludG1heF90IGhpKQoreworICByZXR1cm4g SU5URUdFUlAgKHgpICYmIGxvIDw9IFhJTlQgKHgpICYmIFhJTlQgKHgpIDw9IGhpOworfQor CiAjZGVmaW5lIFRZUEVfUkFOR0VEX0lOVEVHRVJQKHR5cGUsIHgpIFwKLSAgKFRZUEVfU0lH TkVEICh0eXBlKQkJCQkJCQlcCi0gICA/IFJBTkdFRF9JTlRFR0VSUCAoVFlQRV9NSU5JTVVN ICh0eXBlKSwgeCwgVFlQRV9NQVhJTVVNICh0eXBlKSkJXAotICAgOiBSQU5HRURfSU5URUdF UlAgKDAsIHgsIFRZUEVfTUFYSU1VTSAodHlwZSkpKQotCi0jZGVmaW5lIElOVEVHRVJQKHgp IChMSVNQX0lOVF9UQUdfUCAoWFRZUEUgKCh4KSkpKQotI2RlZmluZSBTWU1CT0xQKHgpIChY VFlQRSAoKHgpKSA9PSBMaXNwX1N5bWJvbCkKLSNkZWZpbmUgTUlTQ1AoeCkgKFhUWVBFICgo eCkpID09IExpc3BfTWlzYykKLSNkZWZpbmUgVkVDVE9STElLRVAoeCkgKFhUWVBFICgoeCkp ID09IExpc3BfVmVjdG9ybGlrZSkKLSNkZWZpbmUgU1RSSU5HUCh4KSAoWFRZUEUgKCh4KSkg PT0gTGlzcF9TdHJpbmcpCi0jZGVmaW5lIENPTlNQKHgpIChYVFlQRSAoKHgpKSA9PSBMaXNw X0NvbnMpCi0KLSNkZWZpbmUgRkxPQVRQKHgpIChYVFlQRSAoKHgpKSA9PSBMaXNwX0Zsb2F0 KQotI2RlZmluZSBWRUNUT1JQKHgpIChWRUNUT1JMSUtFUCAoeCkgJiYgIShBU0laRSAoeCkg JiBQU0VVRE9WRUNUT1JfRkxBRykpCi0jZGVmaW5lIE9WRVJMQVlQKHgpIChNSVNDUCAoeCkg JiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01pc2NfT3ZlcmxheSkKLSNkZWZpbmUgTUFSS0VS UCh4KSAoTUlTQ1AgKHgpICYmIFhNSVNDVFlQRSAoeCkgPT0gTGlzcF9NaXNjX01hcmtlcikK LQorICAoSU5URUdFUlAgKHgpCQkJICAgICAgXAorICAgJiYgKFRZUEVfU0lHTkVEICh0eXBl KSA/IFRZUEVfTUlOSU1VTSAodHlwZSkgPD0gWElOVCAoeCkgOiAwIDw9IFhJTlQgKHgpKSBc CisgICAmJiBYSU5UICh4KSA8PSBUWVBFX01BWElNVU0gKHR5cGUpKQorCitMSVNQX0lOTElO RSBib29sCisoQ09OU1ApIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4gbGlzcF9oX0NP TlNQICh4KTsKK30KK0xJU1BfSU5MSU5FIGJvb2wKKyhGTE9BVFApIChMaXNwX09iamVjdCB4 KQoreworICByZXR1cm4gbGlzcF9oX0ZMT0FUUCAoeCk7Cit9CitMSVNQX0lOTElORSBib29s CisoTUlTQ1ApIChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4gbGlzcF9oX01JU0NQICh4 KTsKK30KK0xJU1BfSU5MSU5FIGJvb2wKK1NUUklOR1AgKExpc3BfT2JqZWN0IHgpCit7Cisg IHJldHVybiBYVFlQRSAoeCkgPT0gTGlzcF9TdHJpbmc7Cit9CitMSVNQX0lOTElORSBib29s CisoU1lNQk9MUCkgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBsaXNwX2hfU1lNQk9M UCAoeCk7Cit9CitMSVNQX0lOTElORSBib29sCisoSU5URUdFUlApIChMaXNwX09iamVjdCB4 KQoreworICByZXR1cm4gbGlzcF9oX0lOVEVHRVJQICh4KTsKK30KK0xJU1BfSU5MSU5FIGJv b2wKKyhWRUNUT1JMSUtFUCkgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBsaXNwX2hf VkVDVE9STElLRVAgKHgpOworfQorTElTUF9JTkxJTkUgYm9vbAorVkVDVE9SUCAoTGlzcF9P YmplY3QgeCkKK3sKKyAgcmV0dXJuIFZFQ1RPUkxJS0VQICh4KSAmJiAhIChBU0laRSAoeCkg JiBQU0VVRE9WRUNUT1JfRkxBRyk7Cit9CitMSVNQX0lOTElORSBib29sCitPVkVSTEFZUCAo TGlzcF9PYmplY3QgeCkKK3sKKyAgcmV0dXJuIE1JU0NQICh4KSAmJiBYTUlTQ1RZUEUgKHgp ID09IExpc3BfTWlzY19PdmVybGF5OworfQorTElTUF9JTkxJTkUgYm9vbAorKE1BUktFUlAp IChMaXNwX09iamVjdCB4KQoreworICByZXR1cm4gbGlzcF9oX01BUktFUlAgKHgpOworfQog TElTUF9JTkxJTkUgYm9vbAogU0FWRV9WQUxVRVAgKExpc3BfT2JqZWN0IHgpCiB7CiAgIHJl dHVybiBNSVNDUCAoeCkgJiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01pc2NfU2F2ZV9WYWx1 ZTsKIH0KIAotTElTUF9JTkxJTkUgc3RydWN0IExpc3BfU2F2ZV9WYWx1ZSAqCi1YU0FWRV9W QUxVRSAoTGlzcF9PYmplY3QgYSkKLXsKLSAgZWFzc2VydCAoU0FWRV9WQUxVRVAgKGEpKTsK LSAgcmV0dXJuICYgWE1JU0MgKGEpLT51X3NhdmVfdmFsdWU7Ci19Ci0KLS8qIFJldHVybiB0 aGUgdHlwZSBvZiBWJ3MgTnRoIHNhdmVkIHZhbHVlLiAgKi8KLUxJU1BfSU5MSU5FIGludAot c2F2ZV90eXBlIChzdHJ1Y3QgTGlzcF9TYXZlX1ZhbHVlICp2LCBpbnQgbikKLXsKLSAgZWFz c2VydCAoMCA8PSBuICYmIG4gPCBTQVZFX1ZBTFVFX1NMT1RTKTsKLSAgcmV0dXJuICh2LT5z YXZlX3R5cGUgPj4gKFNBVkVfU0xPVF9CSVRTICogbikgJiAoKDEgPDwgU0FWRV9TTE9UX0JJ VFMpIC0gMSkpOwotfQotCi0vKiBHZXQgYW5kIHNldCB0aGUgTnRoIHNhdmVkIHBvaW50ZXIu ICAqLwotCi1MSVNQX0lOTElORSB2b2lkICoKLVhTQVZFX1BPSU5URVIgKExpc3BfT2JqZWN0 IG9iaiwgaW50IG4pCi17Ci0gIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUgKG9i aiksIG4pID09IFNBVkVfUE9JTlRFUik7Ci0gIHJldHVybiBYU0FWRV9WQUxVRSAob2JqKS0+ ZGF0YVtuXS5wb2ludGVyOzsKLX0KLUxJU1BfSU5MSU5FIHZvaWQKLXNldF9zYXZlX3BvaW50 ZXIgKExpc3BfT2JqZWN0IG9iaiwgaW50IG4sIHZvaWQgKnZhbCkKLXsKLSAgZWFzc2VydCAo c2F2ZV90eXBlIChYU0FWRV9WQUxVRSAob2JqKSwgbikgPT0gU0FWRV9QT0lOVEVSKTsKLSAg WFNBVkVfVkFMVUUgKG9iaiktPmRhdGFbbl0ucG9pbnRlciA9IHZhbDsKLX0KLQotLyogTGlr ZXdpc2UgZm9yIHRoZSBzYXZlZCBpbnRlZ2VyLiAgKi8KLQotTElTUF9JTkxJTkUgcHRyZGlm Zl90Ci1YU0FWRV9JTlRFR0VSIChMaXNwX09iamVjdCBvYmosIGludCBuKQotewotICBlYXNz ZXJ0IChzYXZlX3R5cGUgKFhTQVZFX1ZBTFVFIChvYmopLCBuKSA9PSBTQVZFX0lOVEVHRVIp OwotICByZXR1cm4gWFNBVkVfVkFMVUUgKG9iaiktPmRhdGFbbl0uaW50ZWdlcjsKLX0KLUxJ U1BfSU5MSU5FIHZvaWQKLXNldF9zYXZlX2ludGVnZXIgKExpc3BfT2JqZWN0IG9iaiwgaW50 IG4sIHB0cmRpZmZfdCB2YWwpCi17Ci0gIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFM VUUgKG9iaiksIG4pID09IFNBVkVfSU5URUdFUik7Ci0gIFhTQVZFX1ZBTFVFIChvYmopLT5k YXRhW25dLmludGVnZXIgPSB2YWw7Ci19Ci0KLS8qIEV4dHJhY3QgTnRoIHNhdmVkIG9iamVj dC4gICovCi0KLUxJU1BfSU5MSU5FIExpc3BfT2JqZWN0Ci1YU0FWRV9PQkpFQ1QgKExpc3Bf T2JqZWN0IG9iaiwgaW50IG4pCi17Ci0gIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFM VUUgKG9iaiksIG4pID09IFNBVkVfT0JKRUNUKTsKLSAgcmV0dXJuIFhTQVZFX1ZBTFVFIChv YmopLT5kYXRhW25dLm9iamVjdDsKLX0KLQotI2RlZmluZSBBVVRPTE9BRFAoeCkgKENPTlNQ ICh4KSAmJiBFUSAoUWF1dG9sb2FkLCBYQ0FSICh4KSkpCi0KLSNkZWZpbmUgSU5URldEUCh4 KSAoWEZXRFRZUEUgKHgpID09IExpc3BfRndkX0ludCkKLSNkZWZpbmUgQk9PTEZXRFAoeCkg KFhGV0RUWVBFICh4KSA9PSBMaXNwX0Z3ZF9Cb29sKQotI2RlZmluZSBPQkpGV0RQKHgpIChY RldEVFlQRSAoeCkgPT0gTGlzcF9Gd2RfT2JqKQotI2RlZmluZSBCVUZGRVJfT0JKRldEUCh4 KSAoWEZXRFRZUEUgKHgpID09IExpc3BfRndkX0J1ZmZlcl9PYmopCi0jZGVmaW5lIEtCT0FS RF9PQkpGV0RQKHgpIChYRldEVFlQRSAoeCkgPT0gTGlzcF9Gd2RfS2JvYXJkX09iaikKLQot LyogVHJ1ZSBpZiBvYmplY3QgWCBpcyBhIHBzZXVkb3ZlY3RvciB3aG9zZSBjb2RlIGlzIENP REUuICBUaGUgY2FzdCB0byBzdHJ1Y3QKLSAgIHZlY3Rvcmxpa2VfaGVhZGVyICogYXZvaWRz IGFsaWFzaW5nIGlzc3Vlcy4gICovCi0jZGVmaW5lIFBTRVVET1ZFQ1RPUlAoeCwgY29kZSkJ CQkJCVwKLSAgVFlQRURfUFNFVURPVkVDVE9SUCAoeCwgdmVjdG9ybGlrZV9oZWFkZXIsIGNv ZGUpCi0KLSNkZWZpbmUgUFNFVURPVkVDVE9SX1RZUEVQKHYsIGNvZGUpCQkJCQlcCi0gICgo KHYpLT5zaXplICYgKFBTRVVET1ZFQ1RPUl9GTEFHIHwgUFZFQ19UWVBFX01BU0spKQkJCVwK LSAgID09IChQU0VVRE9WRUNUT1JfRkxBRyB8ICgoY29kZSkgPDwgUFNFVURPVkVDVE9SX0FS RUFfQklUUykpKQotCi0vKiBUcnVlIGlmIG9iamVjdCBYLCB3aXRoIGludGVybmFsIHR5cGUg c3RydWN0IFQgKiwgaXMgYSBwc2V1ZG92ZWN0b3Igd2hvc2UKLSAgIGNvZGUgaXMgQ09ERS4g ICovCi0jZGVmaW5lIFRZUEVEX1BTRVVET1ZFQ1RPUlAoeCwgdCwgY29kZSkJCQkJXAotICAo VkVDVE9STElLRVAgKHgpCQkJCQkJXAotICAgJiYgUFNFVURPVkVDVE9SX1RZUEVQICgoc3Ry dWN0IHQgKikgWFVOVEFHICh4LCBMaXNwX1ZlY3Rvcmxpa2UpLCBjb2RlKSkKK0xJU1BfSU5M SU5FIGJvb2wKK0FVVE9MT0FEUCAoTGlzcF9PYmplY3QgeCkKK3sKKyAgcmV0dXJuIENPTlNQ ICh4KSAmJiBFUSAoUWF1dG9sb2FkLCBYQ0FSICh4KSk7Cit9CisKK0xJU1BfSU5MSU5FIGJv b2wKK0lOVEZXRFAgKHVuaW9uIExpc3BfRndkICphKQoreworICByZXR1cm4gWEZXRFRZUEUg KGEpID09IExpc3BfRndkX0ludDsKK30KK0xJU1BfSU5MSU5FIGJvb2wKK0JPT0xGV0RQICh1 bmlvbiBMaXNwX0Z3ZCAqYSkKK3sKKyAgcmV0dXJuIFhGV0RUWVBFIChhKSA9PSBMaXNwX0Z3 ZF9Cb29sOworfQorTElTUF9JTkxJTkUgYm9vbAorT0JKRldEUCAodW5pb24gTGlzcF9Gd2Qg KmEpCit7CisgIHJldHVybiBYRldEVFlQRSAoYSkgPT0gTGlzcF9Gd2RfT2JqOworfQorTElT UF9JTkxJTkUgYm9vbAorQlVGRkVSX09CSkZXRFAgKHVuaW9uIExpc3BfRndkICphKQorewor ICByZXR1cm4gWEZXRFRZUEUgKGEpID09IExpc3BfRndkX0J1ZmZlcl9PYmo7Cit9CitMSVNQ X0lOTElORSBib29sCitLQk9BUkRfT0JKRldEUCAodW5pb24gTGlzcF9Gd2QgKmEpCit7Cisg IHJldHVybiBYRldEVFlQRSAoYSkgPT0gTGlzcF9Gd2RfS2JvYXJkX09iajsKK30KKworTElT UF9JTkxJTkUgYm9vbAorUFNFVURPVkVDVE9SX1RZUEVQIChzdHJ1Y3QgdmVjdG9ybGlrZV9o ZWFkZXIgKmEsIGludCBjb2RlKQoreworICByZXR1cm4gKChhLT5zaXplICYgKFBTRVVET1ZF Q1RPUl9GTEFHIHwgUFZFQ19UWVBFX01BU0spKQorCSAgPT0gKFBTRVVET1ZFQ1RPUl9GTEFH IHwgKGNvZGUgPDwgUFNFVURPVkVDVE9SX0FSRUFfQklUUykpKTsKK30KKworLyogVHJ1ZSBp ZiBBIGlzIGEgcHNldWRvdmVjdG9yIHdob3NlIGNvZGUgaXMgQ09ERS4gICovCitMSVNQX0lO TElORSBib29sCitQU0VVRE9WRUNUT1JQIChMaXNwX09iamVjdCBhLCBpbnQgY29kZSkKK3sK KyAgaWYgKCEgVkVDVE9STElLRVAgKGEpKQorICAgIHJldHVybiAwOworICBlbHNlCisgICAg eworICAgICAgLyogQ29udmVydGluZyB0byBzdHJ1Y3QgdmVjdG9ybGlrZV9oZWFkZXIgKiBh dm9pZHMgYWxpYXNpbmcgaXNzdWVzLiAgKi8KKyAgICAgIHN0cnVjdCB2ZWN0b3JsaWtlX2hl YWRlciAqaCA9IFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKTsKKyAgICAgIHJldHVybiBQ U0VVRE9WRUNUT1JfVFlQRVAgKGgsIGNvZGUpOworICAgIH0KK30KKwogCiAvKiBUZXN0IGZv ciBzcGVjaWZpYyBwc2V1ZG92ZWN0b3IgdHlwZXMuICAqLwotI2RlZmluZSBXSU5ET1dfQ09O RklHVVJBVElPTlAoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19XSU5ET1dfQ09ORklHVVJB VElPTikKLSNkZWZpbmUgUFJPQ0VTU1AoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19QUk9D RVNTKQotI2RlZmluZSBXSU5ET1dQKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfV0lORE9X KQotI2RlZmluZSBURVJNSU5BTFAoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19URVJNSU5B TCkKLSNkZWZpbmUgU1VCUlAoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19TVUJSKQotI2Rl ZmluZSBDT01QSUxFRFAoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19DT01QSUxFRCkKLSNk ZWZpbmUgQlVGRkVSUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX0JVRkZFUikKLSNkZWZp bmUgQ0hBUl9UQUJMRV9QKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfQ0hBUl9UQUJMRSkK LSNkZWZpbmUgU1VCX0NIQVJfVEFCTEVfUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX1NV Ql9DSEFSX1RBQkxFKQotI2RlZmluZSBCT09MX1ZFQ1RPUl9QKHgpIFBTRVVET1ZFQ1RPUlAg KHgsIFBWRUNfQk9PTF9WRUNUT1IpCi0jZGVmaW5lIEZSQU1FUCh4KSBQU0VVRE9WRUNUT1JQ ICh4LCBQVkVDX0ZSQU1FKQorCitMSVNQX0lOTElORSBib29sCitXSU5ET1dfQ09ORklHVVJB VElPTlAgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQ VkVDX1dJTkRPV19DT05GSUdVUkFUSU9OKTsKK30KKworTElTUF9JTkxJTkUgYm9vbAorUFJP Q0VTU1AgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQ VkVDX1BST0NFU1MpOworfQorCitMSVNQX0lOTElORSBib29sCitXSU5ET1dQIChMaXNwX09i amVjdCBhKQoreworICByZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZFQ19XSU5ET1cpOwor fQorCitMSVNQX0lOTElORSBib29sCitURVJNSU5BTFAgKExpc3BfT2JqZWN0IGEpCit7Cisg IHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVDX1RFUk1JTkFMKTsKK30KKworTElTUF9J TkxJTkUgYm9vbAorU1VCUlAgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9W RUNUT1JQIChhLCBQVkVDX1NVQlIpOworfQorCitMSVNQX0lOTElORSBib29sCitDT01QSUxF RFAgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVD X0NPTVBJTEVEKTsKK30KKworTElTUF9JTkxJTkUgYm9vbAorQlVGRkVSUCAoTGlzcF9PYmpl Y3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEsIFBWRUNfQlVGRkVSKTsKK30K KworTElTUF9JTkxJTkUgYm9vbAorQ0hBUl9UQUJMRV9QIChMaXNwX09iamVjdCBhKQorewor ICByZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZFQ19DSEFSX1RBQkxFKTsKK30KKworTElT UF9JTkxJTkUgYm9vbAorU1VCX0NIQVJfVEFCTEVfUCAoTGlzcF9PYmplY3QgYSkKK3sKKyAg cmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEsIFBWRUNfU1VCX0NIQVJfVEFCTEUpOworfQorCitM SVNQX0lOTElORSBib29sCitCT09MX1ZFQ1RPUl9QIChMaXNwX09iamVjdCBhKQoreworICBy ZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZFQ19CT09MX1ZFQ1RPUik7Cit9CisKK0xJU1Bf SU5MSU5FIGJvb2wKK0ZSQU1FUCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVE T1ZFQ1RPUlAgKGEsIFBWRUNfRlJBTUUpOworfQogCiAvKiBUZXN0IGZvciBpbWFnZSAoaW1h Z2UgLiBzcGVjKSAgKi8KLSNkZWZpbmUgSU1BR0VQKHgpIChDT05TUCAoeCkgJiYgRVEgKFhD QVIgKHgpLCBRaW1hZ2UpKQorTElTUF9JTkxJTkUgYm9vbAorSU1BR0VQIChMaXNwX09iamVj dCB4KQoreworICByZXR1cm4gQ09OU1AgKHgpICYmIEVRIChYQ0FSICh4KSwgUWltYWdlKTsK K30KIAogLyogQXJyYXkgdHlwZXMuICAqLwotCi0jZGVmaW5lIEFSUkFZUCh4KSBcCi0gIChW RUNUT1JQICh4KSB8fCBTVFJJTkdQICh4KSB8fCBDSEFSX1RBQkxFX1AgKHgpIHx8IEJPT0xf VkVDVE9SX1AgKHgpKQorTElTUF9JTkxJTkUgYm9vbAorQVJSQVlQIChMaXNwX09iamVjdCB4 KQoreworICByZXR1cm4gVkVDVE9SUCAoeCkgfHwgU1RSSU5HUCAoeCkgfHwgQ0hBUl9UQUJM RV9QICh4KSB8fCBCT09MX1ZFQ1RPUl9QICh4KTsKK30KIAwKLSNkZWZpbmUgQ0hFQ0tfTElT VCh4KSBcCi0gIENIRUNLX1RZUEUgKENPTlNQICh4KSB8fCBOSUxQICh4KSwgUWxpc3RwLCB4 KQotCi0jZGVmaW5lIENIRUNLX0xJU1RfQ09OUyh4LCB5KSBcCi0gIENIRUNLX1RZUEUgKENP TlNQICh4KSwgUWxpc3RwLCB5KQotCi0jZGVmaW5lIENIRUNLX0xJU1RfRU5EKHgsIHkpIFwK LSAgQ0hFQ0tfVFlQRSAoTklMUCAoeCksIFFsaXN0cCwgeSkKLQotI2RlZmluZSBDSEVDS19T VFJJTkcoeCkgXAotICBDSEVDS19UWVBFIChTVFJJTkdQICh4KSwgUXN0cmluZ3AsIHgpCi0K LSNkZWZpbmUgQ0hFQ0tfU1RSSU5HX0NBUih4KSBcCi0gIENIRUNLX1RZUEUgKFNUUklOR1Ag KFhDQVIgKHgpKSwgUXN0cmluZ3AsIFhDQVIgKHgpKQotCi0jZGVmaW5lIENIRUNLX0NPTlMo eCkgXAotICBDSEVDS19UWVBFIChDT05TUCAoeCksIFFjb25zcCwgeCkKLQotI2RlZmluZSBD SEVDS19TWU1CT0woeCkgXAotICBDSEVDS19UWVBFIChTWU1CT0xQICh4KSwgUXN5bWJvbHAs IHgpCi0KLSNkZWZpbmUgQ0hFQ0tfQ0hBUl9UQUJMRSh4KSBcCi0gIENIRUNLX1RZUEUgKENI QVJfVEFCTEVfUCAoeCksIFFjaGFyX3RhYmxlX3AsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfVkVD VE9SKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoVkVDVE9SUCAoeCksIFF2ZWN0b3JwLCB4KQotCi0j ZGVmaW5lIENIRUNLX1ZFQ1RPUl9PUl9TVFJJTkcoeCkgXAotICBDSEVDS19UWVBFIChWRUNU T1JQICh4KSB8fCBTVFJJTkdQICh4KSwgUWFycmF5cCwgeCkKLQotI2RlZmluZSBDSEVDS19B UlJBWSh4LCBReHh4cCkgXAotICBDSEVDS19UWVBFIChBUlJBWVAgKHgpLCBReHh4cCwgeCkK LQotI2RlZmluZSBDSEVDS19WRUNUT1JfT1JfQ0hBUl9UQUJMRSh4KSBcCi0gIENIRUNLX1RZ UEUgKFZFQ1RPUlAgKHgpIHx8IENIQVJfVEFCTEVfUCAoeCksIFF2ZWN0b3Jfb3JfY2hhcl90 YWJsZV9wLCB4KQotCi0jZGVmaW5lIENIRUNLX0JVRkZFUih4KSBcCi0gIENIRUNLX1RZUEUg KEJVRkZFUlAgKHgpLCBRYnVmZmVycCwgeCkKLQotI2RlZmluZSBDSEVDS19XSU5ET1coeCkg XAotICBDSEVDS19UWVBFIChXSU5ET1dQICh4KSwgUXdpbmRvd3AsIHgpCi0KLSNkZWZpbmUg Q0hFQ0tfV0lORE9XX0NPTkZJR1VSQVRJT04oeCkgXAotICBDSEVDS19UWVBFIChXSU5ET1df Q09ORklHVVJBVElPTlAgKHgpLCBRd2luZG93X2NvbmZpZ3VyYXRpb25fcCwgeCkKLQotI2Rl ZmluZSBDSEVDS19QUk9DRVNTKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoUFJPQ0VTU1AgKHgpLCBR cHJvY2Vzc3AsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfU1VCUih4KSBcCi0gIENIRUNLX1RZUEUg KFNVQlJQICh4KSwgUXN1YnJwLCB4KQotCi0jZGVmaW5lIENIRUNLX05VTUJFUih4KSBcCi0g IENIRUNLX1RZUEUgKElOVEVHRVJQICh4KSwgUWludGVnZXJwLCB4KQotCi0jZGVmaW5lIENI RUNLX05BVE5VTSh4KSBcCi0gIENIRUNLX1RZUEUgKE5BVE5VTVAgKHgpLCBRd2hvbGVudW1w LCB4KQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTElTVCAoTGlzcF9PYmplY3QgeCkKK3sK KyAgQ0hFQ0tfVFlQRSAoQ09OU1AgKHgpIHx8IE5JTFAgKHgpLCBRbGlzdHAsIHgpOworfQor TElTUF9JTkxJTkUgdm9pZAorKENIRUNLX0xJU1RfQ09OUykgKExpc3BfT2JqZWN0IHgsIExp c3BfT2JqZWN0IHkpCit7CisgIGxpc3BfaF9DSEVDS19MSVNUX0NPTlMgKHgsIHkpOworfQor TElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTElTVF9FTkQgKExpc3BfT2JqZWN0IHgsIExpc3Bf T2JqZWN0IHkpCit7CisgIENIRUNLX1RZUEUgKE5JTFAgKHgpLCBRbGlzdHAsIHkpOworfQor TElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfU1RSSU5HIChMaXNwX09iamVjdCB4KQoreworICBD SEVDS19UWVBFIChTVFJJTkdQICh4KSwgUXN0cmluZ3AsIHgpOworfQorTElTUF9JTkxJTkUg dm9pZAorQ0hFQ0tfU1RSSU5HX0NBUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQ RSAoU1RSSU5HUCAoWENBUiAoeCkpLCBRc3RyaW5ncCwgWENBUiAoeCkpOworfQorTElTUF9J TkxJTkUgdm9pZAorQ0hFQ0tfQ09OUyAoTGlzcF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQ RSAoQ09OU1AgKHgpLCBRY29uc3AsIHgpOworfQorTElTUF9JTkxJTkUgdm9pZAorKENIRUNL X1NZTUJPTCkgKExpc3BfT2JqZWN0IHgpCit7CisgIGxpc3BfaF9DSEVDS19TWU1CT0wgKHgp OworfQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfQ0hBUl9UQUJMRSAoTGlzcF9PYmplY3Qg eCkKK3sKKyAgQ0hFQ0tfVFlQRSAoQ0hBUl9UQUJMRV9QICh4KSwgUWNoYXJfdGFibGVfcCwg eCk7Cit9CitMSVNQX0lOTElORSB2b2lkCitDSEVDS19WRUNUT1IgKExpc3BfT2JqZWN0IHgp Cit7CisgIENIRUNLX1RZUEUgKFZFQ1RPUlAgKHgpLCBRdmVjdG9ycCwgeCk7Cit9CitMSVNQ X0lOTElORSB2b2lkCitDSEVDS19WRUNUT1JfT1JfU1RSSU5HIChMaXNwX09iamVjdCB4KQor eworICBDSEVDS19UWVBFIChWRUNUT1JQICh4KSB8fCBTVFJJTkdQICh4KSwgUWFycmF5cCwg eCk7Cit9CitMSVNQX0lOTElORSB2b2lkCitDSEVDS19BUlJBWSAoTGlzcF9PYmplY3QgeCwg TGlzcF9PYmplY3QgUXh4eHApCit7CisgIENIRUNLX1RZUEUgKEFSUkFZUCAoeCksIFF4eHhw LCB4KTsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK0NIRUNLX1ZFQ1RPUl9PUl9DSEFSX1RBQkxF IChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChWRUNUT1JQICh4KSB8fCBDSEFS X1RBQkxFX1AgKHgpLCBRdmVjdG9yX29yX2NoYXJfdGFibGVfcCwgeCk7Cit9CitMSVNQX0lO TElORSB2b2lkCitDSEVDS19CVUZGRVIgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZ UEUgKEJVRkZFUlAgKHgpLCBRYnVmZmVycCwgeCk7Cit9CitMSVNQX0lOTElORSB2b2lkCitD SEVDS19XSU5ET1cgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKFdJTkRPV1Ag KHgpLCBRd2luZG93cCwgeCk7Cit9CitMSVNQX0lOTElORSB2b2lkCitDSEVDS19XSU5ET1df Q09ORklHVVJBVElPTiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQRSAoV0lORE9X X0NPTkZJR1VSQVRJT05QICh4KSwgUXdpbmRvd19jb25maWd1cmF0aW9uX3AsIHgpOworfQor TElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfUFJPQ0VTUyAoTGlzcF9PYmplY3QgeCkKK3sKKyAg Q0hFQ0tfVFlQRSAoUFJPQ0VTU1AgKHgpLCBRcHJvY2Vzc3AsIHgpOworfQorTElTUF9JTkxJ TkUgdm9pZAorQ0hFQ0tfU1VCUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQRSAo U1VCUlAgKHgpLCBRc3VicnAsIHgpOworfQorTElTUF9JTkxJTkUgdm9pZAorKENIRUNLX05V TUJFUikgKExpc3BfT2JqZWN0IHgpCit7CisgIGxpc3BfaF9DSEVDS19OVU1CRVIgKHgpOwor fQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTkFUTlVNIChMaXNwX09iamVjdCB4KQorewor ICBDSEVDS19UWVBFIChOQVROVU1QICh4KSwgUXdob2xlbnVtcCwgeCk7Cit9CiAKICNkZWZp bmUgQ0hFQ0tfUkFOR0VEX0lOVEVHRVIoeCwgbG8sIGhpKQkJCQkJXAogICBkbyB7CQkJCQkJ CQkJXApAQCAtMTk3Miw1NyArMjYzNiw3NiBAQAogICAgICAgQ0hFQ0tfUkFOR0VEX0lOVEVH RVIgKHgsIDAsIFRZUEVfTUFYSU1VTSAodHlwZSkpOwkJCVwKICAgfSB3aGlsZSAoMCkKIAot I2RlZmluZSBDSEVDS19NQVJLRVIoeCkgXAotICBDSEVDS19UWVBFIChNQVJLRVJQICh4KSwg UW1hcmtlcnAsIHgpCitMSVNQX0lOTElORSB2b2lkCitDSEVDS19NQVJLRVIgKExpc3BfT2Jq ZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKE1BUktFUlAgKHgpLCBRbWFya2VycCwgeCk7Cit9 CiAKICNkZWZpbmUgQ0hFQ0tfTlVNQkVSX0NPRVJDRV9NQVJLRVIoeCkgXAogICBkbyB7IGlm IChNQVJLRVJQICgoeCkpKSBYU0VURkFTVElOVCAoeCwgbWFya2VyX3Bvc2l0aW9uICh4KSk7 IFwKICAgICBlbHNlIENIRUNLX1RZUEUgKElOVEVHRVJQICh4KSwgUWludGVnZXJfb3JfbWFy a2VyX3AsIHgpOyB9IHdoaWxlICgwKQogCi0jZGVmaW5lIFhGTE9BVElOVChuKSBleHRyYWN0 X2Zsb2F0KChuKSkKLQotI2RlZmluZSBDSEVDS19GTE9BVCh4KSBcCi0gIENIRUNLX1RZUEUg KEZMT0FUUCAoeCksIFFmbG9hdHAsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfTlVNQkVSX09SX0ZM T0FUKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoRkxPQVRQICh4KSB8fCBJTlRFR0VSUCAoeCksIFFu dW1iZXJwLCB4KQorTElTUF9JTkxJTkUgZG91YmxlCitYRkxPQVRJTlQgKExpc3BfT2JqZWN0 IG4pCit7CisgIHJldHVybiBleHRyYWN0X2Zsb2F0IChuKTsKK30KKworTElTUF9JTkxJTkUg dm9pZAorQ0hFQ0tfRkxPQVQgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKEZM T0FUUCAoeCksIFFmbG9hdHAsIHgpOworfQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTlVN QkVSX09SX0ZMT0FUIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChGTE9BVFAg KHgpIHx8IElOVEVHRVJQICh4KSwgUW51bWJlcnAsIHgpOworfQogCiAjZGVmaW5lIENIRUNL X05VTUJFUl9PUl9GTE9BVF9DT0VSQ0VfTUFSS0VSKHgpIFwKICAgZG8geyBpZiAoTUFSS0VS UCAoeCkpIFhTRVRGQVNUSU5UICh4LCBtYXJrZXJfcG9zaXRpb24gKHgpKTsgXAogICAgIGVs c2UgQ0hFQ0tfVFlQRSAoSU5URUdFUlAgKHgpIHx8IEZMT0FUUCAoeCksIFFudW1iZXJfb3Jf bWFya2VyX3AsIHgpOyB9IHdoaWxlICgwKQogCi0jZGVmaW5lIENIRUNLX09WRVJMQVkoeCkg XAotICBDSEVDS19UWVBFIChPVkVSTEFZUCAoeCksIFFvdmVybGF5cCwgeCkKK0xJU1BfSU5M SU5FIHZvaWQKK0NIRUNLX09WRVJMQVkgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZ UEUgKE9WRVJMQVlQICh4KSwgUW92ZXJsYXlwLCB4KTsKK30KIAogLyogU2luY2Ugd2UgY2Fu J3QgYXNzaWduIGRpcmVjdGx5IHRvIHRoZSBDQVIgb3IgQ0RSIGZpZWxkcyBvZiBhIGNvbnMK ICAgIGNlbGwsIHVzZSB0aGVzZSB3aGVuIGNoZWNraW5nIHRoYXQgdGhvc2UgZmllbGRzIGNv bnRhaW4gbnVtYmVycy4gICovCi0jZGVmaW5lIENIRUNLX05VTUJFUl9DQVIoeCkgXAotICBk byB7CQkJCQlcCi0gICAgTGlzcF9PYmplY3QgdG1wID0gWENBUiAoeCk7CQlcCi0gICAgQ0hF Q0tfTlVNQkVSICh0bXApOwkJCVwKLSAgICBYU0VUQ0FSICgoeCksIHRtcCk7CQkJXAotICB9 IHdoaWxlICgwKQotCi0jZGVmaW5lIENIRUNLX05VTUJFUl9DRFIoeCkgXAotICBkbyB7CQkJ CQlcCi0gICAgTGlzcF9PYmplY3QgdG1wID0gWENEUiAoeCk7CQlcCi0gICAgQ0hFQ0tfTlVN QkVSICh0bXApOwkJCVwKLSAgICBYU0VUQ0RSICgoeCksIHRtcCk7CQkJXAotICB9IHdoaWxl ICgwKQotCi0jZGVmaW5lIENIRUNLX05BVE5VTV9DQVIoeCkgXAotICBkbyB7CQkJCQlcCi0g ICAgTGlzcF9PYmplY3QgdG1wID0gWENBUiAoeCk7CQlcCi0gICAgQ0hFQ0tfTkFUTlVNICh0 bXApOwkJCVwKLSAgICBYU0VUQ0FSICgoeCksIHRtcCk7CQkJXAotICB9IHdoaWxlICgwKQot Ci0jZGVmaW5lIENIRUNLX05BVE5VTV9DRFIoeCkgXAotICBkbyB7CQkJCQlcCi0gICAgTGlz cF9PYmplY3QgdG1wID0gWENEUiAoeCk7CQlcCi0gICAgQ0hFQ0tfTkFUTlVNICh0bXApOwkJ CVwKLSAgICBYU0VUQ0RSICgoeCksIHRtcCk7CQkJXAotICB9IHdoaWxlICgwKQorTElTUF9J TkxJTkUgdm9pZAorQ0hFQ0tfTlVNQkVSX0NBUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgTGlz cF9PYmplY3QgdG1wID0gWENBUiAoeCk7CisgIENIRUNLX05VTUJFUiAodG1wKTsKKyAgWFNF VENBUiAoeCwgdG1wKTsKK30KKworTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTlVNQkVSX0NE UiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgTGlzcF9PYmplY3QgdG1wID0gWENEUiAoeCk7Cisg IENIRUNLX05VTUJFUiAodG1wKTsKKyAgWFNFVENEUiAoeCwgdG1wKTsKK30KKworTElTUF9J TkxJTkUgdm9pZAorQ0hFQ0tfTkFUTlVNX0NBUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgTGlz cF9PYmplY3QgdG1wID0gWENBUiAoeCk7CisgIENIRUNLX05BVE5VTSAodG1wKTsKKyAgWFNF VENBUiAoeCwgdG1wKTsKK30KKworTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfTkFUTlVNX0NE UiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgTGlzcF9PYmplY3QgdG1wID0gWENEUiAoeCk7Cisg IENIRUNLX05BVE5VTSAodG1wKTsKKyAgWFNFVENEUiAoeCwgdG1wKTsKK30KIAwKIC8qIERl ZmluZSBhIGJ1aWx0LWluIGZ1bmN0aW9uIGZvciBjYWxsaW5nIGZyb20gTGlzcC4KICBgbG5h bWUnIHNob3VsZCBiZSB0aGUgbmFtZSB0byBnaXZlIHRoZSBmdW5jdGlvbiBpbiBMaXNwLApA QCAtMjA4OCw4ICsyNzcxLDEyIEBACiAjZGVmaW5lIERFRlVOX0FSR1NfOAkoTGlzcF9PYmpl Y3QsIExpc3BfT2JqZWN0LCBMaXNwX09iamVjdCwgTGlzcF9PYmplY3QsIFwKIAkJCSBMaXNw X09iamVjdCwgTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0LCBMaXNwX09iamVjdCkKIAotLyog Tm9uLXplcm8gaWYgT0JKIGlzIGEgTGlzcCBmdW5jdGlvbi4gICovCi0jZGVmaW5lIEZVTkNU SU9OUChPQkopIGZ1bmN0aW9ucChPQkopCisvKiBUcnVlIGlmIE9CSiBpcyBhIExpc3AgZnVu Y3Rpb24uICAqLworTElTUF9JTkxJTkUgYm9vbAorRlVOQ1RJT05QIChMaXNwX09iamVjdCBv YmopCit7CisgIHJldHVybiBmdW5jdGlvbnAgKG9iaik7Cit9CiAKIC8qIGRlZnN1YnIgKFNu YW1lKTsKICAgIGlzIGhvdyB3ZSBkZWZpbmUgdGhlIHN5bWJvbCBmb3IgZnVuY3Rpb24gYG5h bWUnIGF0IHN0YXJ0LXVwIHRpbWUuICAqLwpAQCAtMjI3Niw3ICsyOTYzLDExIEBACiBleHRl cm4gc3RydWN0IHNwZWNiaW5kaW5nICpzcGVjcGRsX3B0cjsKIGV4dGVybiBwdHJkaWZmX3Qg c3BlY3BkbF9zaXplOwogCi0jZGVmaW5lIFNQRUNQRExfSU5ERVgoKQkoc3BlY3BkbF9wdHIg LSBzcGVjcGRsKQorTElTUF9JTkxJTkUgcHRyZGlmZl90CitTUEVDUERMX0lOREVYICh2b2lk KQoreworICByZXR1cm4gc3BlY3BkbF9wdHIgLSBzcGVjcGRsOworfQogCiAvKiBFdmVyeXRo aW5nIG5lZWRlZCB0byBkZXNjcmliZSBhbiBhY3RpdmUgY29uZGl0aW9uIGNhc2UuCiAKQEAg LTI1OTIsMjcgKzMyODMsMTIgQEAKICNkZWZpbmUgRVhGVU4oZm5uYW1lLCBtYXhhcmdzKSBc CiAgIGV4dGVybiBMaXNwX09iamVjdCBmbm5hbWUgREVGVU5fQVJHU18gIyMgbWF4YXJncwog CisjaW5jbHVkZSAiZ2xvYmFscy5oIgorCiAvKiBGb3J3YXJkIGRlY2xhcmF0aW9ucyBmb3Ig cHJvdG90eXBlcy4gICovCiBzdHJ1Y3Qgd2luZG93Owogc3RydWN0IGZyYW1lOwogCi0vKiBT aW1wbGUgYWNjZXNzIGZ1bmN0aW9ucy4gICovCi0KLUxJU1BfSU5MSU5FIExpc3BfT2JqZWN0 ICoKLWFyZWZfYWRkciAoTGlzcF9PYmplY3QgYXJyYXksIHB0cmRpZmZfdCBpZHgpCi17Ci0g IHJldHVybiAmIFhWRUNUT1IgKGFycmF5KS0+Y29udGVudHNbaWR4XTsKLX0KLQotTElTUF9J TkxJTkUgdm9pZAotZ2NfYXNldCAoTGlzcF9PYmplY3QgYXJyYXksIHB0cmRpZmZfdCBpZHgs IExpc3BfT2JqZWN0IHZhbCkKLXsKLSAgLyogTGlrZSBBU0VULCBidXQgYWxzbyBjYW4gYmUg dXNlZCBpbiB0aGUgZ2FyYmFnZSBjb2xsZWN0b3I6Ci0gICAgIHN3ZWVwX3dlYWtfdGFibGUg Y2FsbHMgc2V0X2hhc2hfa2V5IGV0Yy4gd2hpbGUgdGhlIHRhYmxlIGlzIG1hcmtlZC4gICov Ci0gIGVhc3NlcnQgKDAgPD0gaWR4ICYmIGlkeCA8IChBU0laRSAoYXJyYXkpICYgfkFSUkFZ X01BUktfRkxBRykpOwotICBYVkVDVE9SIChhcnJheSktPmNvbnRlbnRzW2lkeF0gPSB2YWw7 Ci19Ci0KIC8qIENvcHkgQ09VTlQgTGlzcF9PYmplY3RzIGZyb20gQVJHUyB0byBjb250ZW50 cyBvZiBWIHN0YXJ0aW5nIGZyb20gT0ZGU0VULiAgKi8KIAogTElTUF9JTkxJTkUgdm9pZApA QCAtMjg0OSw2ICszNTI1LDcgQEAKIAogZXh0ZXJuIExpc3BfT2JqZWN0IFFidWZmZXIsIFFp bnRlZ2VyLCBRc3ltYm9sOwogCitleHRlcm4gTGlzcF9PYmplY3QgUXN1YnJwOwogZXh0ZXJu IExpc3BfT2JqZWN0IFFmb250X3NwZWMsIFFmb250X2VudGl0eSwgUWZvbnRfb2JqZWN0Owog CiBFWEZVTiAoRmJ5dGVvcmRlciwgMCkgQVRUUklCVVRFX0NPTlNUOwpAQCAtMzIzNyw3ICsz OTE0LDcgQEAKICNpZmRlZiBHQ19DSEVDS19DT05TX0xJU1QKIGV4dGVybiB2b2lkIGNoZWNr X2NvbnNfbGlzdCAodm9pZCk7CiAjZWxzZQotI2RlZmluZSBjaGVja19jb25zX2xpc3QoKSAo KHZvaWQpIDApCitMSVNQX0lOTElORSB2b2lkIChjaGVja19jb25zX2xpc3QpICh2b2lkKSB7 IGxpc3BfaF9jaGVja19jb25zX2xpc3QgKCk7IH0KICNlbmRpZgogCiAjaWZkZWYgUkVMX0FM TE9DCkBAIC0zMzA1LDEwICszOTgyLDEyIEBACiBleHRlcm4gTGlzcF9PYmplY3QgaW50ZXJu XzEgKGNvbnN0IGNoYXIgKiwgcHRyZGlmZl90KTsKIGV4dGVybiBMaXNwX09iamVjdCBpbnRl cm5fY19zdHJpbmdfMSAoY29uc3QgY2hhciAqLCBwdHJkaWZmX3QpOwogZXh0ZXJuIExpc3Bf T2JqZWN0IG9ibG9va3VwIChMaXNwX09iamVjdCwgY29uc3QgY2hhciAqLCBwdHJkaWZmX3Qs IHB0cmRpZmZfdCk7Ci0jZGVmaW5lIExPQURISVNUX0FUVEFDSCh4KSBcCi0gIGRvIHsJCQkJ CQkJCQlcCi0gICAgaWYgKGluaXRpYWxpemVkKSBWY3VycmVudF9sb2FkX2xpc3QgPSBGY29u cyAoeCwgVmN1cnJlbnRfbG9hZF9saXN0KTsgXAotICB9IHdoaWxlICgwKQorTElTUF9JTkxJ TkUgdm9pZAorTE9BREhJU1RfQVRUQUNIIChMaXNwX09iamVjdCB4KQoreworICBpZiAoaW5p dGlhbGl6ZWQpCisgICAgVmN1cnJlbnRfbG9hZF9saXN0ID0gRmNvbnMgKHgsIFZjdXJyZW50 X2xvYWRfbGlzdCk7Cit9CiBleHRlcm4gaW50IG9wZW5wIChMaXNwX09iamVjdCwgTGlzcF9P YmplY3QsIExpc3BfT2JqZWN0LAogICAgICAgICAgICAgICAgICAgTGlzcF9PYmplY3QgKiwg TGlzcF9PYmplY3QpOwogZXh0ZXJuIExpc3BfT2JqZWN0IHN0cmluZ190b19udW1iZXIgKGNo YXIgY29uc3QgKiwgaW50LCBib29sKTsKQEAgLTM0MzEsNiArNDExMCw3IEBACiBleHRlcm4g TGlzcF9PYmplY3QgVmJ1ZmZlcl9hbGlzdDsKIGV4dGVybiBMaXNwX09iamVjdCBzZXRfYnVm ZmVyX2lmX2xpdmUgKExpc3BfT2JqZWN0KTsKIGV4dGVybiBMaXNwX09iamVjdCBvdGhlcl9i dWZmZXJfc2FmZWx5IChMaXNwX09iamVjdCk7CitleHRlcm4gTGlzcF9PYmplY3QgUW92ZXJs YXlwOwogZXh0ZXJuIExpc3BfT2JqZWN0IFFwcmlvcml0eSwgUXdpbmRvdywgUWJlZm9yZV9z dHJpbmcsIFFhZnRlcl9zdHJpbmc7CiBleHRlcm4gTGlzcF9PYmplY3QgZ2V0X3RydWVuYW1l X2J1ZmZlciAoTGlzcF9PYmplY3QpOwogZXh0ZXJuIHZvaWQgaW5pdF9idWZmZXJfb25jZSAo dm9pZCk7CkBAIC0zNTk0LDEwICs0Mjc0LDEwIEBACiB2b2lkIHN5bmNocm9uaXplX3N5c3Rl bV9tZXNzYWdlc19sb2NhbGUgKHZvaWQpOwogdm9pZCBzeW5jaHJvbml6ZV9zeXN0ZW1fdGlt ZV9sb2NhbGUgKHZvaWQpOwogI2Vsc2UKLSNkZWZpbmUgc2V0bG9jYWxlKGNhdGVnb3J5LCBs b2NhbGUpCi0jZGVmaW5lIGZpeHVwX2xvY2FsZSgpCi0jZGVmaW5lIHN5bmNocm9uaXplX3N5 c3RlbV9tZXNzYWdlc19sb2NhbGUoKQotI2RlZmluZSBzeW5jaHJvbml6ZV9zeXN0ZW1fdGlt ZV9sb2NhbGUoKQorTElTUF9JTkxJTkUgY2hhciAqc2V0bG9jYWxlIChpbnQgY2F0LCBjaGFy IGNvbnN0ICpsb2NhbGUpIHsgcmV0dXJuIDA7IH0KK0xJU1BfSU5MSU5FIHZvaWQgZml4dXBf bG9jYWxlICh2b2lkKSB7fQorTElTUF9JTkxJTkUgdm9pZCBzeW5jaHJvbml6ZV9zeXN0ZW1f bWVzc2FnZXNfbG9jYWxlICh2b2lkKSB7fQorTElTUF9JTkxJTkUgdm9pZCBzeW5jaHJvbml6 ZV9zeXN0ZW1fdGltZV9sb2NhbGUgKHZvaWQpIHt9CiAjZW5kaWYKIGV4dGVybiB2b2lkIHNo dXRfZG93bl9lbWFjcyAoaW50LCBMaXNwX09iamVjdCk7CiAKQEAgLTM5NTYsOCArNDYzNiw2 IEBACiAgIH0gd2hpbGUgKDApCiAKIAotI2luY2x1ZGUgImdsb2JhbHMuaCIKLQogLyogQ2hl Y2sgd2hldGhlciBpdCdzIHRpbWUgZm9yIEdDLCBhbmQgcnVuIGl0IGlmIHNvLiAgKi8KIAog TElTUF9JTkxJTkUgdm9pZApAQCAtMzk3MCw3ICs0NjQ4LDcgQEAKICAgICBGZ2FyYmFnZV9j b2xsZWN0ICgpOwogfQogCi1MSVNQX0lOTElORSBpbnQKK0xJU1BfSU5MSU5FIGJvb2wKIGZ1 bmN0aW9ucCAoTGlzcF9PYmplY3Qgb2JqZWN0KQogewogICBpZiAoU1lNQk9MUCAob2JqZWN0 KSAmJiAhTklMUCAoRmZib3VuZHAgKG9iamVjdCkpKQoKPT09IG1vZGlmaWVkIGZpbGUgJ3Ny Yy93aW5kb3cuYycKLS0tIHNyYy93aW5kb3cuYwkyMDEzLTA2LTA0IDE2OjMzOjQ2ICswMDAw CisrKyBzcmMvd2luZG93LmMJMjAxMy0wNi0wOSAxOTo0Mjo1MyArMDAwMApAQCAtNTUsNyAr NTUsOCBAQAogCiBMaXNwX09iamVjdCBRd2luZG93cCwgUXdpbmRvd19saXZlX3A7CiBzdGF0 aWMgTGlzcF9PYmplY3QgUXdpbmRvd192YWxpZF9wOwotc3RhdGljIExpc3BfT2JqZWN0IFF3 aW5kb3dfY29uZmlndXJhdGlvbl9wLCBRcmVjb3JkX3dpbmRvd19idWZmZXI7CitMaXNwX09i amVjdCBRd2luZG93X2NvbmZpZ3VyYXRpb25fcDsKK3N0YXRpYyBMaXNwX09iamVjdCBRcmVj b3JkX3dpbmRvd19idWZmZXI7CiBzdGF0aWMgTGlzcF9PYmplY3QgUXdpbmRvd19kZWxldGFi bGVfcCwgUWRlbGV0ZV93aW5kb3csIFFkaXNwbGF5X2J1ZmZlcjsKIHN0YXRpYyBMaXNwX09i amVjdCBRcmVwbGFjZV9idWZmZXJfaW5fd2luZG93cywgUWdldF9tcnVfd2luZG93Owogc3Rh dGljIExpc3BfT2JqZWN0IFF3aW5kb3dfcmVzaXplX3Jvb3Rfd2luZG93LCBRd2luZG93X3Jl c2l6ZV9yb290X3dpbmRvd192ZXJ0aWNhbGx5OwoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy93 aW5kb3cuaCcKLS0tIHNyYy93aW5kb3cuaAkyMDEzLTAzLTI4IDE0OjA0OjQ5ICswMDAwCisr KyBzcmMvd2luZG93LmgJMjAxMy0wNi0wOSAxOTo0Mjo1MyArMDAwMApAQCAtOTU4LDcgKzk1 OCw3IEBACiAKIC8qIFRoZXNlIHVzZWQgdG8gYmUgaW4gbGlzcC5oLiAgKi8KIAotZXh0ZXJu IExpc3BfT2JqZWN0IFF3aW5kb3dwLCBRd2luZG93X2xpdmVfcDsKK2V4dGVybiBMaXNwX09i amVjdCBRd2luZG93X2xpdmVfcDsKIGV4dGVybiBMaXNwX09iamVjdCBWd2luZG93X2xpc3Q7 CiAKIGV4dGVybiBzdHJ1Y3Qgd2luZG93ICpkZWNvZGVfbGl2ZV93aW5kb3cgKExpc3BfT2Jq ZWN0KTsKCg== --------------080600040104060500050802-- From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 13 12:30:43 2013 Received: (at 11935) by debbugs.gnu.org; 13 Jun 2013 16:30:43 +0000 Received: from localhost ([127.0.0.1]:41761 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UnAQ3-0003vQ-Ms for submit@debbugs.gnu.org; Thu, 13 Jun 2013 12:30:42 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:43799) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UnAPx-0003uv-N9 for 11935@debbugs.gnu.org; Thu, 13 Jun 2013 12:30:36 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id D8B52A60007; Thu, 13 Jun 2013 09:30:27 -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 WELXzvypPMSh; Thu, 13 Jun 2013 09:30:25 -0700 (PDT) Received: from penguin.cs.ucla.edu (Penguin.CS.UCLA.EDU [131.179.64.200]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id DEF3BA60002; Thu, 13 Jun 2013 09:30:25 -0700 (PDT) Message-ID: <51B9F3A1.9020405@cs.ucla.edu> Date: Thu, 13 Jun 2013 09:30:25 -0700 From: Paul Eggert User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130514 Thunderbird/17.0.6 MIME-Version: 1.0 To: Andreas Schwab Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <87k3m7qjrj.fsf@igel.home> In-Reply-To: <87k3m7qjrj.fsf@igel.home> Content-Type: multipart/mixed; boundary="------------080508070900040608090607" X-Spam-Score: -2.7 (--) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.7 (--) This is a multi-part message in MIME format. --------------080508070900040608090607 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 06/06/13 09:36, Andreas Schwab wrote: > Since it's only used in buffer.c it should be moved there. Yes, that's a win, as it makes it clearer to the human reader that the function is used and needed only by one module, and it simplifies lisp.h. Attached is a patch to do that systematically for lisp.h; it assumes the patch I sent out earlier today . A side effect is that this gives GCC -O2 a bit more chance to optimize, shrinking the executable by 3k on my x86-64 platform. --------------080508070900040608090607 Content-Type: text/x-patch; name="inline4o.diff" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="inline4o.diff" === modified file 'src/ChangeLog' --- src/ChangeLog 2013-06-13 14:17:41 +0000 +++ src/ChangeLog 2013-06-13 16:27:13 +0000 @@ -1,5 +1,38 @@ 2013-06-13 Paul Eggert + Move functions from lisp.h to individual modules when possible. + From a suggestion by Andreas Schwab in . + * alloc.c (XFLOAT_INIT, set_symbol_name): + * buffer.c (CHECK_OVERLAY): + * chartab.c (CHECK_CHAR_TABLE, set_char_table_ascii) + (set_char_table_parent): + * coding.c (CHECK_NATNUM_CAR, CHECK_NATNUM_CDR): + * data.c (BOOLFWDP, INTFWDP, KBOARD_OBJFWDP, OBJFWDP, XBOOLFWD) + (XKBOARD_OBJFWD, XINTFWD, XOBJFWD, CHECK_SUBR, set_blv_found) + (blv_value, set_blv_value, set_blv_where, set_blv_defcell) + (set_blv_valcell): + * emacs.c (setlocale) [!HAVE_SETLOCALE]: + * eval.c (specpdl_symbol, specpdl_old_value, specpdl_where) + (specpdl_arg, specpdl_func, backtrace_function, backtrace_nargs) + (backtrace_args, backtrace_debug_on_exit): + * floatfns.c (CHECK_FLOAT): + * fns.c (CHECK_HASH_TABLE, CHECK_LIST_END) + (set_hash_key_and_value, set_hash_next, set_hash_next_slot) + (set_hash_hash, set_hash_hash_slot, set_hash_index) + (set_hash_index_slot): + * keymap.c (CHECK_VECTOR_OR_CHAR_TABLE): + * marker.c (CHECK_MARKER): + * textprop.c (CHECK_STRING_OR_BUFFER): + * window.c (CHECK_WINDOW_CONFIGURATION): + Move here from lisp.h, and make these functions static rather than + extern inline. + * buffer.c (Qoverlayp): + * data.c (Qsubrp): + * fns.c (Qhash_table_p): + * window.c (Qwindow_configuration_p): + Now static. + * lisp.h: Remove the abovementioned defns and decls. + Use functions, not macros, for XINT etc. (Bug#11935). In lisp.h, prefer functions to function-like macros, and constants to object-like macros, when either will do. This: === modified file 'src/alloc.c' --- src/alloc.c 2013-06-05 04:38:04 +0000 +++ src/alloc.c 2013-06-13 15:38:41 +0000 @@ -363,6 +363,11 @@ ((void *) (((uintptr_t) (ptr) + (ALIGNMENT) - 1) \ & ~ ((ALIGNMENT) - 1))) +static void +XFLOAT_INIT (Lisp_Object f, double n) +{ + XFLOAT (f)->u.data = n; +} /************************************************************************ @@ -3189,6 +3194,12 @@ static struct Lisp_Symbol *symbol_free_list; +static void +set_symbol_name (Lisp_Object sym, Lisp_Object name) +{ + XSYMBOL (sym)->name = name; +} + DEFUN ("make-symbol", Fmake_symbol, Smake_symbol, 1, 1, 0, doc: /* Return a newly allocated uninterned symbol whose name is NAME. Its value is void, and its function definition and property list are nil. */) === modified file 'src/buffer.c' --- src/buffer.c 2013-06-05 04:38:04 +0000 +++ src/buffer.c 2013-06-13 15:56:46 +0000 @@ -134,7 +134,7 @@ static Lisp_Object Qget_file_buffer; -Lisp_Object Qoverlayp; +static Lisp_Object Qoverlayp; Lisp_Object Qpriority, Qbefore_string, Qafter_string; @@ -150,6 +150,12 @@ static void modify_overlay (struct buffer *, ptrdiff_t, ptrdiff_t); static Lisp_Object buffer_lisp_local_variables (struct buffer *, bool); +static void +CHECK_OVERLAY (Lisp_Object x) +{ + CHECK_TYPE (OVERLAYP (x), Qoverlayp, x); +} + /* These setters are used only in this file, so they can be private. */ static void bset_abbrev_mode (struct buffer *b, Lisp_Object val) @@ -1539,7 +1545,7 @@ && BUFFER_LIVE_P (XBUFFER (b)) && !BUFFER_HIDDEN_P (XBUFFER (b))); } - + DEFUN ("other-buffer", Fother_buffer, Sother_buffer, 0, 3, 0, doc: /* Return most recently selected buffer other than BUFFER. Buffers not visible in windows are preferred to visible buffers, unless === modified file 'src/chartab.c' --- src/chartab.c 2012-09-24 12:23:25 +0000 +++ src/chartab.c 2013-06-13 15:38:16 +0000 @@ -84,6 +84,22 @@ (STRINGP (OBJ) && SCHARS (OBJ) > 0 \ && ((SREF (OBJ, 0) == 1 || (SREF (OBJ, 0) == 2)))) +static void +CHECK_CHAR_TABLE (Lisp_Object x) +{ + CHECK_TYPE (CHAR_TABLE_P (x), Qchar_table_p, x); +} + +static void +set_char_table_ascii (Lisp_Object table, Lisp_Object val) +{ + XCHAR_TABLE (table)->ascii = val; +} +static void +set_char_table_parent (Lisp_Object table, Lisp_Object val) +{ + XCHAR_TABLE (table)->parent = val; +} DEFUN ("make-char-table", Fmake_char_table, Smake_char_table, 1, 2, 0, doc: /* Return a newly created char-table, with purpose PURPOSE. === modified file 'src/coding.c' --- src/coding.c 2013-05-22 14:53:21 +0000 +++ src/coding.c 2013-06-13 15:38:16 +0000 @@ -655,6 +655,22 @@ (charset_list) = CODING_ATTR_CHARSET_LIST (attrs); \ } while (0) +static void +CHECK_NATNUM_CAR (Lisp_Object x) +{ + Lisp_Object tmp = XCAR (x); + CHECK_NATNUM (tmp); + XSETCAR (x, tmp); +} + +static void +CHECK_NATNUM_CDR (Lisp_Object x) +{ + Lisp_Object tmp = XCDR (x); + CHECK_NATNUM (tmp); + XSETCDR (x, tmp); +} + /* Safely get one byte from the source text pointed by SRC which ends at SRC_END, and set C to that byte. If there are not enough bytes === modified file 'src/data.c' --- src/data.c 2013-06-05 04:38:04 +0000 +++ src/data.c 2013-06-13 15:56:52 +0000 @@ -76,7 +76,7 @@ static Lisp_Object Qcompiled_function, Qframe; Lisp_Object Qbuffer; static Lisp_Object Qchar_table, Qbool_vector, Qhash_table; -Lisp_Object Qsubrp; +static Lisp_Object Qsubrp; static Lisp_Object Qmany, Qunevalled; Lisp_Object Qfont_spec, Qfont_entity, Qfont_object; static Lisp_Object Qdefun; @@ -86,6 +86,94 @@ static void swap_in_symval_forwarding (struct Lisp_Symbol *, struct Lisp_Buffer_Local_Value *); +static bool +BOOLFWDP (union Lisp_Fwd *a) +{ + return XFWDTYPE (a) == Lisp_Fwd_Bool; +} +static bool +INTFWDP (union Lisp_Fwd *a) +{ + return XFWDTYPE (a) == Lisp_Fwd_Int; +} +static bool +KBOARD_OBJFWDP (union Lisp_Fwd *a) +{ + return XFWDTYPE (a) == Lisp_Fwd_Kboard_Obj; +} +static bool +OBJFWDP (union Lisp_Fwd *a) +{ + return XFWDTYPE (a) == Lisp_Fwd_Obj; +} + +static struct Lisp_Boolfwd * +XBOOLFWD (union Lisp_Fwd *a) +{ + eassert (BOOLFWDP (a)); + return &a->u_boolfwd; +} +static struct Lisp_Kboard_Objfwd * +XKBOARD_OBJFWD (union Lisp_Fwd *a) +{ + eassert (KBOARD_OBJFWDP (a)); + return &a->u_kboard_objfwd; +} +static struct Lisp_Intfwd * +XINTFWD (union Lisp_Fwd *a) +{ + eassert (INTFWDP (a)); + return &a->u_intfwd; +} +static struct Lisp_Objfwd * +XOBJFWD (union Lisp_Fwd *a) +{ + eassert (OBJFWDP (a)); + return &a->u_objfwd; +} + +static void +CHECK_SUBR (Lisp_Object x) +{ + CHECK_TYPE (SUBRP (x), Qsubrp, x); +} + +static void +set_blv_found (struct Lisp_Buffer_Local_Value *blv, int found) +{ + eassert (found == !EQ (blv->defcell, blv->valcell)); + blv->found = found; +} + +static Lisp_Object +blv_value (struct Lisp_Buffer_Local_Value *blv) +{ + return XCDR (blv->valcell); +} + +static void +set_blv_value (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val) +{ + XSETCDR (blv->valcell, val); +} + +static void +set_blv_where (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val) +{ + blv->where = val; +} + +static void +set_blv_defcell (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val) +{ + blv->defcell = val; +} + +static void +set_blv_valcell (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val) +{ + blv->valcell = val; +} Lisp_Object wrong_type_argument (register Lisp_Object predicate, register Lisp_Object value) === modified file 'src/emacs.c' --- src/emacs.c 2013-06-05 12:17:02 +0000 +++ src/emacs.c 2013-06-13 15:38:16 +0000 @@ -306,6 +306,13 @@ static void *ns_pool; #endif +#if !HAVE_SETLOCALE +static char * +setlocale (int cat, char const *locale) +{ + return 0; +} +#endif /* Report a fatal error due to signal SIG, output a backtrace of at === modified file 'src/eval.c' --- src/eval.c 2013-06-05 04:38:04 +0000 +++ src/eval.c 2013-06-13 15:44:00 +0000 @@ -115,6 +115,69 @@ static Lisp_Object funcall_lambda (Lisp_Object, ptrdiff_t, Lisp_Object *); static Lisp_Object apply_lambda (Lisp_Object fun, Lisp_Object args); +static Lisp_Object +specpdl_symbol (struct specbinding *pdl) +{ + eassert (pdl->kind >= SPECPDL_LET); + return pdl->v.let.symbol; +} + +static Lisp_Object +specpdl_old_value (struct specbinding *pdl) +{ + eassert (pdl->kind >= SPECPDL_LET); + return pdl->v.let.old_value; +} + +static Lisp_Object +specpdl_where (struct specbinding *pdl) +{ + eassert (pdl->kind > SPECPDL_LET); + return pdl->v.let.where; +} + +static Lisp_Object +specpdl_arg (struct specbinding *pdl) +{ + eassert (pdl->kind == SPECPDL_UNWIND); + return pdl->v.unwind.arg; +} + +static specbinding_func +specpdl_func (struct specbinding *pdl) +{ + eassert (pdl->kind == SPECPDL_UNWIND); + return pdl->v.unwind.func; +} + +static Lisp_Object +backtrace_function (struct specbinding *pdl) +{ + eassert (pdl->kind == SPECPDL_BACKTRACE); + return pdl->v.bt.function; +} + +static ptrdiff_t +backtrace_nargs (struct specbinding *pdl) +{ + eassert (pdl->kind == SPECPDL_BACKTRACE); + return pdl->v.bt.nargs; +} + +static Lisp_Object * +backtrace_args (struct specbinding *pdl) +{ + eassert (pdl->kind == SPECPDL_BACKTRACE); + return pdl->v.bt.args; +} + +static bool +backtrace_debug_on_exit (struct specbinding *pdl) +{ + eassert (pdl->kind == SPECPDL_BACKTRACE); + return pdl->v.bt.debug_on_exit; +} + /* Functions to modify slots of backtrace records. */ static void === modified file 'src/floatfns.c' --- src/floatfns.c 2013-03-24 12:59:45 +0000 +++ src/floatfns.c 2013-06-13 15:38:16 +0000 @@ -41,6 +41,14 @@ # define isnan(x) ((x) != (x)) #endif +/* Check that X is a floating point number. */ + +static void +CHECK_FLOAT (Lisp_Object x) +{ + CHECK_TYPE (FLOATP (x), Qfloatp, x); +} + /* Extract a Lisp number as a `double', or signal an error. */ double === modified file 'src/fns.c' --- src/fns.c 2013-06-05 04:38:04 +0000 +++ src/fns.c 2013-06-13 16:00:53 +0000 @@ -91,6 +91,12 @@ /* Random data-structure functions. */ +static void +CHECK_LIST_END (Lisp_Object x, Lisp_Object y) +{ + CHECK_TYPE (NILP (x), Qlistp, y); +} + DEFUN ("length", Flength, Slength, 1, 1, 0, doc: /* Return the length of vector, list or string SEQUENCE. A byte-code function object is also allowed. @@ -3335,7 +3341,7 @@ /* Various symbols. */ -Lisp_Object Qhash_table_p; +static Lisp_Object Qhash_table_p; static Lisp_Object Qkey, Qvalue, Qeql; Lisp_Object Qeq, Qequal; Lisp_Object QCtest, QCsize, QCrehash_size, QCrehash_threshold, QCweakness; @@ -3346,6 +3352,48 @@ Utilities ***********************************************************************/ +static void +CHECK_HASH_TABLE (Lisp_Object x) +{ + return CHECK_TYPE (HASH_TABLE_P (x), Qhash_table_p, x); +} + +static void +set_hash_key_and_value (struct Lisp_Hash_Table *h, Lisp_Object key_and_value) +{ + h->key_and_value = key_and_value; +} +static void +set_hash_next (struct Lisp_Hash_Table *h, Lisp_Object next) +{ + h->next = next; +} +static void +set_hash_next_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val) +{ + gc_aset (h->next, idx, val); +} +static void +set_hash_hash (struct Lisp_Hash_Table *h, Lisp_Object hash) +{ + h->hash = hash; +} +static void +set_hash_hash_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val) +{ + gc_aset (h->hash, idx, val); +} +static void +set_hash_index (struct Lisp_Hash_Table *h, Lisp_Object index) +{ + h->index = index; +} +static void +set_hash_index_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val) +{ + gc_aset (h->index, idx, val); +} + /* If OBJ is a Lisp hash table, return a pointer to its struct Lisp_Hash_Table. Otherwise, signal an error. */ === modified file 'src/keymap.c' --- src/keymap.c 2013-06-05 01:58:43 +0000 +++ src/keymap.c 2013-06-13 15:38:16 +0000 @@ -106,6 +106,12 @@ Lisp_Object, Lisp_Object, bool, bool); static void silly_event_symbol_error (Lisp_Object); static Lisp_Object get_keyelt (Lisp_Object, bool); + +static void +CHECK_VECTOR_OR_CHAR_TABLE (Lisp_Object x) +{ + CHECK_TYPE (VECTORP (x) || CHAR_TABLE_P (x), Qvector_or_char_table_p, x); +} /* Keymap object support - constructors and predicates. */ === modified file 'src/lisp.h' --- src/lisp.h 2013-06-13 00:07:44 +0000 +++ src/lisp.h 2013-06-13 16:02:41 +0000 @@ -715,7 +715,6 @@ /* Defined in this file. */ union Lisp_Fwd; -LISP_INLINE bool BOOLFWDP (union Lisp_Fwd *); LISP_INLINE bool BOOL_VECTOR_P (Lisp_Object); LISP_INLINE bool BUFFER_OBJFWDP (union Lisp_Fwd *); LISP_INLINE bool BUFFERP (Lisp_Object); @@ -725,12 +724,9 @@ LISP_INLINE bool (FLOATP) (Lisp_Object); LISP_INLINE bool functionp (Lisp_Object); LISP_INLINE bool (INTEGERP) (Lisp_Object); -LISP_INLINE bool INTFWDP (union Lisp_Fwd *); -LISP_INLINE bool KBOARD_OBJFWDP (union Lisp_Fwd *); LISP_INLINE bool (MARKERP) (Lisp_Object); LISP_INLINE bool (MISCP) (Lisp_Object); LISP_INLINE bool (NILP) (Lisp_Object); -LISP_INLINE bool OBJFWDP (union Lisp_Fwd *); LISP_INLINE bool OVERLAYP (Lisp_Object); LISP_INLINE bool PROCESSP (Lisp_Object); LISP_INLINE bool PSEUDOVECTORP (Lisp_Object, int); @@ -745,9 +741,6 @@ LISP_INLINE bool WINDOWP (Lisp_Object); LISP_INLINE struct Lisp_Save_Value *XSAVE_VALUE (Lisp_Object); -/* Defined in buffer.c. */ -extern Lisp_Object Qoverlayp; - /* Defined in chartab.c. */ extern Lisp_Object char_table_ref (Lisp_Object, int); extern void char_table_set (Lisp_Object, int, Lisp_Object); @@ -756,7 +749,7 @@ /* Defined in data.c. */ extern Lisp_Object Qarrayp, Qbufferp, Qbuffer_or_string_p, Qchar_table_p; extern Lisp_Object Qconsp, Qfloatp, Qintegerp, Qlambda, Qlistp, Qmarkerp, Qnil; -extern Lisp_Object Qnumberp, Qsubrp, Qstringp, Qsymbolp, Qvectorp; +extern Lisp_Object Qnumberp, Qstringp, Qsymbolp, Qvectorp; extern Lisp_Object Qvector_or_char_table_p, Qwholenump; extern Lisp_Object Ffboundp (Lisp_Object); extern _Noreturn Lisp_Object wrong_type_argument (Lisp_Object, Lisp_Object); @@ -767,9 +760,6 @@ /* Defined in eval.c. */ extern Lisp_Object Qautoload; -/* Defined in fns.c */ -extern Lisp_Object Qhash_table_p; - /* Defined in floatfns.c. */ extern double extract_float (Lisp_Object); @@ -777,7 +767,7 @@ extern Lisp_Object Qprocessp; /* Defined in window.c. */ -extern Lisp_Object Qwindowp, Qwindow_configuration_p; +extern Lisp_Object Qwindowp; /* Defined in xdisp.c. */ extern Lisp_Object Qimage; @@ -956,13 +946,6 @@ typedef struct interval *INTERVAL; -/* Complain if object is not string or buffer type. */ -LISP_INLINE void -CHECK_STRING_OR_BUFFER (Lisp_Object x) -{ - CHECK_TYPE (STRINGP (x) || BUFFERP (x), Qbuffer_or_string_p, x); -} - struct Lisp_Cons { /* Car of this cons cell. */ @@ -1677,11 +1660,6 @@ { return PSEUDOVECTORP (a, PVEC_HASH_TABLE); } -LISP_INLINE void -CHECK_HASH_TABLE (Lisp_Object x) -{ - return CHECK_TYPE (HASH_TABLE_P (x), Qhash_table_p, x); -} /* Value is the key part of entry IDX in hash table H. */ LISP_INLINE Lisp_Object @@ -2156,40 +2134,12 @@ return a->u_intfwd.type; } -LISP_INLINE struct Lisp_Intfwd * -XINTFWD (union Lisp_Fwd *a) -{ - eassert (INTFWDP (a)); - return &a->u_intfwd; -} - -LISP_INLINE struct Lisp_Boolfwd * -XBOOLFWD (union Lisp_Fwd *a) -{ - eassert (BOOLFWDP (a)); - return &a->u_boolfwd; -} - -LISP_INLINE struct Lisp_Objfwd * -XOBJFWD (union Lisp_Fwd *a) -{ - eassert (OBJFWDP (a)); - return &a->u_objfwd; -} - LISP_INLINE struct Lisp_Buffer_Objfwd * XBUFFER_OBJFWD (union Lisp_Fwd *a) { eassert (BUFFER_OBJFWDP (a)); return &a->u_buffer_objfwd; } - -LISP_INLINE struct Lisp_Kboard_Objfwd * -XKBOARD_OBJFWD (union Lisp_Fwd *a) -{ - eassert (KBOARD_OBJFWDP (a)); - return &a->u_kboard_objfwd; -} /* Lisp floating point type. */ struct Lisp_Float @@ -2207,12 +2157,6 @@ return XFLOAT (f)->u.data; } -LISP_INLINE void -XFLOAT_INIT (Lisp_Object f, double n) -{ - XFLOAT (f)->u.data = n; -} - /* Most hosts nowadays use IEEE floating point, so they use IEC 60559 representations, have infinities and NaNs, and do not trap on exceptions. Define IEEE_FLOATING_POINT if this host is one of the @@ -2392,30 +2336,10 @@ } LISP_INLINE bool -INTFWDP (union Lisp_Fwd *a) -{ - return XFWDTYPE (a) == Lisp_Fwd_Int; -} -LISP_INLINE bool -BOOLFWDP (union Lisp_Fwd *a) -{ - return XFWDTYPE (a) == Lisp_Fwd_Bool; -} -LISP_INLINE bool -OBJFWDP (union Lisp_Fwd *a) -{ - return XFWDTYPE (a) == Lisp_Fwd_Obj; -} -LISP_INLINE bool BUFFER_OBJFWDP (union Lisp_Fwd *a) { return XFWDTYPE (a) == Lisp_Fwd_Buffer_Obj; } -LISP_INLINE bool -KBOARD_OBJFWDP (union Lisp_Fwd *a) -{ - return XFWDTYPE (a) == Lisp_Fwd_Kboard_Obj; -} LISP_INLINE bool PSEUDOVECTOR_TYPEP (struct vectorlike_header *a, int code) @@ -2532,11 +2456,6 @@ lisp_h_CHECK_LIST_CONS (x, y); } LISP_INLINE void -CHECK_LIST_END (Lisp_Object x, Lisp_Object y) -{ - CHECK_TYPE (NILP (x), Qlistp, y); -} -LISP_INLINE void CHECK_STRING (Lisp_Object x) { CHECK_TYPE (STRINGP (x), Qstringp, x); @@ -2557,11 +2476,6 @@ lisp_h_CHECK_SYMBOL (x); } LISP_INLINE void -CHECK_CHAR_TABLE (Lisp_Object x) -{ - CHECK_TYPE (CHAR_TABLE_P (x), Qchar_table_p, x); -} -LISP_INLINE void CHECK_VECTOR (Lisp_Object x) { CHECK_TYPE (VECTORP (x), Qvectorp, x); @@ -2577,11 +2491,6 @@ CHECK_TYPE (ARRAYP (x), Qxxxp, x); } LISP_INLINE void -CHECK_VECTOR_OR_CHAR_TABLE (Lisp_Object x) -{ - CHECK_TYPE (VECTORP (x) || CHAR_TABLE_P (x), Qvector_or_char_table_p, x); -} -LISP_INLINE void CHECK_BUFFER (Lisp_Object x) { CHECK_TYPE (BUFFERP (x), Qbufferp, x); @@ -2592,21 +2501,11 @@ CHECK_TYPE (WINDOWP (x), Qwindowp, x); } LISP_INLINE void -CHECK_WINDOW_CONFIGURATION (Lisp_Object x) -{ - CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x); -} -LISP_INLINE void CHECK_PROCESS (Lisp_Object x) { CHECK_TYPE (PROCESSP (x), Qprocessp, x); } LISP_INLINE void -CHECK_SUBR (Lisp_Object x) -{ - CHECK_TYPE (SUBRP (x), Qsubrp, x); -} -LISP_INLINE void (CHECK_NUMBER) (Lisp_Object x) { lisp_h_CHECK_NUMBER (x); @@ -2636,12 +2535,6 @@ CHECK_RANGED_INTEGER (x, 0, TYPE_MAXIMUM (type)); \ } while (0) -LISP_INLINE void -CHECK_MARKER (Lisp_Object x) -{ - CHECK_TYPE (MARKERP (x), Qmarkerp, x); -} - #define CHECK_NUMBER_COERCE_MARKER(x) \ do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \ else CHECK_TYPE (INTEGERP (x), Qinteger_or_marker_p, x); } while (0) @@ -2653,11 +2546,6 @@ } LISP_INLINE void -CHECK_FLOAT (Lisp_Object x) -{ - CHECK_TYPE (FLOATP (x), Qfloatp, x); -} -LISP_INLINE void CHECK_NUMBER_OR_FLOAT (Lisp_Object x) { CHECK_TYPE (FLOATP (x) || INTEGERP (x), Qnumberp, x); @@ -2667,12 +2555,6 @@ do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x)); \ else CHECK_TYPE (INTEGERP (x) || FLOATP (x), Qnumber_or_marker_p, x); } while (0) -LISP_INLINE void -CHECK_OVERLAY (Lisp_Object x) -{ - CHECK_TYPE (OVERLAYP (x), Qoverlayp, x); -} - /* Since we can't assign directly to the CAR or CDR fields of a cons cell, use these when checking that those fields contain numbers. */ LISP_INLINE void @@ -2690,22 +2572,6 @@ CHECK_NUMBER (tmp); XSETCDR (x, tmp); } - -LISP_INLINE void -CHECK_NATNUM_CAR (Lisp_Object x) -{ - Lisp_Object tmp = XCAR (x); - CHECK_NATNUM (tmp); - XSETCAR (x, tmp); -} - -LISP_INLINE void -CHECK_NATNUM_CDR (Lisp_Object x) -{ - Lisp_Object tmp = XCDR (x); - CHECK_NATNUM (tmp); - XSETCDR (x, tmp); -} /* Define a built-in function for calling from Lisp. `lname' should be the name to give the function in Lisp, @@ -2932,33 +2798,6 @@ } v; }; -LISP_INLINE Lisp_Object specpdl_symbol (struct specbinding *pdl) -{ eassert (pdl->kind >= SPECPDL_LET); return pdl->v.let.symbol; } - -LISP_INLINE Lisp_Object specpdl_old_value (struct specbinding *pdl) -{ eassert (pdl->kind >= SPECPDL_LET); return pdl->v.let.old_value; } - -LISP_INLINE Lisp_Object specpdl_where (struct specbinding *pdl) -{ eassert (pdl->kind > SPECPDL_LET); return pdl->v.let.where; } - -LISP_INLINE Lisp_Object specpdl_arg (struct specbinding *pdl) -{ eassert (pdl->kind == SPECPDL_UNWIND); return pdl->v.unwind.arg; } - -LISP_INLINE specbinding_func specpdl_func (struct specbinding *pdl) -{ eassert (pdl->kind == SPECPDL_UNWIND); return pdl->v.unwind.func; } - -LISP_INLINE Lisp_Object backtrace_function (struct specbinding *pdl) -{ eassert (pdl->kind == SPECPDL_BACKTRACE); return pdl->v.bt.function; } - -LISP_INLINE ptrdiff_t backtrace_nargs (struct specbinding *pdl) -{ eassert (pdl->kind == SPECPDL_BACKTRACE); return pdl->v.bt.nargs; } - -LISP_INLINE Lisp_Object *backtrace_args (struct specbinding *pdl) -{ eassert (pdl->kind == SPECPDL_BACKTRACE); return pdl->v.bt.args; } - -LISP_INLINE bool backtrace_debug_on_exit (struct specbinding *pdl) -{ eassert (pdl->kind == SPECPDL_BACKTRACE); return pdl->v.bt.debug_on_exit; } - extern struct specbinding *specpdl; extern struct specbinding *specpdl_ptr; extern ptrdiff_t specpdl_size; @@ -3301,12 +3140,6 @@ /* Functions to modify hash tables. */ LISP_INLINE void -set_hash_key_and_value (struct Lisp_Hash_Table *h, Lisp_Object key_and_value) -{ - h->key_and_value = key_and_value; -} - -LISP_INLINE void set_hash_key_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val) { gc_aset (h->key_and_value, 2 * idx, val); @@ -3318,52 +3151,10 @@ gc_aset (h->key_and_value, 2 * idx + 1, val); } -LISP_INLINE void -set_hash_next (struct Lisp_Hash_Table *h, Lisp_Object next) -{ - h->next = next; -} - -LISP_INLINE void -set_hash_next_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val) -{ - gc_aset (h->next, idx, val); -} - -LISP_INLINE void -set_hash_hash (struct Lisp_Hash_Table *h, Lisp_Object hash) -{ - h->hash = hash; -} - -LISP_INLINE void -set_hash_hash_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val) -{ - gc_aset (h->hash, idx, val); -} - -LISP_INLINE void -set_hash_index (struct Lisp_Hash_Table *h, Lisp_Object index) -{ - h->index = index; -} - -LISP_INLINE void -set_hash_index_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val) -{ - gc_aset (h->index, idx, val); -} - /* Use these functions to set Lisp_Object or pointer slots of struct Lisp_Symbol. */ LISP_INLINE void -set_symbol_name (Lisp_Object sym, Lisp_Object name) -{ - XSYMBOL (sym)->name = name; -} - -LISP_INLINE void set_symbol_function (Lisp_Object sym, Lisp_Object function) { XSYMBOL (sym)->function = function; @@ -3390,43 +3181,6 @@ return blv->found; } -LISP_INLINE void -set_blv_found (struct Lisp_Buffer_Local_Value *blv, int found) -{ - eassert (found == !EQ (blv->defcell, blv->valcell)); - blv->found = found; -} - -LISP_INLINE Lisp_Object -blv_value (struct Lisp_Buffer_Local_Value *blv) -{ - return XCDR (blv->valcell); -} - -LISP_INLINE void -set_blv_value (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val) -{ - XSETCDR (blv->valcell, val); -} - -LISP_INLINE void -set_blv_where (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val) -{ - blv->where = val; -} - -LISP_INLINE void -set_blv_defcell (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val) -{ - blv->defcell = val; -} - -LISP_INLINE void -set_blv_valcell (struct Lisp_Buffer_Local_Value *blv, Lisp_Object val) -{ - blv->valcell = val; -} - /* Set overlay's property list. */ LISP_INLINE void @@ -3455,21 +3209,11 @@ of setting slots directly. */ LISP_INLINE void -set_char_table_ascii (Lisp_Object table, Lisp_Object val) -{ - XCHAR_TABLE (table)->ascii = val; -} -LISP_INLINE void set_char_table_defalt (Lisp_Object table, Lisp_Object val) { XCHAR_TABLE (table)->defalt = val; } LISP_INLINE void -set_char_table_parent (Lisp_Object table, Lisp_Object val) -{ - XCHAR_TABLE (table)->parent = val; -} -LISP_INLINE void set_char_table_purpose (Lisp_Object table, Lisp_Object val) { XCHAR_TABLE (table)->purpose = val; @@ -3525,7 +3269,6 @@ extern Lisp_Object Qbuffer, Qinteger, Qsymbol; -extern Lisp_Object Qsubrp; extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object; EXFUN (Fbyteorder, 0) ATTRIBUTE_CONST; @@ -4110,7 +3853,6 @@ extern Lisp_Object Vbuffer_alist; extern Lisp_Object set_buffer_if_live (Lisp_Object); extern Lisp_Object other_buffer_safely (Lisp_Object); -extern Lisp_Object Qoverlayp; extern Lisp_Object Qpriority, Qwindow, Qbefore_string, Qafter_string; extern Lisp_Object get_truename_buffer (Lisp_Object); extern void init_buffer_once (void); @@ -4274,7 +4016,6 @@ void synchronize_system_messages_locale (void); void synchronize_system_time_locale (void); #else -LISP_INLINE char *setlocale (int cat, char const *locale) { return 0; } LISP_INLINE void fixup_locale (void) {} LISP_INLINE void synchronize_system_messages_locale (void) {} LISP_INLINE void synchronize_system_time_locale (void) {} === modified file 'src/marker.c' --- src/marker.c 2013-02-19 14:44:03 +0000 +++ src/marker.c 2013-06-13 15:38:16 +0000 @@ -127,6 +127,12 @@ } \ } +static void +CHECK_MARKER (Lisp_Object x) +{ + CHECK_TYPE (MARKERP (x), Qmarkerp, x); +} + /* Return the byte position corresponding to CHARPOS in B. */ ptrdiff_t === modified file 'src/textprop.c' --- src/textprop.c 2013-03-28 14:04:49 +0000 +++ src/textprop.c 2013-06-13 15:38:16 +0000 @@ -98,6 +98,14 @@ set_buffer_internal (old); } +/* Complain if object is not string or buffer type. */ + +static void +CHECK_STRING_OR_BUFFER (Lisp_Object x) +{ + CHECK_TYPE (STRINGP (x) || BUFFERP (x), Qbuffer_or_string_p, x); +} + /* Extract the interval at the position pointed to by BEGIN from OBJECT, a string or buffer. Additionally, check that the positions pointed to by BEGIN and END are within the bounds of OBJECT, and === modified file 'src/window.c' --- src/window.c 2013-06-05 04:38:04 +0000 +++ src/window.c 2013-06-13 16:02:24 +0000 @@ -55,7 +55,7 @@ Lisp_Object Qwindowp, Qwindow_live_p; static Lisp_Object Qwindow_valid_p; -Lisp_Object Qwindow_configuration_p; +static Lisp_Object Qwindow_configuration_p; static Lisp_Object Qrecord_window_buffer; static Lisp_Object Qwindow_deletable_p, Qdelete_window, Qdisplay_buffer; static Lisp_Object Qreplace_buffer_in_windows, Qget_mru_window; @@ -131,6 +131,12 @@ static EMACS_INT window_scroll_preserve_hpos; static EMACS_INT window_scroll_preserve_vpos; +static void +CHECK_WINDOW_CONFIGURATION (Lisp_Object x) +{ + CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x); +} + /* These setters are used only in this file, so they can be private. */ static void wset_combination_limit (struct window *w, Lisp_Object val) --------------080508070900040608090607-- From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 13 18:48:56 2013 Received: (at 11935) by debbugs.gnu.org; 13 Jun 2013 22:48:56 +0000 Received: from localhost ([127.0.0.1]:42425 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UnGK7-0001Ii-WC for submit@debbugs.gnu.org; Thu, 13 Jun 2013 18:48:56 -0400 Received: from ironport2-out.teksavvy.com ([206.248.154.182]:23012) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UnGK4-0001IR-Q7 for 11935@debbugs.gnu.org; Thu, 13 Jun 2013 18:48:53 -0400 X-IronPort-Anti-Spam-Filtered: true X-IronPort-Anti-Spam-Result: Av4EABK/CFFFpZVy/2dsb2JhbABEDr8AF3OCHwEFViMQCzQSFBgNJIgkwS2RCgOkeoFegjla X-IPAS-Result: Av4EABK/CFFFpZVy/2dsb2JhbABEDr8AF3OCHwEFViMQCzQSFBgNJIgkwS2RCgOkeoFegjla X-IronPort-AV: E=Sophos;i="4.84,565,1355115600"; d="scan'208";a="16356444" Received: from 69-165-149-114.dsl.teksavvy.com (HELO ceviche.home) ([69.165.149.114]) by ironport2-out.teksavvy.com with ESMTP/TLS/ADH-AES256-SHA; 13 Jun 2013 18:48:10 -0400 Received: by ceviche.home (Postfix, from userid 20848) id 2950D663E4; Thu, 13 Jun 2013 16:08:08 -0400 (EDT) From: Stefan Monnier To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions Message-ID: References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <51B42B07.5090209@cs.ucla.edu> <51B9DAFC.3010502@cs.ucla.edu> Date: Thu, 13 Jun 2013 16:08:08 -0400 In-Reply-To: <51B9DAFC.3010502@cs.ucla.edu> (Paul Eggert's message of "Thu, 13 Jun 2013 07:45:16 -0700") User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Score: 0.3 (/) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: 0.3 (/) > + the operation's implementation. That way, OP can be implementated ^^^^^^^^^^^^^ implemented > +LISP_INLINE bool > +(LISP_INT_TAG_P) (int x) > +{ > + return lisp_h_LISP_INT_TAG_P (x); > +} Can't we use something like #define FUNCTION_OF_MACRO(fun, type_in, type_out) \ LISP_INLINE type_out (fun) (type_in x) { return lisp_h_##fun (x); } [ I guess it depends on whether the args to FUNCTION_OF_MACRO get macro-expanded before or after expanding the macro. ] Other than that, it looks OK for me, Stefan From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 15 02:43:45 2013 Received: (at 11935) by debbugs.gnu.org; 15 Jun 2013 06:43:45 +0000 Received: from localhost ([127.0.0.1]:45447 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UnkDB-0008Tq-B1 for submit@debbugs.gnu.org; Sat, 15 Jun 2013 02:43:45 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:47554) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UnkD5-0008TK-SM for 11935@debbugs.gnu.org; Sat, 15 Jun 2013 02:43:41 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 613B2A60003; Fri, 14 Jun 2013 23:43:34 -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 NdDb296BHjIR; Fri, 14 Jun 2013 23:43:30 -0700 (PDT) Received: from [192.168.1.9] (pool-71-108-49-126.lsanca.fios.verizon.net [71.108.49.126]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 4ECAB39E8100; Fri, 14 Jun 2013 23:43:30 -0700 (PDT) Message-ID: <51BC0D12.4060807@cs.ucla.edu> Date: Fri, 14 Jun 2013 23:43:30 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130510 Thunderbird/17.0.6 MIME-Version: 1.0 To: Stefan Monnier Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <51B42B07.5090209@cs.ucla.edu> <51B9DAFC.3010502@cs.ucla.edu> In-Reply-To: X-Enigmail-Version: 1.5.1 Content-Type: multipart/mixed; boundary="------------070603050203080502010407" X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" This is a multi-part message in MIME format. --------------070603050203080502010407 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit On 06/13/2013 01:08 PM, Stefan Monnier wrote: > Can't we use something like > > #define FUNCTION_OF_MACRO(fun, type_in, type_out) \ > LISP_INLINE type_out (fun) (type_in x) { return lisp_h_##fun (x); } Sure, though we need to adjust that a bit, as the function can take multiple args, and it might return void (where the 'return' keyword must be omitted). The following variant works for me, and the attached combined patch implements this suggestion. /* Define NAME as a lisp.h inline function that returns TYPE and has arguments declared as ARGDECLS and passed as ARGS. ARGDECLS and ARGS should be parenthesized. Implement the function by calling lisp_h_NAME ARGS. */ #define LISP_MACRO_DEFUN(name, type, argdecls, args) \ LISP_INLINE type (name) argdecls { return lisp_h_##name args; } /* like LISP_MACRO_DEFUN, except NAME returns void. */ #define LISP_MACRO_DEFUN_VOID(name, argdecls, args) \ LISP_INLINE void (name) argdecls { lisp_h_##name args; } --------------070603050203080502010407 Content-Type: text/plain; charset=UTF-8; name="inline4o.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="inline4o.txt" PT09IG1vZGlmaWVkIGZpbGUgJ0NoYW5nZUxvZycKLS0tIENoYW5nZUxvZwkyMDEzLTA2LTEx IDE4OjA1OjA1ICswMDAwCisrKyBDaGFuZ2VMb2cJMjAxMy0wNi0xNSAwNjoxNzowNyArMDAw MApAQCAtMSwzICsxLDkgQEAKKzIwMTMtMDYtMTUgIFBhdWwgRWdnZXJ0ICA8ZWdnZXJ0QGNz LnVjbGEuZWR1PgorCisJVXNlIGZ1bmN0aW9ucywgbm90IG1hY3JvcywgZm9yIFhJTlQgZXRj LiAoQnVnIzExOTM1KS4KKwkqIGNvbmZpZ3VyZS5hYyAoV0FSTl9DRkxBR1MpOiBSZW1vdmUg LVdiYWQtZnVuY3Rpb24tY2FzdCwKKwlhcyBpdCBnZW5lcmF0ZXMgYm9ndXMgd2FybmluZ3Mg YWJvdXQgcmVhc29uYWJsZSBjYXN0cyBvZiBjYWxscy4KKwogMjAxMy0wNi0xMSAgUGF1bCBF Z2dlcnQgIDxlZ2dlcnRAY3MudWNsYS5lZHU+CiAKIAktLXdpdGhvdXQtYWxsIHNob3VsZCBp bXBseSAtLXdpdGgtZmlsZS1ub3RpZmljYXRpb249bm8uICAoQnVnIzE0NTY5KQoKPT09IG1v ZGlmaWVkIGZpbGUgJ2NvbmZpZ3VyZS5hYycKLS0tIGNvbmZpZ3VyZS5hYwkyMDEzLTA2LTEz IDA2OjI4OjA1ICswMDAwCisrKyBjb25maWd1cmUuYWMJMjAxMy0wNi0xMyAxNTozODowMyAr MDAwMApAQCAtNzc2LDYgKzc3Niw3IEBACiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAjIHNpZ25lZCBvdmVyZmxvdyBoYXMgdW5kZWZpbmVkIGJlaGF2aW9yCiAgIG53 PSIkbncgLVdzeW5jLW5hbmQiICAgICAgICAgICAgICAjIGlycmVsZXZhbnQgaGVyZSwgYW5k IHByb3Zva2VzIE9iakMgd2FybmluZwogICBudz0iJG53IC1XdW5zYWZlLWxvb3Atb3B0aW1p emF0aW9ucyIgIyBPSyB0byBzdXBwcmVzcyB1bnNhZmUgb3B0aW1pemF0aW9ucworICBudz0i JG53IC1XYmFkLWZ1bmN0aW9uLWNhc3QiICAgICAgIyBUaGVzZSBjYXN0cyBhcmUgbm8gd29y c2UgdGhhbiBvdGhlcnMuCiAKICAgIyBFbWFjcyBkb2Vzbid0IGNhcmUgYWJvdXQgc2hhZG93 aW5nOyBzZWUKICAgIyA8aHR0cDovL2xpc3RzLmdudS5vcmcvYXJjaGl2ZS9odG1sL2VtYWNz LWRpZmZzLzIwMTEtMTEvbXNnMDAyNjUuaHRtbD4uCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3Jj L0NoYW5nZUxvZycKLS0tIHNyYy9DaGFuZ2VMb2cJMjAxMy0wNi0xMyAyMjoyNDo1MiArMDAw MAorKysgc3JjL0NoYW5nZUxvZwkyMDEzLTA2LTE1IDA2OjE3OjA3ICswMDAwCkBAIC0xLDMg KzEsMTY0IEBACisyMDEzLTA2LTE1ICBQYXVsIEVnZ2VydCAgPGVnZ2VydEBjcy51Y2xhLmVk dT4KKworCU1vdmUgZnVuY3Rpb25zIGZyb20gbGlzcC5oIHRvIGluZGl2aWR1YWwgbW9kdWxl cyB3aGVuIHBvc3NpYmxlLgorCUZyb20gYSBzdWdnZXN0aW9uIGJ5IEFuZHJlYXMgU2Nod2Fi IGluIDxodHRwOi8vYnVncy5nbnUub3JnLzExOTM1IzY4Pi4KKwkqIGFsbG9jLmMgKFhGTE9B VF9JTklULCBzZXRfc3ltYm9sX25hbWUpOgorCSogYnVmZmVyLmMgKENIRUNLX09WRVJMQVkp OgorCSogY2hhcnRhYi5jIChDSEVDS19DSEFSX1RBQkxFLCBzZXRfY2hhcl90YWJsZV9hc2Np aSkKKwkoc2V0X2NoYXJfdGFibGVfcGFyZW50KToKKwkqIGNvZGluZy5jIChDSEVDS19OQVRO VU1fQ0FSLCBDSEVDS19OQVROVU1fQ0RSKToKKwkqIGRhdGEuYyAoQk9PTEZXRFAsIElOVEZX RFAsIEtCT0FSRF9PQkpGV0RQLCBPQkpGV0RQLCBYQk9PTEZXRCkKKwkoWEtCT0FSRF9PQkpG V0QsIFhJTlRGV0QsIFhPQkpGV0QsIENIRUNLX1NVQlIsIHNldF9ibHZfZm91bmQpCisJKGJs dl92YWx1ZSwgc2V0X2Jsdl92YWx1ZSwgc2V0X2Jsdl93aGVyZSwgc2V0X2Jsdl9kZWZjZWxs KQorCShzZXRfYmx2X3ZhbGNlbGwpOgorCSogZW1hY3MuYyAoc2V0bG9jYWxlKSBbIUhBVkVf U0VUTE9DQUxFXToKKwkqIGV2YWwuYyAoc3BlY3BkbF9zeW1ib2wsIHNwZWNwZGxfb2xkX3Zh bHVlLCBzcGVjcGRsX3doZXJlKQorCShzcGVjcGRsX2FyZywgc3BlY3BkbF9mdW5jLCBiYWNr dHJhY2VfZnVuY3Rpb24sIGJhY2t0cmFjZV9uYXJncykKKwkoYmFja3RyYWNlX2FyZ3MsIGJh Y2t0cmFjZV9kZWJ1Z19vbl9leGl0KToKKwkqIGZsb2F0Zm5zLmMgKENIRUNLX0ZMT0FUKToK KwkqIGZucy5jIChDSEVDS19IQVNIX1RBQkxFLCBDSEVDS19MSVNUX0VORCkKKwkoc2V0X2hh c2hfa2V5X2FuZF92YWx1ZSwgc2V0X2hhc2hfbmV4dCwgc2V0X2hhc2hfbmV4dF9zbG90KQor CShzZXRfaGFzaF9oYXNoLCBzZXRfaGFzaF9oYXNoX3Nsb3QsIHNldF9oYXNoX2luZGV4KQor CShzZXRfaGFzaF9pbmRleF9zbG90KToKKwkqIGtleW1hcC5jIChDSEVDS19WRUNUT1JfT1Jf Q0hBUl9UQUJMRSk6CisJKiBtYXJrZXIuYyAoQ0hFQ0tfTUFSS0VSKToKKwkqIHRleHRwcm9w LmMgKENIRUNLX1NUUklOR19PUl9CVUZGRVIpOgorCSogd2luZG93LmMgKENIRUNLX1dJTkRP V19DT05GSUdVUkFUSU9OKToKKwlNb3ZlIGhlcmUgZnJvbSBsaXNwLmgsIGFuZCBtYWtlIHRo ZXNlIGZ1bmN0aW9ucyBzdGF0aWMgcmF0aGVyIHRoYW4KKwlleHRlcm4gaW5saW5lLgorCSog YnVmZmVyLmMgKFFvdmVybGF5cCk6CisJKiBkYXRhLmMgKFFzdWJycCk6CisJKiBmbnMuYyAo UWhhc2hfdGFibGVfcCk6CisJKiB3aW5kb3cuYyAoUXdpbmRvd19jb25maWd1cmF0aW9uX3Ap OgorCU5vdyBzdGF0aWMuCisJKiBsaXNwLmg6IFJlbW92ZSB0aGUgYWJvdmVtZW50aW9uZWQg ZGVmbnMgYW5kIGRlY2xzLgorCisJVXNlIGZ1bmN0aW9ucywgbm90IG1hY3JvcywgZm9yIFhJ TlQgZXRjLiAoQnVnIzExOTM1KS4KKwlJbiBsaXNwLmgsIHByZWZlciBmdW5jdGlvbnMgdG8g ZnVuY3Rpb24tbGlrZSBtYWNyb3MsIGFuZAorCWNvbnN0YW50cyB0byBvYmplY3QtbGlrZSBt YWNyb3MsIHdoZW4gZWl0aGVyIHdpbGwgZG8uICBUaGlzOgorCSAuIHNpbXBsaWZpZXMgdXNl LCBhcyB0aGVyZSdzIG5vIG1vcmUgbmVlZCB0byB3b3JyeSBhYm91dAorCSAgIGFyZ3VtZW50 cycgc2lkZSBlZmZlY3RzIGJlaW5nIGV2YWx1YXRlZCBtdWx0aXBsZSB0aW1lcy4KKwkgLiBt YWtlcyB0aGUgY29kZSBlYXNpZXIgdG8gZGVidWcgb24gc29tZSBwbGF0Zm9ybXMuCisJSG93 ZXZlciwgd2hlbiB1c2luZyBnY2MgLU8wLCBrZWVwIHVzaW5nIGZ1bmN0aW9uLWxpa2UgbWFj cm9zCisJZm9yIGEgZmV3IGNyaXRpY2FsIG9wZXJhdGlvbnMsIGZvciBwZXJmb3JtYW5jZSBy ZWFzb25zLgorCVRoaXMgc29ydCBvZiB0aGluZyBpc24ndCBuZWVkZWQgd2l0aCBnY2MgLU9n LCBidXQgLU9nCisJaXMgYSBHQ0MgNC44IGZlYXR1cmUgYW5kIGlzbid0IHdpZGVseS1lbm91 Z2ggYXZhaWxhYmxlIHlldC4KKwkqIGFsbG9jLmMgKGdkYl9tYWtlX2VudW1zX3Zpc2libGUp IFtVU0VfTFNCX1RBR106CisJUmVtb3ZlIGVudW0gbHNiX2JpdHM7IG5vIGxvbmdlciBuZWVk ZWQuCisJKGFsbG9jYXRlX21pc2MsIGZyZWVfbWlzYyk6IERvbid0IHVzZSBYTUlTQ1RZUEUg YXMgYW4gbHZhbHVlLgorCSogYnVmZmVyLmMgKFFvdmVybGFwKToKKwkqIGRhdGEuYyAoUXN1 YnJwKToKKwkqIGZucy5jIChRaGFzaF90YWJsZV9wKToKKwlOb3cgZXh0ZXJuLCBzbyBsaXNw LmggY2FuIHVzZSB0aGVzZSBzeW1ib2xzLgorCSogZGlzcGV4dGVybi5oOiBJbmNsdWRlIGNo YXJhY3Rlci5oLCBmb3IgTUFYX0NIQVIgZXRjLgorCShHTFlQSCwgR0xZUEhfQ0hBUiwgR0xZ UEhfRkFDRSwgU0VUX0dMWVBIX0NIQVIsIFNFVF9HTFlQSF9GQUNFKQorCShTRVRfR0xZUEgs IEdMWVBIX0NPREVfQ0hBUiwgR0xZUEhfQ09ERV9GQUNFKQorCShTRVRfR0xZUEhfRlJPTV9H TFlQSF9DT0RFLCBHTFlQSF9NT0RFX0xJTkVfRkFDRSwgR0xZUEhfQ0hBUl9WQUxJRF9QKQor CShHTFlQSF9DT0RFX1ApOiBNb3ZlIGhlcmUgZnJvbSBsaXNwLmguCisJKEdMWVBIX0NIQVIs IEdMWVBIX0ZBQ0UsIEdMWVBIX0NPREVfQ0hBUiwgR0xZUEhfQ09ERV9GQUNFKQorCShHTFlQ SF9DSEFSX1ZBTElEX1AsIEdMWVBIX0NPREVfUCk6IE5vdyBmdW5jdGlvbnMsIG5vdCBtYWNy b3MuCisJKEdMWVBIX01PREVfTElORV9GQUNFKTogTm93IGVudW1zLCBub3QgbWFjcm9zLgor CSogZXZhbC5jIChGYXV0b2xvYWQpOiBDYXN0IFhVTlRBRyBvdXRwdXQgdG8gaW50cHRyX3Qs IHNpbmNlCisJWFVOVEFHIG5vdyByZXR1cm5zIHZvaWQgKi4KKwkqIGxpc3AuaCAobGlzcF9o X1hMSSwgbGlzcF9oX1hJTCwgbGlzcF9oX0NIRUNLX0xJU1RfQ09OUykKKwkobGlzcF9oX0NI RUNLX05VTUJFUiBDSEVDS19TWU1CT0wsIGxpc3BfaF9DSEVDS19UWVBFKQorCShsaXNwX2hf Q09OU1AsIGxpc3BfaF9FUSwgbGlzcF9oX0ZMT0FUUCwgbGlzcF9oX0lOVEVHRVJQKQorCShs aXNwX2hfTUFSS0VSUCwgbGlzcF9oX01JU0NQLCBsaXNwX2hfTklMUCkKKwkobGlzcF9oX1NF VF9TWU1CT0xfVkFMLCBsaXNwX2hfU1lNQk9MX0NPTlNUQU5UX1ApCisJKGxpc3BfaF9TWU1C T0xfVkFMLCBsaXNwX2hfU1lNQk9MUCwgbGlzcF9oX1ZFQ1RPUkxJS0VQKQorCShsaXNwX2hf WENBUiwgbGlzcF9oX1hDRFIsIGxpc3BfaF9YQ09OUywgbGlzcF9oX1hIQVNIKQorCShsaXNw X2hfWFBOVFIsIGxpc3BfaF9YU1lNQk9MKToKKwlOZXcgbWFjcm9zLCByZW5hbWVkIGZyb20g dGhlaXIgc2Fucy1saXNwX2hfIGNvdW50ZXJwYXJ0cy4KKwkoWExJLCBYSUwsIENIRUNLX0xJ U1RfQ09OUywgQ0hFQ0tfTlVNQkVSIENIRUNLX1NZTUJPTCkKKwkoQ0hFQ0tfVFlQRSwgQ09O U1AsIEVRLCBGTE9BVFAsIElOVEVHRVJQLCBNQVJLRVJQKQorCShNSVNDUCwgTklMUCwgU0VU X1NZTUJPTF9WQUwsIFNZTUJPTF9DT05TVEFOVF9QLCBTWU1CT0xfVkFMLCBTWU1CT0xQKQor CShWRUNUT1JMSUtFUCwgWENBUiwgWENEUiwgWENPTlMsIFhIQVNILCBYUE5UUiwgWFNZTUJP TCk6CisJSWYgY29tcGlsaW5nIHZpYSBHQ0Mgd2l0aG91dCBvcHRpbWl6YXRpb24sIGRlZmlu ZSB0aGVzZSBhcyBtYWNyb3MKKwlpbiBhZGRpdGlvbiB0byBpbmxpbmUgZnVuY3Rpb25zLgor CVRvIGRpc2FibGUgdGhpcywgY29tcGlsZSB3aXRoIC1ESU5MSU5JTkc9MC4KKwkoTElTUF9N QUNST19ERUZVTiwgTElTUF9NQUNST19ERUZVTl9WT0lEKTogTmV3IG1hY3Jvcy4KKwkoY2hl Y2tfY29uc19saXN0KSBbIUdDX0NIRUNLX0NPTlNfTElTVF06IExpa2V3aXNlLgorCShtYWtl X251bWJlciwgWEZBU1RJTlQsIFhJTlQsIFhUWVBFLCBYVU5UQUcpOiBMaWtld2lzZSwgYnV0 CisJaGFuZC1vcHRpbWl6ZSBvbmx5IGluIHRoZSBVU0VfTFNCX1RBRyBjYXNlLCBhcyBHTlVp c2ggaG9zdHMgZG8gdGhhdC4KKwkoSU5UTUFTSywgVkFMTUFTSyk6IE5vdyBtYWNyb3MsIHNp bmNlIHN0YXRpYyB2YWx1ZXMgY2Fubm90IGJlCisJYWNjZXNzZWQgZnJvbSBleHRlcm4gaW5s aW5lIGZ1bmN0aW9ucy4KKwkoVkFMTUFTSyk6IEFsc28gYSBjb25zdGFudCwgZm9yIGJlbmVm aXQgb2Ygb2xkIEdEQi4KKwkoTElTUF9JTlRfVEFHX1ApOiBSZW1vdmU7IG5vIGxvbmdlciBu ZWVkZWQgYXMgdGhlIG9ubHkgY2FsbGVyCisJaXMgSU5URUdFUlAsIHdoaWNoIGNhbiBmb2xk IGl0IGluLgorCShYTEksIFhJTCwgWEhBU0gsIFhUWVBFLFhJTlQsIFhGQVNUSU5ULCBYVUlO VCkKKwkobWFrZV9udW1iZXIsIFhQTlRSLCBYVU5UQUcsIEVRLCBYQ09OUywgWFZFQ1RPUiwg WFNUUklORywgWFNZTUJPTCkKKwkoWEZMT0FULCBYUFJPQ0VTUywgWFdJTkRPVywgWFRFUk1J TkFMLCBYU1VCUiwgWEJVRkZFUiwgWENIQVJfVEFCTEUpCisJKFhTVUJfQ0hBUl9UQUJMRSwg WEJPT0xfVkVDVE9SLCBtYWtlX2xpc3BfcHRyLCBDSEVDS19UWVBFKQorCShDSEVDS19TVFJJ TkdfT1JfQlVGRkVSLCBYQ0FSLCBYQ0RSLCBYU0VUQ0FSLCBYU0VUQ0RSLCBDQVIsIENEUikK KwkoQ0FSX1NBRkUsIENEUl9TQUZFLCBTVFJJTkdfTVVMVElCWVRFLCBTREFUQSwgU1NEQVRB LCBTUkVGLCBTU0VUKQorCShTQ0hBUlMsIFNUUklOR19CWVRFUywgU0JZVEVTLCBTVFJJTkdf U0VUX0NIQVJTLCBTVFJJTkdfQ09QWUlOLCBBUkVGKQorCShBU0laRSwgQVNFVCwgQ0hBUl9U QUJMRV9SRUZfQVNDSUksIENIQVJfVEFCTEVfUkVGKQorCShDSEFSX1RBQkxFX1NFVCwgQ0hB Ul9UQUJMRV9FWFRSQV9TTE9UUywgU1lNQk9MX1ZBTCwgU1lNQk9MX0FMSUFTKQorCShTWU1C T0xfQkxWLCBTWU1CT0xfRldELCBTRVRfU1lNQk9MX1ZBTCwgU0VUX1NZTUJPTF9BTElBUykK KwkoU0VUX1NZTUJPTF9CTFYsIFNFVF9TWU1CT0xfRldELCBTWU1CT0xfTkFNRSwgU1lNQk9M X0lOVEVSTkVEX1ApCisJKFNZTUJPTF9JTlRFUk5FRF9JTl9JTklUSUFMX09CQVJSQVlfUCwg U1lNQk9MX0NPTlNUQU5UX1ApCisJKFhIQVNIX1RBQkxFLCBIQVNIX1RBQkxFX1AsIENIRUNL X0hBU0hfVEFCTEUsIEhBU0hfS0VZLCBIQVNIX1ZBTFVFKQorCShIQVNIX05FWFQsIEhBU0hf SEFTSCwgSEFTSF9JTkRFWCwgSEFTSF9UQUJMRV9TSVpFKQorCShYTUlTQywgWE1JU0NBTlks IFhNQVJLRVIsIFhPVkVSTEFZLCBYU0FWRV9WQUxVRSwgWEZXRFRZUEUpCisJKFhJTlRGV0Qs IFhCT09MRldELCBYT0JKRldELCBYQlVGRkVSX09CSkZXRCwgWEtCT0FSRF9PQkpGV0QpCisJ KFhGTE9BVF9EQVRBLCBYRkxPQVRfSU5JVCwgTklMUCwgTlVNQkVSUCwgTkFUTlVNUCkKKwko UkFOR0VEX0lOVEVHRVJQLCBDT05TUCwgRkxPQVRQLCBNSVNDUCwgU1RSSU5HUCwgU1lNQk9M UCkKKwkoSU5URUdFUlAsIFZFQ1RPUkxJS0VQLCBWRUNUT1JQLCBPVkVSTEFZUCkKKwkoTUFS S0VSUCwgU0FWRV9WQUxVRVAsIEFVVE9MT0FEUCwgSU5URldEUCwgQk9PTEZXRFAsIE9CSkZX RFApCisJKEJVRkZFUl9PQkpGV0RQLCBLQk9BUkRfT0JKRldEUCwgUFNFVURPVkVDVE9SX1RZ UEVQKQorCShQU0VVRE9WRUNUT1JQLCBXSU5ET1dfQ09ORklHVVJBVElPTlAsIFBST0NFU1NQ LCBXSU5ET1dQKQorCShURVJNSU5BTFAsIFNVQlJQLCBDT01QSUxFRFAsIEJVRkZFUlAsIENI QVJfVEFCTEVfUCkKKwkoU1VCX0NIQVJfVEFCTEVfUCwgQk9PTF9WRUNUT1JfUCwgRlJBTUVQ LCBJTUFHRVAsIEFSUkFZUCkKKwkoQ0hFQ0tfTElTVCwgQ0hFQ0tfTElTVF9DT05TLCBDSEVD S19MSVNUX0VORCwgQ0hFQ0tfU1RSSU5HKQorCShDSEVDS19TVFJJTkdfQ0FSLCBDSEVDS19D T05TLCBDSEVDS19TWU1CT0wsIENIRUNLX0NIQVJfVEFCTEUpCisJKENIRUNLX1ZFQ1RPUiwg Q0hFQ0tfVkVDVE9SX09SX1NUUklORywgQ0hFQ0tfQVJSQVkpCisJKENIRUNLX1ZFQ1RPUl9P Ul9DSEFSX1RBQkxFLCBDSEVDS19CVUZGRVIsIENIRUNLX1dJTkRPVykKKwkoQ0hFQ0tfV0lO RE9XX0NPTkZJR1VSQVRJT04sIENIRUNLX1BST0NFU1MsIENIRUNLX1NVQlIpCisJKENIRUNL X05VTUJFUiwgQ0hFQ0tfTkFUTlVNLCBDSEVDS19NQVJLRVIsIFhGTE9BVElOVCkKKwkoQ0hF Q0tfRkxPQVQsIENIRUNLX05VTUJFUl9PUl9GTE9BVCwgQ0hFQ0tfT1ZFUkxBWSkKKwkoQ0hF Q0tfTlVNQkVSX0NBUiwgQ0hFQ0tfTlVNQkVSX0NEUiwgQ0hFQ0tfTkFUTlVNX0NBUikKKwko Q0hFQ0tfTkFUTlVNX0NEUiwgRlVOQ1RJT05QLCBTUEVDUERMX0lOREVYLCBMT0FESElTVF9B VFRBQ0gpCisJTm93IGZ1bmN0aW9ucy4KKwkoY2hlY2tfY29uc19saXN0KSBbIUdDX0NIRUNL X0NPTlNfTElTVF06IE5ldyBlbXB0eSBmdW5jdGlvbi4KKwkoTElTUF9NQUtFX1JWQUxVRSwg VFlQRU1BU0spOiBSZW1vdmU7IG5vIGxvbmdlciBuZWVkZWQuCisJKFZBTE1BU0spOiBEZWZp bmUgaW4gb25lIHBsYWNlIHJhdGhlciB0aGFuIGluIHR3bywgbWVyZ2luZyB0aGUKKwlVU0Vf TFNCX1RBRyBwYXJ0czsgdGhpcyBpcyBzaW1wbGVyLgorCShhcmVmX2FkZHIsIGdjX2FzZXQs IE1PU1RfUE9TSVRJVkVfRklYTlVNLCBNT1NUX05FR0FUSVZFX0ZJWE5VTSkKKwkobWF4LCBt aW4sIHN0cnVjdCBMaXNwX1N0cmluZywgVU5TSUdORURfQ01QLCBBU0NJSV9DSEFSX1ApOgor CU1vdmUgdXAsIHRvIGF2b2lkIHVzZSBiZWZvcmUgZGVmaW5pdGlvbi4KKwlBbHNvIGluY2x1 ZGUgImdsb2JhbHMuaCIgZWFybGllciwgZm9yIHRoZSBzYW1lIHJlYXNvbi4KKwkobWFrZV9u YXRudW0pOiBOZXcgZnVuY3Rpb24uCisJKFhVTlRBRyk6IE5vdyByZXR1cm5zIHZvaWQgKiwg bm90IGludHB0cl90LCBhcyB0aGlzIG1lYW5zIGZld2VyIGNhc3RzLgorCSh1bmlvbiBMaXNw X0Z3ZCwgQk9PTEZXRFAsIEJPT0xfVkVDVE9SX1AsIEJVRkZFUl9PQkpGV0RQLCBCVUZGRVJQ KQorCShDSEFSX1RBQkxFX1AsIENIQVJfVEFCTEVfUkVGX0FTQ0lJLCBDT05TUCwgRkxPQVRQ LCBJTlRFR0VSUCwgSU5URldEUCkKKwkoS0JPQVJEX09CSkZXRFAsIE1BUktFUlAsIE1JU0NQ LCBOSUxQLCBPQkpGV0RQLCBPVkVSTEFZUCwgUFJPQ0VTU1ApCisJKFBTRVVET1ZFQ1RPUlAs IFNBVkVfVkFMVUVQLCBTVFJJTkdQLCBTVUJfQ0hBUl9UQUJMRV9QLCBTVUJSUCwgU1lNQk9M UCkKKwkoVkVDVE9STElLRVAsIFdJTkRPV1AsIFFvdmVybGF5cCwgY2hhcl90YWJsZV9yZWYs IGNoYXJfdGFibGVfc2V0KQorCShjaGFyX3RhYmxlX3RyYW5zbGF0ZSwgUWFycmF5cCwgUWJ1 ZmZlcnAsIFFidWZmZXJfb3Jfc3RyaW5nX3ApCisJKFFjaGFyX3RhYmxlX3AsIFFjb25zcCwg UWZsb2F0cCwgUWludGVnZXJwLCBRbGFtYmRhLCBRbGlzdHAsIFFtYXJrZXJwKQorCShRbmls LCBRbnVtYmVycCwgUXN1YnJwLCBRc3RyaW5ncCwgUXN5bWJvbHAsIFF2ZWN0b3JwKQorCShR dmVjdG9yX29yX2NoYXJfdGFibGVfcCwgUXdob2xlbnVtcCwgRmZib3VuZHAsIHdyb25nX3R5 cGVfYXJndW1lbnQpCisJKGluaXRpYWxpemVkLCBRaGFzaF90YWJsZV9wLCBleHRyYWN0X2Zs b2F0LCBRcHJvY2Vzc3AsIFF3aW5kb3dwKQorCShRd2luZG93X2NvbmZpZ3VyYXRpb25fcCwg UWltYWdlKTogTmV3IGZvcndhcmQgZGVjbGFyYXRpb25zLgorCShYU0VURkFTVElOVCk6IFNp bXBsaWZ5IGJ5IHJld3JpdGluZyBpbiB0ZXJtcyBvZiBtYWtlX25hdG51bS4KKwkoU1RSSU5H X0NPUFlJTik6IFJlbW92ZTsgdW51c2VkLgorCShYQ0FSX0FTX0xWQUxVRSwgWENEUl9BU19M VkFMVUUpOiBSZW1vdmUgdGhlc2UgbWFjcm9zLCByZXBsYWNpbmcgd2l0aCAuLi4KKwkoeGNh cl9hZGRyLCB4Y2RyX2FkZHIpOiBOZXcgZnVuY3Rpb25zLiAgQWxsIHVzZXMgY2hhbmdlZC4K KwkoSUVFRV9GTE9BVElOR19QT0lOVCk6IE5vdyBhIGNvbnN0YW50LCBub3QgYSBtYWNyby4K KwkoR0xZUEgsIEdMWVBIX0NIQVIsIEdMWVBIX0ZBQ0UsIFNFVF9HTFlQSF9DSEFSLCBTRVRf R0xZUEhfRkFDRSkKKwkoU0VUX0dMWVBILCBHTFlQSF9DT0RFX0NIQVIsIEdMWVBIX0NPREVf RkFDRSkKKwkoU0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERSwgR0xZUEhfTU9ERV9MSU5FX0ZB Q0UsIEdMWVBIX0NIQVJfVkFMSURfUCkKKwkoR0xZUEhfQ09ERV9QKTogTW92ZSB0byBkaXNw ZXh0ZXJuLmgsIHRvIGF2b2lkIGRlZmluZS1iZWZvcmUtdXNlLgorCShUWVBFX1JBTkdFRF9J TlRFR0VSUCk6IFNpbXBsaWZ5LgorCShRc3VicnAsIFFoYXNoX3RhYmxlX3AsIFFvdmVybGF5 cCk6IE5ldyBleHRlcm4gZGVjbHMuCisJKHNldGxvY2FsZSwgZml4dXBfbG9jYWxlLCBzeW5j aHJvbml6ZV9zeXN0ZW1fbWVzc2FnZXNfbG9jYWxlKQorCShzeW5jaHJvbml6ZV9zeXN0ZW1f dGltZV9sb2NhbGUpIFshSEFWRV9TRVRMT0NBTEVdOgorCU5vdyBlbXB0eSBmdW5jdGlvbnMs IG5vdCBtYWNyb3MuCisJKGZ1bmN0aW9ucCk6IFJldHVybiBib29sLCBub3QgaW50LgorCSog d2luZG93LmMgKFF3aW5kb3dfY29uZmlndXJhdGlvbl9wKTogTm93IGV4dGVybiwKKwlzbyB3 aW5kb3cuaCBjYW4gdXNlIGl0LgorCSogd2luZG93LmggKFF3aW5kb3dwKTogTW92ZSBkZWNs IGJhY2sgdG8gbGlzcC5oLgorCiAyMDEzLTA2LTEzICBTdGVmYW4gTW9ubmllciAgPG1vbm5p ZXJAaXJvLnVtb250cmVhbC5jYT4KIAogCSogbHJlYWQuYyAoc3ltc19vZl9scmVhZCk6Cgo9 PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2FsbG9jLmMnCi0tLSBzcmMvYWxsb2MuYwkyMDEzLTA2 LTAzIDA5OjAxOjUzICswMDAwCisrKyBzcmMvYWxsb2MuYwkyMDEzLTA2LTEzIDE1OjM4OjQx ICswMDAwCkBAIC0zNjMsNiArMzYzLDExIEBACiAgICgodm9pZCAqKSAoKCh1aW50cHRyX3Qp IChwdHIpICsgKEFMSUdOTUVOVCkgLSAxKSBcCiAJICAgICAmIH4gKChBTElHTk1FTlQpIC0g MSkpKQogCitzdGF0aWMgdm9pZAorWEZMT0FUX0lOSVQgKExpc3BfT2JqZWN0IGYsIGRvdWJs ZSBuKQoreworICBYRkxPQVQgKGYpLT51LmRhdGEgPSBuOworfQogCiAMCiAvKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqCkBAIC0zMTg5LDYgKzMxOTQsMTIgQEAKIAogc3RhdGljIHN0cnVjdCBMaXNw X1N5bWJvbCAqc3ltYm9sX2ZyZWVfbGlzdDsKIAorc3RhdGljIHZvaWQKK3NldF9zeW1ib2xf bmFtZSAoTGlzcF9PYmplY3Qgc3ltLCBMaXNwX09iamVjdCBuYW1lKQoreworICBYU1lNQk9M IChzeW0pLT5uYW1lID0gbmFtZTsKK30KKwogREVGVU4gKCJtYWtlLXN5bWJvbCIsIEZtYWtl X3N5bWJvbCwgU21ha2Vfc3ltYm9sLCAxLCAxLCAwLAogICAgICAgIGRvYzogLyogUmV0dXJu IGEgbmV3bHkgYWxsb2NhdGVkIHVuaW50ZXJuZWQgc3ltYm9sIHdob3NlIG5hbWUgaXMgTkFN RS4KIEl0cyB2YWx1ZSBpcyB2b2lkLCBhbmQgaXRzIGZ1bmN0aW9uIGRlZmluaXRpb24gYW5k IHByb3BlcnR5IGxpc3QgYXJlIG5pbC4gICovKQpAQCAtMzMwOSw3ICszMzIwLDcgQEAKICAg LS10b3RhbF9mcmVlX21hcmtlcnM7CiAgIGNvbnNpbmdfc2luY2VfZ2MgKz0gc2l6ZW9mICh1 bmlvbiBMaXNwX01pc2MpOwogICBtaXNjX29iamVjdHNfY29uc2VkKys7Ci0gIFhNSVNDVFlQ RSAodmFsKSA9IHR5cGU7CisgIFhNSVNDQU5ZICh2YWwpLT50eXBlID0gdHlwZTsKICAgWE1J U0NBTlkgKHZhbCktPmdjbWFya2JpdCA9IDA7CiAgIHJldHVybiB2YWw7CiB9CkBAIC0zMzE5 LDcgKzMzMzAsNyBAQAogdm9pZAogZnJlZV9taXNjIChMaXNwX09iamVjdCBtaXNjKQogewot ICBYTUlTQ1RZUEUgKG1pc2MpID0gTGlzcF9NaXNjX0ZyZWU7CisgIFhNSVNDQU5ZIChtaXNj KS0+dHlwZSA9IExpc3BfTWlzY19GcmVlOwogICBYTUlTQyAobWlzYyktPnVfZnJlZS5jaGFp biA9IG1hcmtlcl9mcmVlX2xpc3Q7CiAgIG1hcmtlcl9mcmVlX2xpc3QgPSBYTUlTQyAobWlz Yyk7CiAgIGNvbnNpbmdfc2luY2VfZ2MgLT0gc2l6ZW9mICh1bmlvbiBMaXNwX01pc2MpOwpA QCAtNTY0Nyw3ICs1NjU4LDcgQEAKIAl7CiAJICBDT05TX01BUksgKFhDT05TICh0YWlsKSk7 CiAJICBtYXJrX29iamVjdCAoWENBUiAodGFpbCkpOwotCSAgcHJldiA9ICZYQ0RSX0FTX0xW QUxVRSAodGFpbCk7CisJICBwcmV2ID0geGNkcl9hZGRyICh0YWlsKTsKIAl9CiAgICAgfQog ICBtYXJrX29iamVjdCAodGFpbCk7CkBAIC02Njg5LDggKzY3MDAsNSBAQAogICBlbnVtIE1B WF9BTExPQ0EgTUFYX0FMTE9DQTsKICAgZW51bSBNb3JlX0xpc3BfQml0cyBNb3JlX0xpc3Bf Qml0czsKICAgZW51bSBwdmVjX3R5cGUgcHZlY190eXBlOwotI2lmIFVTRV9MU0JfVEFHCi0g IGVudW0gbHNiX2JpdHMgbHNiX2JpdHM7Ci0jZW5kaWYKIH0gY29uc3QgRVhURVJOQUxMWV9W SVNJQkxFIGdkYl9tYWtlX2VudW1zX3Zpc2libGUgPSB7MH07CiAjZW5kaWYJLyogX19HTlVD X18gKi8KCj09PSBtb2RpZmllZCBmaWxlICdzcmMvYnVmZmVyLmMnCi0tLSBzcmMvYnVmZmVy LmMJMjAxMy0wNS0wNyAxNDoxMjo1NyArMDAwMAorKysgc3JjL2J1ZmZlci5jCTIwMTMtMDYt MTMgMTU6NTY6NDYgKzAwMDAKQEAgLTE1MCw2ICsxNTAsMTIgQEAKIHN0YXRpYyB2b2lkIG1v ZGlmeV9vdmVybGF5IChzdHJ1Y3QgYnVmZmVyICosIHB0cmRpZmZfdCwgcHRyZGlmZl90KTsK IHN0YXRpYyBMaXNwX09iamVjdCBidWZmZXJfbGlzcF9sb2NhbF92YXJpYWJsZXMgKHN0cnVj dCBidWZmZXIgKiwgYm9vbCk7CiAKK3N0YXRpYyB2b2lkCitDSEVDS19PVkVSTEFZIChMaXNw X09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChPVkVSTEFZUCAoeCksIFFvdmVybGF5cCwg eCk7Cit9CisKIC8qIFRoZXNlIHNldHRlcnMgYXJlIHVzZWQgb25seSBpbiB0aGlzIGZpbGUs IHNvIHRoZXkgY2FuIGJlIHByaXZhdGUuICAqLwogc3RhdGljIHZvaWQKIGJzZXRfYWJicmV2 X21vZGUgKHN0cnVjdCBidWZmZXIgKmIsIExpc3BfT2JqZWN0IHZhbCkKQEAgLTE1MzksNyAr MTU0NSw3IEBACiAJICAmJiBCVUZGRVJfTElWRV9QIChYQlVGRkVSIChiKSkKIAkgICYmICFC VUZGRVJfSElEREVOX1AgKFhCVUZGRVIgKGIpKSk7CiB9Ci0JICAKKwogREVGVU4gKCJvdGhl ci1idWZmZXIiLCBGb3RoZXJfYnVmZmVyLCBTb3RoZXJfYnVmZmVyLCAwLCAzLCAwLAogICAg ICAgIGRvYzogLyogUmV0dXJuIG1vc3QgcmVjZW50bHkgc2VsZWN0ZWQgYnVmZmVyIG90aGVy IHRoYW4gQlVGRkVSLgogQnVmZmVycyBub3QgdmlzaWJsZSBpbiB3aW5kb3dzIGFyZSBwcmVm ZXJyZWQgdG8gdmlzaWJsZSBidWZmZXJzLCB1bmxlc3MKCj09PSBtb2RpZmllZCBmaWxlICdz cmMvY2hhcnRhYi5jJwotLS0gc3JjL2NoYXJ0YWIuYwkyMDEyLTA5LTI0IDEyOjIzOjI1ICsw MDAwCisrKyBzcmMvY2hhcnRhYi5jCTIwMTMtMDYtMTMgMTU6Mzg6MTYgKzAwMDAKQEAgLTg0 LDYgKzg0LDIyIEBACiAgIChTVFJJTkdQIChPQkopICYmIFNDSEFSUyAoT0JKKSA+IDAJXAog ICAgJiYgKChTUkVGIChPQkosIDApID09IDEgfHwgKFNSRUYgKE9CSiwgMCkgPT0gMikpKSkK IAorc3RhdGljIHZvaWQKK0NIRUNLX0NIQVJfVEFCTEUgKExpc3BfT2JqZWN0IHgpCit7Cisg IENIRUNLX1RZUEUgKENIQVJfVEFCTEVfUCAoeCksIFFjaGFyX3RhYmxlX3AsIHgpOworfQor CitzdGF0aWMgdm9pZAorc2V0X2NoYXJfdGFibGVfYXNjaWkgKExpc3BfT2JqZWN0IHRhYmxl LCBMaXNwX09iamVjdCB2YWwpCit7CisgIFhDSEFSX1RBQkxFICh0YWJsZSktPmFzY2lpID0g dmFsOworfQorc3RhdGljIHZvaWQKK3NldF9jaGFyX3RhYmxlX3BhcmVudCAoTGlzcF9PYmpl Y3QgdGFibGUsIExpc3BfT2JqZWN0IHZhbCkKK3sKKyAgWENIQVJfVEFCTEUgKHRhYmxlKS0+ cGFyZW50ID0gdmFsOworfQogDAogREVGVU4gKCJtYWtlLWNoYXItdGFibGUiLCBGbWFrZV9j aGFyX3RhYmxlLCBTbWFrZV9jaGFyX3RhYmxlLCAxLCAyLCAwLAogICAgICAgIGRvYzogLyog UmV0dXJuIGEgbmV3bHkgY3JlYXRlZCBjaGFyLXRhYmxlLCB3aXRoIHB1cnBvc2UgUFVSUE9T RS4KCj09PSBtb2RpZmllZCBmaWxlICdzcmMvY29kaW5nLmMnCi0tLSBzcmMvY29kaW5nLmMJ MjAxMy0wNS0yMiAxNDo1MzoyMSArMDAwMAorKysgc3JjL2NvZGluZy5jCTIwMTMtMDYtMTMg MTU6Mzg6MTYgKzAwMDAKQEAgLTY1NSw2ICs2NTUsMjIgQEAKICAgICAoY2hhcnNldF9saXN0 KSA9IENPRElOR19BVFRSX0NIQVJTRVRfTElTVCAoYXR0cnMpOwlcCiAgIH0gd2hpbGUgKDAp CiAKK3N0YXRpYyB2b2lkCitDSEVDS19OQVROVU1fQ0FSIChMaXNwX09iamVjdCB4KQorewor ICBMaXNwX09iamVjdCB0bXAgPSBYQ0FSICh4KTsKKyAgQ0hFQ0tfTkFUTlVNICh0bXApOwor ICBYU0VUQ0FSICh4LCB0bXApOworfQorCitzdGF0aWMgdm9pZAorQ0hFQ0tfTkFUTlVNX0NE UiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgTGlzcF9PYmplY3QgdG1wID0gWENEUiAoeCk7Cisg IENIRUNLX05BVE5VTSAodG1wKTsKKyAgWFNFVENEUiAoeCwgdG1wKTsKK30KKwogCiAvKiBT YWZlbHkgZ2V0IG9uZSBieXRlIGZyb20gdGhlIHNvdXJjZSB0ZXh0IHBvaW50ZWQgYnkgU1JD IHdoaWNoIGVuZHMKICAgIGF0IFNSQ19FTkQsIGFuZCBzZXQgQyB0byB0aGF0IGJ5dGUuICBJ ZiB0aGVyZSBhcmUgbm90IGVub3VnaCBieXRlcwoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9k YXRhLmMnCi0tLSBzcmMvZGF0YS5jCTIwMTMtMDYtMDMgMTg6Mjk6MzAgKzAwMDAKKysrIHNy Yy9kYXRhLmMJMjAxMy0wNi0xMyAxNTo1Njo1MiArMDAwMApAQCAtNzYsNyArNzYsOCBAQAog c3RhdGljIExpc3BfT2JqZWN0IFFjb21waWxlZF9mdW5jdGlvbiwgUWZyYW1lOwogTGlzcF9P YmplY3QgUWJ1ZmZlcjsKIHN0YXRpYyBMaXNwX09iamVjdCBRY2hhcl90YWJsZSwgUWJvb2xf dmVjdG9yLCBRaGFzaF90YWJsZTsKLXN0YXRpYyBMaXNwX09iamVjdCBRc3VicnAsIFFtYW55 LCBRdW5ldmFsbGVkOworc3RhdGljIExpc3BfT2JqZWN0IFFzdWJycDsKK3N0YXRpYyBMaXNw X09iamVjdCBRbWFueSwgUXVuZXZhbGxlZDsKIExpc3BfT2JqZWN0IFFmb250X3NwZWMsIFFm b250X2VudGl0eSwgUWZvbnRfb2JqZWN0Owogc3RhdGljIExpc3BfT2JqZWN0IFFkZWZ1bjsK IApAQCAtODUsNiArODYsOTQgQEAKIAogc3RhdGljIHZvaWQgc3dhcF9pbl9zeW12YWxfZm9y d2FyZGluZyAoc3RydWN0IExpc3BfU3ltYm9sICosIHN0cnVjdCBMaXNwX0J1ZmZlcl9Mb2Nh bF9WYWx1ZSAqKTsKIAorc3RhdGljIGJvb2wKK0JPT0xGV0RQICh1bmlvbiBMaXNwX0Z3ZCAq YSkKK3sKKyAgcmV0dXJuIFhGV0RUWVBFIChhKSA9PSBMaXNwX0Z3ZF9Cb29sOworfQorc3Rh dGljIGJvb2wKK0lOVEZXRFAgKHVuaW9uIExpc3BfRndkICphKQoreworICByZXR1cm4gWEZX RFRZUEUgKGEpID09IExpc3BfRndkX0ludDsKK30KK3N0YXRpYyBib29sCitLQk9BUkRfT0JK RldEUCAodW5pb24gTGlzcF9Gd2QgKmEpCit7CisgIHJldHVybiBYRldEVFlQRSAoYSkgPT0g TGlzcF9Gd2RfS2JvYXJkX09iajsKK30KK3N0YXRpYyBib29sCitPQkpGV0RQICh1bmlvbiBM aXNwX0Z3ZCAqYSkKK3sKKyAgcmV0dXJuIFhGV0RUWVBFIChhKSA9PSBMaXNwX0Z3ZF9PYmo7 Cit9CisKK3N0YXRpYyBzdHJ1Y3QgTGlzcF9Cb29sZndkICoKK1hCT09MRldEICh1bmlvbiBM aXNwX0Z3ZCAqYSkKK3sKKyAgZWFzc2VydCAoQk9PTEZXRFAgKGEpKTsKKyAgcmV0dXJuICZh LT51X2Jvb2xmd2Q7Cit9CitzdGF0aWMgc3RydWN0IExpc3BfS2JvYXJkX09iamZ3ZCAqCitY S0JPQVJEX09CSkZXRCAodW5pb24gTGlzcF9Gd2QgKmEpCit7CisgIGVhc3NlcnQgKEtCT0FS RF9PQkpGV0RQIChhKSk7CisgIHJldHVybiAmYS0+dV9rYm9hcmRfb2JqZndkOworfQorc3Rh dGljIHN0cnVjdCBMaXNwX0ludGZ3ZCAqCitYSU5URldEICh1bmlvbiBMaXNwX0Z3ZCAqYSkK K3sKKyAgZWFzc2VydCAoSU5URldEUCAoYSkpOworICByZXR1cm4gJmEtPnVfaW50ZndkOwor fQorc3RhdGljIHN0cnVjdCBMaXNwX09iamZ3ZCAqCitYT0JKRldEICh1bmlvbiBMaXNwX0Z3 ZCAqYSkKK3sKKyAgZWFzc2VydCAoT0JKRldEUCAoYSkpOworICByZXR1cm4gJmEtPnVfb2Jq ZndkOworfQorCitzdGF0aWMgdm9pZAorQ0hFQ0tfU1VCUiAoTGlzcF9PYmplY3QgeCkKK3sK KyAgQ0hFQ0tfVFlQRSAoU1VCUlAgKHgpLCBRc3VicnAsIHgpOworfQorCitzdGF0aWMgdm9p ZAorc2V0X2Jsdl9mb3VuZCAoc3RydWN0IExpc3BfQnVmZmVyX0xvY2FsX1ZhbHVlICpibHYs IGludCBmb3VuZCkKK3sKKyAgZWFzc2VydCAoZm91bmQgPT0gIUVRIChibHYtPmRlZmNlbGws IGJsdi0+dmFsY2VsbCkpOworICBibHYtPmZvdW5kID0gZm91bmQ7Cit9CisKK3N0YXRpYyBM aXNwX09iamVjdAorYmx2X3ZhbHVlIChzdHJ1Y3QgTGlzcF9CdWZmZXJfTG9jYWxfVmFsdWUg KmJsdikKK3sKKyAgcmV0dXJuIFhDRFIgKGJsdi0+dmFsY2VsbCk7Cit9CisKK3N0YXRpYyB2 b2lkCitzZXRfYmx2X3ZhbHVlIChzdHJ1Y3QgTGlzcF9CdWZmZXJfTG9jYWxfVmFsdWUgKmJs diwgTGlzcF9PYmplY3QgdmFsKQoreworICBYU0VUQ0RSIChibHYtPnZhbGNlbGwsIHZhbCk7 Cit9CisKK3N0YXRpYyB2b2lkCitzZXRfYmx2X3doZXJlIChzdHJ1Y3QgTGlzcF9CdWZmZXJf TG9jYWxfVmFsdWUgKmJsdiwgTGlzcF9PYmplY3QgdmFsKQoreworICBibHYtPndoZXJlID0g dmFsOworfQorCitzdGF0aWMgdm9pZAorc2V0X2Jsdl9kZWZjZWxsIChzdHJ1Y3QgTGlzcF9C dWZmZXJfTG9jYWxfVmFsdWUgKmJsdiwgTGlzcF9PYmplY3QgdmFsKQoreworICBibHYtPmRl ZmNlbGwgPSB2YWw7Cit9CisKK3N0YXRpYyB2b2lkCitzZXRfYmx2X3ZhbGNlbGwgKHN0cnVj dCBMaXNwX0J1ZmZlcl9Mb2NhbF9WYWx1ZSAqYmx2LCBMaXNwX09iamVjdCB2YWwpCit7Cisg IGJsdi0+dmFsY2VsbCA9IHZhbDsKK30KIAogTGlzcF9PYmplY3QKIHdyb25nX3R5cGVfYXJn dW1lbnQgKHJlZ2lzdGVyIExpc3BfT2JqZWN0IHByZWRpY2F0ZSwgcmVnaXN0ZXIgTGlzcF9P YmplY3QgdmFsdWUpCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2Rpc3BleHRlcm4uaCcKLS0t IHNyYy9kaXNwZXh0ZXJuLmgJMjAxMy0wNi0wOCAxODoyODozNiArMDAwMAorKysgc3JjL2Rp c3BleHRlcm4uaAkyMDEzLTA2LTEzIDE1OjM4OjAzICswMDAwCkBAIC0yMiw2ICsyMiw4IEBA CiAjaWZuZGVmIERJU1BFWFRFUk5fSF9JTkNMVURFRAogI2RlZmluZSBESVNQRVhURVJOX0hf SU5DTFVERUQKIAorI2luY2x1ZGUgImNoYXJhY3Rlci5oIgorCiAjaWZkZWYgSEFWRV9YX1dJ TkRPV1MKIAogI2luY2x1ZGUgPFgxMS9YbGliLmg+CkBAIC0yNzAsNiArMjcyLDU1IEBACiAJ CQkJR2x5cGhzCiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKKy8qIFRoZSBnbHlwaCBkYXRhdHlw ZSwgdXNlZCB0byByZXByZXNlbnQgY2hhcmFjdGVycyBvbiB0aGUgZGlzcGxheS4KKyAgIEl0 IGNvbnNpc3RzIG9mIGEgY2hhciBjb2RlIGFuZCBhIGZhY2UgaWQuICAqLworCit0eXBlZGVm IHN0cnVjdCB7CisgIGludCBjaDsKKyAgaW50IGZhY2VfaWQ7Cit9IEdMWVBIOworCisvKiBS ZXR1cm4gYSBnbHlwaCdzIGNoYXJhY3RlciBjb2RlLiAgKi8KK0RJU1BFWFRFUk5fSU5MSU5F IGludCBHTFlQSF9DSEFSIChHTFlQSCBnbHlwaCkgeyByZXR1cm4gZ2x5cGguY2g7IH0KKwor LyogUmV0dXJuIGEgZ2x5cGgncyBmYWNlIElELiAgKi8KK0RJU1BFWFRFUk5fSU5MSU5FIGlu dCBHTFlQSF9GQUNFIChHTFlQSCBnbHlwaCkgeyByZXR1cm4gZ2x5cGguZmFjZV9pZDsgfQor CisjZGVmaW5lIFNFVF9HTFlQSF9DSEFSKGdseXBoLCBjaGFyKSAoKGdseXBoKS5jaCA9IChj aGFyKSkKKyNkZWZpbmUgU0VUX0dMWVBIX0ZBQ0UoZ2x5cGgsIGZhY2UpICgoZ2x5cGgpLmZh Y2VfaWQgPSAoZmFjZSkpCisjZGVmaW5lIFNFVF9HTFlQSChnbHlwaCwgY2hhciwgZmFjZSkg XAorICAoKGdseXBoKS5jaCA9IChjaGFyKSwgKGdseXBoKS5mYWNlX2lkID0gKGZhY2UpKQor CisvKiBUaGUgZm9sbG93aW5nIGFyZSB2YWxpZCBvbmx5IGlmIEdMWVBIX0NPREVfUCAoZ2Mp LiAgKi8KKworRElTUEVYVEVSTl9JTkxJTkUgaW50CitHTFlQSF9DT0RFX0NIQVIgKExpc3Bf T2JqZWN0IGdjKQoreworICByZXR1cm4gKENPTlNQIChnYykKKwkgID8gWElOVCAoWENBUiAo Z2MpKQorCSAgOiBYSU5UIChnYykgJiBNQVhfQ0hBUik7Cit9CisKK0RJU1BFWFRFUk5fSU5M SU5FIGludAorR0xZUEhfQ09ERV9GQUNFIChMaXNwX09iamVjdCBnYykKK3sKKyAgcmV0dXJu IENPTlNQIChnYykgPyBYSU5UIChYQ0RSIChnYykpIDogWElOVCAoZ2MpID4+IENIQVJBQ1RF UkJJVFM7Cit9CisKKyNkZWZpbmUgU0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERShnbHlwaCwg Z2MpCQkJCVwKKyAgZG8JCQkJCQkJCQlcCisgICAgewkJCQkJCQkJCVwKKyAgICAgIGlmIChD T05TUCAoZ2MpKQkJCQkJCQlcCisJU0VUX0dMWVBIIChnbHlwaCwgWElOVCAoWENBUiAoZ2Mp KSwgWElOVCAoWENEUiAoZ2MpKSk7CQlcCisgICAgICBlbHNlCQkJCQkJCQlcCisJU0VUX0dM WVBIIChnbHlwaCwgKFhJTlQgKGdjKSAmICgoMSA8PCBDSEFSQUNURVJCSVRTKS0xKSksCVwK KwkJICAgKFhJTlQgKGdjKSA+PiBDSEFSQUNURVJCSVRTKSk7CQkJXAorICAgIH0JCQkJCQkJ CQlcCisgIHdoaWxlICgwKQorCisvKiBUaGUgSUQgb2YgdGhlIG1vZGUgbGluZSBoaWdobGln aHRpbmcgZmFjZS4gICovCitlbnVtIHsgR0xZUEhfTU9ERV9MSU5FX0ZBQ0UgPSAxIH07CisK IC8qIEVudW1lcmF0aW9uIG9mIGdseXBoIHR5cGVzLiAgR2x5cGggc3RydWN0dXJlcyBjb250 YWluIGEgdHlwZSBmaWVsZAogICAgY29udGFpbmluZyBvbmUgb2YgdGhlIGVudW1lcmF0b3Jz IGRlZmluZWQgaGVyZS4gICovCiAKQEAgLTE3NzQsNiArMTgyNSwzMCBAQAogCiAjZW5kaWYg Lyogbm90IEhBVkVfV0lORE9XX1NZU1RFTSAqLwogCisvKiBSZXR1cm4gdHJ1ZSBpZiBHIGNv bnRhaW5zIGEgdmFsaWQgY2hhcmFjdGVyIGNvZGUuICAqLworRElTUEVYVEVSTl9JTkxJTkUg Ym9vbAorR0xZUEhfQ0hBUl9WQUxJRF9QIChHTFlQSCBnKQoreworICByZXR1cm4gQ0hBUl9W QUxJRF9QIChHTFlQSF9DSEFSIChnKSk7Cit9CisKKy8qIFRoZSBnbHlwaCBjb2RlIGZyb20g YSBkaXNwbGF5IHZlY3RvciBtYXkgZWl0aGVyIGJlIGFuIGludGVnZXIgd2hpY2gKKyAgIGVu Y29kZXMgYSBjaGFyIGNvZGUgaW4gdGhlIGxvd2VyIENIQVJBQ1RFUkJJVFMgYml0cyBhbmQg YSAodmVyeSBzbWFsbCkKKyAgIGZhY2UtaWQgaW4gdGhlIHVwcGVyIGJpdHMsIG9yIGl0IG1h eSBiZSBhIGNvbnMgKENIQVIgLiBGQUNFLUlEKS4gICovCisKK0RJU1BFWFRFUk5fSU5MSU5F IGJvb2wKK0dMWVBIX0NPREVfUCAoTGlzcF9PYmplY3QgZ2MpCit7CisgIHJldHVybiAoQ09O U1AgKGdjKQorCSAgPyAoQ0hBUkFDVEVSUCAoWENBUiAoZ2MpKQorCSAgICAgJiYgUkFOR0VE X0lOVEVHRVJQICgwLCBYQ0RSIChnYyksIE1BWF9GQUNFX0lEKSkKKwkgIDogKFJBTkdFRF9J TlRFR0VSUAorCSAgICAgKDAsIGdjLAorCSAgICAgIChNQVhfRkFDRV9JRCA8IFRZUEVfTUFY SU1VTSAoRU1BQ1NfSU5UKSA+PiBDSEFSQUNURVJCSVRTCisJICAgICAgID8gKChFTUFDU19J TlQpIE1BWF9GQUNFX0lEIDw8IENIQVJBQ1RFUkJJVFMpIHwgTUFYX0NIQVIKKwkgICAgICAg OiBUWVBFX01BWElNVU0gKEVNQUNTX0lOVCkpKSkpOworfQorCiAvKiBOb24temVybyBtZWFu cyBmYWNlIGF0dHJpYnV0ZXMgaGF2ZSBiZWVuIGNoYW5nZWQgc2luY2UgdGhlIGxhc3QKICAg IHJlZGlzcGxheS4gIFVzZWQgaW4gcmVkaXNwbGF5X2ludGVybmFsLiAgKi8KIAoKPT09IG1v ZGlmaWVkIGZpbGUgJ3NyYy9lbWFjcy5jJwotLS0gc3JjL2VtYWNzLmMJMjAxMy0wNi0wNSAx MjoxNzowMiArMDAwMAorKysgc3JjL2VtYWNzLmMJMjAxMy0wNi0xMyAxNTozODoxNiArMDAw MApAQCAtMzA2LDYgKzMwNiwxMyBAQAogc3RhdGljIHZvaWQgKm5zX3Bvb2w7CiAjZW5kaWYK IAorI2lmICFIQVZFX1NFVExPQ0FMRQorc3RhdGljIGNoYXIgKgorc2V0bG9jYWxlIChpbnQg Y2F0LCBjaGFyIGNvbnN0ICpsb2NhbGUpCit7CisgIHJldHVybiAwOworfQorI2VuZGlmCiAK IAogLyogUmVwb3J0IGEgZmF0YWwgZXJyb3IgZHVlIHRvIHNpZ25hbCBTSUcsIG91dHB1dCBh IGJhY2t0cmFjZSBvZiBhdAoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9ldmFsLmMnCi0tLSBz cmMvZXZhbC5jCTIwMTMtMDYtMDMgMTg6Mjk6MzAgKzAwMDAKKysrIHNyYy9ldmFsLmMJMjAx My0wNi0xMyAxNTo0NDowMCArMDAwMApAQCAtMTE1LDYgKzExNSw2OSBAQAogc3RhdGljIExp c3BfT2JqZWN0IGZ1bmNhbGxfbGFtYmRhIChMaXNwX09iamVjdCwgcHRyZGlmZl90LCBMaXNw X09iamVjdCAqKTsKIHN0YXRpYyBMaXNwX09iamVjdCBhcHBseV9sYW1iZGEgKExpc3BfT2Jq ZWN0IGZ1biwgTGlzcF9PYmplY3QgYXJncyk7CiAKK3N0YXRpYyBMaXNwX09iamVjdAorc3Bl Y3BkbF9zeW1ib2wgKHN0cnVjdCBzcGVjYmluZGluZyAqcGRsKQoreworICBlYXNzZXJ0IChw ZGwtPmtpbmQgPj0gU1BFQ1BETF9MRVQpOworICByZXR1cm4gcGRsLT52LmxldC5zeW1ib2w7 Cit9CisKK3N0YXRpYyBMaXNwX09iamVjdAorc3BlY3BkbF9vbGRfdmFsdWUgKHN0cnVjdCBz cGVjYmluZGluZyAqcGRsKQoreworICBlYXNzZXJ0IChwZGwtPmtpbmQgPj0gU1BFQ1BETF9M RVQpOworICByZXR1cm4gcGRsLT52LmxldC5vbGRfdmFsdWU7Cit9CisKK3N0YXRpYyBMaXNw X09iamVjdAorc3BlY3BkbF93aGVyZSAoc3RydWN0IHNwZWNiaW5kaW5nICpwZGwpCit7Cisg IGVhc3NlcnQgKHBkbC0+a2luZCA+IFNQRUNQRExfTEVUKTsKKyAgcmV0dXJuIHBkbC0+di5s ZXQud2hlcmU7Cit9CisKK3N0YXRpYyBMaXNwX09iamVjdAorc3BlY3BkbF9hcmcgKHN0cnVj dCBzcGVjYmluZGluZyAqcGRsKQoreworICBlYXNzZXJ0IChwZGwtPmtpbmQgPT0gU1BFQ1BE TF9VTldJTkQpOworICByZXR1cm4gcGRsLT52LnVud2luZC5hcmc7Cit9CisKK3N0YXRpYyBz cGVjYmluZGluZ19mdW5jCitzcGVjcGRsX2Z1bmMgKHN0cnVjdCBzcGVjYmluZGluZyAqcGRs KQoreworICBlYXNzZXJ0IChwZGwtPmtpbmQgPT0gU1BFQ1BETF9VTldJTkQpOworICByZXR1 cm4gcGRsLT52LnVud2luZC5mdW5jOworfQorCitzdGF0aWMgTGlzcF9PYmplY3QKK2JhY2t0 cmFjZV9mdW5jdGlvbiAoc3RydWN0IHNwZWNiaW5kaW5nICpwZGwpCit7CisgIGVhc3NlcnQg KHBkbC0+a2luZCA9PSBTUEVDUERMX0JBQ0tUUkFDRSk7CisgIHJldHVybiBwZGwtPnYuYnQu ZnVuY3Rpb247Cit9CisKK3N0YXRpYyBwdHJkaWZmX3QKK2JhY2t0cmFjZV9uYXJncyAoc3Ry dWN0IHNwZWNiaW5kaW5nICpwZGwpCit7CisgIGVhc3NlcnQgKHBkbC0+a2luZCA9PSBTUEVD UERMX0JBQ0tUUkFDRSk7CisgIHJldHVybiBwZGwtPnYuYnQubmFyZ3M7Cit9CisKK3N0YXRp YyBMaXNwX09iamVjdCAqCitiYWNrdHJhY2VfYXJncyAoc3RydWN0IHNwZWNiaW5kaW5nICpw ZGwpCit7CisgIGVhc3NlcnQgKHBkbC0+a2luZCA9PSBTUEVDUERMX0JBQ0tUUkFDRSk7Cisg IHJldHVybiBwZGwtPnYuYnQuYXJnczsKK30KKworc3RhdGljIGJvb2wKK2JhY2t0cmFjZV9k ZWJ1Z19vbl9leGl0IChzdHJ1Y3Qgc3BlY2JpbmRpbmcgKnBkbCkKK3sKKyAgZWFzc2VydCAo cGRsLT5raW5kID09IFNQRUNQRExfQkFDS1RSQUNFKTsKKyAgcmV0dXJuIHBkbC0+di5idC5k ZWJ1Z19vbl9leGl0OworfQorCiAvKiBGdW5jdGlvbnMgdG8gbW9kaWZ5IHNsb3RzIG9mIGJh Y2t0cmFjZSByZWNvcmRzLiAgKi8KIAogc3RhdGljIHZvaWQKCj09PSBtb2RpZmllZCBmaWxl ICdzcmMvZmxvYXRmbnMuYycKLS0tIHNyYy9mbG9hdGZucy5jCTIwMTMtMDMtMjQgMTI6NTk6 NDUgKzAwMDAKKysrIHNyYy9mbG9hdGZucy5jCTIwMTMtMDYtMTMgMTU6Mzg6MTYgKzAwMDAK QEAgLTQxLDYgKzQxLDE0IEBACiAjIGRlZmluZSBpc25hbih4KSAoKHgpICE9ICh4KSkKICNl bmRpZgogCisvKiBDaGVjayB0aGF0IFggaXMgYSBmbG9hdGluZyBwb2ludCBudW1iZXIuICAq LworCitzdGF0aWMgdm9pZAorQ0hFQ0tfRkxPQVQgKExpc3BfT2JqZWN0IHgpCit7CisgIENI RUNLX1RZUEUgKEZMT0FUUCAoeCksIFFmbG9hdHAsIHgpOworfQorCiAvKiBFeHRyYWN0IGEg TGlzcCBudW1iZXIgYXMgYSBgZG91YmxlJywgb3Igc2lnbmFsIGFuIGVycm9yLiAgKi8KIAog ZG91YmxlCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2Zucy5jJwotLS0gc3JjL2Zucy5jCTIw MTMtMDYtMTMgMjI6MjQ6NTIgKzAwMDAKKysrIHNyYy9mbnMuYwkyMDEzLTA2LTE1IDA2OjE3 OjA3ICswMDAwCkBAIC05MSw2ICs5MSwxMiBAQAogCiAvKiBSYW5kb20gZGF0YS1zdHJ1Y3R1 cmUgZnVuY3Rpb25zLiAgKi8KIAorc3RhdGljIHZvaWQKK0NIRUNLX0xJU1RfRU5EIChMaXNw X09iamVjdCB4LCBMaXNwX09iamVjdCB5KQoreworICBDSEVDS19UWVBFIChOSUxQICh4KSwg UWxpc3RwLCB5KTsKK30KKwogREVGVU4gKCJsZW5ndGgiLCBGbGVuZ3RoLCBTbGVuZ3RoLCAx LCAxLCAwLAogICAgICAgIGRvYzogLyogUmV0dXJuIHRoZSBsZW5ndGggb2YgdmVjdG9yLCBs aXN0IG9yIHN0cmluZyBTRVFVRU5DRS4KIEEgYnl0ZS1jb2RlIGZ1bmN0aW9uIG9iamVjdCBp cyBhbHNvIGFsbG93ZWQuCkBAIC0zMzM3LDcgKzMzNDMsOCBAQAogCiAvKiBWYXJpb3VzIHN5 bWJvbHMuICAqLwogCi1zdGF0aWMgTGlzcF9PYmplY3QgUWhhc2hfdGFibGVfcCwgUWtleSwg UXZhbHVlLCBRZXFsOworc3RhdGljIExpc3BfT2JqZWN0IFFoYXNoX3RhYmxlX3A7CitzdGF0 aWMgTGlzcF9PYmplY3QgUWtleSwgUXZhbHVlLCBRZXFsOwogTGlzcF9PYmplY3QgUWVxLCBR ZXF1YWw7CiBMaXNwX09iamVjdCBRQ3Rlc3QsIFFDc2l6ZSwgUUNyZWhhc2hfc2l6ZSwgUUNy ZWhhc2hfdGhyZXNob2xkLCBRQ3dlYWtuZXNzOwogc3RhdGljIExpc3BfT2JqZWN0IFFoYXNo X3RhYmxlX3Rlc3QsIFFrZXlfb3JfdmFsdWUsIFFrZXlfYW5kX3ZhbHVlOwpAQCAtMzM0Nyw2 ICszMzU0LDQ4IEBACiAJCQkgICAgICAgVXRpbGl0aWVzCiAgKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiov CiAKK3N0YXRpYyB2b2lkCitDSEVDS19IQVNIX1RBQkxFIChMaXNwX09iamVjdCB4KQorewor ICByZXR1cm4gQ0hFQ0tfVFlQRSAoSEFTSF9UQUJMRV9QICh4KSwgUWhhc2hfdGFibGVfcCwg eCk7Cit9CisKK3N0YXRpYyB2b2lkCitzZXRfaGFzaF9rZXlfYW5kX3ZhbHVlIChzdHJ1Y3Qg TGlzcF9IYXNoX1RhYmxlICpoLCBMaXNwX09iamVjdCBrZXlfYW5kX3ZhbHVlKQoreworICBo LT5rZXlfYW5kX3ZhbHVlID0ga2V5X2FuZF92YWx1ZTsKK30KK3N0YXRpYyB2b2lkCitzZXRf aGFzaF9uZXh0IChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoLCBMaXNwX09iamVjdCBuZXh0 KQoreworICBoLT5uZXh0ID0gbmV4dDsKK30KK3N0YXRpYyB2b2lkCitzZXRfaGFzaF9uZXh0 X3Nsb3QgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIHB0cmRpZmZfdCBpZHgsIExpc3Bf T2JqZWN0IHZhbCkKK3sKKyAgZ2NfYXNldCAoaC0+bmV4dCwgaWR4LCB2YWwpOworfQorc3Rh dGljIHZvaWQKK3NldF9oYXNoX2hhc2ggKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIExp c3BfT2JqZWN0IGhhc2gpCit7CisgIGgtPmhhc2ggPSBoYXNoOworfQorc3RhdGljIHZvaWQK K3NldF9oYXNoX2hhc2hfc2xvdCAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgcHRyZGlm Zl90IGlkeCwgTGlzcF9PYmplY3QgdmFsKQoreworICBnY19hc2V0IChoLT5oYXNoLCBpZHgs IHZhbCk7Cit9CitzdGF0aWMgdm9pZAorc2V0X2hhc2hfaW5kZXggKHN0cnVjdCBMaXNwX0hh c2hfVGFibGUgKmgsIExpc3BfT2JqZWN0IGluZGV4KQoreworICBoLT5pbmRleCA9IGluZGV4 OworfQorc3RhdGljIHZvaWQKK3NldF9oYXNoX2luZGV4X3Nsb3QgKHN0cnVjdCBMaXNwX0hh c2hfVGFibGUgKmgsIHB0cmRpZmZfdCBpZHgsIExpc3BfT2JqZWN0IHZhbCkKK3sKKyAgZ2Nf YXNldCAoaC0+aW5kZXgsIGlkeCwgdmFsKTsKK30KKwogLyogSWYgT0JKIGlzIGEgTGlzcCBo YXNoIHRhYmxlLCByZXR1cm4gYSBwb2ludGVyIHRvIGl0cyBzdHJ1Y3QKICAgIExpc3BfSGFz aF9UYWJsZS4gIE90aGVyd2lzZSwgc2lnbmFsIGFuIGVycm9yLiAgKi8KIAoKPT09IG1vZGlm aWVkIGZpbGUgJ3NyYy9rZXltYXAuYycKLS0tIHNyYy9rZXltYXAuYwkyMDEzLTA2LTA1IDAx OjU4OjQzICswMDAwCisrKyBzcmMva2V5bWFwLmMJMjAxMy0wNi0xMyAxNTozODoxNiArMDAw MApAQCAtMTA2LDYgKzEwNiwxMiBAQAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBM aXNwX09iamVjdCwgTGlzcF9PYmplY3QsIGJvb2wsIGJvb2wpOwogc3RhdGljIHZvaWQgc2ls bHlfZXZlbnRfc3ltYm9sX2Vycm9yIChMaXNwX09iamVjdCk7CiBzdGF0aWMgTGlzcF9PYmpl Y3QgZ2V0X2tleWVsdCAoTGlzcF9PYmplY3QsIGJvb2wpOworCitzdGF0aWMgdm9pZAorQ0hF Q0tfVkVDVE9SX09SX0NIQVJfVEFCTEUgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZ UEUgKFZFQ1RPUlAgKHgpIHx8IENIQVJfVEFCTEVfUCAoeCksIFF2ZWN0b3Jfb3JfY2hhcl90 YWJsZV9wLCB4KTsKK30KIAwKIC8qIEtleW1hcCBvYmplY3Qgc3VwcG9ydCAtIGNvbnN0cnVj dG9ycyBhbmQgcHJlZGljYXRlcy4JCQkqLwogCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL2xp c3AuaCcKLS0tIHNyYy9saXNwLmgJMjAxMy0wNi0wNSAxMjoxNzowMiArMDAwMAorKysgc3Jj L2xpc3AuaAkyMDEzLTA2LTE1IDA2OjMzOjI3ICswMDAwCkBAIC0yMjAsNiArMjIwLDEzOSBA QAogI2VuZGlmCiAKIAorLyogU29tZSBvcGVyYXRpb25zIGFyZSBzbyBjb21tb25seSBleGVj dXRlZCB0aGF0IHRoZXkgYXJlIGltcGxlbWVudGVkCisgICBhcyBtYWNyb3MsIG5vdCBmdW5j dGlvbnMsIGJlY2F1c2Ugb3RoZXJ3aXNlIHJ1bnRpbWUgcGVyZm9ybWFuY2Ugd291bGQKKyAg IHN1ZmZlciB0b28gbXVjaCB3aGVuIGNvbXBpbGluZyB3aXRoIEdDQyB3aXRob3V0IG9wdGlt aXphdGlvbi4KKyAgIFRoZXJlJ3Mgbm8gbmVlZCB0byBpbmxpbmUgZXZlcnl0aGluZywganVz dCB0aGUgb3BlcmF0aW9ucyB0aGF0CisgICB3b3VsZCBvdGhlcndpc2UgY2F1c2UgYSBzZXJp b3VzIHBlcmZvcm1hbmNlIHByb2JsZW0uCisKKyAgIEZvciBlYWNoIHN1Y2ggb3BlcmF0aW9u IE9QLCBkZWZpbmUgYSBtYWNybyBsaXNwX2hfT1AgdGhhdCBjb250YWlucworICAgdGhlIG9w ZXJhdGlvbidzIGltcGxlbWVudGF0aW9uLiAgVGhhdCB3YXksIE9QIGNhbiBiZSBpbXBsZW1l bnRhdGVkCisgICB2aWEgYSBtYWNybyBkZWZpbml0aW9uIGxpa2UgdGhpczoKKworICAgICAj ZGVmaW5lIE9QKHgpIGxpc3BfaF9PUCAoeCkKKworICAgYW5kL29yIHZpYSBhIGZ1bmN0aW9u IGRlZmluaXRpb24gbGlrZSB0aGlzOgorCisgICAgIExJU1BfTUFDUk9fREVGVU4gKE9QLCBM aXNwX09iamVjdCwgKExpc3BfT2JqZWN0IHgpLCAoeCkpCisKKyAgIHdoaWNoIG1hY3JvLWV4 cGFuZHMgdG8gdGhpczoKKworICAgICBMaXNwX09iamVjdCAoT1ApIChMaXNwX09iamVjdCB4 KSB7IHJldHVybiBsaXNwX2hfT1AgKHgpOyB9CisKKyAgIHdpdGhvdXQgd29ycnlpbmcgYWJv dXQgdGhlIGltcGxlbWVudGF0aW9ucyBkaXZlcmdpbmcsIHNpbmNlCisgICBsaXNwX2hfT1Ag ZGVmaW5lcyB0aGUgYWN0dWFsIGltcGxlbWVudGF0aW9uLiAgVGhlIGxpc3BfaF9PUCBtYWNy b3MKKyAgIGFyZSBpbnRlbmRlZCB0byBiZSBwcml2YXRlIHRvIHRoaXMgaW5jbHVkZSBmaWxl LCBhbmQgc2hvdWxkIG5vdCBiZQorICAgdXNlZCBlbHNld2hlcmUuCisKKyAgIEZJWE1FOiBS ZW1vdmUgdGhlIGxpc3BfaF9PUCBtYWNyb3MsIGFuZCBkZWZpbmUganVzdCB0aGUgaW5saW5l IE9QCisgICBmdW5jdGlvbnMsIG9uY2UgbW9zdCBkZXZlbG9wZXJzIGhhdmUgYWNjZXNzIHRv IEdDQyA0Ljggb3IgbGF0ZXIgYW5kCisgICBjYW4gdXNlICJnY2MgLU9nIiB0byBkZWJ1Zy4g IE1heWJlIGluIHRoZSB5ZWFyIDIwMTYuICBTZWUKKyAgIEJ1ZyMxMTkzNS4KKworICAgQ29t bWVudGFyeSBmb3IgdGhlc2UgbWFjcm9zIGNhbiBiZSBmb3VuZCBuZWFyIHRoZWlyIGNvcnJl c3BvbmRpbmcKKyAgIGZ1bmN0aW9ucywgYmVsb3cuICAqLworCisjaWYgQ0hFQ0tfTElTUF9P QkpFQ1RfVFlQRQorIyBkZWZpbmUgbGlzcF9oX1hMSShvKSAoKG8pLmkpCisjIGRlZmluZSBs aXNwX2hfWElMKGkpICgoTGlzcF9PYmplY3QpIHsgaSB9KQorI2Vsc2UKKyMgZGVmaW5lIGxp c3BfaF9YTEkobykgKG8pCisjIGRlZmluZSBsaXNwX2hfWElMKGkpIChpKQorI2VuZGlmCisj ZGVmaW5lIGxpc3BfaF9DSEVDS19MSVNUX0NPTlMoeCwgeSkgQ0hFQ0tfVFlQRSAoQ09OU1Ag KHgpLCBRbGlzdHAsIHkpCisjZGVmaW5lIGxpc3BfaF9DSEVDS19OVU1CRVIoeCkgQ0hFQ0tf VFlQRSAoSU5URUdFUlAgKHgpLCBRaW50ZWdlcnAsIHgpCisjZGVmaW5lIGxpc3BfaF9DSEVD S19TWU1CT0woeCkgQ0hFQ0tfVFlQRSAoU1lNQk9MUCAoeCksIFFzeW1ib2xwLCB4KQorI2Rl ZmluZSBsaXNwX2hfQ0hFQ0tfVFlQRShvaywgUXh4eHAsIHgpIFwKKyAgICgodm9pZCkgKChv aykgfHwgd3JvbmdfdHlwZV9hcmd1bWVudCAoUXh4eHAsIHgpKSkKKyNkZWZpbmUgbGlzcF9o X0NPTlNQKHgpIChYVFlQRSAoeCkgPT0gTGlzcF9Db25zKQorI2RlZmluZSBsaXNwX2hfRVEo eCwgeSkgKFhMSSAoeCkgPT0gWExJICh5KSkKKyNkZWZpbmUgbGlzcF9oX0ZMT0FUUCh4KSAo WFRZUEUgKHgpID09IExpc3BfRmxvYXQpCisjZGVmaW5lIGxpc3BfaF9JTlRFR0VSUCh4KSAo KFhUWVBFICh4KSAmIH5MaXNwX0ludDEpID09IDApCisjZGVmaW5lIGxpc3BfaF9NQVJLRVJQ KHgpIChNSVNDUCAoeCkgJiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01pc2NfTWFya2VyKQor I2RlZmluZSBsaXNwX2hfTUlTQ1AoeCkgKFhUWVBFICh4KSA9PSBMaXNwX01pc2MpCisjZGVm aW5lIGxpc3BfaF9OSUxQKHgpIEVRICh4LCBRbmlsKQorI2RlZmluZSBsaXNwX2hfU0VUX1NZ TUJPTF9WQUwoc3ltLCB2KSBcCisgICAoZWFzc2VydCAoKHN5bSktPnJlZGlyZWN0ID09IFNZ TUJPTF9QTEFJTlZBTCksIChzeW0pLT52YWwudmFsdWUgPSAodikpCisjZGVmaW5lIGxpc3Bf aF9TWU1CT0xfQ09OU1RBTlRfUChzeW0pIChYU1lNQk9MIChzeW0pLT5jb25zdGFudCkKKyNk ZWZpbmUgbGlzcF9oX1NZTUJPTF9WQUwoc3ltKSBcCisgICAoZWFzc2VydCAoKHN5bSktPnJl ZGlyZWN0ID09IFNZTUJPTF9QTEFJTlZBTCksIChzeW0pLT52YWwudmFsdWUpCisjZGVmaW5l IGxpc3BfaF9TWU1CT0xQKHgpIChYVFlQRSAoeCkgPT0gTGlzcF9TeW1ib2wpCisjZGVmaW5l IGxpc3BfaF9WRUNUT1JMSUtFUCh4KSAoWFRZUEUgKHgpID09IExpc3BfVmVjdG9ybGlrZSkK KyNkZWZpbmUgbGlzcF9oX1hDQVIoYykgWENPTlMgKGMpLT5jYXIKKyNkZWZpbmUgbGlzcF9o X1hDRFIoYykgWENPTlMgKGMpLT51LmNkcgorI2RlZmluZSBsaXNwX2hfWENPTlMoYSkgXAor ICAgKGVhc3NlcnQgKENPTlNQIChhKSksIChzdHJ1Y3QgTGlzcF9Db25zICopIFhVTlRBRyAo YSwgTGlzcF9Db25zKSkKKyNkZWZpbmUgbGlzcF9oX1hIQVNIKGEpIFhVSU5UIChhKQorI2Rl ZmluZSBsaXNwX2hfWFBOVFIoYSkgXAorICAgKCh2b2lkICopIChpbnRwdHJfdCkgKChYTEkg KGEpICYgVkFMTUFTSykgfCBEQVRBX1NFR19CSVRTKSkKKyNkZWZpbmUgbGlzcF9oX1hTWU1C T0woYSkgXAorICAgKGVhc3NlcnQgKFNZTUJPTFAgKGEpKSwgKHN0cnVjdCBMaXNwX1N5bWJv bCAqKSBYVU5UQUcgKGEsIExpc3BfU3ltYm9sKSkKKyNpZm5kZWYgR0NfQ0hFQ0tfQ09OU19M SVNUCisjIGRlZmluZSBsaXNwX2hfY2hlY2tfY29uc19saXN0KCkgKCh2b2lkKSAwKQorI2Vu ZGlmCisjaWYgVVNFX0xTQl9UQUcKKyMgZGVmaW5lIGxpc3BfaF9tYWtlX251bWJlcihuKSBY SUwgKChFTUFDU19JTlQpIChuKSA8PCBJTlRUWVBFQklUUykKKyMgZGVmaW5lIGxpc3BfaF9Y RkFTVElOVChhKSBYSU5UIChhKQorIyBkZWZpbmUgbGlzcF9oX1hJTlQoYSkgKFhMSSAoYSkg Pj4gSU5UVFlQRUJJVFMpCisjIGRlZmluZSBsaXNwX2hfWFRZUEUoYSkgKChlbnVtIExpc3Bf VHlwZSkgKFhMSSAoYSkgJiB+VkFMTUFTSykpCisjIGRlZmluZSBsaXNwX2hfWFVOVEFHKGEs IHR5cGUpICgodm9pZCAqKSAoWExJIChhKSAtICh0eXBlKSkpCisjZW5kaWYKKworLyogV2hl biBjb21waWxpbmcgdmlhIGdjYyAtTzAsIGRlZmluZSB0aGUga2V5IG9wZXJhdGlvbnMgYXMg bWFjcm9zLCBhcworICAgRW1hY3MgaXMgdG9vIHNsb3cgb3RoZXJ3aXNlLiAgVG8gZGlzYWJs ZSB0aGlzIG9wdGltaXphdGlvbiwgY29tcGlsZQorICAgd2l0aCAtRElOTElOSU5HPTAuICAq LworI2lmIChkZWZpbmVkIF9fTk9fSU5MSU5FX18gXAorICAgICAmJiAhIGRlZmluZWQgX19P UFRJTUlaRV9fICYmICEgZGVmaW5lZCBfX09QVElNSVpFX1NJWkVfXyBcCisgICAgICYmICEg KGRlZmluZWQgSU5MSU5JTkcgJiYgISBJTkxJTklORykpCisjIGRlZmluZSBYTEkobykgbGlz cF9oX1hMSSAobykKKyMgZGVmaW5lIFhJTChpKSBsaXNwX2hfWElMIChpKQorIyBkZWZpbmUg Q0hFQ0tfTElTVF9DT05TKHgsIHkpIGxpc3BfaF9DSEVDS19MSVNUX0NPTlMgKHgsIHkpCisj IGRlZmluZSBDSEVDS19OVU1CRVIoeCkgbGlzcF9oX0NIRUNLX05VTUJFUiAoeCkKKyMgZGVm aW5lIENIRUNLX1NZTUJPTCh4KSBsaXNwX2hfQ0hFQ0tfU1lNQk9MICh4KQorIyBkZWZpbmUg Q0hFQ0tfVFlQRShvaywgUXh4eHAsIHgpIGxpc3BfaF9DSEVDS19UWVBFIChvaywgUXh4eHAs IHgpCisjIGRlZmluZSBDT05TUCh4KSBsaXNwX2hfQ09OU1AgKHgpCisjIGRlZmluZSBFUSh4 LCB5KSBsaXNwX2hfRVEgKHgsIHkpCisjIGRlZmluZSBGTE9BVFAoeCkgbGlzcF9oX0ZMT0FU UCAoeCkKKyMgZGVmaW5lIElOVEVHRVJQKHgpIGxpc3BfaF9JTlRFR0VSUCAoeCkKKyMgZGVm aW5lIE1BUktFUlAoeCkgbGlzcF9oX01BUktFUlAgKHgpCisjIGRlZmluZSBNSVNDUCh4KSBs aXNwX2hfTUlTQ1AgKHgpCisjIGRlZmluZSBOSUxQKHgpIGxpc3BfaF9OSUxQICh4KQorIyBk ZWZpbmUgU0VUX1NZTUJPTF9WQUwoc3ltLCB2KSBsaXNwX2hfU0VUX1NZTUJPTF9WQUwgKHN5 bSwgdikKKyMgZGVmaW5lIFNZTUJPTF9DT05TVEFOVF9QKHN5bSkgbGlzcF9oX1NZTUJPTF9D T05TVEFOVF9QIChzeW0pCisjIGRlZmluZSBTWU1CT0xfVkFMKHN5bSkgbGlzcF9oX1NZTUJP TF9WQUwgKHN5bSkKKyMgZGVmaW5lIFNZTUJPTFAoeCkgbGlzcF9oX1NZTUJPTFAgKHgpCisj IGRlZmluZSBWRUNUT1JMSUtFUCh4KSBsaXNwX2hfVkVDVE9STElLRVAgKHgpCisjIGRlZmlu ZSBYQ0FSKGMpIGxpc3BfaF9YQ0FSIChjKQorIyBkZWZpbmUgWENEUihjKSBsaXNwX2hfWENE UiAoYykKKyMgZGVmaW5lIFhDT05TKGEpIGxpc3BfaF9YQ09OUyAoYSkKKyMgZGVmaW5lIFhI QVNIKGEpIGxpc3BfaF9YSEFTSCAoYSkKKyMgZGVmaW5lIFhQTlRSKGEpIGxpc3BfaF9YUE5U UiAoYSkKKyMgZGVmaW5lIFhTWU1CT0woYSkgbGlzcF9oX1hTWU1CT0wgKGEpCisjIGlmbmRl ZiBHQ19DSEVDS19DT05TX0xJU1QKKyMgIGRlZmluZSBjaGVja19jb25zX2xpc3QoKSBsaXNw X2hfY2hlY2tfY29uc19saXN0ICgpCisjIGVuZGlmCisjIGlmIFVTRV9MU0JfVEFHCisjICBk ZWZpbmUgbWFrZV9udW1iZXIobikgbGlzcF9oX21ha2VfbnVtYmVyIChuKQorIyAgZGVmaW5l IFhGQVNUSU5UKGEpIGxpc3BfaF9YRkFTVElOVCAoYSkKKyMgIGRlZmluZSBYSU5UKGEpIGxp c3BfaF9YSU5UIChhKQorIyAgZGVmaW5lIFhUWVBFKGEpIGxpc3BfaF9YVFlQRSAoYSkKKyMg IGRlZmluZSBYVU5UQUcoYSwgdHlwZSkgbGlzcF9oX1hVTlRBRyAoYSwgdHlwZSkKKyMgZW5k aWYKKyNlbmRpZgorCisvKiBEZWZpbmUgTkFNRSBhcyBhIGxpc3AuaCBpbmxpbmUgZnVuY3Rp b24gdGhhdCByZXR1cm5zIFRZUEUgYW5kIGhhcworICAgYXJndW1lbnRzIGRlY2xhcmVkIGFz IEFSR0RFQ0xTIGFuZCBwYXNzZWQgYXMgQVJHUy4gIEFSR0RFQ0xTIGFuZAorICAgQVJHUyBz aG91bGQgYmUgcGFyZW50aGVzaXplZC4gIEltcGxlbWVudCB0aGUgZnVuY3Rpb24gYnkgY2Fs bGluZworICAgbGlzcF9oX05BTUUgQVJHUy4gICovCisjZGVmaW5lIExJU1BfTUFDUk9fREVG VU4obmFtZSwgdHlwZSwgYXJnZGVjbHMsIGFyZ3MpIFwKKyAgTElTUF9JTkxJTkUgdHlwZSAo bmFtZSkgYXJnZGVjbHMgeyByZXR1cm4gbGlzcF9oXyMjbmFtZSBhcmdzOyB9CisKKy8qIGxp a2UgTElTUF9NQUNST19ERUZVTiwgZXhjZXB0IE5BTUUgcmV0dXJucyB2b2lkLiAgKi8KKyNk ZWZpbmUgTElTUF9NQUNST19ERUZVTl9WT0lEKG5hbWUsIGFyZ2RlY2xzLCBhcmdzKSBcCisg IExJU1BfSU5MSU5FIHZvaWQgKG5hbWUpIGFyZ2RlY2xzIHsgbGlzcF9oXyMjbmFtZSBhcmdz OyB9CisKKwogLyogRGVmaW5lIHRoZSBmdW5kYW1lbnRhbCBMaXNwIGRhdGEgc3RydWN0dXJl cy4gICovCiAKIC8qIFRoaXMgaXMgdGhlIHNldCBvZiBMaXNwIGRhdGEgdHlwZXMuICBJZiB5 b3Ugd2FudCB0byBkZWZpbmUgYSBuZXcKQEAgLTIzMCw3ICszNjMsNiBAQAogICAgZXh0ZW5k aW5nIHRoZWlyIHJhbmdlIGZyb20sIGUuZy4sIC0yXjI4Li4yXjI4LTEgdG8gLTJeMjkuLjJe MjktMS4gICovCiAjZGVmaW5lIElOVE1BU0sgKEVNQUNTX0lOVF9NQVggPj4gKElOVFRZUEVC SVRTIC0gMSkpCiAjZGVmaW5lIGNhc2VfTGlzcF9JbnQgY2FzZSBMaXNwX0ludDA6IGNhc2Ug TGlzcF9JbnQxCi0jZGVmaW5lIExJU1BfSU5UX1RBR19QKHgpICgoKHgpICYgfkxpc3BfSW50 MSkgPT0gMCkKIAogLyogSWRlYSBzdG9sZW4gZnJvbSBHREIuICBNU1ZDIGRvZXNuJ3Qgc3Vw cG9ydCBlbnVtcyBpbiBiaXRmaWVsZHMsCiAgICBhbmQgeGxjIGNvbXBsYWlucyB2b2NpZmVy b3VzbHkgYWJvdXQgdGhlbS4gICovCkBAIC0zNTksMjAgKzQ5MSw2IEBACiAKIHR5cGVkZWYg c3RydWN0IHsgRU1BQ1NfSU5UIGk7IH0gTGlzcF9PYmplY3Q7CiAKLSNkZWZpbmUgWExJKG8p IChvKS5pCi1MSVNQX0lOTElORSBMaXNwX09iamVjdAotWElMIChFTUFDU19JTlQgaSkKLXsK LSAgTGlzcF9PYmplY3QgbyA9IHsgaSB9OwotICByZXR1cm4gbzsKLX0KLQotTElTUF9JTkxJ TkUgTGlzcF9PYmplY3QKLUxJU1BfTUFLRV9SVkFMVUUgKExpc3BfT2JqZWN0IG8pCi17Ci0g ICAgcmV0dXJuIG87Ci19Ci0KICNkZWZpbmUgTElTUF9JTklUSUFMTFlfWkVSTyB7MH0KIAog I3VuZGVmIENIRUNLX0xJU1BfT0JKRUNUX1RZUEUKQEAgLTM4MiwxMyArNTAwLDE1IEBACiAv KiBJZiBhIHN0cnVjdCB0eXBlIGlzIG5vdCB3YW50ZWQsIGRlZmluZSBMaXNwX09iamVjdCBh cyBqdXN0IGEgbnVtYmVyLiAgKi8KIAogdHlwZWRlZiBFTUFDU19JTlQgTGlzcF9PYmplY3Q7 Ci0jZGVmaW5lIFhMSShvKSAobykKLSNkZWZpbmUgWElMKGkpIChpKQotI2RlZmluZSBMSVNQ X01BS0VfUlZBTFVFKG8pICgwICsgKG8pKQogI2RlZmluZSBMSVNQX0lOSVRJQUxMWV9aRVJP IDAKIGVudW0gQ0hFQ0tfTElTUF9PQkpFQ1RfVFlQRSB7IENIRUNLX0xJU1BfT0JKRUNUX1RZ UEUgPSAwIH07CiAjZW5kaWYgLyogQ0hFQ0tfTElTUF9PQkpFQ1RfVFlQRSAqLwogCisvKiBD b252ZXJ0IGEgTGlzcF9PYmplY3QgdG8gdGhlIGNvcnJlc3BvbmRpbmcgRU1BQ1NfSU5UIGFu ZCB2aWNlIHZlcnNhLgorICAgQXQgdGhlIG1hY2hpbmUgbGV2ZWwsIHRoZXNlIG9wZXJhdGlv bnMgYXJlIG5vLW9wcy4gICovCitMSVNQX01BQ1JPX0RFRlVOIChYTEksIEVNQUNTX0lOVCwg KExpc3BfT2JqZWN0IG8pLCAobykpCitMSVNQX01BQ1JPX0RFRlVOIChYSUwsIExpc3BfT2Jq ZWN0LCAoRU1BQ1NfSU5UIGkpLCAoaSkpCisKIC8qIEluIHRoZSBzaXplIHdvcmQgb2YgYSB2 ZWN0b3IsIHRoaXMgYml0IG1lYW5zIHRoZSB2ZWN0b3IgaGFzIGJlZW4gbWFya2VkLiAgKi8K IAogc3RhdGljIHB0cmRpZmZfdCBjb25zdCBBUlJBWV9NQVJLX0ZMQUcKQEAgLTQ2MCw4NSAr NTgwLDEwOSBAQAogICAgIEJPT0xfVkVDVE9SX0JJVFNfUEVSX0NIQVIgPSA4CiAgIH07CiAM Ci0vKiBUaGVzZSBtYWNyb3MgZXh0cmFjdCB2YXJpb3VzIHNvcnRzIG9mIHZhbHVlcyBmcm9t IGEgTGlzcF9PYmplY3QuCisvKiBUaGVzZSBmdW5jdGlvbnMgZXh0cmFjdCB2YXJpb3VzIHNv cnRzIG9mIHZhbHVlcyBmcm9tIGEgTGlzcF9PYmplY3QuCiAgRm9yIGV4YW1wbGUsIGlmIHRl bSBpcyBhIExpc3BfT2JqZWN0IHdob3NlIHR5cGUgaXMgTGlzcF9Db25zLAogIFhDT05TICh0 ZW0pIGlzIHRoZSBzdHJ1Y3QgTGlzcF9Db25zICogcG9pbnRpbmcgdG8gdGhlIG1lbW9yeSBm b3IgdGhhdCBjb25zLiAgKi8KIAotI2lmIFVTRV9MU0JfVEFHCi0KLWVudW0gbHNiX2JpdHMK LSAgewotICAgIFRZUEVNQVNLID0gKDEgPDwgR0NUWVBFQklUUykgLSAxLAotICAgIFZBTE1B U0sgPSB+IFRZUEVNQVNLCi0gIH07Ci0jZGVmaW5lIFhUWVBFKGEpICgoZW51bSBMaXNwX1R5 cGUpIChYTEkgKGEpICYgVFlQRU1BU0spKQotI2RlZmluZSBYSU5UKGEpIChYTEkgKGEpID4+ IElOVFRZUEVCSVRTKQotI2RlZmluZSBYVUlOVChhKSAoKEVNQUNTX1VJTlQpIFhMSSAoYSkg Pj4gSU5UVFlQRUJJVFMpCi0jZGVmaW5lIG1ha2VfbnVtYmVyKE4pIFhJTCAoKEVNQUNTX0lO VCkgKE4pIDw8IElOVFRZUEVCSVRTKQotI2RlZmluZSBtYWtlX2xpc3BfcHRyKHB0ciwgdHlw ZSkgXAotICAoZWFzc2VydCAoWFRZUEUgKFhJTCAoKGludHB0cl90KSAocHRyKSkpID09IDAp LCAvKiBDaGVjayBhbGlnbm1lbnQuICAqLyAgXAotICAgWElMICgodHlwZSkgfCAoaW50cHRy X3QpIChwdHIpKSkKLQotI2RlZmluZSBYUE5UUihhKSAoKGludHB0cl90KSAoWExJIChhKSAm IH5UWVBFTUFTSykpCi0jZGVmaW5lIFhVTlRBRyhhLCB0eXBlKSAoKGludHB0cl90KSAoWExJ IChhKSAtICh0eXBlKSkpCi0KLSNlbHNlICAvKiBub3QgVVNFX0xTQl9UQUcgKi8KLQogc3Rh dGljIEVNQUNTX0lOVCBjb25zdCBWQUxNQVNLCi0jZGVmaW5lIFZBTE1BU0sgVkFMX01BWAor I2RlZmluZSBWQUxNQVNLIChVU0VfTFNCX1RBRyA/IC0gKDEgPDwgR0NUWVBFQklUUykgOiBW QUxfTUFYKQogICAgICAgPSBWQUxNQVNLOwogCi0jZGVmaW5lIFhUWVBFKGEpICgoZW51bSBM aXNwX1R5cGUpICgoRU1BQ1NfVUlOVCkgWExJIChhKSA+PiBWQUxCSVRTKSkKLQotLyogRm9y IGludGVnZXJzIGtub3duIHRvIGJlIHBvc2l0aXZlLCBYRkFTVElOVCBwcm92aWRlcyBmYXN0 IHJldHJpZXZhbAotICAgYW5kIFhTRVRGQVNUSU5UIHByb3ZpZGVzIGZhc3Qgc3RvcmFnZS4g IFRoaXMgdGFrZXMgYWR2YW50YWdlIG9mIHRoZQotICAgZmFjdCB0aGF0IExpc3AgaW50ZWdl cnMgaGF2ZSB6ZXJvLWJpdHMgaW4gdGhlaXIgdGFncy4gICovCi0jZGVmaW5lIFhGQVNUSU5U KGEpIChYTEkgKGEpICsgMCkKLSNkZWZpbmUgWFNFVEZBU1RJTlQoYSwgYikgKChhKSA9IFhJ TCAoYikpCi0KLS8qIEV4dHJhY3QgdGhlIHZhbHVlIG9mIGEgTGlzcF9PYmplY3QgYXMgYSAo dW4pc2lnbmVkIGludGVnZXIuICAqLwotCi0jZGVmaW5lIFhJTlQoYSkgKFhMSSAoYSkgPDwg SU5UVFlQRUJJVFMgPj4gSU5UVFlQRUJJVFMpCi0jZGVmaW5lIFhVSU5UKGEpICgoRU1BQ1Nf VUlOVCkgKFhMSSAoYSkgJiBJTlRNQVNLKSkKLSNkZWZpbmUgbWFrZV9udW1iZXIoTikgWElM ICgoRU1BQ1NfSU5UKSAoTikgJiBJTlRNQVNLKQotCi0jZGVmaW5lIG1ha2VfbGlzcF9wdHIo cHRyLCB0eXBlKSBcCi0gIChYSUwgKChFTUFDU19JTlQpICgoRU1BQ1NfVUlOVCkgKHR5cGUp IDw8IFZBTEJJVFMpICBcCi0JKyAoKGludHB0cl90KSAocHRyKSAmIFZBTE1BU0spKSkKLQot LyogREFUQV9TRUdfQklUUyBmb3JjZXMgZXh0cmEgYml0cyB0byBiZSBvcidkIGluIHdpdGgg YW55IHBvaW50ZXJzCi0gICB3aGljaCB3ZXJlIHN0b3JlZCBpbiBhIExpc3BfT2JqZWN0LiAg Ki8KLSNkZWZpbmUgWFBOVFIoYSkgKCh1aW50cHRyX3QpICgoWExJIChhKSAmIFZBTE1BU0sp IHwgREFUQV9TRUdfQklUUykpCi0KLSNlbmRpZiAvKiBub3QgVVNFX0xTQl9UQUcgKi8KLQot LyogUmV0dXJuIGEgKExpc3AtaW50ZWdlciBzaXplZCkgaGFzaCBvZiB0aGUgTGlzcF9PYmpl Y3QgdmFsdWUuICBIYXBwZW5zIHRvIGJlCi0gICBsaWtlIFhVSU5UIHJpZ2h0IG5vdywgYnV0 IFhVSU5UIHNob3VsZCBvbmx5IGJlIGFwcGxpZWQgdG8gb2JqZWN0cyB3ZSBrbm93Ci0gICBh cmUgaW50ZWdlcnMuICAqLwotI2RlZmluZSBYSEFTSChhKSBYVUlOVCAoYSkKLQotLyogRm9y IGludGVnZXJzIGtub3duIHRvIGJlIHBvc2l0aXZlLCBYRkFTVElOVCBzb21ldGltZXMgcHJv dmlkZXMKLSAgIGZhc3RlciByZXRyaWV2YWwgYW5kIFhTRVRGQVNUSU5UIHByb3ZpZGVzIGZh c3RlciBzdG9yYWdlLgotICAgSWYgbm90LCBmYWxsYmFjayBvbiB0aGUgbm9uLWFjY2VsZXJh dGVkIHBhdGguICAqLwotI2lmbmRlZiBYRkFTVElOVAotIyBkZWZpbmUgWEZBU1RJTlQoYSkg KFhJTlQgKGEpKQotIyBkZWZpbmUgWFNFVEZBU1RJTlQoYSwgYikgKFhTRVRJTlQgKGEsIGIp KQotI2VuZGlmCi0KLS8qIEV4dHJhY3QgdGhlIHBvaW50ZXIgdmFsdWUgb2YgdGhlIExpc3Ag b2JqZWN0IEEsIHVuZGVyIHRoZQotICAgYXNzdW1wdGlvbiB0aGF0IEEncyB0eXBlIGlzIFRZ UEUuICBUaGlzIGlzIGEgZmFsbGJhY2sKLSAgIGltcGxlbWVudGF0aW9uIGlmIG5vdGhpbmcg ZmFzdGVyIGlzIGF2YWlsYWJsZS4gICovCi0jaWZuZGVmIFhVTlRBRwotIyBkZWZpbmUgWFVO VEFHKGEsIHR5cGUpIFhQTlRSIChhKQotI2VuZGlmCi0KLSNkZWZpbmUgRVEoeCwgeSkgKFhM SSAoeCkgPT0gWExJICh5KSkKLQogLyogTGFyZ2VzdCBhbmQgc21hbGxlc3QgcmVwcmVzZW50 YWJsZSBmaXhudW0gdmFsdWVzLiAgVGhlc2UgYXJlIHRoZSBDCiAgICB2YWx1ZXMuICBUaGV5 IGFyZSBtYWNyb3MgZm9yIHVzZSBpbiBzdGF0aWMgaW5pdGlhbGl6ZXJzLiAgKi8KICNkZWZp bmUgTU9TVF9QT1NJVElWRV9GSVhOVU0gKEVNQUNTX0lOVF9NQVggPj4gSU5UVFlQRUJJVFMp CiAjZGVmaW5lIE1PU1RfTkVHQVRJVkVfRklYTlVNICgtMSAtIE1PU1RfUE9TSVRJVkVfRklY TlVNKQogCisvKiBFeHRyYWN0IHRoZSBwb2ludGVyIGhpZGRlbiB3aXRoaW4gQS4gICovCitM SVNQX01BQ1JPX0RFRlVOIChYUE5UUiwgdm9pZCAqLCAoTGlzcF9PYmplY3QgYSksIChhKSkK KworI2lmIFVTRV9MU0JfVEFHCisKK0xJU1BfTUFDUk9fREVGVU4gKG1ha2VfbnVtYmVyLCBM aXNwX09iamVjdCwgKEVNQUNTX0lOVCBuKSwgKG4pKQorTElTUF9NQUNST19ERUZVTiAoWElO VCwgRU1BQ1NfSU5ULCAoTGlzcF9PYmplY3QgYSksIChhKSkKK0xJU1BfTUFDUk9fREVGVU4g KFhGQVNUSU5ULCBFTUFDU19JTlQsIChMaXNwX09iamVjdCBhKSwgKGEpKQorTElTUF9NQUNS T19ERUZVTiAoWFRZUEUsIGVudW0gTGlzcF9UeXBlLCAoTGlzcF9PYmplY3QgYSksIChhKSkK K0xJU1BfTUFDUk9fREVGVU4gKFhVTlRBRywgdm9pZCAqLCAoTGlzcF9PYmplY3QgYSwgaW50 IHR5cGUpLCAoYSwgdHlwZSkpCisKKyNlbHNlIC8qICEgVVNFX0xTQl9UQUcgKi8KKworLyog QWx0aG91Z2ggY29tcGlsZWQgb25seSBpZiAhIFVTRV9MU0JfVEFHLCB0aGUgZm9sbG93aW5n IGZ1bmN0aW9ucworICAgYWxzbyB3b3JrIHdoZW4gVVNFX0xTQl9UQUc7IHRoaXMgaXMgdG8g YWlkIGZ1dHVyZSBtYWludGVuYW5jZSB3aGVuCisgICB0aGUgbGlzcF9oXyogbWFjcm9zIGFy ZSBldmVudHVhbGx5IHJlbW92ZWQuICAqLworCisvKiBNYWtlIGEgTGlzcCBpbnRlZ2VyIHJl cHJlc2VudGluZyB0aGUgdmFsdWUgb2YgdGhlIGxvdyBvcmRlcgorICAgYml0cyBvZiBOLiAg Ki8KK0xJU1BfSU5MSU5FIExpc3BfT2JqZWN0CittYWtlX251bWJlciAoRU1BQ1NfSU5UIG4p Cit7CisgIHJldHVybiBYSUwgKFVTRV9MU0JfVEFHID8gbiA8PCBJTlRUWVBFQklUUyA6IG4g JiBJTlRNQVNLKTsKK30KKworLyogRXh0cmFjdCBBJ3MgdmFsdWUgYXMgYSBzaWduZWQgaW50 ZWdlci4gICovCitMSVNQX0lOTElORSBFTUFDU19JTlQKK1hJTlQgKExpc3BfT2JqZWN0IGEp Cit7CisgIEVNQUNTX0lOVCBpID0gWExJIChhKTsKKyAgcmV0dXJuIChVU0VfTFNCX1RBRyA/ IGkgOiBpIDw8IElOVFRZUEVCSVRTKSA+PiBJTlRUWVBFQklUUzsKK30KKworLyogTGlrZSBY SU5UIChBKSwgYnV0IG1heSBiZSBmYXN0ZXIuICBBIG11c3QgYmUgbm9ubmVnYXRpdmUuCisg ICBJZiAhIFVTRV9MU0JfVEFHLCB0aGlzIHRha2VzIGFkdmFudGFnZSBvZiB0aGUgZmFjdCB0 aGF0IExpc3AKKyAgIGludGVnZXJzIGhhdmUgemVyby1iaXRzIGluIHRoZWlyIHRhZ3MuICAq LworTElTUF9JTkxJTkUgRU1BQ1NfSU5UCitYRkFTVElOVCAoTGlzcF9PYmplY3QgYSkKK3sK KyAgRU1BQ1NfSU5UIG4gPSBVU0VfTFNCX1RBRyA/IFhJTlQgKGEpIDogWExJIChhKTsKKyAg ZWFzc2VydCAoMCA8PSBuKTsKKyAgcmV0dXJuIG47Cit9CisKKy8qIEV4dHJhY3QgQSdzIHR5 cGUuICAqLworTElTUF9JTkxJTkUgZW51bSBMaXNwX1R5cGUKK1hUWVBFIChMaXNwX09iamVj dCBhKQoreworICBFTUFDU19VSU5UIGkgPSBYTEkgKGEpOworICByZXR1cm4gVVNFX0xTQl9U QUcgPyBpICYgflZBTE1BU0sgOiBpID4+IFZBTEJJVFM7Cit9CisKKy8qIEV4dHJhY3QgQSdz IHBvaW50ZXIgdmFsdWUsIGFzc3VtaW5nIEEncyB0eXBlIGlzIFRZUEUuICAqLworTElTUF9J TkxJTkUgdm9pZCAqCitYVU5UQUcgKExpc3BfT2JqZWN0IGEsIGludCB0eXBlKQoreworICBp ZiAoVVNFX0xTQl9UQUcpCisgICAgeworICAgICAgaW50cHRyX3QgaSA9IFhMSSAoYSkgLSB0 eXBlOworICAgICAgcmV0dXJuICh2b2lkICopIGk7CisgICAgfQorICByZXR1cm4gWFBOVFIg KGEpOworfQorCisjZW5kaWYgLyogISBVU0VfTFNCX1RBRyAqLworCisvKiBFeHRyYWN0IEEn cyB2YWx1ZSBhcyBhbiB1bnNpZ25lZCBpbnRlZ2VyLiAgKi8KK0xJU1BfSU5MSU5FIEVNQUNT X1VJTlQKK1hVSU5UIChMaXNwX09iamVjdCBhKQoreworICBFTUFDU19VSU5UIGkgPSBYTEkg KGEpOworICByZXR1cm4gVVNFX0xTQl9UQUcgPyBpID4+IElOVFRZUEVCSVRTIDogaSAmIElO VE1BU0s7Cit9CisKKy8qIFJldHVybiBBJ3MgKExpc3AtaW50ZWdlciBzaXplZCkgaGFzaC4g IEhhcHBlbnMgdG8gYmUgbGlrZSBYVUlOVAorICAgcmlnaHQgbm93LCBidXQgWFVJTlQgc2hv dWxkIG9ubHkgYmUgYXBwbGllZCB0byBvYmplY3RzIHdlIGtub3cgYXJlCisgICBpbnRlZ2Vy cy4gICovCitMSVNQX01BQ1JPX0RFRlVOIChYSEFTSCwgRU1BQ1NfSU5ULCAoTGlzcF9PYmpl Y3QgYSksIChhKSkKKworLyogTGlrZSBtYWtlX251bWJlciAoTiksIGJ1dCBtYXkgYmUgZmFz dGVyLiAgTiBtdXN0IGJlIGluIG5vbm5lZ2F0aXZlIHJhbmdlLiAgKi8KK0xJU1BfSU5MSU5F IExpc3BfT2JqZWN0CittYWtlX25hdG51bSAoRU1BQ1NfSU5UIG4pCit7CisgIGVhc3NlcnQg KDAgPD0gbiAmJiBuIDw9IE1PU1RfUE9TSVRJVkVfRklYTlVNKTsKKyAgcmV0dXJuIFVTRV9M U0JfVEFHID8gbWFrZV9udW1iZXIgKG4pIDogWElMIChuKTsKK30KKworLyogUmV0dXJuIHRy dWUgaWYgWCBhbmQgWSBhcmUgdGhlIHNhbWUgb2JqZWN0LiAgKi8KK0xJU1BfTUFDUk9fREVG VU4gKEVRLCBib29sLCAoTGlzcF9PYmplY3QgeCwgTGlzcF9PYmplY3QgeSksICh4LCB5KSkK KwogLyogVmFsdWUgaXMgbm9uLXplcm8gaWYgSSBkb2Vzbid0IGZpdCBpbnRvIGEgTGlzcCBm aXhudW0uICBJdCBpcwogICAgd3JpdHRlbiB0aGlzIHdheSBzbyB0aGF0IGl0IGFsc28gd29y a3MgaWYgSSBpcyBvZiB1bnNpZ25lZAogICAgdHlwZSBvciBpZiBJIGlzIGEgTmFOLiAgKi8K QEAgLTU1MSw2NiArNjk1LDE3MyBAQAogewogICByZXR1cm4gbnVtIDwgbG93ZXIgPyBsb3dl ciA6IG51bSA8PSB1cHBlciA/IG51bSA6IHVwcGVyOwogfQotCi0MCisMCisvKiBGb3J3YXJk IGRlY2xhcmF0aW9ucy4gICovCisKKy8qIERlZmluZWQgaW4gdGhpcyBmaWxlLiAgKi8KK3Vu aW9uIExpc3BfRndkOworTElTUF9JTkxJTkUgYm9vbCBCT09MX1ZFQ1RPUl9QIChMaXNwX09i amVjdCk7CitMSVNQX0lOTElORSBib29sIEJVRkZFUl9PQkpGV0RQICh1bmlvbiBMaXNwX0Z3 ZCAqKTsKK0xJU1BfSU5MSU5FIGJvb2wgQlVGRkVSUCAoTGlzcF9PYmplY3QpOworTElTUF9J TkxJTkUgYm9vbCBDSEFSX1RBQkxFX1AgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIExp c3BfT2JqZWN0IENIQVJfVEFCTEVfUkVGX0FTQ0lJIChMaXNwX09iamVjdCwgcHRyZGlmZl90 KTsKK0xJU1BfSU5MSU5FIGJvb2wgKENPTlNQKSAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJ TkUgYm9vbCAoRkxPQVRQKSAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCBmdW5j dGlvbnAgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIGJvb2wgKElOVEVHRVJQKSAoTGlz cF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCAoTUFSS0VSUCkgKExpc3BfT2JqZWN0KTsK K0xJU1BfSU5MSU5FIGJvb2wgKE1JU0NQKSAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUg Ym9vbCAoTklMUCkgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIGJvb2wgT1ZFUkxBWVAg KExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIGJvb2wgUFJPQ0VTU1AgKExpc3BfT2JqZWN0 KTsKK0xJU1BfSU5MSU5FIGJvb2wgUFNFVURPVkVDVE9SUCAoTGlzcF9PYmplY3QsIGludCk7 CitMSVNQX0lOTElORSBib29sIFNBVkVfVkFMVUVQIChMaXNwX09iamVjdCk7CitMSVNQX0lO TElORSB2b2lkIHNldF9zdWJfY2hhcl90YWJsZV9jb250ZW50cyAoTGlzcF9PYmplY3QsIHB0 cmRpZmZfdCwKKwkJCQkJICAgICAgTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgYm9vbCBT VFJJTkdQIChMaXNwX09iamVjdCk7CitMSVNQX0lOTElORSBib29sIFNVQl9DSEFSX1RBQkxF X1AgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIGJvb2wgU1VCUlAgKExpc3BfT2JqZWN0 KTsKK0xJU1BfSU5MSU5FIGJvb2wgKFNZTUJPTFApIChMaXNwX09iamVjdCk7CitMSVNQX0lO TElORSBib29sIChWRUNUT1JMSUtFUCkgKExpc3BfT2JqZWN0KTsKK0xJU1BfSU5MSU5FIGJv b2wgV0lORE9XUCAoTGlzcF9PYmplY3QpOworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfU2F2 ZV9WYWx1ZSAqWFNBVkVfVkFMVUUgKExpc3BfT2JqZWN0KTsKKworLyogRGVmaW5lZCBpbiBj aGFydGFiLmMuICAqLworZXh0ZXJuIExpc3BfT2JqZWN0IGNoYXJfdGFibGVfcmVmIChMaXNw X09iamVjdCwgaW50KTsKK2V4dGVybiB2b2lkIGNoYXJfdGFibGVfc2V0IChMaXNwX09iamVj dCwgaW50LCBMaXNwX09iamVjdCk7CitleHRlcm4gaW50IGNoYXJfdGFibGVfdHJhbnNsYXRl IChMaXNwX09iamVjdCwgaW50KTsKKworLyogRGVmaW5lZCBpbiBkYXRhLmMuICAqLworZXh0 ZXJuIExpc3BfT2JqZWN0IFFhcnJheXAsIFFidWZmZXJwLCBRYnVmZmVyX29yX3N0cmluZ19w LCBRY2hhcl90YWJsZV9wOworZXh0ZXJuIExpc3BfT2JqZWN0IFFjb25zcCwgUWZsb2F0cCwg UWludGVnZXJwLCBRbGFtYmRhLCBRbGlzdHAsIFFtYXJrZXJwLCBRbmlsOworZXh0ZXJuIExp c3BfT2JqZWN0IFFudW1iZXJwLCBRc3RyaW5ncCwgUXN5bWJvbHAsIFF2ZWN0b3JwOworZXh0 ZXJuIExpc3BfT2JqZWN0IFF2ZWN0b3Jfb3JfY2hhcl90YWJsZV9wLCBRd2hvbGVudW1wOwor ZXh0ZXJuIExpc3BfT2JqZWN0IEZmYm91bmRwIChMaXNwX09iamVjdCk7CitleHRlcm4gX05v cmV0dXJuIExpc3BfT2JqZWN0IHdyb25nX3R5cGVfYXJndW1lbnQgKExpc3BfT2JqZWN0LCBM aXNwX09iamVjdCk7CisKKy8qIERlZmluZWQgaW4gZW1hY3MuYy4gICovCitleHRlcm4gYm9v bCBpbml0aWFsaXplZDsKKworLyogRGVmaW5lZCBpbiBldmFsLmMuICAqLworZXh0ZXJuIExp c3BfT2JqZWN0IFFhdXRvbG9hZDsKKworLyogRGVmaW5lZCBpbiBmbG9hdGZucy5jLiAgKi8K K2V4dGVybiBkb3VibGUgZXh0cmFjdF9mbG9hdCAoTGlzcF9PYmplY3QpOworCisvKiBEZWZp bmVkIGluIHByb2Nlc3MuYy4gICovCitleHRlcm4gTGlzcF9PYmplY3QgUXByb2Nlc3NwOwor CisvKiBEZWZpbmVkIGluIHdpbmRvdy5jLiAgKi8KK2V4dGVybiBMaXNwX09iamVjdCBRd2lu ZG93cDsKKworLyogRGVmaW5lZCBpbiB4ZGlzcC5jLiAgKi8KK2V4dGVybiBMaXNwX09iamVj dCBRaW1hZ2U7CisMCisKIC8qIEV4dHJhY3QgYSB2YWx1ZSBvciBhZGRyZXNzIGZyb20gYSBM aXNwX09iamVjdC4gICovCiAKLSNkZWZpbmUgWENPTlMoYSkgICAoZWFzc2VydCAoQ09OU1Ag KGEpKSwgXAotCQkgICAgKHN0cnVjdCBMaXNwX0NvbnMgKikgWFVOVEFHIChhLCBMaXNwX0Nv bnMpKQotI2RlZmluZSBYVkVDVE9SKGEpIChlYXNzZXJ0IChWRUNUT1JMSUtFUCAoYSkpLCBc Ci0JCSAgICAoc3RydWN0IExpc3BfVmVjdG9yICopIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3Js aWtlKSkKLSNkZWZpbmUgWFNUUklORyhhKSAoZWFzc2VydCAoU1RSSU5HUCAoYSkpLCBcCi0J CSAgICAoc3RydWN0IExpc3BfU3RyaW5nICopIFhVTlRBRyAoYSwgTGlzcF9TdHJpbmcpKQot I2RlZmluZSBYU1lNQk9MKGEpIChlYXNzZXJ0IChTWU1CT0xQIChhKSksIFwKLQkJICAgIChz dHJ1Y3QgTGlzcF9TeW1ib2wgKikgWFVOVEFHIChhLCBMaXNwX1N5bWJvbCkpCi0jZGVmaW5l IFhGTE9BVChhKSAgKGVhc3NlcnQgKEZMT0FUUCAoYSkpLCBcCi0JCSAgICAoc3RydWN0IExp c3BfRmxvYXQgKikgWFVOVEFHIChhLCBMaXNwX0Zsb2F0KSkKLQotLyogTWlzYyB0eXBlcy4g ICovCi0KLSNkZWZpbmUgWE1JU0MoYSkJKCh1bmlvbiBMaXNwX01pc2MgKikgWFVOVEFHIChh LCBMaXNwX01pc2MpKQotI2RlZmluZSBYTUlTQ0FOWShhKQkoZWFzc2VydCAoTUlTQ1AgKGEp KSwgJihYTUlTQyAoYSktPnVfYW55KSkKLSNkZWZpbmUgWE1JU0NUWVBFKGEpICAgKFhNSVND QU5ZIChhKS0+dHlwZSkKLSNkZWZpbmUgWE1BUktFUihhKQkoZWFzc2VydCAoTUFSS0VSUCAo YSkpLCAmKFhNSVNDIChhKS0+dV9tYXJrZXIpKQotI2RlZmluZSBYT1ZFUkxBWShhKQkoZWFz c2VydCAoT1ZFUkxBWVAgKGEpKSwgJihYTUlTQyAoYSktPnVfb3ZlcmxheSkpCi0KLS8qIEZv cndhcmRpbmcgb2JqZWN0IHR5cGVzLiAgKi8KLQotI2RlZmluZSBYRldEVFlQRShhKSAgICAg KGEtPnVfaW50ZndkLnR5cGUpCi0jZGVmaW5lIFhJTlRGV0QoYSkJKGVhc3NlcnQgKElOVEZX RFAgKGEpKSwgJigoYSktPnVfaW50ZndkKSkKLSNkZWZpbmUgWEJPT0xGV0QoYSkJKGVhc3Nl cnQgKEJPT0xGV0RQIChhKSksICYoKGEpLT51X2Jvb2xmd2QpKQotI2RlZmluZSBYT0JKRldE KGEpCShlYXNzZXJ0IChPQkpGV0RQIChhKSksICYoKGEpLT51X29iamZ3ZCkpCi0jZGVmaW5l IFhCVUZGRVJfT0JKRldEKGEpIFwKLSAgKGVhc3NlcnQgKEJVRkZFUl9PQkpGV0RQIChhKSks ICYoKGEpLT51X2J1ZmZlcl9vYmpmd2QpKQotI2RlZmluZSBYS0JPQVJEX09CSkZXRChhKSBc Ci0gIChlYXNzZXJ0IChLQk9BUkRfT0JKRldEUCAoYSkpLCAmKChhKS0+dV9rYm9hcmRfb2Jq ZndkKSkKK0xJU1BfTUFDUk9fREVGVU4gKFhDT05TLCBzdHJ1Y3QgTGlzcF9Db25zICosIChM aXNwX09iamVjdCBhKSwgKGEpKQorCitMSVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9WZWN0b3Ig KgorWFZFQ1RPUiAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoVkVDVE9STElLRVAg KGEpKTsKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKTsKK30KKworTElT UF9JTkxJTkUgc3RydWN0IExpc3BfU3RyaW5nICoKK1hTVFJJTkcgKExpc3BfT2JqZWN0IGEp Cit7CisgIGVhc3NlcnQgKFNUUklOR1AgKGEpKTsKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlz cF9TdHJpbmcpOworfQorCitMSVNQX01BQ1JPX0RFRlVOIChYU1lNQk9MLCBzdHJ1Y3QgTGlz cF9TeW1ib2wgKiwgKExpc3BfT2JqZWN0IGEpLCAoYSkpCisKK0xJU1BfSU5MSU5FIHN0cnVj dCBMaXNwX0Zsb2F0ICoKK1hGTE9BVCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAo RkxPQVRQIChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfRmxvYXQpOworfQogCiAv KiBQc2V1ZG92ZWN0b3IgdHlwZXMuICAqLwotc3RydWN0IExpc3BfUHJvY2VzczsKLUxJU1Bf SU5MSU5FIExpc3BfT2JqZWN0IG1ha2VfbGlzcF9wcm9jIChzdHJ1Y3QgTGlzcF9Qcm9jZXNz ICpwKQoteyByZXR1cm4gbWFrZV9saXNwX3B0ciAocCwgTGlzcF9WZWN0b3JsaWtlKTsgfQot I2RlZmluZSBYUFJPQ0VTUyhhKSAoZWFzc2VydCAoUFJPQ0VTU1AgKGEpKSwgXAotCQkgICAg IChzdHJ1Y3QgTGlzcF9Qcm9jZXNzICopIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKSkK LSNkZWZpbmUgWFdJTkRPVyhhKSAoZWFzc2VydCAoV0lORE9XUCAoYSkpLAkJCQlcCi0JCSAg ICAoc3RydWN0IHdpbmRvdyAqKSBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSkpCi0jZGVm aW5lIFhURVJNSU5BTChhKSAoZWFzc2VydCAoVEVSTUlOQUxQIChhKSksIFwKLQkJICAgICAg KHN0cnVjdCB0ZXJtaW5hbCAqKSBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSkpCi0jZGVm aW5lIFhTVUJSKGEpIChlYXNzZXJ0IChTVUJSUCAoYSkpLCBcCi0JCSAgKHN0cnVjdCBMaXNw X1N1YnIgKikgWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpKQotI2RlZmluZSBYQlVGRkVS KGEpIChlYXNzZXJ0IChCVUZGRVJQIChhKSksIFwKLQkJICAgIChzdHJ1Y3QgYnVmZmVyICop IFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKSkKLSNkZWZpbmUgWENIQVJfVEFCTEUoYSkg KGVhc3NlcnQgKENIQVJfVEFCTEVfUCAoYSkpLCBcCi0JCQkoc3RydWN0IExpc3BfQ2hhcl9U YWJsZSAqKSBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSkpCi0jZGVmaW5lIFhTVUJfQ0hB Ul9UQUJMRShhKSAoZWFzc2VydCAoU1VCX0NIQVJfVEFCTEVfUCAoYSkpLCBcCi0JCQkgICAg KChzdHJ1Y3QgTGlzcF9TdWJfQ2hhcl9UYWJsZSAqKSBcCi0JCQkgICAgIFhVTlRBRyAoYSwg TGlzcF9WZWN0b3JsaWtlKSkpCi0jZGVmaW5lIFhCT09MX1ZFQ1RPUihhKSAoZWFzc2VydCAo Qk9PTF9WRUNUT1JfUCAoYSkpLCBcCi0JCQkgKChzdHJ1Y3QgTGlzcF9Cb29sX1ZlY3RvciAq KSBcCi0JCQkgIFhVTlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKSkpCisKK0xJU1BfSU5MSU5F IHN0cnVjdCBMaXNwX1Byb2Nlc3MgKgorWFBST0NFU1MgKExpc3BfT2JqZWN0IGEpCit7Cisg IGVhc3NlcnQgKFBST0NFU1NQIChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVj dG9ybGlrZSk7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVjdCB3aW5kb3cgKgorWFdJTkRPVyAo TGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoV0lORE9XUCAoYSkpOworICByZXR1cm4g WFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3Qg dGVybWluYWwgKgorWFRFUk1JTkFMIChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4gWFVO VEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3QgTGlz cF9TdWJyICoKK1hTVUJSIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChTVUJSUCAo YSkpOworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitMSVNQ X0lOTElORSBzdHJ1Y3QgYnVmZmVyICoKK1hCVUZGRVIgKExpc3BfT2JqZWN0IGEpCit7Cisg IGVhc3NlcnQgKEJVRkZFUlAgKGEpKTsKKyAgcmV0dXJuIFhVTlRBRyAoYSwgTGlzcF9WZWN0 b3JsaWtlKTsKK30KKworTElTUF9JTkxJTkUgc3RydWN0IExpc3BfQ2hhcl9UYWJsZSAqCitY Q0hBUl9UQUJMRSAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoQ0hBUl9UQUJMRV9Q IChhKSk7CisgIHJldHVybiBYVU5UQUcgKGEsIExpc3BfVmVjdG9ybGlrZSk7Cit9CisKK0xJ U1BfSU5MSU5FIHN0cnVjdCBMaXNwX1N1Yl9DaGFyX1RhYmxlICoKK1hTVUJfQ0hBUl9UQUJM RSAoTGlzcF9PYmplY3QgYSkKK3sKKyAgZWFzc2VydCAoU1VCX0NIQVJfVEFCTEVfUCAoYSkp OworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworfQorCitMSVNQX0lO TElORSBzdHJ1Y3QgTGlzcF9Cb29sX1ZlY3RvciAqCitYQk9PTF9WRUNUT1IgKExpc3BfT2Jq ZWN0IGEpCit7CisgIGVhc3NlcnQgKEJPT0xfVkVDVE9SX1AgKGEpKTsKKyAgcmV0dXJuIFhV TlRBRyAoYSwgTGlzcF9WZWN0b3JsaWtlKTsKK30KIAogLyogQ29uc3RydWN0IGEgTGlzcF9P YmplY3QgZnJvbSBhIHZhbHVlIG9yIGFkZHJlc3MuICAqLwogCitMSVNQX0lOTElORSBMaXNw X09iamVjdAorbWFrZV9saXNwX3B0ciAodm9pZCAqcHRyLCBlbnVtIExpc3BfVHlwZSB0eXBl KQoreworICBFTUFDU19VSU5UIHV0eXBlID0gdHlwZTsKKyAgRU1BQ1NfVUlOVCB0eXBlYml0 cyA9IFVTRV9MU0JfVEFHID8gdHlwZSA6IHV0eXBlIDw8IFZBTEJJVFM7CisgIExpc3BfT2Jq ZWN0IGEgPSBYSUwgKHR5cGViaXRzIHwgKHVpbnRwdHJfdCkgcHRyKTsKKyAgZWFzc2VydCAo WFRZUEUgKGEpID09IHR5cGUgJiYgWFVOVEFHIChhLCB0eXBlKSA9PSBwdHIpOworICByZXR1 cm4gYTsKK30KKworTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK21ha2VfbGlzcF9wcm9jIChz dHJ1Y3QgTGlzcF9Qcm9jZXNzICpwKQoreworICByZXR1cm4gbWFrZV9saXNwX3B0ciAocCwg TGlzcF9WZWN0b3JsaWtlKTsKK30KKwogI2RlZmluZSBYU0VUSU5UKGEsIGIpICgoYSkgPSBt YWtlX251bWJlciAoYikpCisjZGVmaW5lIFhTRVRGQVNUSU5UKGEsIGIpICgoYSkgPSBtYWtl X25hdG51bSAoYikpCiAjZGVmaW5lIFhTRVRDT05TKGEsIGIpICgoYSkgPSBtYWtlX2xpc3Bf cHRyIChiLCBMaXNwX0NvbnMpKQogI2RlZmluZSBYU0VUVkVDVE9SKGEsIGIpICgoYSkgPSBt YWtlX2xpc3BfcHRyIChiLCBMaXNwX1ZlY3Rvcmxpa2UpKQogI2RlZmluZSBYU0VUU1RSSU5H KGEsIGIpICgoYSkgPSBtYWtlX2xpc3BfcHRyIChiLCBMaXNwX1N0cmluZykpCkBAIC02NTYs MzUgKzkwNywxMCBAQAogI2RlZmluZSBYU0VUQk9PTF9WRUNUT1IoYSwgYikgKFhTRVRQU0VV RE9WRUNUT1IgKGEsIGIsIFBWRUNfQk9PTF9WRUNUT1IpKQogI2RlZmluZSBYU0VUU1VCX0NI QVJfVEFCTEUoYSwgYikgKFhTRVRQU0VVRE9WRUNUT1IgKGEsIGIsIFBWRUNfU1VCX0NIQVJf VEFCTEUpKQogCi0vKiBDb252ZW5pZW5jZSBtYWNyb3MgZm9yIGRlYWxpbmcgd2l0aCBMaXNw IGFycmF5cy4gICovCi0KLSNkZWZpbmUgQVJFRihBUlJBWSwgSURYKQlYVkVDVE9SICgoQVJS QVkpKS0+Y29udGVudHNbSURYXQotI2RlZmluZSBBU0laRShBUlJBWSkJCVhWRUNUT1IgKChB UlJBWSkpLT5oZWFkZXIuc2l6ZQotI2RlZmluZSBBU0VUKEFSUkFZLCBJRFgsIFZBTCkJXAot ICAoZWFzc2VydCAoMCA8PSAoSURYKSAmJiAoSURYKSA8IEFTSVpFIChBUlJBWSkpLAlcCi0g ICBYVkVDVE9SIChBUlJBWSktPmNvbnRlbnRzW0lEWF0gPSAoVkFMKSkKLQotLyogQ29udmVu aWVuY2UgbWFjcm9zIGZvciBkZWFsaW5nIHdpdGggTGlzcCBzdHJpbmdzLiAgKi8KLQotI2Rl ZmluZSBTREFUQShzdHJpbmcpCQkoWFNUUklORyAoc3RyaW5nKS0+ZGF0YSArIDApCi0jZGVm aW5lIFNSRUYoc3RyaW5nLCBpbmRleCkJKFNEQVRBIChzdHJpbmcpW2luZGV4XSArIDApCi0j ZGVmaW5lIFNTRVQoc3RyaW5nLCBpbmRleCwgbmV3KSAoU0RBVEEgKHN0cmluZylbaW5kZXhd ID0gKG5ldykpCi0jZGVmaW5lIFNDSEFSUyhzdHJpbmcpCQkoWFNUUklORyAoc3RyaW5nKS0+ c2l6ZSArIDApCi0jZGVmaW5lIFNCWVRFUyhzdHJpbmcpCQkoU1RSSU5HX0JZVEVTIChYU1RS SU5HIChzdHJpbmcpKSArIDApCi0KLS8qIEF2b2lkICJkaWZmZXIgaW4gc2lnbiIgd2Fybmlu Z3MuICAqLwotI2RlZmluZSBTU0RBVEEoeCkgICgoY2hhciAqKSBTREFUQSAoeCkpCi0KLSNk ZWZpbmUgU1RSSU5HX1NFVF9DSEFSUyhzdHJpbmcsIG5ld3NpemUpIFwKLSAgICAoWFNUUklO RyAoc3RyaW5nKS0+c2l6ZSA9IChuZXdzaXplKSkKLQotI2RlZmluZSBTVFJJTkdfQ09QWUlO KHN0cmluZywgaW5kZXgsIG5ldywgY291bnQpIFwKLSAgICBtZW1jcHkgKFNEQVRBIChzdHJp bmcpICsgaW5kZXgsIG5ldywgY291bnQpCi0KIC8qIFR5cGUgY2hlY2tpbmcuICAqLwogCi0j ZGVmaW5lIENIRUNLX1RZUEUob2ssIFF4eHhwLCB4KSBcCi0gIGRvIHsgaWYgKCEob2spKSB3 cm9uZ190eXBlX2FyZ3VtZW50IChReHh4cCwgKHgpKTsgfSB3aGlsZSAoMCkKK0xJU1BfTUFD Uk9fREVGVU5fVk9JRCAoQ0hFQ0tfVFlQRSwgKGludCBvaywgTGlzcF9PYmplY3QgUXh4eHAs IExpc3BfT2JqZWN0IHgpLAorCQkgICAgICAgKG9rLCBReHh4cCwgeCkpCiAKIC8qIERlcHJl Y2F0ZWQgYW5kIHdpbGwgYmUgcmVtb3ZlZCBzb29uLiAgKi8KIApAQCAtNjk0LDEwICs5MjAs NiBAQAogCiB0eXBlZGVmIHN0cnVjdCBpbnRlcnZhbCAqSU5URVJWQUw7CiAKLS8qIENvbXBs YWluIGlmIG9iamVjdCBpcyBub3Qgc3RyaW5nIG9yIGJ1ZmZlciB0eXBlLiAgKi8KLSNkZWZp bmUgQ0hFQ0tfU1RSSU5HX09SX0JVRkZFUih4KSBcCi0gIENIRUNLX1RZUEUgKFNUUklOR1Ag KHgpIHx8IEJVRkZFUlAgKHgpLCBRYnVmZmVyX29yX3N0cmluZ19wLCB4KQotCiBzdHJ1Y3Qg TGlzcF9Db25zCiAgIHsKICAgICAvKiBDYXIgb2YgdGhpcyBjb25zIGNlbGwuICAqLwpAQCAt NzE0LDY0ICs5MzYsODYgQEAKICAgfTsKIAogLyogVGFrZSB0aGUgY2FyIG9yIGNkciBvZiBz b21ldGhpbmcga25vd24gdG8gYmUgYSBjb25zIGNlbGwuICAqLwotLyogVGhlIF9BU19MVkFM VUUgbWFjcm9zIHNob3VsZG4ndCBiZSB1c2VkIG91dHNpZGUgb2YgdGhlIG1pbmltYWwgc2V0 CisvKiBUaGUgX2FkZHIgZnVuY3Rpb25zIHNob3VsZG4ndCBiZSB1c2VkIG91dHNpZGUgb2Yg dGhlIG1pbmltYWwgc2V0CiAgICBvZiBjb2RlIHRoYXQgaGFzIHRvIGtub3cgd2hhdCBhIGNv bnMgY2VsbCBsb29rcyBsaWtlLiAgT3RoZXIgY29kZSBub3QKICAgIHBhcnQgb2YgdGhlIGJh c2ljIGxpc3AgaW1wbGVtZW50YXRpb24gc2hvdWxkIGFzc3VtZSB0aGF0IHRoZSBjYXIgYW5k IGNkcgotICAgZmllbGRzIGFyZSBub3QgYWNjZXNzaWJsZSBhcyBsdmFsdWVzLiAgKFdoYXQg aWYgd2Ugd2FudCB0byBzd2l0Y2ggdG8KKyAgIGZpZWxkcyBhcmUgbm90IGFjY2Vzc2libGUu ICAoV2hhdCBpZiB3ZSB3YW50IHRvIHN3aXRjaCB0bwogICAgYSBjb3B5aW5nIGNvbGxlY3Rv ciBzb21lZGF5PyAgQ2FjaGVkIGNvbnMgY2VsbCBmaWVsZCBhZGRyZXNzZXMgbWF5IGJlCiAg ICBpbnZhbGlkYXRlZCBhdCBhcmJpdHJhcnkgcG9pbnRzLikgICovCi0jZGVmaW5lIFhDQVJf QVNfTFZBTFVFKGMpIChYQ09OUyAoYyktPmNhcikKLSNkZWZpbmUgWENEUl9BU19MVkFMVUUo YykgKFhDT05TIChjKS0+dS5jZHIpCitMSVNQX0lOTElORSBMaXNwX09iamVjdCAqCit4Y2Fy X2FkZHIgKExpc3BfT2JqZWN0IGMpCit7CisgIHJldHVybiAmWENPTlMgKGMpLT5jYXI7Cit9 CitMSVNQX0lOTElORSBMaXNwX09iamVjdCAqCit4Y2RyX2FkZHIgKExpc3BfT2JqZWN0IGMp Cit7CisgIHJldHVybiAmWENPTlMgKGMpLT51LmNkcjsKK30KIAogLyogVXNlIHRoZXNlIGZy b20gbm9ybWFsIGNvZGUuICAqLwotI2RlZmluZSBYQ0FSKGMpCUxJU1BfTUFLRV9SVkFMVUUg KFhDQVJfQVNfTFZBTFVFIChjKSkKLSNkZWZpbmUgWENEUihjKSBMSVNQX01BS0VfUlZBTFVF IChYQ0RSX0FTX0xWQUxVRSAoYykpCitMSVNQX01BQ1JPX0RFRlVOIChYQ0FSLCBMaXNwX09i amVjdCwgKExpc3BfT2JqZWN0IGMpLCAoYykpCitMSVNQX01BQ1JPX0RFRlVOIChYQ0RSLCBM aXNwX09iamVjdCwgKExpc3BfT2JqZWN0IGMpLCAoYykpCiAKIC8qIFVzZSB0aGVzZSB0byBz ZXQgdGhlIGZpZWxkcyBvZiBhIGNvbnMgY2VsbC4KIAogICAgTm90ZSB0aGF0IGJvdGggYXJn dW1lbnRzIG1heSByZWZlciB0byB0aGUgc2FtZSBvYmplY3QsIHNvICduJwotICAgc2hvdWxk IG5vdCBiZSByZWFkIGFmdGVyICdjJyBpcyBmaXJzdCBtb2RpZmllZC4gIEFsc28sIG5laXRo ZXIKLSAgIGFyZ3VtZW50IHNob3VsZCBiZSBldmFsdWF0ZWQgbW9yZSB0aGFuIG9uY2U7IHNp ZGUgZWZmZWN0cyBhcmUKLSAgIGVzcGVjaWFsbHkgY29tbW9uIGluIHRoZSBzZWNvbmQgYXJn dW1lbnQuICAqLwotI2RlZmluZSBYU0VUQ0FSKGMsbikgKFhDQVJfQVNfTFZBTFVFIChjKSA9 IChuKSkKLSNkZWZpbmUgWFNFVENEUihjLG4pIChYQ0RSX0FTX0xWQUxVRSAoYykgPSAobikp Ci0KLS8qIFRha2UgdGhlIGNhciBvciBjZHIgb2Ygc29tZXRoaW5nIHdob3NlIHR5cGUgaXMg bm90IGtub3duLiAgKi8KLSNkZWZpbmUgQ0FSKGMpCQkJCQlcCi0gKENPTlNQICgoYykpID8g WENBUiAoKGMpKQkJCVwKLSAgOiBOSUxQICgoYykpID8gUW5pbAkJCQlcCi0gIDogd3Jvbmdf dHlwZV9hcmd1bWVudCAoUWxpc3RwLCAoYykpKQotCi0jZGVmaW5lIENEUihjKQkJCQkJXAot IChDT05TUCAoKGMpKSA/IFhDRFIgKChjKSkJCQlcCi0gIDogTklMUCAoKGMpKSA/IFFuaWwJ CQkJXAotICA6IHdyb25nX3R5cGVfYXJndW1lbnQgKFFsaXN0cCwgKGMpKSkKLQotLyogVGFr ZSB0aGUgY2FyIG9yIGNkciBvZiBzb21ldGhpbmcgd2hvc2UgdHlwZSBpcyBub3Qga25vd24u ICAqLwotI2RlZmluZSBDQVJfU0FGRShjKQkJCQlcCi0gIChDT05TUCAoKGMpKSA/IFhDQVIg KChjKSkgOiBRbmlsKQotCi0jZGVmaW5lIENEUl9TQUZFKGMpCQkJCVwKLSAgKENPTlNQICgo YykpID8gWENEUiAoKGMpKSA6IFFuaWwpCisgICBzaG91bGQgbm90IGJlIHJlYWQgYWZ0ZXIg J2MnIGlzIGZpcnN0IG1vZGlmaWVkLiAgKi8KK0xJU1BfSU5MSU5FIHZvaWQKK1hTRVRDQVIg KExpc3BfT2JqZWN0IGMsIExpc3BfT2JqZWN0IG4pCit7CisgICp4Y2FyX2FkZHIgKGMpID0g bjsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK1hTRVRDRFIgKExpc3BfT2JqZWN0IGMsIExpc3Bf T2JqZWN0IG4pCit7CisgICp4Y2RyX2FkZHIgKGMpID0gbjsKK30KKworLyogVGFrZSB0aGUg Y2FyIG9yIGNkciBvZiBzb21ldGhpbmcgd2hvc2UgdHlwZSBpcyBub3Qga25vd24uICAqLwor TElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK0NBUiAoTGlzcF9PYmplY3QgYykKK3sKKyAgcmV0 dXJuIChDT05TUCAoYykgPyBYQ0FSIChjKQorCSAgOiBOSUxQIChjKSA/IFFuaWwKKwkgIDog d3JvbmdfdHlwZV9hcmd1bWVudCAoUWxpc3RwLCBjKSk7Cit9CitMSVNQX0lOTElORSBMaXNw X09iamVjdAorQ0RSIChMaXNwX09iamVjdCBjKQoreworICByZXR1cm4gKENPTlNQIChjKSA/ IFhDRFIgKGMpCisJICA6IE5JTFAgKGMpID8gUW5pbAorCSAgOiB3cm9uZ190eXBlX2FyZ3Vt ZW50IChRbGlzdHAsIGMpKTsKK30KKworLyogVGFrZSB0aGUgY2FyIG9yIGNkciBvZiBzb21l dGhpbmcgd2hvc2UgdHlwZSBpcyBub3Qga25vd24uICAqLworTElTUF9JTkxJTkUgTGlzcF9P YmplY3QKK0NBUl9TQUZFIChMaXNwX09iamVjdCBjKQoreworICByZXR1cm4gQ09OU1AgKGMp ID8gWENBUiAoYykgOiBRbmlsOworfQorTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK0NEUl9T QUZFIChMaXNwX09iamVjdCBjKQoreworICByZXR1cm4gQ09OU1AgKGMpID8gWENEUiAoYykg OiBRbmlsOworfQorCisvKiBJbiBhIHN0cmluZyBvciB2ZWN0b3IsIHRoZSBzaWduIGJpdCBv ZiB0aGUgYHNpemUnIGlzIHRoZSBnYyBtYXJrIGJpdC4gICovCisKK3N0cnVjdCBMaXNwX1N0 cmluZworICB7CisgICAgcHRyZGlmZl90IHNpemU7CisgICAgcHRyZGlmZl90IHNpemVfYnl0 ZTsKKyAgICBJTlRFUlZBTCBpbnRlcnZhbHM7CQkvKiBUZXh0IHByb3BlcnRpZXMgaW4gdGhp cyBzdHJpbmcuICAqLworICAgIHVuc2lnbmVkIGNoYXIgKmRhdGE7CisgIH07CiAKIC8qIFRy dWUgaWYgU1RSIGlzIGEgbXVsdGlieXRlIHN0cmluZy4gICovCi0jZGVmaW5lIFNUUklOR19N VUxUSUJZVEUoU1RSKSAgXAotICAoWFNUUklORyAoU1RSKS0+c2l6ZV9ieXRlID49IDApCi0K LS8qIFJldHVybiB0aGUgbGVuZ3RoIGluIGJ5dGVzIG9mIFNUUi4gICovCi0KLSNpZmRlZiBH Q19DSEVDS19TVFJJTkdfQllURVMKLQotc3RydWN0IExpc3BfU3RyaW5nOwotZXh0ZXJuIHB0 cmRpZmZfdCBzdHJpbmdfYnl0ZXMgKHN0cnVjdCBMaXNwX1N0cmluZyAqKTsKLSNkZWZpbmUg U1RSSU5HX0JZVEVTKFMpIHN0cmluZ19ieXRlcyAoKFMpKQotCi0jZWxzZSAvKiBub3QgR0Nf Q0hFQ0tfU1RSSU5HX0JZVEVTICovCi0KLSNkZWZpbmUgU1RSSU5HX0JZVEVTKFNUUikgIFwK LSAgKChTVFIpLT5zaXplX2J5dGUgPCAwID8gKFNUUiktPnNpemUgOiAoU1RSKS0+c2l6ZV9i eXRlKQotCi0jZW5kaWYgLyogbm90IEdDX0NIRUNLX1NUUklOR19CWVRFUyAqLworTElTUF9J TkxJTkUgYm9vbAorU1RSSU5HX01VTFRJQllURSAoTGlzcF9PYmplY3Qgc3RyKQoreworICBy ZXR1cm4gMCA8PSBYU1RSSU5HIChzdHIpLT5zaXplX2J5dGU7Cit9CiAKIC8qIEFuIHVwcGVy IGJvdW5kIG9uIHRoZSBudW1iZXIgb2YgYnl0ZXMgaW4gYSBMaXNwIHN0cmluZywgbm90CiAg ICBjb3VudGluZyB0aGUgdGVybWluYXRpbmcgbnVsbC4gIFRoaXMgYSB0aWdodCBlbm91Z2gg Ym91bmQgdG8KQEAgLTgwMiwyMCArMTA0Niw2NSBAQAogICAgICAgKFNUUikgPSBlbXB0eV9t dWx0aWJ5dGVfc3RyaW5nOyAgXAogICAgIGVsc2UgWFNUUklORyAoU1RSKS0+c2l6ZV9ieXRl ID0gWFNUUklORyAoU1RSKS0+c2l6ZTsgfSB3aGlsZSAoMCkKIAotLyogSW4gYSBzdHJpbmcg b3IgdmVjdG9yLCB0aGUgc2lnbiBiaXQgb2YgdGhlIGBzaXplJyBpcyB0aGUgZ2MgbWFyayBi aXQuICAqLworLyogQ29udmVuaWVuY2UgZnVuY3Rpb25zIGZvciBkZWFsaW5nIHdpdGggTGlz cCBzdHJpbmdzLiAgKi8KIAotc3RydWN0IExpc3BfU3RyaW5nCi0gIHsKLSAgICBwdHJkaWZm X3Qgc2l6ZTsKLSAgICBwdHJkaWZmX3Qgc2l6ZV9ieXRlOwotICAgIElOVEVSVkFMIGludGVy dmFsczsJCS8qIFRleHQgcHJvcGVydGllcyBpbiB0aGlzIHN0cmluZy4gICovCi0gICAgdW5z aWduZWQgY2hhciAqZGF0YTsKLSAgfTsKK0xJU1BfSU5MSU5FIHVuc2lnbmVkIGNoYXIgKgor U0RBVEEgKExpc3BfT2JqZWN0IHN0cmluZykKK3sKKyAgcmV0dXJuIFhTVFJJTkcgKHN0cmlu ZyktPmRhdGE7Cit9CitMSVNQX0lOTElORSBjaGFyICoKK1NTREFUQSAoTGlzcF9PYmplY3Qg c3RyaW5nKQoreworICAvKiBBdm9pZCAiZGlmZmVyIGluIHNpZ24iIHdhcm5pbmdzLiAgKi8K KyAgcmV0dXJuIChjaGFyICopIFNEQVRBIChzdHJpbmcpOworfQorTElTUF9JTkxJTkUgdW5z aWduZWQgY2hhcgorU1JFRiAoTGlzcF9PYmplY3Qgc3RyaW5nLCBwdHJkaWZmX3QgaW5kZXgp Cit7CisgIHJldHVybiBTREFUQSAoc3RyaW5nKVtpbmRleF07Cit9CitMSVNQX0lOTElORSB2 b2lkCitTU0VUIChMaXNwX09iamVjdCBzdHJpbmcsIHB0cmRpZmZfdCBpbmRleCwgdW5zaWdu ZWQgY2hhciBuZXcpCit7CisgIFNEQVRBIChzdHJpbmcpW2luZGV4XSA9IG5ldzsKK30KK0xJ U1BfSU5MSU5FIHB0cmRpZmZfdAorU0NIQVJTIChMaXNwX09iamVjdCBzdHJpbmcpCit7Cisg IHJldHVybiBYU1RSSU5HIChzdHJpbmcpLT5zaXplOworfQorTElTUF9JTkxJTkUgcHRyZGlm Zl90CitTVFJJTkdfQllURVMgKHN0cnVjdCBMaXNwX1N0cmluZyAqcykKK3sKKyNpZmRlZiBH Q19DSEVDS19TVFJJTkdfQllURVMKKyAgZXh0ZXJuIHB0cmRpZmZfdCBzdHJpbmdfYnl0ZXMg KHN0cnVjdCBMaXNwX1N0cmluZyAqKTsKKyAgcmV0dXJuIHN0cmluZ19ieXRlcyAocyk7Cisj ZWxzZQorICByZXR1cm4gcy0+c2l6ZV9ieXRlIDwgMCA/IHMtPnNpemUgOiBzLT5zaXplX2J5 dGU7CisjZW5kaWYKK30KK0xJU1BfSU5MSU5FIHB0cmRpZmZfdAorU0JZVEVTIChMaXNwX09i amVjdCBzdHJpbmcpCit7CisgIHJldHVybiBTVFJJTkdfQllURVMgKFhTVFJJTkcgKHN0cmlu ZykpOworfQorTElTUF9JTkxJTkUgdm9pZAorU1RSSU5HX1NFVF9DSEFSUyAoTGlzcF9PYmpl Y3Qgc3RyaW5nLCBwdHJkaWZmX3QgbmV3c2l6ZSkKK3sKKyAgWFNUUklORyAoc3RyaW5nKS0+ c2l6ZSA9IG5ld3NpemU7Cit9CitMSVNQX0lOTElORSB2b2lkCitTVFJJTkdfQ09QWUlOIChM aXNwX09iamVjdCBzdHJpbmcsIHB0cmRpZmZfdCBpbmRleCwgY2hhciBjb25zdCAqbmV3LAor CSAgICAgICBwdHJkaWZmX3QgY291bnQpCit7CisgIG1lbWNweSAoU0RBVEEgKHN0cmluZykg KyBpbmRleCwgbmV3LCBjb3VudCk7Cit9CiAKIC8qIEhlYWRlciBvZiB2ZWN0b3ItbGlrZSBv YmplY3RzLiAgVGhpcyBkb2N1bWVudHMgdGhlIGxheW91dCBjb25zdHJhaW50cyBvbgogICAg dmVjdG9ycyBhbmQgcHNldWRvdmVjdG9ycyAob2JqZWN0cyBvZiBQVkVDX3h4eCBzdWJ0eXBl KS4gIEl0IGFsc28gcHJldmVudHMKLSAgIGNvbXBpbGVycyBmcm9tIGJlaW5nIGZvb2xlZCBi eSBFbWFjcydzIHR5cGUgcHVubmluZzogdGhlIFhTRVRQU0VVRE9WRUNUT1IKLSAgIGFuZCBQ U0VVRE9WRUNUT1JQIG1hY3JvcyBjYXN0IHRoZWlyIHBvaW50ZXJzIHRvIHN0cnVjdCB2ZWN0 b3JsaWtlX2hlYWRlciAqLAorICAgY29tcGlsZXJzIGZyb20gYmVpbmcgZm9vbGVkIGJ5IEVt YWNzJ3MgdHlwZSBwdW5uaW5nOiBYU0VUUFNFVURPVkVDVE9SCisgICBhbmQgUFNFVURPVkVD VE9SUCBjYXN0IHRoZWlyIHBvaW50ZXJzIHRvIHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRlciAq LAogICAgYmVjYXVzZSB3aGVuIHR3byBzdWNoIHBvaW50ZXJzIHBvdGVudGlhbGx5IGFsaWFz LCBhIGNvbXBpbGVyIHdvbid0CiAgICBpbmNvcnJlY3RseSByZW9yZGVyIGxvYWRzIGFuZCBz dG9yZXMgdG8gdGhlaXIgc2l6ZSBmaWVsZHMuICBTZWUKICAgIDxodHRwOi8vZGViYnVncy5n bnUub3JnL2NnaS9idWdyZXBvcnQuY2dpP2J1Zz04NTQ2Pi4gICovCkBAIC04NzQsNiArMTE2 Myw0MiBAQAogICAgIHdvcmRfc2l6ZSA9IHNpemVvZiAoTGlzcF9PYmplY3QpCiAgIH07CiAK Ky8qIENvbnZlbmllbmNlcyBmb3IgZGVhbGluZyB3aXRoIExpc3AgYXJyYXlzLiAgKi8KKwor TElTUF9JTkxJTkUgTGlzcF9PYmplY3QKK0FSRUYgKExpc3BfT2JqZWN0IGFycmF5LCBwdHJk aWZmX3QgaWR4KQoreworICByZXR1cm4gWFZFQ1RPUiAoYXJyYXkpLT5jb250ZW50c1tpZHhd OworfQorCitMSVNQX0lOTElORSBMaXNwX09iamVjdCAqCithcmVmX2FkZHIgKExpc3BfT2Jq ZWN0IGFycmF5LCBwdHJkaWZmX3QgaWR4KQoreworICByZXR1cm4gJiBYVkVDVE9SIChhcnJh eSktPmNvbnRlbnRzW2lkeF07Cit9CisKK0xJU1BfSU5MSU5FIHB0cmRpZmZfdAorQVNJWkUg KExpc3BfT2JqZWN0IGFycmF5KQoreworICByZXR1cm4gWFZFQ1RPUiAoYXJyYXkpLT5oZWFk ZXIuc2l6ZTsKK30KKworTElTUF9JTkxJTkUgdm9pZAorQVNFVCAoTGlzcF9PYmplY3QgYXJy YXksIHB0cmRpZmZfdCBpZHgsIExpc3BfT2JqZWN0IHZhbCkKK3sKKyAgZWFzc2VydCAoMCA8 PSBpZHggJiYgaWR4IDwgQVNJWkUgKGFycmF5KSk7CisgIFhWRUNUT1IgKGFycmF5KS0+Y29u dGVudHNbaWR4XSA9IHZhbDsKK30KKworTElTUF9JTkxJTkUgdm9pZAorZ2NfYXNldCAoTGlz cF9PYmplY3QgYXJyYXksIHB0cmRpZmZfdCBpZHgsIExpc3BfT2JqZWN0IHZhbCkKK3sKKyAg LyogTGlrZSBBU0VULCBidXQgYWxzbyBjYW4gYmUgdXNlZCBpbiB0aGUgZ2FyYmFnZSBjb2xs ZWN0b3I6CisgICAgIHN3ZWVwX3dlYWtfdGFibGUgY2FsbHMgc2V0X2hhc2hfa2V5IGV0Yy4g d2hpbGUgdGhlIHRhYmxlIGlzIG1hcmtlZC4gICovCisgIGVhc3NlcnQgKDAgPD0gaWR4ICYm IGlkeCA8IChBU0laRSAoYXJyYXkpICYgfkFSUkFZX01BUktfRkxBRykpOworICBYVkVDVE9S IChhcnJheSktPmNvbnRlbnRzW2lkeF0gPSB2YWw7Cit9CisKIC8qIElmIGEgc3RydWN0IGlz IG1hZGUgdG8gbG9vayBsaWtlIGEgdmVjdG9yLCB0aGlzIG1hY3JvIHJldHVybnMgdGhlIGxl bmd0aAogICAgb2YgdGhlIHNob3J0ZXN0IHZlY3RvciB0aGF0IHdvdWxkIGhvbGQgdGhhdCBz dHJ1Y3QuICAqLwogCkBAIC04ODcsNDMgKzEyMTIsNiBAQAogI2RlZmluZSBQU0VVRE9WRUNT SVpFKHR5cGUsIG5vbmxpc3BmaWVsZCkJCQlcCiAgICgob2Zmc2V0b2YgKHR5cGUsIG5vbmxp c3BmaWVsZCkgLSBoZWFkZXJfc2l6ZSkgLyB3b3JkX3NpemUpCiAKLS8qIEEgY2hhci10YWJs ZSBpcyBhIGtpbmQgb2YgdmVjdG9ybGlrZSwgd2l0aCBjb250ZW50cyBhcmUgbGlrZSBhCi0g ICB2ZWN0b3IgYnV0IHdpdGggYSBmZXcgb3RoZXIgc2xvdHMuICBGb3Igc29tZSBwdXJwb3Nl cywgaXQgbWFrZXMKLSAgIHNlbnNlIHRvIGhhbmRsZSBhIGNoYXItdGFibGUgd2l0aCB0eXBl IHN0cnVjdCBMaXNwX1ZlY3Rvci4gIEFuCi0gICBlbGVtZW50IG9mIGEgY2hhciB0YWJsZSBj YW4gYmUgYW55IExpc3Agb2JqZWN0cywgYnV0IGlmIGl0IGlzIGEgc3ViCi0gICBjaGFyLXRh YmxlLCB3ZSB0cmVhdCBpdCBhIHRhYmxlIHRoYXQgY29udGFpbnMgaW5mb3JtYXRpb24gb2Yg YQotICAgc3BlY2lmaWMgcmFuZ2Ugb2YgY2hhcmFjdGVycy4gIEEgc3ViIGNoYXItdGFibGUg aGFzIHRoZSBzYW1lCi0gICBzdHJ1Y3R1cmUgYXMgYSB2ZWN0b3IuICBBIHN1YiBjaGFyIHRh YmxlIGFwcGVhcnMgb25seSBpbiBhbiBlbGVtZW50Ci0gICBvZiBhIGNoYXItdGFibGUsIGFu ZCB0aGVyZSdzIG5vIHdheSB0byBhY2Nlc3MgaXQgZGlyZWN0bHkgZnJvbQotICAgRW1hY3Mg TGlzcCBwcm9ncmFtLiAgKi8KLQotI2lmZGVmIF9fR05VQ19fCi0KLSNkZWZpbmUgQ0hBUl9U QUJMRV9SRUZfQVNDSUkoQ1QsIElEWCkJCQkJCVwKLSAgKHtzdHJ1Y3QgTGlzcF9DaGFyX1Rh YmxlICpfdGJsID0gTlVMTDsJCQkJXAotICAgIExpc3BfT2JqZWN0IF92YWw7CQkJCQkJCVwK LSAgICBkbyB7CQkJCQkJCQlcCi0gICAgICBfdGJsID0gX3RibCA/IFhDSEFSX1RBQkxFIChf dGJsLT5wYXJlbnQpIDogWENIQVJfVEFCTEUgKENUKTsJXAotICAgICAgX3ZhbCA9ICghIFNV Ql9DSEFSX1RBQkxFX1AgKF90YmwtPmFzY2lpKSA/IF90YmwtPmFzY2lpCQlcCi0JICAgICAg OiBYU1VCX0NIQVJfVEFCTEUgKF90YmwtPmFzY2lpKS0+Y29udGVudHNbSURYXSk7CQlcCi0g ICAgICBpZiAoTklMUCAoX3ZhbCkpCQkJCQkJCVwKLQlfdmFsID0gX3RibC0+ZGVmYWx0OwkJ CQkJCVwKLSAgICB9IHdoaWxlIChOSUxQIChfdmFsKSAmJiAhIE5JTFAgKF90YmwtPnBhcmVu dCkpOwkJCVwKLSAgICBfdmFsOyB9KQotCi0jZWxzZSAgLyogbm90IF9fR05VQ19fICovCi0K LSNkZWZpbmUgQ0hBUl9UQUJMRV9SRUZfQVNDSUkoQ1QsIElEWCkJCQkJCSAgXAotICAoISBO SUxQIChYQ0hBUl9UQUJMRSAoQ1QpLT5hc2NpaSkJCQkJCSAgXAotICAgPyAoISBTVUJfQ0hB Ul9UQUJMRV9QIChYQ0hBUl9UQUJMRSAoQ1QpLT5hc2NpaSkJCQkgIFwKLSAgICAgID8gWENI QVJfVEFCTEUgKENUKS0+YXNjaWkJCQkJCQkgIFwKLSAgICAgIDogISBOSUxQIChYU1VCX0NI QVJfVEFCTEUgKFhDSEFSX1RBQkxFIChDVCktPmFzY2lpKS0+Y29udGVudHNbSURYXSkgXAot ICAgICAgPyBYU1VCX0NIQVJfVEFCTEUgKFhDSEFSX1RBQkxFIChDVCktPmFzY2lpKS0+Y29u dGVudHNbSURYXQkgIFwKLSAgICAgIDogY2hhcl90YWJsZV9yZWYgKChDVCksIChJRFgpKSkJ CQkJCSAgXAotICAgOiAgY2hhcl90YWJsZV9yZWYgKChDVCksIChJRFgpKSkKLQotI2VuZGlm CS8qIG5vdCBfX0dOVUNfXyAqLwotCiAvKiBDb21wdXRlIEEgT1AgQiwgdXNpbmcgdGhlIHVu c2lnbmVkIGNvbXBhcmlzb24gb3BlcmF0b3IgT1AuICBBIGFuZCBCCiAgICBzaG91bGQgYmUg aW50ZWdlciBleHByZXNzaW9ucy4gIFRoaXMgaXMgbm90IHRoZSBzYW1lIGFzCiAgICBtYXRo ZW1hdGljYWwgY29tcGFyaXNvbjsgZm9yIGV4YW1wbGUsIFVOU0lHTkVEX0NNUCAoMCwgPCwg LTEpCkBAIC05MzcsMTggKzEyMjUsMTUgQEAKIC8qIE5vbnplcm8gaWZmIEMgaXMgYW4gQVND SUkgY2hhcmFjdGVyLiAgKi8KICNkZWZpbmUgQVNDSUlfQ0hBUl9QKGMpIFVOU0lHTkVEX0NN UCAoYywgPCwgMHg4MCkKIAotLyogQWxtb3N0IGVxdWl2YWxlbnQgdG8gRmFyZWYgKENULCBJ RFgpIHdpdGggb3B0aW1pemF0aW9uIGZvciBBU0NJSQotICAgY2hhcmFjdGVycy4gIERvIG5v dCBjaGVjayB2YWxpZGl0eSBvZiBDVC4gICovCi0jZGVmaW5lIENIQVJfVEFCTEVfUkVGKENU LCBJRFgpCQkJCQlcCi0gIChBU0NJSV9DSEFSX1AgKElEWCkgPyBDSEFSX1RBQkxFX1JFRl9B U0NJSSAoKENUKSwgKElEWCkpCVwKLSAgIDogY2hhcl90YWJsZV9yZWYgKChDVCksIChJRFgp KSkKLQotLyogRXF1aXZhbGVudCB0byBGYXNldCAoQ1QsIElEWCwgVkFMKSB3aXRoIG9wdGlt aXphdGlvbiBmb3IgQVNDSUkgYW5kCi0gICA4LWJpdCBFdXJvcGVhbiBjaGFyYWN0ZXJzLiAg RG8gbm90IGNoZWNrIHZhbGlkaXR5IG9mIENULiAgKi8KLSNkZWZpbmUgQ0hBUl9UQUJMRV9T RVQoQ1QsIElEWCwgVkFMKQkJCQkJXAotICAoQVNDSUlfQ0hBUl9QIChJRFgpICYmIFNVQl9D SEFSX1RBQkxFX1AgKFhDSEFSX1RBQkxFIChDVCktPmFzY2lpKQlcCi0gICA/IHNldF9zdWJf Y2hhcl90YWJsZV9jb250ZW50cyAoWENIQVJfVEFCTEUgKENUKS0+YXNjaWksIElEWCwgVkFM KQlcCi0gICA6IGNoYXJfdGFibGVfc2V0IChDVCwgSURYLCBWQUwpKQorLyogQSBjaGFyLXRh YmxlIGlzIGEga2luZCBvZiB2ZWN0b3JsaWtlLCB3aXRoIGNvbnRlbnRzIGFyZSBsaWtlIGEK KyAgIHZlY3RvciBidXQgd2l0aCBhIGZldyBvdGhlciBzbG90cy4gIEZvciBzb21lIHB1cnBv c2VzLCBpdCBtYWtlcworICAgc2Vuc2UgdG8gaGFuZGxlIGEgY2hhci10YWJsZSB3aXRoIHR5 cGUgc3RydWN0IExpc3BfVmVjdG9yLiAgQW4KKyAgIGVsZW1lbnQgb2YgYSBjaGFyIHRhYmxl IGNhbiBiZSBhbnkgTGlzcCBvYmplY3RzLCBidXQgaWYgaXQgaXMgYSBzdWIKKyAgIGNoYXIt dGFibGUsIHdlIHRyZWF0IGl0IGEgdGFibGUgdGhhdCBjb250YWlucyBpbmZvcm1hdGlvbiBv ZiBhCisgICBzcGVjaWZpYyByYW5nZSBvZiBjaGFyYWN0ZXJzLiAgQSBzdWIgY2hhci10YWJs ZSBoYXMgdGhlIHNhbWUKKyAgIHN0cnVjdHVyZSBhcyBhIHZlY3Rvci4gIEEgc3ViIGNoYXIg dGFibGUgYXBwZWFycyBvbmx5IGluIGFuIGVsZW1lbnQKKyAgIG9mIGEgY2hhci10YWJsZSwg YW5kIHRoZXJlJ3Mgbm8gd2F5IHRvIGFjY2VzcyBpdCBkaXJlY3RseSBmcm9tCisgICBFbWFj cyBMaXNwIHByb2dyYW0uICAqLwogCiBlbnVtIENIQVJUQUJfU0laRV9CSVRTCiAgIHsKQEAg LTEwMTIsNiArMTI5Nyw0NSBAQAogICAgIExpc3BfT2JqZWN0IGNvbnRlbnRzWzFdOwogICB9 OwogCitMSVNQX0lOTElORSBMaXNwX09iamVjdAorQ0hBUl9UQUJMRV9SRUZfQVNDSUkgKExp c3BfT2JqZWN0IGN0LCBwdHJkaWZmX3QgaWR4KQoreworICBzdHJ1Y3QgTGlzcF9DaGFyX1Rh YmxlICp0YmwgPSBOVUxMOworICBMaXNwX09iamVjdCB2YWw7CisgIGRvCisgICAgeworICAg ICAgdGJsID0gdGJsID8gWENIQVJfVEFCTEUgKHRibC0+cGFyZW50KSA6IFhDSEFSX1RBQkxF IChjdCk7CisgICAgICB2YWwgPSAoISBTVUJfQ0hBUl9UQUJMRV9QICh0YmwtPmFzY2lpKSA/ IHRibC0+YXNjaWkKKwkgICAgIDogWFNVQl9DSEFSX1RBQkxFICh0YmwtPmFzY2lpKS0+Y29u dGVudHNbaWR4XSk7CisgICAgICBpZiAoTklMUCAodmFsKSkKKwl2YWwgPSB0YmwtPmRlZmFs dDsKKyAgICB9CisgIHdoaWxlIChOSUxQICh2YWwpICYmICEgTklMUCAodGJsLT5wYXJlbnQp KTsKKworICByZXR1cm4gdmFsOworfQorCisvKiBBbG1vc3QgZXF1aXZhbGVudCB0byBGYXJl ZiAoQ1QsIElEWCkgd2l0aCBvcHRpbWl6YXRpb24gZm9yIEFTQ0lJCisgICBjaGFyYWN0ZXJz LiAgRG8gbm90IGNoZWNrIHZhbGlkaXR5IG9mIENULiAgKi8KK0xJU1BfSU5MSU5FIExpc3Bf T2JqZWN0CitDSEFSX1RBQkxFX1JFRiAoTGlzcF9PYmplY3QgY3QsIGludCBpZHgpCit7Cisg IHJldHVybiAoQVNDSUlfQ0hBUl9QIChpZHgpCisJICA/IENIQVJfVEFCTEVfUkVGX0FTQ0lJ IChjdCwgaWR4KQorCSAgOiBjaGFyX3RhYmxlX3JlZiAoY3QsIGlkeCkpOworfQorCisvKiBF cXVpdmFsZW50IHRvIEZhc2V0IChDVCwgSURYLCBWQUwpIHdpdGggb3B0aW1pemF0aW9uIGZv ciBBU0NJSSBhbmQKKyAgIDgtYml0IEV1cm9wZWFuIGNoYXJhY3RlcnMuICBEbyBub3QgY2hl Y2sgdmFsaWRpdHkgb2YgQ1QuICAqLworTElTUF9JTkxJTkUgdm9pZAorQ0hBUl9UQUJMRV9T RVQgKExpc3BfT2JqZWN0IGN0LCBpbnQgaWR4LCBMaXNwX09iamVjdCB2YWwpCit7CisgIGlm IChBU0NJSV9DSEFSX1AgKGlkeCkgJiYgU1VCX0NIQVJfVEFCTEVfUCAoWENIQVJfVEFCTEUg KGN0KS0+YXNjaWkpKQorICAgIHNldF9zdWJfY2hhcl90YWJsZV9jb250ZW50cyAoWENIQVJf VEFCTEUgKGN0KS0+YXNjaWksIGlkeCwgdmFsKTsKKyAgZWxzZQorICAgIGNoYXJfdGFibGVf c2V0IChjdCwgaWR4LCB2YWwpOworfQorCiAvKiBUaGlzIHN0cnVjdHVyZSBkZXNjcmliZXMg YSBidWlsdC1pbiBmdW5jdGlvbi4KICAgIEl0IGlzIGdlbmVyYXRlZCBieSB0aGUgREVGVU4g bWFjcm8gb25seS4KICAgIGRlZnN1YnIgbWFrZXMgaXQgaW50byBhIExpc3Agb2JqZWN0LiAg Ki8KQEAgLTEwNDgsOCArMTM3MiwxMiBAQAogCiAvKiBSZXR1cm4gdGhlIG51bWJlciBvZiAi ZXh0cmEiIHNsb3RzIGluIHRoZSBjaGFyIHRhYmxlIENULiAgKi8KIAotI2RlZmluZSBDSEFS X1RBQkxFX0VYVFJBX1NMT1RTKENUKQlcCi0gICgoKENUKS0+aGVhZGVyLnNpemUgJiBQU0VV RE9WRUNUT1JfU0laRV9NQVNLKSAtIENIQVJfVEFCTEVfU1RBTkRBUkRfU0xPVFMpCitMSVNQ X0lOTElORSBpbnQKK0NIQVJfVEFCTEVfRVhUUkFfU0xPVFMgKHN0cnVjdCBMaXNwX0NoYXJf VGFibGUgKmN0KQoreworICByZXR1cm4gKChjdC0+aGVhZGVyLnNpemUgJiBQU0VVRE9WRUNU T1JfU0laRV9NQVNLKQorCSAgLSBDSEFSX1RBQkxFX1NUQU5EQVJEX1NMT1RTKTsKK30KIAog DAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqCkBAIC0xMTIxLDQwICsxNDQ5LDc2IEBACiAKIC8qIFZh bHVlIGlzIG5hbWUgb2Ygc3ltYm9sLiAgKi8KIAotI2RlZmluZSBTWU1CT0xfVkFMKHN5bSkJ CQkJCQkJXAotICAoZWFzc2VydCAoKHN5bSktPnJlZGlyZWN0ID09IFNZTUJPTF9QTEFJTlZB TCksICBzeW0tPnZhbC52YWx1ZSkKLSNkZWZpbmUgU1lNQk9MX0FMSUFTKHN5bSkJCQkJCQlc Ci0gIChlYXNzZXJ0ICgoc3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9MX1ZBUkFMSUFTKSwgIChz eW0pLT52YWwuYWxpYXMpCi0jZGVmaW5lIFNZTUJPTF9CTFYoc3ltKQkJCQkJCQlcCi0gIChl YXNzZXJ0ICgoc3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9MX0xPQ0FMSVpFRCksIChzeW0pLT52 YWwuYmx2KQotI2RlZmluZSBTWU1CT0xfRldEKHN5bSkJCQkJCQkJXAotICAoZWFzc2VydCAo KHN5bSktPnJlZGlyZWN0ID09IFNZTUJPTF9GT1JXQVJERUQpLCAoc3ltKS0+dmFsLmZ3ZCkK LSNkZWZpbmUgU0VUX1NZTUJPTF9WQUwoc3ltLCB2KQkJCQkJCVwKLSAgKGVhc3NlcnQgKChz eW0pLT5yZWRpcmVjdCA9PSBTWU1CT0xfUExBSU5WQUwpLCAgKHN5bSktPnZhbC52YWx1ZSA9 ICh2KSkKLSNkZWZpbmUgU0VUX1NZTUJPTF9BTElBUyhzeW0sIHYpCQkJCQlcCi0gIChlYXNz ZXJ0ICgoc3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9MX1ZBUkFMSUFTKSwgIChzeW0pLT52YWwu YWxpYXMgPSAodikpCi0jZGVmaW5lIFNFVF9TWU1CT0xfQkxWKHN5bSwgdikJCQkJCQlcCi0g IChlYXNzZXJ0ICgoc3ltKS0+cmVkaXJlY3QgPT0gU1lNQk9MX0xPQ0FMSVpFRCksIChzeW0p LT52YWwuYmx2ID0gKHYpKQotI2RlZmluZSBTRVRfU1lNQk9MX0ZXRChzeW0sIHYpCQkJCQkJ XAotICAoZWFzc2VydCAoKHN5bSktPnJlZGlyZWN0ID09IFNZTUJPTF9GT1JXQVJERUQpLCAo c3ltKS0+dmFsLmZ3ZCA9ICh2KSkKLQotI2RlZmluZSBTWU1CT0xfTkFNRShzeW0pIFhTWU1C T0wgKHN5bSktPm5hbWUKLQotLyogVmFsdWUgaXMgbm9uLXplcm8gaWYgU1lNIGlzIGFuIGlu dGVybmVkIHN5bWJvbC4gICovCi0KLSNkZWZpbmUgU1lNQk9MX0lOVEVSTkVEX1Aoc3ltKQkJ CQlcCi0gIChYU1lNQk9MIChzeW0pLT5pbnRlcm5lZCAhPSBTWU1CT0xfVU5JTlRFUk5FRCkK LQotLyogVmFsdWUgaXMgbm9uLXplcm8gaWYgU1lNIGlzIGludGVybmVkIGluIGluaXRpYWxf b2JhcnJheS4gICovCi0KLSNkZWZpbmUgU1lNQk9MX0lOVEVSTkVEX0lOX0lOSVRJQUxfT0JB UlJBWV9QKHN5bSkJCQlcCi0gIChYU1lNQk9MIChzeW0pLT5pbnRlcm5lZCA9PSBTWU1CT0xf SU5URVJORURfSU5fSU5JVElBTF9PQkFSUkFZKQorTElTUF9NQUNST19ERUZVTiAoU1lNQk9M X1ZBTCwgTGlzcF9PYmplY3QsIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSksIChzeW0pKQor CitMSVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9TeW1ib2wgKgorU1lNQk9MX0FMSUFTIChzdHJ1 Y3QgTGlzcF9TeW1ib2wgKnN5bSkKK3sKKyAgZWFzc2VydCAoc3ltLT5yZWRpcmVjdCA9PSBT WU1CT0xfVkFSQUxJQVMpOworICByZXR1cm4gc3ltLT52YWwuYWxpYXM7Cit9CitMSVNQX0lO TElORSBzdHJ1Y3QgTGlzcF9CdWZmZXJfTG9jYWxfVmFsdWUgKgorU1lNQk9MX0JMViAoc3Ry dWN0IExpc3BfU3ltYm9sICpzeW0pCit7CisgIGVhc3NlcnQgKHN5bS0+cmVkaXJlY3QgPT0g U1lNQk9MX0xPQ0FMSVpFRCk7CisgIHJldHVybiBzeW0tPnZhbC5ibHY7Cit9CitMSVNQX0lO TElORSB1bmlvbiBMaXNwX0Z3ZCAqCitTWU1CT0xfRldEIChzdHJ1Y3QgTGlzcF9TeW1ib2wg KnN5bSkKK3sKKyAgZWFzc2VydCAoc3ltLT5yZWRpcmVjdCA9PSBTWU1CT0xfRk9SV0FSREVE KTsKKyAgcmV0dXJuIHN5bS0+dmFsLmZ3ZDsKK30KKworTElTUF9NQUNST19ERUZVTl9WT0lE IChTRVRfU1lNQk9MX1ZBTCwKKwkJICAgICAgIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSwg TGlzcF9PYmplY3QgdiksIChzeW0sIHYpKQorCitMSVNQX0lOTElORSB2b2lkCitTRVRfU1lN Qk9MX0FMSUFTIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSwgc3RydWN0IExpc3BfU3ltYm9s ICp2KQoreworICBlYXNzZXJ0IChzeW0tPnJlZGlyZWN0ID09IFNZTUJPTF9WQVJBTElBUyk7 CisgIHN5bS0+dmFsLmFsaWFzID0gdjsKK30KK0xJU1BfSU5MSU5FIHZvaWQKK1NFVF9TWU1C T0xfQkxWIChzdHJ1Y3QgTGlzcF9TeW1ib2wgKnN5bSwgc3RydWN0IExpc3BfQnVmZmVyX0xv Y2FsX1ZhbHVlICp2KQoreworICBlYXNzZXJ0IChzeW0tPnJlZGlyZWN0ID09IFNZTUJPTF9M T0NBTElaRUQpOworICBzeW0tPnZhbC5ibHYgPSB2OworfQorTElTUF9JTkxJTkUgdm9pZAor U0VUX1NZTUJPTF9GV0QgKHN0cnVjdCBMaXNwX1N5bWJvbCAqc3ltLCB1bmlvbiBMaXNwX0Z3 ZCAqdikKK3sKKyAgZWFzc2VydCAoc3ltLT5yZWRpcmVjdCA9PSBTWU1CT0xfRk9SV0FSREVE KTsKKyAgc3ltLT52YWwuZndkID0gdjsKK30KKworTElTUF9JTkxJTkUgTGlzcF9PYmplY3QK K1NZTUJPTF9OQU1FIChMaXNwX09iamVjdCBzeW0pCit7CisgIHJldHVybiBYU1lNQk9MIChz eW0pLT5uYW1lOworfQorCisvKiBWYWx1ZSBpcyB0cnVlIGlmIFNZTSBpcyBhbiBpbnRlcm5l ZCBzeW1ib2wuICAqLworCitMSVNQX0lOTElORSBib29sCitTWU1CT0xfSU5URVJORURfUCAo TGlzcF9PYmplY3Qgc3ltKQoreworICByZXR1cm4gWFNZTUJPTCAoc3ltKS0+aW50ZXJuZWQg IT0gU1lNQk9MX1VOSU5URVJORUQ7Cit9CisKKy8qIFZhbHVlIGlzIHRydWUgaWYgU1lNIGlz IGludGVybmVkIGluIGluaXRpYWxfb2JhcnJheS4gICovCisKK0xJU1BfSU5MSU5FIGJvb2wK K1NZTUJPTF9JTlRFUk5FRF9JTl9JTklUSUFMX09CQVJSQVlfUCAoTGlzcF9PYmplY3Qgc3lt KQoreworICByZXR1cm4gWFNZTUJPTCAoc3ltKS0+aW50ZXJuZWQgPT0gU1lNQk9MX0lOVEVS TkVEX0lOX0lOSVRJQUxfT0JBUlJBWTsKK30KIAogLyogVmFsdWUgaXMgbm9uLXplcm8gaWYg c3ltYm9sIGlzIGNvbnNpZGVyZWQgYSBjb25zdGFudCwgaS5lLiBpdHMKICAgIHZhbHVlIGNh bm5vdCBiZSBjaGFuZ2VkICh0aGVyZSBpcyBhbiBleGNlcHRpb24gZm9yIGtleXdvcmQgc3lt Ym9scywKICAgIHdob3NlIHZhbHVlIGNhbiBiZSBzZXQgdG8gdGhlIGtleXdvcmQgc3ltYm9s IGl0c2VsZikuICAqLwogCi0jZGVmaW5lIFNZTUJPTF9DT05TVEFOVF9QKHN5bSkgWFNZTUJP TCAoc3ltKS0+Y29uc3RhbnQKK0xJU1BfTUFDUk9fREVGVU4gKFNZTUJPTF9DT05TVEFOVF9Q LCBpbnQsIChMaXNwX09iamVjdCBzeW0pLCAoc3ltKSkKIAogI2RlZmluZSBERUZTWU0oc3lt LCBuYW1lKQkJCQkJCVwKICAgZG8geyAoc3ltKSA9IGludGVybl9jX3N0cmluZyAoKG5hbWUp KTsgc3RhdGljcHJvICgmKHN5bSkpOyB9IHdoaWxlICgwKQpAQCAtMTI0MCw0MiArMTYwNCw2 NCBAQAogfTsKIAogCi0jZGVmaW5lIFhIQVNIX1RBQkxFKE9CSikgXAotICAgICAoKHN0cnVj dCBMaXNwX0hhc2hfVGFibGUgKikgWFVOVEFHIChPQkosIExpc3BfVmVjdG9ybGlrZSkpCitM SVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICoKK1hIQVNIX1RBQkxFIChMaXNw X09iamVjdCBhKQoreworICByZXR1cm4gWFVOVEFHIChhLCBMaXNwX1ZlY3Rvcmxpa2UpOwor fQogCiAjZGVmaW5lIFhTRVRfSEFTSF9UQUJMRShWQVIsIFBUUikgXAogICAgICAoWFNFVFBT RVVET1ZFQ1RPUiAoVkFSLCBQVFIsIFBWRUNfSEFTSF9UQUJMRSkpCiAKLSNkZWZpbmUgSEFT SF9UQUJMRV9QKE9CSikgIFBTRVVET1ZFQ1RPUlAgKE9CSiwgUFZFQ19IQVNIX1RBQkxFKQot Ci0jZGVmaW5lIENIRUNLX0hBU0hfVEFCTEUoeCkgXAotICBDSEVDS19UWVBFIChIQVNIX1RB QkxFX1AgKHgpLCBRaGFzaF90YWJsZV9wLCB4KQorTElTUF9JTkxJTkUgYm9vbAorSEFTSF9U QUJMRV9QIChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwg UFZFQ19IQVNIX1RBQkxFKTsKK30KIAogLyogVmFsdWUgaXMgdGhlIGtleSBwYXJ0IG9mIGVu dHJ5IElEWCBpbiBoYXNoIHRhYmxlIEguICAqLwotCi0jZGVmaW5lIEhBU0hfS0VZKEgsIElE WCkgICBBUkVGICgoSCktPmtleV9hbmRfdmFsdWUsIDIgKiAoSURYKSkKK0xJU1BfSU5MSU5F IExpc3BfT2JqZWN0CitIQVNIX0tFWSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgcHRy ZGlmZl90IGlkeCkKK3sKKyAgcmV0dXJuIEFSRUYgKGgtPmtleV9hbmRfdmFsdWUsIDIgKiBp ZHgpOworfQogCiAvKiBWYWx1ZSBpcyB0aGUgdmFsdWUgcGFydCBvZiBlbnRyeSBJRFggaW4g aGFzaCB0YWJsZSBILiAgKi8KLQotI2RlZmluZSBIQVNIX1ZBTFVFKEgsIElEWCkgQVJFRiAo KEgpLT5rZXlfYW5kX3ZhbHVlLCAyICogKElEWCkgKyAxKQorTElTUF9JTkxJTkUgTGlzcF9P YmplY3QKK0hBU0hfVkFMVUUgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIHB0cmRpZmZf dCBpZHgpCit7CisgIHJldHVybiBBUkVGIChoLT5rZXlfYW5kX3ZhbHVlLCAyICogaWR4ICsg MSk7Cit9CiAKIC8qIFZhbHVlIGlzIHRoZSBpbmRleCBvZiB0aGUgbmV4dCBlbnRyeSBmb2xs b3dpbmcgdGhlIG9uZSBhdCBJRFgKICAgIGluIGhhc2ggdGFibGUgSC4gICovCi0KLSNkZWZp bmUgSEFTSF9ORVhUKEgsIElEWCkgIEFSRUYgKChIKS0+bmV4dCwgKElEWCkpCitMSVNQX0lO TElORSBMaXNwX09iamVjdAorSEFTSF9ORVhUIChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpo LCBwdHJkaWZmX3QgaWR4KQoreworICByZXR1cm4gQVJFRiAoaC0+bmV4dCwgaWR4KTsKK30K IAogLyogVmFsdWUgaXMgdGhlIGhhc2ggY29kZSBjb21wdXRlZCBmb3IgZW50cnkgSURYIGlu IGhhc2ggdGFibGUgSC4gICovCi0KLSNkZWZpbmUgSEFTSF9IQVNIKEgsIElEWCkgIEFSRUYg KChIKS0+aGFzaCwgKElEWCkpCitMSVNQX0lOTElORSBMaXNwX09iamVjdAorSEFTSF9IQVNI IChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoLCBwdHJkaWZmX3QgaWR4KQoreworICByZXR1 cm4gQVJFRiAoaC0+aGFzaCwgaWR4KTsKK30KIAogLyogVmFsdWUgaXMgdGhlIGluZGV4IG9m IHRoZSBlbGVtZW50IGluIGhhc2ggdGFibGUgSCB0aGF0IGlzIHRoZQogICAgc3RhcnQgb2Yg dGhlIGNvbGxpc2lvbiBsaXN0IGF0IGluZGV4IElEWCBpbiB0aGUgaW5kZXggdmVjdG9yIG9m IEguICAqLwotCi0jZGVmaW5lIEhBU0hfSU5ERVgoSCwgSURYKSAgQVJFRiAoKEgpLT5pbmRl eCwgKElEWCkpCitMSVNQX0lOTElORSBMaXNwX09iamVjdAorSEFTSF9JTkRFWCAoc3RydWN0 IExpc3BfSGFzaF9UYWJsZSAqaCwgcHRyZGlmZl90IGlkeCkKK3sKKyAgcmV0dXJuIEFSRUYg KGgtPmluZGV4LCBpZHgpOworfQogCiAvKiBWYWx1ZSBpcyB0aGUgc2l6ZSBvZiBoYXNoIHRh YmxlIEguICAqLwotCi0jZGVmaW5lIEhBU0hfVEFCTEVfU0laRShIKSBBU0laRSAoKEgpLT5u ZXh0KQorTElTUF9JTkxJTkUgcHRyZGlmZl90CitIQVNIX1RBQkxFX1NJWkUgKHN0cnVjdCBM aXNwX0hhc2hfVGFibGUgKmgpCit7CisgIHJldHVybiBBU0laRSAoaC0+bmV4dCk7Cit9CiAK IC8qIERlZmF1bHQgc2l6ZSBmb3IgaGFzaCB0YWJsZXMgaWYgbm90IHNwZWNpZmllZC4gICov CiAKQEAgLTE0ODUsNiArMTg3MSw1MyBAQAogICAgIH0gZGF0YVtTQVZFX1ZBTFVFX1NMT1RT XTsKICAgfTsKIAorLyogUmV0dXJuIHRoZSB0eXBlIG9mIFYncyBOdGggc2F2ZWQgdmFsdWUu ICAqLworTElTUF9JTkxJTkUgaW50CitzYXZlX3R5cGUgKHN0cnVjdCBMaXNwX1NhdmVfVmFs dWUgKnYsIGludCBuKQoreworICBlYXNzZXJ0ICgwIDw9IG4gJiYgbiA8IFNBVkVfVkFMVUVf U0xPVFMpOworICByZXR1cm4gKHYtPnNhdmVfdHlwZSA+PiAoU0FWRV9TTE9UX0JJVFMgKiBu KSAmICgoMSA8PCBTQVZFX1NMT1RfQklUUykgLSAxKSk7Cit9CisKKy8qIEdldCBhbmQgc2V0 IHRoZSBOdGggc2F2ZWQgcG9pbnRlci4gICovCisKK0xJU1BfSU5MSU5FIHZvaWQgKgorWFNB VkVfUE9JTlRFUiAoTGlzcF9PYmplY3Qgb2JqLCBpbnQgbikKK3sKKyAgZWFzc2VydCAoc2F2 ZV90eXBlIChYU0FWRV9WQUxVRSAob2JqKSwgbikgPT0gU0FWRV9QT0lOVEVSKTsKKyAgcmV0 dXJuIFhTQVZFX1ZBTFVFIChvYmopLT5kYXRhW25dLnBvaW50ZXI7OworfQorTElTUF9JTkxJ TkUgdm9pZAorc2V0X3NhdmVfcG9pbnRlciAoTGlzcF9PYmplY3Qgb2JqLCBpbnQgbiwgdm9p ZCAqdmFsKQoreworICBlYXNzZXJ0IChzYXZlX3R5cGUgKFhTQVZFX1ZBTFVFIChvYmopLCBu KSA9PSBTQVZFX1BPSU5URVIpOworICBYU0FWRV9WQUxVRSAob2JqKS0+ZGF0YVtuXS5wb2lu dGVyID0gdmFsOworfQorCisvKiBMaWtld2lzZSBmb3IgdGhlIHNhdmVkIGludGVnZXIuICAq LworCitMSVNQX0lOTElORSBwdHJkaWZmX3QKK1hTQVZFX0lOVEVHRVIgKExpc3BfT2JqZWN0 IG9iaiwgaW50IG4pCit7CisgIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUgKG9i aiksIG4pID09IFNBVkVfSU5URUdFUik7CisgIHJldHVybiBYU0FWRV9WQUxVRSAob2JqKS0+ ZGF0YVtuXS5pbnRlZ2VyOworfQorTElTUF9JTkxJTkUgdm9pZAorc2V0X3NhdmVfaW50ZWdl ciAoTGlzcF9PYmplY3Qgb2JqLCBpbnQgbiwgcHRyZGlmZl90IHZhbCkKK3sKKyAgZWFzc2Vy dCAoc2F2ZV90eXBlIChYU0FWRV9WQUxVRSAob2JqKSwgbikgPT0gU0FWRV9JTlRFR0VSKTsK KyAgWFNBVkVfVkFMVUUgKG9iaiktPmRhdGFbbl0uaW50ZWdlciA9IHZhbDsKK30KKworLyog RXh0cmFjdCBOdGggc2F2ZWQgb2JqZWN0LiAgKi8KKworTElTUF9JTkxJTkUgTGlzcF9PYmpl Y3QKK1hTQVZFX09CSkVDVCAoTGlzcF9PYmplY3Qgb2JqLCBpbnQgbikKK3sKKyAgZWFzc2Vy dCAoc2F2ZV90eXBlIChYU0FWRV9WQUxVRSAob2JqKSwgbikgPT0gU0FWRV9PQkpFQ1QpOwor ICByZXR1cm4gWFNBVkVfVkFMVUUgKG9iaiktPmRhdGFbbl0ub2JqZWN0OworfQorCiAvKiBB IG1pc2NlbGxhbmVvdXMgb2JqZWN0LCB3aGVuIGl0J3Mgb24gdGhlIGZyZWUgbGlzdC4gICov CiBzdHJ1Y3QgTGlzcF9GcmVlCiAgIHsKQEAgLTE1MDYsNiArMTkzOSw0NiBAQAogICAgIHN0 cnVjdCBMaXNwX1NhdmVfVmFsdWUgdV9zYXZlX3ZhbHVlOwogICB9OwogCitMSVNQX0lOTElO RSB1bmlvbiBMaXNwX01pc2MgKgorWE1JU0MgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVy biBYVU5UQUcgKGEsIExpc3BfTWlzYyk7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVjdCBMaXNw X01pc2NfQW55ICoKK1hNSVNDQU5ZIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChN SVNDUCAoYSkpOworICByZXR1cm4gJiBYTUlTQyAoYSktPnVfYW55OworfQorCitMSVNQX0lO TElORSBlbnVtIExpc3BfTWlzY19UeXBlCitYTUlTQ1RZUEUgKExpc3BfT2JqZWN0IGEpCit7 CisgIHJldHVybiBYTUlTQ0FOWSAoYSktPnR5cGU7Cit9CisKK0xJU1BfSU5MSU5FIHN0cnVj dCBMaXNwX01hcmtlciAqCitYTUFSS0VSIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0 IChNQVJLRVJQIChhKSk7CisgIHJldHVybiAmIFhNSVNDIChhKS0+dV9tYXJrZXI7Cit9CisK K0xJU1BfSU5MSU5FIHN0cnVjdCBMaXNwX092ZXJsYXkgKgorWE9WRVJMQVkgKExpc3BfT2Jq ZWN0IGEpCit7CisgIGVhc3NlcnQgKE9WRVJMQVlQIChhKSk7CisgIHJldHVybiAmIFhNSVND IChhKS0+dV9vdmVybGF5OworfQorCitMSVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9TYXZlX1Zh bHVlICoKK1hTQVZFX1ZBTFVFIChMaXNwX09iamVjdCBhKQoreworICBlYXNzZXJ0IChTQVZF X1ZBTFVFUCAoYSkpOworICByZXR1cm4gJiBYTUlTQyAoYSktPnVfc2F2ZV92YWx1ZTsKK30K KwwKIC8qIEZvcndhcmRpbmcgcG9pbnRlciB0byBhbiBpbnQgdmFyaWFibGUuCiAgICBUaGlz IGlzIGFsbG93ZWQgb25seSBpbiB0aGUgdmFsdWUgY2VsbCBvZiBhIHN5bWJvbCwKICAgIGFu ZCBpdCBtZWFucyB0aGF0IHRoZSBzeW1ib2wncyB2YWx1ZSByZWFsbHkgbGl2ZXMgaW4gdGhl CkBAIC0xNjEyLDYgKzIwODUsMTkgQEAKICAgICBzdHJ1Y3QgTGlzcF9CdWZmZXJfT2JqZndk IHVfYnVmZmVyX29iamZ3ZDsKICAgICBzdHJ1Y3QgTGlzcF9LYm9hcmRfT2JqZndkIHVfa2Jv YXJkX29iamZ3ZDsKICAgfTsKKworTElTUF9JTkxJTkUgZW51bSBMaXNwX0Z3ZF9UeXBlCitY RldEVFlQRSAodW5pb24gTGlzcF9Gd2QgKmEpCit7CisgIHJldHVybiBhLT51X2ludGZ3ZC50 eXBlOworfQorCitMSVNQX0lOTElORSBzdHJ1Y3QgTGlzcF9CdWZmZXJfT2JqZndkICoKK1hC VUZGRVJfT0JKRldEICh1bmlvbiBMaXNwX0Z3ZCAqYSkKK3sKKyAgZWFzc2VydCAoQlVGRkVS X09CSkZXRFAgKGEpKTsKKyAgcmV0dXJuICZhLT51X2J1ZmZlcl9vYmpmd2Q7Cit9CiAMCiAv KiBMaXNwIGZsb2F0aW5nIHBvaW50IHR5cGUuICAqLwogc3RydWN0IExpc3BfRmxvYXQKQEAg LTE2MjMsOCArMjEwOSwxMSBAQAogICAgIH0gdTsKICAgfTsKIAotI2RlZmluZSBYRkxPQVRf REFUQShmKSAoMCA/IFhGTE9BVCAoZiktPnUuZGF0YSA6ICBYRkxPQVQgKGYpLT51LmRhdGEp Ci0jZGVmaW5lIFhGTE9BVF9JTklUKGYsIG4pIChYRkxPQVQgKGYpLT51LmRhdGEgPSAobikp CitMSVNQX0lOTElORSBkb3VibGUKK1hGTE9BVF9EQVRBIChMaXNwX09iamVjdCBmKQorewor ICByZXR1cm4gWEZMT0FUIChmKS0+dS5kYXRhOworfQogCiAvKiBNb3N0IGhvc3RzIG5vd2Fk YXlzIHVzZSBJRUVFIGZsb2F0aW5nIHBvaW50LCBzbyB0aGV5IHVzZSBJRUMgNjA1NTkKICAg IHJlcHJlc2VudGF0aW9ucywgaGF2ZSBpbmZpbml0aWVzIGFuZCBOYU5zLCBhbmQgZG8gbm90 IHRyYXAgb24KQEAgLTE2MzMsOCArMjEyMiwxMiBAQAogICAgd2FudGVkIGhlcmUsIGJ1dCBp cyBub3QgcXVpdGUgcmlnaHQgYmVjYXVzZSBFbWFjcyBkb2VzIG5vdCByZXF1aXJlCiAgICBh bGwgdGhlIGZlYXR1cmVzIG9mIEMxMSBBbm5leCBGIChhbmQgZG9lcyBub3QgcmVxdWlyZSBD MTEgYXQgYWxsLAogICAgZm9yIHRoYXQgbWF0dGVyKS4gICovCi0jZGVmaW5lIElFRUVfRkxP QVRJTkdfUE9JTlQgKEZMVF9SQURJWCA9PSAyICYmIEZMVF9NQU5UX0RJRyA9PSAyNCBcCi0J CQkgICAgICYmIEZMVF9NSU5fRVhQID09IC0xMjUgJiYgRkxUX01BWF9FWFAgPT0gMTI4KQor ZW51bQorICB7CisgICAgSUVFRV9GTE9BVElOR19QT0lOVAorICAgICAgPSAoRkxUX1JBRElY ID09IDIgJiYgRkxUX01BTlRfRElHID09IDI0CisJICYmIEZMVF9NSU5fRVhQID09IC0xMjUg JiYgRkxUX01BWF9FWFAgPT0gMTI4KQorICB9OwogCiAvKiBBIGNoYXJhY3RlciwgZGVjbGFy ZWQgd2l0aCB0aGUgZm9sbG93aW5nIHR5cGVkZWYsIGlzIGEgbWVtYmVyCiAgICBvZiBzb21l IGNoYXJhY3RlciBzZXQgYXNzb2NpYXRlZCB3aXRoIHRoZSBjdXJyZW50IGJ1ZmZlci4gICov CkBAIC0xNjc1LDY0ICsyMTY4LDYgQEAKICAgICAgICBpdHNlbGYuICAqLwogICAgIENIQVJB Q1RFUkJJVFMgPSAyMgogICB9OwotCi0KLQotDAotLyogVGhlIGdseXBoIGRhdGF0eXBlLCB1 c2VkIHRvIHJlcHJlc2VudCBjaGFyYWN0ZXJzIG9uIHRoZSBkaXNwbGF5LgotICAgSXQgY29u c2lzdHMgb2YgYSBjaGFyIGNvZGUgYW5kIGEgZmFjZSBpZC4gICovCi0KLXR5cGVkZWYgc3Ry dWN0IHsKLSAgaW50IGNoOwotICBpbnQgZmFjZV9pZDsKLX0gR0xZUEg7Ci0KLS8qIFJldHVy biBhIGdseXBoJ3MgY2hhcmFjdGVyIGNvZGUuICAqLwotI2RlZmluZSBHTFlQSF9DSEFSKGds eXBoKSAoKGdseXBoKS5jaCkKLQotLyogUmV0dXJuIGEgZ2x5cGgncyBmYWNlIElELiAgKi8K LSNkZWZpbmUgR0xZUEhfRkFDRShnbHlwaCkgKChnbHlwaCkuZmFjZV9pZCkKLQotI2RlZmlu ZSBTRVRfR0xZUEhfQ0hBUihnbHlwaCwgY2hhcikgKChnbHlwaCkuY2ggPSAoY2hhcikpCi0j ZGVmaW5lIFNFVF9HTFlQSF9GQUNFKGdseXBoLCBmYWNlKSAoKGdseXBoKS5mYWNlX2lkID0g KGZhY2UpKQotI2RlZmluZSBTRVRfR0xZUEgoZ2x5cGgsIGNoYXIsIGZhY2UpICgoZ2x5cGgp LmNoID0gKGNoYXIpLCAoZ2x5cGgpLmZhY2VfaWQgPSAoZmFjZSkpCi0KLS8qIFJldHVybiAx IGlmIEdMWVBIIGNvbnRhaW5zIHZhbGlkIGNoYXJhY3RlciBjb2RlLiAgKi8KLSNkZWZpbmUg R0xZUEhfQ0hBUl9WQUxJRF9QKGdseXBoKSBDSEFSX1ZBTElEX1AgKEdMWVBIX0NIQVIgKGds eXBoKSkKLQotCi0vKiBHbHlwaCBDb2RlIGZyb20gYSBkaXNwbGF5IHZlY3RvciBtYXkgZWl0 aGVyIGJlIGFuIGludGVnZXIgd2hpY2gKLSAgIGVuY29kZXMgYSBjaGFyIGNvZGUgaW4gdGhl IGxvd2VyIENIQVJBQ1RFUkJJVFMgYml0cyBhbmQgYSAodmVyeSBzbWFsbCkKLSAgIGZhY2Ut aWQgaW4gdGhlIHVwcGVyIGJpdHMsIG9yIGl0IG1heSBiZSBhIGNvbnMgKENIQVIgLiBGQUNF LUlEKS4gICovCi0KLSNkZWZpbmUgR0xZUEhfQ09ERV9QKGdjKQkJCQkJCVwKLSAgKENPTlNQ IChnYykJCQkJCQkJCVwKLSAgID8gKENIQVJBQ1RFUlAgKFhDQVIgKGdjKSkJCQkJCQlcCi0g ICAgICAmJiBSQU5HRURfSU5URUdFUlAgKDAsIFhDRFIgKGdjKSwgTUFYX0ZBQ0VfSUQpKQkJ CVwKLSAgIDogKFJBTkdFRF9JTlRFR0VSUAkJCQkJCQlcCi0gICAgICAoMCwgZ2MsCQkJCQkJ CQlcCi0gICAgICAgKE1BWF9GQUNFX0lEIDwgVFlQRV9NQVhJTVVNIChFTUFDU19JTlQpID4+ IENIQVJBQ1RFUkJJVFMJCVwKLQk/ICgoRU1BQ1NfSU5UKSBNQVhfRkFDRV9JRCA8PCBDSEFS QUNURVJCSVRTKSB8IE1BWF9DSEFSCQlcCi0JOiBUWVBFX01BWElNVU0gKEVNQUNTX0lOVCkp KSkpCi0KLS8qIFRoZSBmb2xsb3dpbmcgYXJlIHZhbGlkIG9ubHkgaWYgR0xZUEhfQ09ERV9Q IChnYykuICAqLwotCi0jZGVmaW5lIEdMWVBIX0NPREVfQ0hBUihnYykgXAotICAoQ09OU1Ag KGdjKSA/IFhJTlQgKFhDQVIgKGdjKSkgOiBYSU5UIChnYykgJiAoKDEgPDwgQ0hBUkFDVEVS QklUUykgLSAxKSkKLQotI2RlZmluZSBHTFlQSF9DT0RFX0ZBQ0UoZ2MpIFwKLSAgKENPTlNQ IChnYykgPyBYSU5UIChYQ0RSIChnYykpIDogWElOVCAoZ2MpID4+IENIQVJBQ1RFUkJJVFMp Ci0KLSNkZWZpbmUgU0VUX0dMWVBIX0ZST01fR0xZUEhfQ09ERShnbHlwaCwgZ2MpCQkJCVwK LSAgZG8JCQkJCQkJCQlcCi0gICAgewkJCQkJCQkJCVwKLSAgICAgIGlmIChDT05TUCAoZ2Mp KQkJCQkJCQlcCi0JU0VUX0dMWVBIIChnbHlwaCwgWElOVCAoWENBUiAoZ2MpKSwgWElOVCAo WENEUiAoZ2MpKSk7CQlcCi0gICAgICBlbHNlCQkJCQkJCQlcCi0JU0VUX0dMWVBIIChnbHlw aCwgKFhJTlQgKGdjKSAmICgoMSA8PCBDSEFSQUNURVJCSVRTKS0xKSksCVwKLQkJICAgKFhJ TlQgKGdjKSA+PiBDSEFSQUNURVJCSVRTKSk7CQkJXAotICAgIH0JCQkJCQkJCQlcCi0gIHdo aWxlICgwKQogDAogLyogU3RydWN0dXJlIHRvIGhvbGQgbW91c2UgaGlnaGxpZ2h0IGRhdGEu ICBUaGlzIGlzIGhlcmUgYmVjYXVzZSBvdGhlcgogICAgaGVhZGVyIGZpbGVzIG5lZWQgaXQg Zm9yIGRlZmluaW5nIHN0cnVjdCB4X291dHB1dCBldGMuICAqLwpAQCAtMTc2OCwxOTAgKzIy MDMsMjM1IEBACiAMCiAvKiBEYXRhIHR5cGUgY2hlY2tpbmcuICAqLwogCi0jZGVmaW5lIE5J TFAoeCkgIEVRICh4LCBRbmlsKQotCi0jZGVmaW5lIE5VTUJFUlAoeCkgKElOVEVHRVJQICh4 KSB8fCBGTE9BVFAgKHgpKQotI2RlZmluZSBOQVROVU1QKHgpIChJTlRFR0VSUCAoeCkgJiYg WElOVCAoeCkgPj0gMCkKLQotI2RlZmluZSBSQU5HRURfSU5URUdFUlAobG8sIHgsIGhpKSBc Ci0gIChJTlRFR0VSUCAoeCkgJiYgKGxvKSA8PSBYSU5UICh4KSAmJiBYSU5UICh4KSA8PSAo aGkpKQorTElTUF9NQUNST19ERUZVTiAoTklMUCwgYm9vbCwgKExpc3BfT2JqZWN0IHgpLCAo eCkpCisKK0xJU1BfSU5MSU5FIGJvb2wKK05VTUJFUlAgKExpc3BfT2JqZWN0IHgpCit7Cisg IHJldHVybiBJTlRFR0VSUCAoeCkgfHwgRkxPQVRQICh4KTsKK30KK0xJU1BfSU5MSU5FIGJv b2wKK05BVE5VTVAgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBJTlRFR0VSUCAoeCkg JiYgMCA8PSBYSU5UICh4KTsKK30KKworTElTUF9JTkxJTkUgYm9vbAorUkFOR0VEX0lOVEVH RVJQIChpbnRtYXhfdCBsbywgTGlzcF9PYmplY3QgeCwgaW50bWF4X3QgaGkpCit7CisgIHJl dHVybiBJTlRFR0VSUCAoeCkgJiYgbG8gPD0gWElOVCAoeCkgJiYgWElOVCAoeCkgPD0gaGk7 Cit9CisKICNkZWZpbmUgVFlQRV9SQU5HRURfSU5URUdFUlAodHlwZSwgeCkgXAotICAoVFlQ RV9TSUdORUQgKHR5cGUpCQkJCQkJCVwKLSAgID8gUkFOR0VEX0lOVEVHRVJQIChUWVBFX01J TklNVU0gKHR5cGUpLCB4LCBUWVBFX01BWElNVU0gKHR5cGUpKQlcCi0gICA6IFJBTkdFRF9J TlRFR0VSUCAoMCwgeCwgVFlQRV9NQVhJTVVNICh0eXBlKSkpCi0KLSNkZWZpbmUgSU5URUdF UlAoeCkgKExJU1BfSU5UX1RBR19QIChYVFlQRSAoKHgpKSkpCi0jZGVmaW5lIFNZTUJPTFAo eCkgKFhUWVBFICgoeCkpID09IExpc3BfU3ltYm9sKQotI2RlZmluZSBNSVNDUCh4KSAoWFRZ UEUgKCh4KSkgPT0gTGlzcF9NaXNjKQotI2RlZmluZSBWRUNUT1JMSUtFUCh4KSAoWFRZUEUg KCh4KSkgPT0gTGlzcF9WZWN0b3JsaWtlKQotI2RlZmluZSBTVFJJTkdQKHgpIChYVFlQRSAo KHgpKSA9PSBMaXNwX1N0cmluZykKLSNkZWZpbmUgQ09OU1AoeCkgKFhUWVBFICgoeCkpID09 IExpc3BfQ29ucykKLQotI2RlZmluZSBGTE9BVFAoeCkgKFhUWVBFICgoeCkpID09IExpc3Bf RmxvYXQpCi0jZGVmaW5lIFZFQ1RPUlAoeCkgKFZFQ1RPUkxJS0VQICh4KSAmJiAhKEFTSVpF ICh4KSAmIFBTRVVET1ZFQ1RPUl9GTEFHKSkKLSNkZWZpbmUgT1ZFUkxBWVAoeCkgKE1JU0NQ ICh4KSAmJiBYTUlTQ1RZUEUgKHgpID09IExpc3BfTWlzY19PdmVybGF5KQotI2RlZmluZSBN QVJLRVJQKHgpIChNSVNDUCAoeCkgJiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01pc2NfTWFy a2VyKQotCisgIChJTlRFR0VSUCAoeCkJCQkgICAgICBcCisgICAmJiAoVFlQRV9TSUdORUQg KHR5cGUpID8gVFlQRV9NSU5JTVVNICh0eXBlKSA8PSBYSU5UICh4KSA6IDAgPD0gWElOVCAo eCkpIFwKKyAgICYmIFhJTlQgKHgpIDw9IFRZUEVfTUFYSU1VTSAodHlwZSkpCisKK0xJU1Bf TUFDUk9fREVGVU4gKENPTlNQLCBib29sLCAoTGlzcF9PYmplY3QgeCksICh4KSkKK0xJU1Bf TUFDUk9fREVGVU4gKEZMT0FUUCwgYm9vbCwgKExpc3BfT2JqZWN0IHgpLCAoeCkpCitMSVNQ X01BQ1JPX0RFRlVOIChNSVNDUCwgYm9vbCwgKExpc3BfT2JqZWN0IHgpLCAoeCkpCitMSVNQ X01BQ1JPX0RFRlVOIChTWU1CT0xQLCBib29sLCAoTGlzcF9PYmplY3QgeCksICh4KSkKK0xJ U1BfTUFDUk9fREVGVU4gKElOVEVHRVJQLCBib29sLCAoTGlzcF9PYmplY3QgeCksICh4KSkK K0xJU1BfTUFDUk9fREVGVU4gKFZFQ1RPUkxJS0VQLCBib29sLCAoTGlzcF9PYmplY3QgeCks ICh4KSkKK0xJU1BfTUFDUk9fREVGVU4gKE1BUktFUlAsIGJvb2wsIChMaXNwX09iamVjdCB4 KSwgKHgpKQorCitMSVNQX0lOTElORSBib29sCitTVFJJTkdQIChMaXNwX09iamVjdCB4KQor eworICByZXR1cm4gWFRZUEUgKHgpID09IExpc3BfU3RyaW5nOworfQorTElTUF9JTkxJTkUg Ym9vbAorVkVDVE9SUCAoTGlzcF9PYmplY3QgeCkKK3sKKyAgcmV0dXJuIFZFQ1RPUkxJS0VQ ICh4KSAmJiAhIChBU0laRSAoeCkgJiBQU0VVRE9WRUNUT1JfRkxBRyk7Cit9CitMSVNQX0lO TElORSBib29sCitPVkVSTEFZUCAoTGlzcF9PYmplY3QgeCkKK3sKKyAgcmV0dXJuIE1JU0NQ ICh4KSAmJiBYTUlTQ1RZUEUgKHgpID09IExpc3BfTWlzY19PdmVybGF5OworfQogTElTUF9J TkxJTkUgYm9vbAogU0FWRV9WQUxVRVAgKExpc3BfT2JqZWN0IHgpCiB7CiAgIHJldHVybiBN SVNDUCAoeCkgJiYgWE1JU0NUWVBFICh4KSA9PSBMaXNwX01pc2NfU2F2ZV9WYWx1ZTsKIH0K IAotTElTUF9JTkxJTkUgc3RydWN0IExpc3BfU2F2ZV9WYWx1ZSAqCi1YU0FWRV9WQUxVRSAo TGlzcF9PYmplY3QgYSkKLXsKLSAgZWFzc2VydCAoU0FWRV9WQUxVRVAgKGEpKTsKLSAgcmV0 dXJuICYgWE1JU0MgKGEpLT51X3NhdmVfdmFsdWU7Ci19Ci0KLS8qIFJldHVybiB0aGUgdHlw ZSBvZiBWJ3MgTnRoIHNhdmVkIHZhbHVlLiAgKi8KLUxJU1BfSU5MSU5FIGludAotc2F2ZV90 eXBlIChzdHJ1Y3QgTGlzcF9TYXZlX1ZhbHVlICp2LCBpbnQgbikKLXsKLSAgZWFzc2VydCAo MCA8PSBuICYmIG4gPCBTQVZFX1ZBTFVFX1NMT1RTKTsKLSAgcmV0dXJuICh2LT5zYXZlX3R5 cGUgPj4gKFNBVkVfU0xPVF9CSVRTICogbikgJiAoKDEgPDwgU0FWRV9TTE9UX0JJVFMpIC0g MSkpOwotfQotCi0vKiBHZXQgYW5kIHNldCB0aGUgTnRoIHNhdmVkIHBvaW50ZXIuICAqLwot Ci1MSVNQX0lOTElORSB2b2lkICoKLVhTQVZFX1BPSU5URVIgKExpc3BfT2JqZWN0IG9iaiwg aW50IG4pCi17Ci0gIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUgKG9iaiksIG4p ID09IFNBVkVfUE9JTlRFUik7Ci0gIHJldHVybiBYU0FWRV9WQUxVRSAob2JqKS0+ZGF0YVtu XS5wb2ludGVyOzsKLX0KLUxJU1BfSU5MSU5FIHZvaWQKLXNldF9zYXZlX3BvaW50ZXIgKExp c3BfT2JqZWN0IG9iaiwgaW50IG4sIHZvaWQgKnZhbCkKLXsKLSAgZWFzc2VydCAoc2F2ZV90 eXBlIChYU0FWRV9WQUxVRSAob2JqKSwgbikgPT0gU0FWRV9QT0lOVEVSKTsKLSAgWFNBVkVf VkFMVUUgKG9iaiktPmRhdGFbbl0ucG9pbnRlciA9IHZhbDsKLX0KLQotLyogTGlrZXdpc2Ug Zm9yIHRoZSBzYXZlZCBpbnRlZ2VyLiAgKi8KLQotTElTUF9JTkxJTkUgcHRyZGlmZl90Ci1Y U0FWRV9JTlRFR0VSIChMaXNwX09iamVjdCBvYmosIGludCBuKQotewotICBlYXNzZXJ0IChz YXZlX3R5cGUgKFhTQVZFX1ZBTFVFIChvYmopLCBuKSA9PSBTQVZFX0lOVEVHRVIpOwotICBy ZXR1cm4gWFNBVkVfVkFMVUUgKG9iaiktPmRhdGFbbl0uaW50ZWdlcjsKLX0KLUxJU1BfSU5M SU5FIHZvaWQKLXNldF9zYXZlX2ludGVnZXIgKExpc3BfT2JqZWN0IG9iaiwgaW50IG4sIHB0 cmRpZmZfdCB2YWwpCi17Ci0gIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUgKG9i aiksIG4pID09IFNBVkVfSU5URUdFUik7Ci0gIFhTQVZFX1ZBTFVFIChvYmopLT5kYXRhW25d LmludGVnZXIgPSB2YWw7Ci19Ci0KLS8qIEV4dHJhY3QgTnRoIHNhdmVkIG9iamVjdC4gICov Ci0KLUxJU1BfSU5MSU5FIExpc3BfT2JqZWN0Ci1YU0FWRV9PQkpFQ1QgKExpc3BfT2JqZWN0 IG9iaiwgaW50IG4pCi17Ci0gIGVhc3NlcnQgKHNhdmVfdHlwZSAoWFNBVkVfVkFMVUUgKG9i aiksIG4pID09IFNBVkVfT0JKRUNUKTsKLSAgcmV0dXJuIFhTQVZFX1ZBTFVFIChvYmopLT5k YXRhW25dLm9iamVjdDsKLX0KLQotI2RlZmluZSBBVVRPTE9BRFAoeCkgKENPTlNQICh4KSAm JiBFUSAoUWF1dG9sb2FkLCBYQ0FSICh4KSkpCi0KLSNkZWZpbmUgSU5URldEUCh4KSAoWEZX RFRZUEUgKHgpID09IExpc3BfRndkX0ludCkKLSNkZWZpbmUgQk9PTEZXRFAoeCkgKFhGV0RU WVBFICh4KSA9PSBMaXNwX0Z3ZF9Cb29sKQotI2RlZmluZSBPQkpGV0RQKHgpIChYRldEVFlQ RSAoeCkgPT0gTGlzcF9Gd2RfT2JqKQotI2RlZmluZSBCVUZGRVJfT0JKRldEUCh4KSAoWEZX RFRZUEUgKHgpID09IExpc3BfRndkX0J1ZmZlcl9PYmopCi0jZGVmaW5lIEtCT0FSRF9PQkpG V0RQKHgpIChYRldEVFlQRSAoeCkgPT0gTGlzcF9Gd2RfS2JvYXJkX09iaikKLQotLyogVHJ1 ZSBpZiBvYmplY3QgWCBpcyBhIHBzZXVkb3ZlY3RvciB3aG9zZSBjb2RlIGlzIENPREUuICBU aGUgY2FzdCB0byBzdHJ1Y3QKLSAgIHZlY3Rvcmxpa2VfaGVhZGVyICogYXZvaWRzIGFsaWFz aW5nIGlzc3Vlcy4gICovCi0jZGVmaW5lIFBTRVVET1ZFQ1RPUlAoeCwgY29kZSkJCQkJCVwK LSAgVFlQRURfUFNFVURPVkVDVE9SUCAoeCwgdmVjdG9ybGlrZV9oZWFkZXIsIGNvZGUpCi0K LSNkZWZpbmUgUFNFVURPVkVDVE9SX1RZUEVQKHYsIGNvZGUpCQkJCQlcCi0gICgoKHYpLT5z aXplICYgKFBTRVVET1ZFQ1RPUl9GTEFHIHwgUFZFQ19UWVBFX01BU0spKQkJCVwKLSAgID09 IChQU0VVRE9WRUNUT1JfRkxBRyB8ICgoY29kZSkgPDwgUFNFVURPVkVDVE9SX0FSRUFfQklU UykpKQotCi0vKiBUcnVlIGlmIG9iamVjdCBYLCB3aXRoIGludGVybmFsIHR5cGUgc3RydWN0 IFQgKiwgaXMgYSBwc2V1ZG92ZWN0b3Igd2hvc2UKLSAgIGNvZGUgaXMgQ09ERS4gICovCi0j ZGVmaW5lIFRZUEVEX1BTRVVET1ZFQ1RPUlAoeCwgdCwgY29kZSkJCQkJXAotICAoVkVDVE9S TElLRVAgKHgpCQkJCQkJXAotICAgJiYgUFNFVURPVkVDVE9SX1RZUEVQICgoc3RydWN0IHQg KikgWFVOVEFHICh4LCBMaXNwX1ZlY3Rvcmxpa2UpLCBjb2RlKSkKK0xJU1BfSU5MSU5FIGJv b2wKK0FVVE9MT0FEUCAoTGlzcF9PYmplY3QgeCkKK3sKKyAgcmV0dXJuIENPTlNQICh4KSAm JiBFUSAoUWF1dG9sb2FkLCBYQ0FSICh4KSk7Cit9CisKK0xJU1BfSU5MSU5FIGJvb2wKK0JV RkZFUl9PQkpGV0RQICh1bmlvbiBMaXNwX0Z3ZCAqYSkKK3sKKyAgcmV0dXJuIFhGV0RUWVBF IChhKSA9PSBMaXNwX0Z3ZF9CdWZmZXJfT2JqOworfQorCitMSVNQX0lOTElORSBib29sCitQ U0VVRE9WRUNUT1JfVFlQRVAgKHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRlciAqYSwgaW50IGNv ZGUpCit7CisgIHJldHVybiAoKGEtPnNpemUgJiAoUFNFVURPVkVDVE9SX0ZMQUcgfCBQVkVD X1RZUEVfTUFTSykpCisJICA9PSAoUFNFVURPVkVDVE9SX0ZMQUcgfCAoY29kZSA8PCBQU0VV RE9WRUNUT1JfQVJFQV9CSVRTKSkpOworfQorCisvKiBUcnVlIGlmIEEgaXMgYSBwc2V1ZG92 ZWN0b3Igd2hvc2UgY29kZSBpcyBDT0RFLiAgKi8KK0xJU1BfSU5MSU5FIGJvb2wKK1BTRVVE T1ZFQ1RPUlAgKExpc3BfT2JqZWN0IGEsIGludCBjb2RlKQoreworICBpZiAoISBWRUNUT1JM SUtFUCAoYSkpCisgICAgcmV0dXJuIDA7CisgIGVsc2UKKyAgICB7CisgICAgICAvKiBDb252 ZXJ0aW5nIHRvIHN0cnVjdCB2ZWN0b3JsaWtlX2hlYWRlciAqIGF2b2lkcyBhbGlhc2luZyBp c3N1ZXMuICAqLworICAgICAgc3RydWN0IHZlY3Rvcmxpa2VfaGVhZGVyICpoID0gWFVOVEFH IChhLCBMaXNwX1ZlY3Rvcmxpa2UpOworICAgICAgcmV0dXJuIFBTRVVET1ZFQ1RPUl9UWVBF UCAoaCwgY29kZSk7CisgICAgfQorfQorCiAKIC8qIFRlc3QgZm9yIHNwZWNpZmljIHBzZXVk b3ZlY3RvciB0eXBlcy4gICovCi0jZGVmaW5lIFdJTkRPV19DT05GSUdVUkFUSU9OUCh4KSBQ U0VVRE9WRUNUT1JQICh4LCBQVkVDX1dJTkRPV19DT05GSUdVUkFUSU9OKQotI2RlZmluZSBQ Uk9DRVNTUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX1BST0NFU1MpCi0jZGVmaW5lIFdJ TkRPV1AoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19XSU5ET1cpCi0jZGVmaW5lIFRFUk1J TkFMUCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX1RFUk1JTkFMKQotI2RlZmluZSBTVUJS UCh4KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX1NVQlIpCi0jZGVmaW5lIENPTVBJTEVEUCh4 KSBQU0VVRE9WRUNUT1JQICh4LCBQVkVDX0NPTVBJTEVEKQotI2RlZmluZSBCVUZGRVJQKHgp IFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfQlVGRkVSKQotI2RlZmluZSBDSEFSX1RBQkxFX1Ao eCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19DSEFSX1RBQkxFKQotI2RlZmluZSBTVUJfQ0hB Ul9UQUJMRV9QKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfU1VCX0NIQVJfVEFCTEUpCi0j ZGVmaW5lIEJPT0xfVkVDVE9SX1AoeCkgUFNFVURPVkVDVE9SUCAoeCwgUFZFQ19CT09MX1ZF Q1RPUikKLSNkZWZpbmUgRlJBTUVQKHgpIFBTRVVET1ZFQ1RPUlAgKHgsIFBWRUNfRlJBTUUp CisKK0xJU1BfSU5MSU5FIGJvb2wKK1dJTkRPV19DT05GSUdVUkFUSU9OUCAoTGlzcF9PYmpl Y3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEsIFBWRUNfV0lORE9XX0NPTkZJ R1VSQVRJT04pOworfQorCitMSVNQX0lOTElORSBib29sCitQUk9DRVNTUCAoTGlzcF9PYmpl Y3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEsIFBWRUNfUFJPQ0VTUyk7Cit9 CisKK0xJU1BfSU5MSU5FIGJvb2wKK1dJTkRPV1AgKExpc3BfT2JqZWN0IGEpCit7CisgIHJl dHVybiBQU0VVRE9WRUNUT1JQIChhLCBQVkVDX1dJTkRPVyk7Cit9CisKK0xJU1BfSU5MSU5F IGJvb2wKK1RFUk1JTkFMUCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZF Q1RPUlAgKGEsIFBWRUNfVEVSTUlOQUwpOworfQorCitMSVNQX0lOTElORSBib29sCitTVUJS UCAoTGlzcF9PYmplY3QgYSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEsIFBWRUNf U1VCUik7Cit9CisKK0xJU1BfSU5MSU5FIGJvb2wKK0NPTVBJTEVEUCAoTGlzcF9PYmplY3Qg YSkKK3sKKyAgcmV0dXJuIFBTRVVET1ZFQ1RPUlAgKGEsIFBWRUNfQ09NUElMRUQpOworfQor CitMSVNQX0lOTElORSBib29sCitCVUZGRVJQIChMaXNwX09iamVjdCBhKQoreworICByZXR1 cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZFQ19CVUZGRVIpOworfQorCitMSVNQX0lOTElORSBi b29sCitDSEFSX1RBQkxFX1AgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9W RUNUT1JQIChhLCBQVkVDX0NIQVJfVEFCTEUpOworfQorCitMSVNQX0lOTElORSBib29sCitT VUJfQ0hBUl9UQUJMRV9QIChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4gUFNFVURPVkVD VE9SUCAoYSwgUFZFQ19TVUJfQ0hBUl9UQUJMRSk7Cit9CisKK0xJU1BfSU5MSU5FIGJvb2wK K0JPT0xfVkVDVE9SX1AgKExpc3BfT2JqZWN0IGEpCit7CisgIHJldHVybiBQU0VVRE9WRUNU T1JQIChhLCBQVkVDX0JPT0xfVkVDVE9SKTsKK30KKworTElTUF9JTkxJTkUgYm9vbAorRlJB TUVQIChMaXNwX09iamVjdCBhKQoreworICByZXR1cm4gUFNFVURPVkVDVE9SUCAoYSwgUFZF Q19GUkFNRSk7Cit9CiAKIC8qIFRlc3QgZm9yIGltYWdlIChpbWFnZSAuIHNwZWMpICAqLwot I2RlZmluZSBJTUFHRVAoeCkgKENPTlNQICh4KSAmJiBFUSAoWENBUiAoeCksIFFpbWFnZSkp CitMSVNQX0lOTElORSBib29sCitJTUFHRVAgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVy biBDT05TUCAoeCkgJiYgRVEgKFhDQVIgKHgpLCBRaW1hZ2UpOworfQogCiAvKiBBcnJheSB0 eXBlcy4gICovCi0KLSNkZWZpbmUgQVJSQVlQKHgpIFwKLSAgKFZFQ1RPUlAgKHgpIHx8IFNU UklOR1AgKHgpIHx8IENIQVJfVEFCTEVfUCAoeCkgfHwgQk9PTF9WRUNUT1JfUCAoeCkpCitM SVNQX0lOTElORSBib29sCitBUlJBWVAgKExpc3BfT2JqZWN0IHgpCit7CisgIHJldHVybiBW RUNUT1JQICh4KSB8fCBTVFJJTkdQICh4KSB8fCBDSEFSX1RBQkxFX1AgKHgpIHx8IEJPT0xf VkVDVE9SX1AgKHgpOworfQogDAotI2RlZmluZSBDSEVDS19MSVNUKHgpIFwKLSAgQ0hFQ0tf VFlQRSAoQ09OU1AgKHgpIHx8IE5JTFAgKHgpLCBRbGlzdHAsIHgpCi0KLSNkZWZpbmUgQ0hF Q0tfTElTVF9DT05TKHgsIHkpIFwKLSAgQ0hFQ0tfVFlQRSAoQ09OU1AgKHgpLCBRbGlzdHAs IHkpCi0KLSNkZWZpbmUgQ0hFQ0tfTElTVF9FTkQoeCwgeSkgXAotICBDSEVDS19UWVBFIChO SUxQICh4KSwgUWxpc3RwLCB5KQotCi0jZGVmaW5lIENIRUNLX1NUUklORyh4KSBcCi0gIENI RUNLX1RZUEUgKFNUUklOR1AgKHgpLCBRc3RyaW5ncCwgeCkKLQotI2RlZmluZSBDSEVDS19T VFJJTkdfQ0FSKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoU1RSSU5HUCAoWENBUiAoeCkpLCBRc3Ry aW5ncCwgWENBUiAoeCkpCi0KLSNkZWZpbmUgQ0hFQ0tfQ09OUyh4KSBcCi0gIENIRUNLX1RZ UEUgKENPTlNQICh4KSwgUWNvbnNwLCB4KQotCi0jZGVmaW5lIENIRUNLX1NZTUJPTCh4KSBc Ci0gIENIRUNLX1RZUEUgKFNZTUJPTFAgKHgpLCBRc3ltYm9scCwgeCkKLQotI2RlZmluZSBD SEVDS19DSEFSX1RBQkxFKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoQ0hBUl9UQUJMRV9QICh4KSwg UWNoYXJfdGFibGVfcCwgeCkKLQotI2RlZmluZSBDSEVDS19WRUNUT1IoeCkgXAotICBDSEVD S19UWVBFIChWRUNUT1JQICh4KSwgUXZlY3RvcnAsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfVkVD VE9SX09SX1NUUklORyh4KSBcCi0gIENIRUNLX1RZUEUgKFZFQ1RPUlAgKHgpIHx8IFNUUklO R1AgKHgpLCBRYXJyYXlwLCB4KQotCi0jZGVmaW5lIENIRUNLX0FSUkFZKHgsIFF4eHhwKSBc Ci0gIENIRUNLX1RZUEUgKEFSUkFZUCAoeCksIFF4eHhwLCB4KQotCi0jZGVmaW5lIENIRUNL X1ZFQ1RPUl9PUl9DSEFSX1RBQkxFKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoVkVDVE9SUCAoeCkg fHwgQ0hBUl9UQUJMRV9QICh4KSwgUXZlY3Rvcl9vcl9jaGFyX3RhYmxlX3AsIHgpCi0KLSNk ZWZpbmUgQ0hFQ0tfQlVGRkVSKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoQlVGRkVSUCAoeCksIFFi dWZmZXJwLCB4KQotCi0jZGVmaW5lIENIRUNLX1dJTkRPVyh4KSBcCi0gIENIRUNLX1RZUEUg KFdJTkRPV1AgKHgpLCBRd2luZG93cCwgeCkKLQotI2RlZmluZSBDSEVDS19XSU5ET1dfQ09O RklHVVJBVElPTih4KSBcCi0gIENIRUNLX1RZUEUgKFdJTkRPV19DT05GSUdVUkFUSU9OUCAo eCksIFF3aW5kb3dfY29uZmlndXJhdGlvbl9wLCB4KQotCi0jZGVmaW5lIENIRUNLX1BST0NF U1MoeCkgXAotICBDSEVDS19UWVBFIChQUk9DRVNTUCAoeCksIFFwcm9jZXNzcCwgeCkKLQot I2RlZmluZSBDSEVDS19TVUJSKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoU1VCUlAgKHgpLCBRc3Vi cnAsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfTlVNQkVSKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoSU5U RUdFUlAgKHgpLCBRaW50ZWdlcnAsIHgpCi0KLSNkZWZpbmUgQ0hFQ0tfTkFUTlVNKHgpIFwK LSAgQ0hFQ0tfVFlQRSAoTkFUTlVNUCAoeCksIFF3aG9sZW51bXAsIHgpCitMSVNQX0lOTElO RSB2b2lkCitDSEVDS19MSVNUIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChD T05TUCAoeCkgfHwgTklMUCAoeCksIFFsaXN0cCwgeCk7Cit9CisKK0xJU1BfTUFDUk9fREVG VU5fVk9JRCAoQ0hFQ0tfTElTVF9DT05TLCAoTGlzcF9PYmplY3QgeCwgTGlzcF9PYmplY3Qg eSksICh4LCB5KSkKK0xJU1BfTUFDUk9fREVGVU5fVk9JRCAoQ0hFQ0tfU1lNQk9MLCAoTGlz cF9PYmplY3QgeCksICh4KSkKK0xJU1BfTUFDUk9fREVGVU5fVk9JRCAoQ0hFQ0tfTlVNQkVS LCAoTGlzcF9PYmplY3QgeCksICh4KSkKKworTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfU1RS SU5HIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChTVFJJTkdQICh4KSwgUXN0 cmluZ3AsIHgpOworfQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfU1RSSU5HX0NBUiAoTGlz cF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQRSAoU1RSSU5HUCAoWENBUiAoeCkpLCBRc3Ry aW5ncCwgWENBUiAoeCkpOworfQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfQ09OUyAoTGlz cF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQRSAoQ09OU1AgKHgpLCBRY29uc3AsIHgpOwor fQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfVkVDVE9SIChMaXNwX09iamVjdCB4KQorewor ICBDSEVDS19UWVBFIChWRUNUT1JQICh4KSwgUXZlY3RvcnAsIHgpOworfQorTElTUF9JTkxJ TkUgdm9pZAorQ0hFQ0tfVkVDVE9SX09SX1NUUklORyAoTGlzcF9PYmplY3QgeCkKK3sKKyAg Q0hFQ0tfVFlQRSAoVkVDVE9SUCAoeCkgfHwgU1RSSU5HUCAoeCksIFFhcnJheXAsIHgpOwor fQorTElTUF9JTkxJTkUgdm9pZAorQ0hFQ0tfQVJSQVkgKExpc3BfT2JqZWN0IHgsIExpc3Bf T2JqZWN0IFF4eHhwKQoreworICBDSEVDS19UWVBFIChBUlJBWVAgKHgpLCBReHh4cCwgeCk7 Cit9CitMSVNQX0lOTElORSB2b2lkCitDSEVDS19CVUZGRVIgKExpc3BfT2JqZWN0IHgpCit7 CisgIENIRUNLX1RZUEUgKEJVRkZFUlAgKHgpLCBRYnVmZmVycCwgeCk7Cit9CitMSVNQX0lO TElORSB2b2lkCitDSEVDS19XSU5ET1cgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZ UEUgKFdJTkRPV1AgKHgpLCBRd2luZG93cCwgeCk7Cit9CitMSVNQX0lOTElORSB2b2lkCitD SEVDS19QUk9DRVNTIChMaXNwX09iamVjdCB4KQoreworICBDSEVDS19UWVBFIChQUk9DRVNT UCAoeCksIFFwcm9jZXNzcCwgeCk7Cit9CitMSVNQX0lOTElORSB2b2lkCitDSEVDS19OQVRO VU0gKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKE5BVE5VTVAgKHgpLCBRd2hv bGVudW1wLCB4KTsKK30KIAogI2RlZmluZSBDSEVDS19SQU5HRURfSU5URUdFUih4LCBsbywg aGkpCQkJCQlcCiAgIGRvIHsJCQkJCQkJCQlcCkBAIC0xOTcyLDU3ICsyNDUyLDQzIEBACiAg ICAgICBDSEVDS19SQU5HRURfSU5URUdFUiAoeCwgMCwgVFlQRV9NQVhJTVVNICh0eXBlKSk7 CQkJXAogICB9IHdoaWxlICgwKQogCi0jZGVmaW5lIENIRUNLX01BUktFUih4KSBcCi0gIENI RUNLX1RZUEUgKE1BUktFUlAgKHgpLCBRbWFya2VycCwgeCkKLQogI2RlZmluZSBDSEVDS19O VU1CRVJfQ09FUkNFX01BUktFUih4KSBcCiAgIGRvIHsgaWYgKE1BUktFUlAgKCh4KSkpIFhT RVRGQVNUSU5UICh4LCBtYXJrZXJfcG9zaXRpb24gKHgpKTsgXAogICAgIGVsc2UgQ0hFQ0tf VFlQRSAoSU5URUdFUlAgKHgpLCBRaW50ZWdlcl9vcl9tYXJrZXJfcCwgeCk7IH0gd2hpbGUg KDApCiAKLSNkZWZpbmUgWEZMT0FUSU5UKG4pIGV4dHJhY3RfZmxvYXQoKG4pKQotCi0jZGVm aW5lIENIRUNLX0ZMT0FUKHgpIFwKLSAgQ0hFQ0tfVFlQRSAoRkxPQVRQICh4KSwgUWZsb2F0 cCwgeCkKLQotI2RlZmluZSBDSEVDS19OVU1CRVJfT1JfRkxPQVQoeCkgXAotICBDSEVDS19U WVBFIChGTE9BVFAgKHgpIHx8IElOVEVHRVJQICh4KSwgUW51bWJlcnAsIHgpCitMSVNQX0lO TElORSBkb3VibGUKK1hGTE9BVElOVCAoTGlzcF9PYmplY3QgbikKK3sKKyAgcmV0dXJuIGV4 dHJhY3RfZmxvYXQgKG4pOworfQorCitMSVNQX0lOTElORSB2b2lkCitDSEVDS19OVU1CRVJf T1JfRkxPQVQgKExpc3BfT2JqZWN0IHgpCit7CisgIENIRUNLX1RZUEUgKEZMT0FUUCAoeCkg fHwgSU5URUdFUlAgKHgpLCBRbnVtYmVycCwgeCk7Cit9CiAKICNkZWZpbmUgQ0hFQ0tfTlVN QkVSX09SX0ZMT0FUX0NPRVJDRV9NQVJLRVIoeCkgXAogICBkbyB7IGlmIChNQVJLRVJQICh4 KSkgWFNFVEZBU1RJTlQgKHgsIG1hcmtlcl9wb3NpdGlvbiAoeCkpOyBcCiAgICAgZWxzZSBD SEVDS19UWVBFIChJTlRFR0VSUCAoeCkgfHwgRkxPQVRQICh4KSwgUW51bWJlcl9vcl9tYXJr ZXJfcCwgeCk7IH0gd2hpbGUgKDApCiAKLSNkZWZpbmUgQ0hFQ0tfT1ZFUkxBWSh4KSBcCi0g IENIRUNLX1RZUEUgKE9WRVJMQVlQICh4KSwgUW92ZXJsYXlwLCB4KQotCiAvKiBTaW5jZSB3 ZSBjYW4ndCBhc3NpZ24gZGlyZWN0bHkgdG8gdGhlIENBUiBvciBDRFIgZmllbGRzIG9mIGEg Y29ucwogICAgY2VsbCwgdXNlIHRoZXNlIHdoZW4gY2hlY2tpbmcgdGhhdCB0aG9zZSBmaWVs ZHMgY29udGFpbiBudW1iZXJzLiAgKi8KLSNkZWZpbmUgQ0hFQ0tfTlVNQkVSX0NBUih4KSBc Ci0gIGRvIHsJCQkJCVwKLSAgICBMaXNwX09iamVjdCB0bXAgPSBYQ0FSICh4KTsJCVwKLSAg ICBDSEVDS19OVU1CRVIgKHRtcCk7CQkJXAotICAgIFhTRVRDQVIgKCh4KSwgdG1wKTsJCQlc Ci0gIH0gd2hpbGUgKDApCi0KLSNkZWZpbmUgQ0hFQ0tfTlVNQkVSX0NEUih4KSBcCi0gIGRv IHsJCQkJCVwKLSAgICBMaXNwX09iamVjdCB0bXAgPSBYQ0RSICh4KTsJCVwKLSAgICBDSEVD S19OVU1CRVIgKHRtcCk7CQkJXAotICAgIFhTRVRDRFIgKCh4KSwgdG1wKTsJCQlcCi0gIH0g d2hpbGUgKDApCi0KLSNkZWZpbmUgQ0hFQ0tfTkFUTlVNX0NBUih4KSBcCi0gIGRvIHsJCQkJ CVwKLSAgICBMaXNwX09iamVjdCB0bXAgPSBYQ0FSICh4KTsJCVwKLSAgICBDSEVDS19OQVRO VU0gKHRtcCk7CQkJXAotICAgIFhTRVRDQVIgKCh4KSwgdG1wKTsJCQlcCi0gIH0gd2hpbGUg KDApCi0KLSNkZWZpbmUgQ0hFQ0tfTkFUTlVNX0NEUih4KSBcCi0gIGRvIHsJCQkJCVwKLSAg ICBMaXNwX09iamVjdCB0bXAgPSBYQ0RSICh4KTsJCVwKLSAgICBDSEVDS19OQVROVU0gKHRt cCk7CQkJXAotICAgIFhTRVRDRFIgKCh4KSwgdG1wKTsJCQlcCi0gIH0gd2hpbGUgKDApCitM SVNQX0lOTElORSB2b2lkCitDSEVDS19OVU1CRVJfQ0FSIChMaXNwX09iamVjdCB4KQorewor ICBMaXNwX09iamVjdCB0bXAgPSBYQ0FSICh4KTsKKyAgQ0hFQ0tfTlVNQkVSICh0bXApOwor ICBYU0VUQ0FSICh4LCB0bXApOworfQorCitMSVNQX0lOTElORSB2b2lkCitDSEVDS19OVU1C RVJfQ0RSIChMaXNwX09iamVjdCB4KQoreworICBMaXNwX09iamVjdCB0bXAgPSBYQ0RSICh4 KTsKKyAgQ0hFQ0tfTlVNQkVSICh0bXApOworICBYU0VUQ0RSICh4LCB0bXApOworfQogDAog LyogRGVmaW5lIGEgYnVpbHQtaW4gZnVuY3Rpb24gZm9yIGNhbGxpbmcgZnJvbSBMaXNwLgog IGBsbmFtZScgc2hvdWxkIGJlIHRoZSBuYW1lIHRvIGdpdmUgdGhlIGZ1bmN0aW9uIGluIExp c3AsCkBAIC0yMDg4LDggKzI1NTQsMTIgQEAKICNkZWZpbmUgREVGVU5fQVJHU184CShMaXNw X09iamVjdCwgTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0LCBMaXNwX09iamVjdCwgXAogCQkJ IExpc3BfT2JqZWN0LCBMaXNwX09iamVjdCwgTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0KQog Ci0vKiBOb24temVybyBpZiBPQkogaXMgYSBMaXNwIGZ1bmN0aW9uLiAgKi8KLSNkZWZpbmUg RlVOQ1RJT05QKE9CSikgZnVuY3Rpb25wKE9CSikKKy8qIFRydWUgaWYgT0JKIGlzIGEgTGlz cCBmdW5jdGlvbi4gICovCitMSVNQX0lOTElORSBib29sCitGVU5DVElPTlAgKExpc3BfT2Jq ZWN0IG9iaikKK3sKKyAgcmV0dXJuIGZ1bmN0aW9ucCAob2JqKTsKK30KIAogLyogZGVmc3Vi ciAoU25hbWUpOwogICAgaXMgaG93IHdlIGRlZmluZSB0aGUgc3ltYm9sIGZvciBmdW5jdGlv biBgbmFtZScgYXQgc3RhcnQtdXAgdGltZS4gICovCkBAIC0yMjQ1LDM4ICsyNzE1LDE1IEBA CiAgICAgfSB2OwogICB9OwogCi1MSVNQX0lOTElORSBMaXNwX09iamVjdCBzcGVjcGRsX3N5 bWJvbCAoc3RydWN0IHNwZWNiaW5kaW5nICpwZGwpCi17IGVhc3NlcnQgKHBkbC0+a2luZCA+ PSBTUEVDUERMX0xFVCk7IHJldHVybiBwZGwtPnYubGV0LnN5bWJvbDsgfQotCi1MSVNQX0lO TElORSBMaXNwX09iamVjdCBzcGVjcGRsX29sZF92YWx1ZSAoc3RydWN0IHNwZWNiaW5kaW5n ICpwZGwpCi17IGVhc3NlcnQgKHBkbC0+a2luZCA+PSBTUEVDUERMX0xFVCk7IHJldHVybiBw ZGwtPnYubGV0Lm9sZF92YWx1ZTsgfQotCi1MSVNQX0lOTElORSBMaXNwX09iamVjdCBzcGVj cGRsX3doZXJlIChzdHJ1Y3Qgc3BlY2JpbmRpbmcgKnBkbCkKLXsgZWFzc2VydCAocGRsLT5r aW5kID4gU1BFQ1BETF9MRVQpOyByZXR1cm4gcGRsLT52LmxldC53aGVyZTsgfQotCi1MSVNQ X0lOTElORSBMaXNwX09iamVjdCBzcGVjcGRsX2FyZyAoc3RydWN0IHNwZWNiaW5kaW5nICpw ZGwpCi17IGVhc3NlcnQgKHBkbC0+a2luZCA9PSBTUEVDUERMX1VOV0lORCk7IHJldHVybiBw ZGwtPnYudW53aW5kLmFyZzsgfQotCi1MSVNQX0lOTElORSBzcGVjYmluZGluZ19mdW5jIHNw ZWNwZGxfZnVuYyAoc3RydWN0IHNwZWNiaW5kaW5nICpwZGwpCi17IGVhc3NlcnQgKHBkbC0+ a2luZCA9PSBTUEVDUERMX1VOV0lORCk7IHJldHVybiBwZGwtPnYudW53aW5kLmZ1bmM7IH0K LQotTElTUF9JTkxJTkUgTGlzcF9PYmplY3QgYmFja3RyYWNlX2Z1bmN0aW9uIChzdHJ1Y3Qg c3BlY2JpbmRpbmcgKnBkbCkKLXsgZWFzc2VydCAocGRsLT5raW5kID09IFNQRUNQRExfQkFD S1RSQUNFKTsgcmV0dXJuIHBkbC0+di5idC5mdW5jdGlvbjsgfQotCi1MSVNQX0lOTElORSBw dHJkaWZmX3QgYmFja3RyYWNlX25hcmdzIChzdHJ1Y3Qgc3BlY2JpbmRpbmcgKnBkbCkKLXsg ZWFzc2VydCAocGRsLT5raW5kID09IFNQRUNQRExfQkFDS1RSQUNFKTsgcmV0dXJuIHBkbC0+ di5idC5uYXJnczsgfQotCi1MSVNQX0lOTElORSBMaXNwX09iamVjdCAqYmFja3RyYWNlX2Fy Z3MgKHN0cnVjdCBzcGVjYmluZGluZyAqcGRsKQoteyBlYXNzZXJ0IChwZGwtPmtpbmQgPT0g U1BFQ1BETF9CQUNLVFJBQ0UpOyByZXR1cm4gcGRsLT52LmJ0LmFyZ3M7IH0KLQotTElTUF9J TkxJTkUgYm9vbCBiYWNrdHJhY2VfZGVidWdfb25fZXhpdCAoc3RydWN0IHNwZWNiaW5kaW5n ICpwZGwpCi17IGVhc3NlcnQgKHBkbC0+a2luZCA9PSBTUEVDUERMX0JBQ0tUUkFDRSk7IHJl dHVybiBwZGwtPnYuYnQuZGVidWdfb25fZXhpdDsgfQotCiBleHRlcm4gc3RydWN0IHNwZWNi aW5kaW5nICpzcGVjcGRsOwogZXh0ZXJuIHN0cnVjdCBzcGVjYmluZGluZyAqc3BlY3BkbF9w dHI7CiBleHRlcm4gcHRyZGlmZl90IHNwZWNwZGxfc2l6ZTsKIAotI2RlZmluZSBTUEVDUERM X0lOREVYKCkJKHNwZWNwZGxfcHRyIC0gc3BlY3BkbCkKK0xJU1BfSU5MSU5FIHB0cmRpZmZf dAorU1BFQ1BETF9JTkRFWCAodm9pZCkKK3sKKyAgcmV0dXJuIHNwZWNwZGxfcHRyIC0gc3Bl Y3BkbDsKK30KIAogLyogRXZlcnl0aGluZyBuZWVkZWQgdG8gZGVzY3JpYmUgYW4gYWN0aXZl IGNvbmRpdGlvbiBjYXNlLgogCkBAIC0yNTkyLDI3ICszMDM5LDEyIEBACiAjZGVmaW5lIEVY RlVOKGZubmFtZSwgbWF4YXJncykgXAogICBleHRlcm4gTGlzcF9PYmplY3QgZm5uYW1lIERF RlVOX0FSR1NfICMjIG1heGFyZ3MKIAorI2luY2x1ZGUgImdsb2JhbHMuaCIKKwogLyogRm9y d2FyZCBkZWNsYXJhdGlvbnMgZm9yIHByb3RvdHlwZXMuICAqLwogc3RydWN0IHdpbmRvdzsK IHN0cnVjdCBmcmFtZTsKIAotLyogU2ltcGxlIGFjY2VzcyBmdW5jdGlvbnMuICAqLwotCi1M SVNQX0lOTElORSBMaXNwX09iamVjdCAqCi1hcmVmX2FkZHIgKExpc3BfT2JqZWN0IGFycmF5 LCBwdHJkaWZmX3QgaWR4KQotewotICByZXR1cm4gJiBYVkVDVE9SIChhcnJheSktPmNvbnRl bnRzW2lkeF07Ci19Ci0KLUxJU1BfSU5MSU5FIHZvaWQKLWdjX2FzZXQgKExpc3BfT2JqZWN0 IGFycmF5LCBwdHJkaWZmX3QgaWR4LCBMaXNwX09iamVjdCB2YWwpCi17Ci0gIC8qIExpa2Ug QVNFVCwgYnV0IGFsc28gY2FuIGJlIHVzZWQgaW4gdGhlIGdhcmJhZ2UgY29sbGVjdG9yOgot ICAgICBzd2VlcF93ZWFrX3RhYmxlIGNhbGxzIHNldF9oYXNoX2tleSBldGMuIHdoaWxlIHRo ZSB0YWJsZSBpcyBtYXJrZWQuICAqLwotICBlYXNzZXJ0ICgwIDw9IGlkeCAmJiBpZHggPCAo QVNJWkUgKGFycmF5KSAmIH5BUlJBWV9NQVJLX0ZMQUcpKTsKLSAgWFZFQ1RPUiAoYXJyYXkp LT5jb250ZW50c1tpZHhdID0gdmFsOwotfQotCiAvKiBDb3B5IENPVU5UIExpc3BfT2JqZWN0 cyBmcm9tIEFSR1MgdG8gY29udGVudHMgb2YgViBzdGFydGluZyBmcm9tIE9GRlNFVC4gICov CiAKIExJU1BfSU5MSU5FIHZvaWQKQEAgLTI2MjUsMTIgKzMwNTcsNiBAQAogLyogRnVuY3Rp b25zIHRvIG1vZGlmeSBoYXNoIHRhYmxlcy4gICovCiAKIExJU1BfSU5MSU5FIHZvaWQKLXNl dF9oYXNoX2tleV9hbmRfdmFsdWUgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIExpc3Bf T2JqZWN0IGtleV9hbmRfdmFsdWUpCi17Ci0gIGgtPmtleV9hbmRfdmFsdWUgPSBrZXlfYW5k X3ZhbHVlOwotfQotCi1MSVNQX0lOTElORSB2b2lkCiBzZXRfaGFzaF9rZXlfc2xvdCAoc3Ry dWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgcHRyZGlmZl90IGlkeCwgTGlzcF9PYmplY3QgdmFs KQogewogICBnY19hc2V0IChoLT5rZXlfYW5kX3ZhbHVlLCAyICogaWR4LCB2YWwpOwpAQCAt MjY0Miw1MiArMzA2OCwxMCBAQAogICBnY19hc2V0IChoLT5rZXlfYW5kX3ZhbHVlLCAyICog aWR4ICsgMSwgdmFsKTsKIH0KIAotTElTUF9JTkxJTkUgdm9pZAotc2V0X2hhc2hfbmV4dCAo c3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgTGlzcF9PYmplY3QgbmV4dCkKLXsKLSAgaC0+ bmV4dCA9IG5leHQ7Ci19Ci0KLUxJU1BfSU5MSU5FIHZvaWQKLXNldF9oYXNoX25leHRfc2xv dCAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgcHRyZGlmZl90IGlkeCwgTGlzcF9PYmpl Y3QgdmFsKQotewotICBnY19hc2V0IChoLT5uZXh0LCBpZHgsIHZhbCk7Ci19Ci0KLUxJU1Bf SU5MSU5FIHZvaWQKLXNldF9oYXNoX2hhc2ggKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgs IExpc3BfT2JqZWN0IGhhc2gpCi17Ci0gIGgtPmhhc2ggPSBoYXNoOwotfQotCi1MSVNQX0lO TElORSB2b2lkCi1zZXRfaGFzaF9oYXNoX3Nsb3QgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUg KmgsIHB0cmRpZmZfdCBpZHgsIExpc3BfT2JqZWN0IHZhbCkKLXsKLSAgZ2NfYXNldCAoaC0+ aGFzaCwgaWR4LCB2YWwpOwotfQotCi1MSVNQX0lOTElORSB2b2lkCi1zZXRfaGFzaF9pbmRl eCAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCwgTGlzcF9PYmplY3QgaW5kZXgpCi17Ci0g IGgtPmluZGV4ID0gaW5kZXg7Ci19Ci0KLUxJU1BfSU5MSU5FIHZvaWQKLXNldF9oYXNoX2lu ZGV4X3Nsb3QgKHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmgsIHB0cmRpZmZfdCBpZHgsIExp c3BfT2JqZWN0IHZhbCkKLXsKLSAgZ2NfYXNldCAoaC0+aW5kZXgsIGlkeCwgdmFsKTsKLX0K LQogLyogVXNlIHRoZXNlIGZ1bmN0aW9ucyB0byBzZXQgTGlzcF9PYmplY3QKICAgIG9yIHBv aW50ZXIgc2xvdHMgb2Ygc3RydWN0IExpc3BfU3ltYm9sLiAgKi8KIAogTElTUF9JTkxJTkUg dm9pZAotc2V0X3N5bWJvbF9uYW1lIChMaXNwX09iamVjdCBzeW0sIExpc3BfT2JqZWN0IG5h bWUpCi17Ci0gIFhTWU1CT0wgKHN5bSktPm5hbWUgPSBuYW1lOwotfQotCi1MSVNQX0lOTElO RSB2b2lkCiBzZXRfc3ltYm9sX2Z1bmN0aW9uIChMaXNwX09iamVjdCBzeW0sIExpc3BfT2Jq ZWN0IGZ1bmN0aW9uKQogewogICBYU1lNQk9MIChzeW0pLT5mdW5jdGlvbiA9IGZ1bmN0aW9u OwpAQCAtMjcxNCw0MyArMzA5OCw2IEBACiAgIHJldHVybiBibHYtPmZvdW5kOwogfQogCi1M SVNQX0lOTElORSB2b2lkCi1zZXRfYmx2X2ZvdW5kIChzdHJ1Y3QgTGlzcF9CdWZmZXJfTG9j YWxfVmFsdWUgKmJsdiwgaW50IGZvdW5kKQotewotICBlYXNzZXJ0IChmb3VuZCA9PSAhRVEg KGJsdi0+ZGVmY2VsbCwgYmx2LT52YWxjZWxsKSk7Ci0gIGJsdi0+Zm91bmQgPSBmb3VuZDsK LX0KLQotTElTUF9JTkxJTkUgTGlzcF9PYmplY3QKLWJsdl92YWx1ZSAoc3RydWN0IExpc3Bf QnVmZmVyX0xvY2FsX1ZhbHVlICpibHYpCi17Ci0gIHJldHVybiBYQ0RSIChibHYtPnZhbGNl bGwpOwotfQotCi1MSVNQX0lOTElORSB2b2lkCi1zZXRfYmx2X3ZhbHVlIChzdHJ1Y3QgTGlz cF9CdWZmZXJfTG9jYWxfVmFsdWUgKmJsdiwgTGlzcF9PYmplY3QgdmFsKQotewotICBYU0VU Q0RSIChibHYtPnZhbGNlbGwsIHZhbCk7Ci19Ci0KLUxJU1BfSU5MSU5FIHZvaWQKLXNldF9i bHZfd2hlcmUgKHN0cnVjdCBMaXNwX0J1ZmZlcl9Mb2NhbF9WYWx1ZSAqYmx2LCBMaXNwX09i amVjdCB2YWwpCi17Ci0gIGJsdi0+d2hlcmUgPSB2YWw7Ci19Ci0KLUxJU1BfSU5MSU5FIHZv aWQKLXNldF9ibHZfZGVmY2VsbCAoc3RydWN0IExpc3BfQnVmZmVyX0xvY2FsX1ZhbHVlICpi bHYsIExpc3BfT2JqZWN0IHZhbCkKLXsKLSAgYmx2LT5kZWZjZWxsID0gdmFsOwotfQotCi1M SVNQX0lOTElORSB2b2lkCi1zZXRfYmx2X3ZhbGNlbGwgKHN0cnVjdCBMaXNwX0J1ZmZlcl9M b2NhbF9WYWx1ZSAqYmx2LCBMaXNwX09iamVjdCB2YWwpCi17Ci0gIGJsdi0+dmFsY2VsbCA9 IHZhbDsKLX0KLQogLyogU2V0IG92ZXJsYXkncyBwcm9wZXJ0eSBsaXN0LiAgKi8KIAogTElT UF9JTkxJTkUgdm9pZApAQCAtMjc3OSwyMSArMzEyNiwxMSBAQAogICAgb2Ygc2V0dGluZyBz bG90cyBkaXJlY3RseS4gICovCiAKIExJU1BfSU5MSU5FIHZvaWQKLXNldF9jaGFyX3RhYmxl X2FzY2lpIChMaXNwX09iamVjdCB0YWJsZSwgTGlzcF9PYmplY3QgdmFsKQotewotICBYQ0hB Ul9UQUJMRSAodGFibGUpLT5hc2NpaSA9IHZhbDsKLX0KLUxJU1BfSU5MSU5FIHZvaWQKIHNl dF9jaGFyX3RhYmxlX2RlZmFsdCAoTGlzcF9PYmplY3QgdGFibGUsIExpc3BfT2JqZWN0IHZh bCkKIHsKICAgWENIQVJfVEFCTEUgKHRhYmxlKS0+ZGVmYWx0ID0gdmFsOwogfQogTElTUF9J TkxJTkUgdm9pZAotc2V0X2NoYXJfdGFibGVfcGFyZW50IChMaXNwX09iamVjdCB0YWJsZSwg TGlzcF9PYmplY3QgdmFsKQotewotICBYQ0hBUl9UQUJMRSAodGFibGUpLT5wYXJlbnQgPSB2 YWw7Ci19Ci1MSVNQX0lOTElORSB2b2lkCiBzZXRfY2hhcl90YWJsZV9wdXJwb3NlIChMaXNw X09iamVjdCB0YWJsZSwgTGlzcF9PYmplY3QgdmFsKQogewogICBYQ0hBUl9UQUJMRSAodGFi bGUpLT5wdXJwb3NlID0gdmFsOwpAQCAtMzIzNyw3ICszNTc0LDcgQEAKICNpZmRlZiBHQ19D SEVDS19DT05TX0xJU1QKIGV4dGVybiB2b2lkIGNoZWNrX2NvbnNfbGlzdCAodm9pZCk7CiAj ZWxzZQotI2RlZmluZSBjaGVja19jb25zX2xpc3QoKSAoKHZvaWQpIDApCitMSVNQX0lOTElO RSB2b2lkIChjaGVja19jb25zX2xpc3QpICh2b2lkKSB7IGxpc3BfaF9jaGVja19jb25zX2xp c3QgKCk7IH0KICNlbmRpZgogCiAjaWZkZWYgUkVMX0FMTE9DCkBAIC0zMzA1LDEwICszNjQy LDEyIEBACiBleHRlcm4gTGlzcF9PYmplY3QgaW50ZXJuXzEgKGNvbnN0IGNoYXIgKiwgcHRy ZGlmZl90KTsKIGV4dGVybiBMaXNwX09iamVjdCBpbnRlcm5fY19zdHJpbmdfMSAoY29uc3Qg Y2hhciAqLCBwdHJkaWZmX3QpOwogZXh0ZXJuIExpc3BfT2JqZWN0IG9ibG9va3VwIChMaXNw X09iamVjdCwgY29uc3QgY2hhciAqLCBwdHJkaWZmX3QsIHB0cmRpZmZfdCk7Ci0jZGVmaW5l IExPQURISVNUX0FUVEFDSCh4KSBcCi0gIGRvIHsJCQkJCQkJCQlcCi0gICAgaWYgKGluaXRp YWxpemVkKSBWY3VycmVudF9sb2FkX2xpc3QgPSBGY29ucyAoeCwgVmN1cnJlbnRfbG9hZF9s aXN0KTsgXAotICB9IHdoaWxlICgwKQorTElTUF9JTkxJTkUgdm9pZAorTE9BREhJU1RfQVRU QUNIIChMaXNwX09iamVjdCB4KQoreworICBpZiAoaW5pdGlhbGl6ZWQpCisgICAgVmN1cnJl bnRfbG9hZF9saXN0ID0gRmNvbnMgKHgsIFZjdXJyZW50X2xvYWRfbGlzdCk7Cit9CiBleHRl cm4gaW50IG9wZW5wIChMaXNwX09iamVjdCwgTGlzcF9PYmplY3QsIExpc3BfT2JqZWN0LAog ICAgICAgICAgICAgICAgICAgTGlzcF9PYmplY3QgKiwgTGlzcF9PYmplY3QpOwogZXh0ZXJu IExpc3BfT2JqZWN0IHN0cmluZ190b19udW1iZXIgKGNoYXIgY29uc3QgKiwgaW50LCBib29s KTsKQEAgLTM1OTQsMTAgKzM5MzMsOSBAQAogdm9pZCBzeW5jaHJvbml6ZV9zeXN0ZW1fbWVz c2FnZXNfbG9jYWxlICh2b2lkKTsKIHZvaWQgc3luY2hyb25pemVfc3lzdGVtX3RpbWVfbG9j YWxlICh2b2lkKTsKICNlbHNlCi0jZGVmaW5lIHNldGxvY2FsZShjYXRlZ29yeSwgbG9jYWxl KQotI2RlZmluZSBmaXh1cF9sb2NhbGUoKQotI2RlZmluZSBzeW5jaHJvbml6ZV9zeXN0ZW1f bWVzc2FnZXNfbG9jYWxlKCkKLSNkZWZpbmUgc3luY2hyb25pemVfc3lzdGVtX3RpbWVfbG9j YWxlKCkKK0xJU1BfSU5MSU5FIHZvaWQgZml4dXBfbG9jYWxlICh2b2lkKSB7fQorTElTUF9J TkxJTkUgdm9pZCBzeW5jaHJvbml6ZV9zeXN0ZW1fbWVzc2FnZXNfbG9jYWxlICh2b2lkKSB7 fQorTElTUF9JTkxJTkUgdm9pZCBzeW5jaHJvbml6ZV9zeXN0ZW1fdGltZV9sb2NhbGUgKHZv aWQpIHt9CiAjZW5kaWYKIGV4dGVybiB2b2lkIHNodXRfZG93bl9lbWFjcyAoaW50LCBMaXNw X09iamVjdCk7CiAKQEAgLTM5NTYsOCArNDI5NCw2IEBACiAgIH0gd2hpbGUgKDApCiAKIAot I2luY2x1ZGUgImdsb2JhbHMuaCIKLQogLyogQ2hlY2sgd2hldGhlciBpdCdzIHRpbWUgZm9y IEdDLCBhbmQgcnVuIGl0IGlmIHNvLiAgKi8KIAogTElTUF9JTkxJTkUgdm9pZApAQCAtMzk3 MCw3ICs0MzA2LDcgQEAKICAgICBGZ2FyYmFnZV9jb2xsZWN0ICgpOwogfQogCi1MSVNQX0lO TElORSBpbnQKK0xJU1BfSU5MSU5FIGJvb2wKIGZ1bmN0aW9ucCAoTGlzcF9PYmplY3Qgb2Jq ZWN0KQogewogICBpZiAoU1lNQk9MUCAob2JqZWN0KSAmJiAhTklMUCAoRmZib3VuZHAgKG9i amVjdCkpKQoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy9tYXJrZXIuYycKLS0tIHNyYy9tYXJr ZXIuYwkyMDEzLTAyLTE5IDE0OjQ0OjAzICswMDAwCisrKyBzcmMvbWFya2VyLmMJMjAxMy0w Ni0xMyAxNTozODoxNiArMDAwMApAQCAtMTI3LDYgKzEyNywxMiBAQAogICAgIH0JCQkJCQkJ CQlcCiB9CiAKK3N0YXRpYyB2b2lkCitDSEVDS19NQVJLRVIgKExpc3BfT2JqZWN0IHgpCit7 CisgIENIRUNLX1RZUEUgKE1BUktFUlAgKHgpLCBRbWFya2VycCwgeCk7Cit9CisKIC8qIFJl dHVybiB0aGUgYnl0ZSBwb3NpdGlvbiBjb3JyZXNwb25kaW5nIHRvIENIQVJQT1MgaW4gQi4g ICovCiAKIHB0cmRpZmZfdAoKPT09IG1vZGlmaWVkIGZpbGUgJ3NyYy90ZXh0cHJvcC5jJwot LS0gc3JjL3RleHRwcm9wLmMJMjAxMy0wMy0yOCAxNDowNDo0OSArMDAwMAorKysgc3JjL3Rl eHRwcm9wLmMJMjAxMy0wNi0xMyAxNTozODoxNiArMDAwMApAQCAtOTgsNiArOTgsMTQgQEAK ICAgc2V0X2J1ZmZlcl9pbnRlcm5hbCAob2xkKTsKIH0KIAorLyogQ29tcGxhaW4gaWYgb2Jq ZWN0IGlzIG5vdCBzdHJpbmcgb3IgYnVmZmVyIHR5cGUuICAqLworCitzdGF0aWMgdm9pZAor Q0hFQ0tfU1RSSU5HX09SX0JVRkZFUiAoTGlzcF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQ RSAoU1RSSU5HUCAoeCkgfHwgQlVGRkVSUCAoeCksIFFidWZmZXJfb3Jfc3RyaW5nX3AsIHgp OworfQorCiAvKiBFeHRyYWN0IHRoZSBpbnRlcnZhbCBhdCB0aGUgcG9zaXRpb24gcG9pbnRl ZCB0byBieSBCRUdJTiBmcm9tCiAgICBPQkpFQ1QsIGEgc3RyaW5nIG9yIGJ1ZmZlci4gIEFk ZGl0aW9uYWxseSwgY2hlY2sgdGhhdCB0aGUgcG9zaXRpb25zCiAgICBwb2ludGVkIHRvIGJ5 IEJFR0lOIGFuZCBFTkQgYXJlIHdpdGhpbiB0aGUgYm91bmRzIG9mIE9CSkVDVCwgYW5kCgo9 PT0gbW9kaWZpZWQgZmlsZSAnc3JjL3dpbmRvdy5jJwotLS0gc3JjL3dpbmRvdy5jCTIwMTMt MDYtMDQgMTY6MzM6NDYgKzAwMDAKKysrIHNyYy93aW5kb3cuYwkyMDEzLTA2LTEzIDE2OjAy OjI0ICswMDAwCkBAIC01NSw3ICs1NSw4IEBACiAKIExpc3BfT2JqZWN0IFF3aW5kb3dwLCBR d2luZG93X2xpdmVfcDsKIHN0YXRpYyBMaXNwX09iamVjdCBRd2luZG93X3ZhbGlkX3A7Ci1z dGF0aWMgTGlzcF9PYmplY3QgUXdpbmRvd19jb25maWd1cmF0aW9uX3AsIFFyZWNvcmRfd2lu ZG93X2J1ZmZlcjsKK3N0YXRpYyBMaXNwX09iamVjdCBRd2luZG93X2NvbmZpZ3VyYXRpb25f cDsKK3N0YXRpYyBMaXNwX09iamVjdCBRcmVjb3JkX3dpbmRvd19idWZmZXI7CiBzdGF0aWMg TGlzcF9PYmplY3QgUXdpbmRvd19kZWxldGFibGVfcCwgUWRlbGV0ZV93aW5kb3csIFFkaXNw bGF5X2J1ZmZlcjsKIHN0YXRpYyBMaXNwX09iamVjdCBRcmVwbGFjZV9idWZmZXJfaW5fd2lu ZG93cywgUWdldF9tcnVfd2luZG93Owogc3RhdGljIExpc3BfT2JqZWN0IFF3aW5kb3dfcmVz aXplX3Jvb3Rfd2luZG93LCBRd2luZG93X3Jlc2l6ZV9yb290X3dpbmRvd192ZXJ0aWNhbGx5 OwpAQCAtMTMwLDYgKzEzMSwxMiBAQAogc3RhdGljIEVNQUNTX0lOVCB3aW5kb3dfc2Nyb2xs X3ByZXNlcnZlX2hwb3M7CiBzdGF0aWMgRU1BQ1NfSU5UIHdpbmRvd19zY3JvbGxfcHJlc2Vy dmVfdnBvczsKIAwKK3N0YXRpYyB2b2lkCitDSEVDS19XSU5ET1dfQ09ORklHVVJBVElPTiAo TGlzcF9PYmplY3QgeCkKK3sKKyAgQ0hFQ0tfVFlQRSAoV0lORE9XX0NPTkZJR1VSQVRJT05Q ICh4KSwgUXdpbmRvd19jb25maWd1cmF0aW9uX3AsIHgpOworfQorCiAvKiBUaGVzZSBzZXR0 ZXJzIGFyZSB1c2VkIG9ubHkgaW4gdGhpcyBmaWxlLCBzbyB0aGV5IGNhbiBiZSBwcml2YXRl LiAgKi8KIHN0YXRpYyB2b2lkCiB3c2V0X2NvbWJpbmF0aW9uX2xpbWl0IChzdHJ1Y3Qgd2lu ZG93ICp3LCBMaXNwX09iamVjdCB2YWwpCgo9PT0gbW9kaWZpZWQgZmlsZSAnc3JjL3dpbmRv dy5oJwotLS0gc3JjL3dpbmRvdy5oCTIwMTMtMDMtMjggMTQ6MDQ6NDkgKzAwMDAKKysrIHNy Yy93aW5kb3cuaAkyMDEzLTA2LTEzIDE1OjM4OjAzICswMDAwCkBAIC05NTgsNyArOTU4LDcg QEAKIAogLyogVGhlc2UgdXNlZCB0byBiZSBpbiBsaXNwLmguICAqLwogCi1leHRlcm4gTGlz cF9PYmplY3QgUXdpbmRvd3AsIFF3aW5kb3dfbGl2ZV9wOworZXh0ZXJuIExpc3BfT2JqZWN0 IFF3aW5kb3dfbGl2ZV9wOwogZXh0ZXJuIExpc3BfT2JqZWN0IFZ3aW5kb3dfbGlzdDsKIAog ZXh0ZXJuIHN0cnVjdCB3aW5kb3cgKmRlY29kZV9saXZlX3dpbmRvdyAoTGlzcF9PYmplY3Qp OwoK --------------070603050203080502010407-- From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 15 10:22:47 2013 Received: (at 11935) by debbugs.gnu.org; 15 Jun 2013 14:22:48 +0000 Received: from localhost ([127.0.0.1]:46541 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UnrNP-0001Wj-IL for submit@debbugs.gnu.org; Sat, 15 Jun 2013 10:22:47 -0400 Received: from ironport2-out.teksavvy.com ([206.248.154.182]:30590) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UnrNN-0001WC-NM for 11935@debbugs.gnu.org; Sat, 15 Jun 2013 10:22:46 -0400 X-IronPort-Anti-Spam-Filtered: true X-IronPort-Anti-Spam-Result: Av4EABK/CFFFpZVy/2dsb2JhbABEDr8AF3OCHgEBBAFWIwULCzQSFBgNJIgeBsEtkQoDpHqBXoI5Wg X-IPAS-Result: Av4EABK/CFFFpZVy/2dsb2JhbABEDr8AF3OCHgEBBAFWIwULCzQSFBgNJIgeBsEtkQoDpHqBXoI5Wg X-IronPort-AV: E=Sophos;i="4.84,565,1355115600"; d="scan'208";a="16458820" Received: from 69-165-149-114.dsl.teksavvy.com (HELO pastel.home) ([69.165.149.114]) by ironport2-out.teksavvy.com with ESMTP/TLS/ADH-AES256-SHA; 15 Jun 2013 10:22:34 -0400 Received: by pastel.home (Postfix, from userid 20848) id 4D0CC62CC8; Sat, 15 Jun 2013 10:22:39 -0400 (EDT) From: Stefan Monnier To: Paul Eggert Subject: Re: bug#11935: XINT etc. should be functions Message-ID: References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <51B42B07.5090209@cs.ucla.edu> <51B9DAFC.3010502@cs.ucla.edu> <51BC0D12.4060807@cs.ucla.edu> Date: Sat, 15 Jun 2013 10:22:39 -0400 In-Reply-To: <51BC0D12.4060807@cs.ucla.edu> (Paul Eggert's message of "Fri, 14 Jun 2013 23:43:30 -0700") User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3.50 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-Spam-Score: 0.3 (/) X-Debbugs-Envelope-To: 11935 Cc: 11935@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: 0.3 (/) > The following variant works for me, and the attached combined > patch implements this suggestion. Looks OK to me, thank you, Stefan From debbugs-submit-bounces@debbugs.gnu.org Mon Jun 17 02:05:28 2013 Received: (at 11935-done) by debbugs.gnu.org; 17 Jun 2013 06:05:28 +0000 Received: from localhost ([127.0.0.1]:49573 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UoSZD-0002XO-I6 for submit@debbugs.gnu.org; Mon, 17 Jun 2013 02:05:27 -0400 Received: from smtp.cs.ucla.edu ([131.179.128.62]:32889) by debbugs.gnu.org with esmtp (Exim 4.80) (envelope-from ) id 1UoSZB-0002Wx-8g for 11935-done@debbugs.gnu.org; Mon, 17 Jun 2013 02:05:26 -0400 Received: from localhost (localhost.localdomain [127.0.0.1]) by smtp.cs.ucla.edu (Postfix) with ESMTP id 57FE639E8108; Sun, 16 Jun 2013 23:05:19 -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 BajaJezXC9yY; Sun, 16 Jun 2013 23:05:19 -0700 (PDT) Received: from [192.168.1.9] (pool-71-108-49-126.lsanca.fios.verizon.net [71.108.49.126]) by smtp.cs.ucla.edu (Postfix) with ESMTPSA id 0B01339E8100; Sun, 16 Jun 2013 23:05:19 -0700 (PDT) Message-ID: <51BEA71E.9040802@cs.ucla.edu> Date: Sun, 16 Jun 2013 23:05:18 -0700 From: Paul Eggert Organization: UCLA Computer Science Department User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130510 Thunderbird/17.0.6 MIME-Version: 1.0 To: Stefan Monnier Subject: Re: bug#11935: XINT etc. should be functions References: <500039B7.8050106@cs.ucla.edu> <51B0B137.5020705@cs.ucla.edu> <51B3D1B5.8020807@cs.ucla.edu> <51B42B07.5090209@cs.ucla.edu> <51B9DAFC.3010502@cs.ucla.edu> <51BC0D12.4060807@cs.ucla.edu> In-Reply-To: X-Enigmail-Version: 1.5.1 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Score: -3.4 (---) X-Debbugs-Envelope-To: 11935-done Cc: 11935-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.4 (---) On 06/15/2013 07:22 AM, Stefan Monnier wrote: > Looks OK to me, thank you, OK, I installed that as trunk bzr 113012 and am marking this as done. From unknown Fri Aug 08 22:24:15 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, 15 Jul 2013 11:24:05 +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 From debbugs-submit-bounces@debbugs.gnu.org Sat Mar 14 22:45:07 2020 Received: (at control) by debbugs.gnu.org; 15 Mar 2020 02:45:07 +0000 Received: from localhost ([127.0.0.1]:34125 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1jDJH1-0008TT-4m for submit@debbugs.gnu.org; Sat, 14 Mar 2020 22:45:07 -0400 Received: from mail-ed1-f51.google.com ([209.85.208.51]:46646) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1jDJ5x-0008BO-SL for control@debbugs.gnu.org; Sat, 14 Mar 2020 22:33:42 -0400 Received: by mail-ed1-f51.google.com with SMTP id ca19so17371912edb.13 for ; Sat, 14 Mar 2020 19:33:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:from:date:message-id:subject:to; bh=3tECD12b1Y9C/IySoZHwJzBO/QUaW+POiHxH0Tjg71E=; b=GXnelLjUjh06aW4m4N83WIz6rYRPJz9PIGMSQPqCYyARmOjFkosmMLO8Qz1Rart6pS Bpja/LQNHhqWuPxxG9Fez7Eljis3QZH/M8HmhrMKehJMXurohI8wlxjuEDf44WCXnz6y NTWRbDe39USCQcTPl5pzObAEvaAFEnhtaGSVsqQjz/d7qomDCDlS60yF8AwI/vSPsx8a 2Jqux9OlbyXX9R6o7NuXXnMJ9Zub5uMnHuzoglm1PXsEOerYs9RGH7wYFgkR8Zj17Jnw z4kZWQjxHyj4O3R2+NJU2fEOvhd7MYkgrcyptbd02TaDXHgWdUkbz19R23oeFlwT8HXj pDGQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:from:date:message-id:subject:to; bh=3tECD12b1Y9C/IySoZHwJzBO/QUaW+POiHxH0Tjg71E=; b=PZrUn2kkzkj+eMk1IdF7vMDtMkAqYO6V5LE4fPClTye2nLuWz0KqbRCOrLy0HtfGN2 T0Lan00BOz0AaA4hz8FJ0U4SlVkdRS7w+u2YCHuOWACu6aaOKHvexoGZ9uwAqF3fmr9i bpbqc5Zi4rRFU/r9KzzOSa2Fbg4S5We62bfqBwT2OdP2aD0Oeuw16zeIlNhpz7M1E7uX XwHb5jBJo6jKNIB0yxbCLz3t8YkR3NCTLudwAMu+1tKyMzydN1gtyVZdqDVL92J+Or6l wgY8Bw5dyH6fPg06lkuPKxrtifpWV+tpJyimSxjkCFgTtpbidQ1fk2mGMy4xHW8tT9wP TRnA== X-Gm-Message-State: ANhLgQ0+RZwqrOjtLxyblZ5r9revHtjssFX7Iesd+yk0BcGu2KPQNglq 4P7yiSX388FM8EFDSrbVFXN19WasDHZSIUTZ347gciD/ X-Google-Smtp-Source: ADFU+vvbX4l3E6cPpLa3OFniHRWLOl852MJKsJh5cYjm85UL8kwizcZp3Z4XST8tDhLw3sObYPhajQkkkbrZSSYGgNw= X-Received: by 2002:a50:8c03:: with SMTP id p3mr19859753edp.129.1584239615556; Sat, 14 Mar 2020 19:33:35 -0700 (PDT) MIME-Version: 1.0 From: Kyle Brodie Date: Sat, 14 Mar 2020 19:33:24 -0700 Message-ID: Subject: To: control@debbugs.gnu.org Content-Type: multipart/alternative; boundary="000000000000863f2405a0db87e7" X-Spam-Score: 2.0 (++) X-Spam-Report: Spam detection software, running on the system "debbugs.gnu.org", has NOT identified this incoming email as spam. The original message has been attached to this so you can view it or label similar future email. If you have any questions, see the administrator of that system for details. Content preview: unarchive 11935 unarchive 11935 Content analysis details: (2.0 points, 10.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -0.0 SPF_PASS SPF: sender matches SPF record 0.0 SPF_HELO_NONE SPF: HELO does not publish an SPF Record 0.0 FREEMAIL_FROM Sender email is commonly abused enduser mail provider (kylecbrodie[at]gmail.com) 0.0 HTML_MESSAGE BODY: HTML included in message -0.0 RCVD_IN_MSPIKE_H2 RBL: Average reputation (+2) [209.85.208.51 listed in wl.mailspike.net] -0.0 RCVD_IN_DNSWL_NONE RBL: Sender listed at https://www.dnswl.org/, no trust [209.85.208.51 listed in list.dnswl.org] 2.0 BLANK_SUBJECT Subject is present but empty X-Debbugs-Envelope-To: control X-Mailman-Approved-At: Sat, 14 Mar 2020 22:45:06 -0400 X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: 1.0 (+) --000000000000863f2405a0db87e7 Content-Type: text/plain; charset="UTF-8" unarchive 11935 --000000000000863f2405a0db87e7 Content-Type: text/html; charset="UTF-8"
unarchive 11935
--000000000000863f2405a0db87e7-- From unknown Fri Aug 08 22:24:15 2025 Received: (at fakecontrol) by fakecontrolmessage; To: internal_control@debbugs.gnu.org From: Debbugs Internal Request Subject: Internal Control Message-Id: bug archived. Date: Sun, 12 Apr 2020 11:24:05 +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