From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id E49583834E61 for ; Wed, 1 Jun 2022 09:02:37 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org E49583834E61 Received: from mail-oi1-f200.google.com (mail-oi1-f200.google.com [209.85.167.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-542-5OsuE38jNGiqkDhBDkOxrw-1; Wed, 01 Jun 2022 05:02:36 -0400 X-MC-Unique: 5OsuE38jNGiqkDhBDkOxrw-1 Received: by mail-oi1-f200.google.com with SMTP id p83-20020acaf156000000b0032bef7ddf13so753239oih.16 for ; Wed, 01 Jun 2022 02:02:36 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=qJ/QwbwUzL1NESHMj6EYzHYgHcUnBWlOCLkidgXXl0c=; b=j6hLw2yqr5W6EvU1LeDpXshUc6QLcqlXFqx80hhSxiib0ZuzMTdqat0Yvougo2yE0a 2Dai9DNGV9Vc2tN7rfpx9WLq11dDWYdHf4l8yJI8HQcToVgrWr1s6wHkhYDBs77UiVVL Lki9h9462EACDv6jImjw8DVQKYWTDIkd312Zis1F6tHBxIR0D+hU+nsk1F8GeXFqsq8t 2XUpK0pXTj8RjwV/QGdwLwnxdc8PRBXJU3fT27unjakFiFQkQ93EXcyVi6BYg+9FP7Ag UB64XZ6NmuZ88lf4YBJW0r94QbadjvvAnURsO0sES3tw0K1fM+COTLZrf4rVlcdmDM4L 6Jww== X-Gm-Message-State: AOAM530pckKnyBm84FUj0EW4wTMpIUjHFC3hf3kdw0kusq+oHudEHPBJ 6pcz7X8WaSqKA1fSGx7uGrx6dayJB+HxirLpojzmoZNCasco2mpPyFOmHsH0S4/+CL8YIPGqht5 /iizuK2GwAhaNzqpBJVdElKTzZf1SKhnm9A== X-Received: by 2002:a05:6870:4307:b0:f2:3989:e85f with SMTP id w7-20020a056870430700b000f23989e85fmr15941419oah.265.1654074155207; Wed, 01 Jun 2022 02:02:35 -0700 (PDT) X-Google-Smtp-Source: ABdhPJwiCE/TPh/8GYhS6T0aFM/xvBt4a+BclSpdx6p6zyr0diO/PurTdnkayOVPxQot8BWMy91pKVdsV9vL1AFl7rE= X-Received: by 2002:a05:6870:4307:b0:f2:3989:e85f with SMTP id w7-20020a056870430700b000f23989e85fmr15941403oah.265.1654074154835; Wed, 01 Jun 2022 02:02:34 -0700 (PDT) MIME-Version: 1.0 References: <20220530132751.1752112-1-aldyh@redhat.com> <20220530132751.1752112-4-aldyh@redhat.com> In-Reply-To: <20220530132751.1752112-4-aldyh@redhat.com> From: Aldy Hernandez Date: Wed, 1 Jun 2022 11:02:23 +0200 Message-ID: Subject: Re: [PATCH 4/5] Revamp irange_allocator to handle vranges. To: GCC patches X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="0000000000006e912205e05f26bb" X-Spam-Status: No, score=-11.8 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_NONE, TXREP, T_FILL_THIS_FORM_SHORT, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 01 Jun 2022 09:02:42 -0000 --0000000000006e912205e05f26bb Content-Type: text/plain; charset="UTF-8" Final patch committed. Re-tested on x86-64 Linux. On Mon, May 30, 2022 at 3:28 PM Aldy Hernandez wrote: > > This patch revamps the range allocator to handle generic vrange's. > I've cleaned it up somehow to make it obvious the various things you > can allocate with it. I've also moved away from overloads into > distinct names when appropriate. > > The various entry points are now: > > // Allocate a range of TYPE. > vrange *alloc_vrange (tree type); > // Allocate a memory block of BYTES. > void *alloc (unsigned bytes); > // Return a clone of SRC. > template T *clone (const T &src); > > It is now possible to allocate a clone of an irange, or any future > range types: > > irange *i = allocator.clone (some_irange); > frange *f = allocator.clone (some_frange); > > You can actually do so without the <>, but I find it clearer to > specify the vrange type. > > So with it you can allocate a specific range type, or vrange, or a > block of memory. > > I have rewritten the C style casts to C++ casts, since casts tend to > be hints of problematic designs. With the C++ casts you can at least > grep for them easier. Speak of which, the next patch, which converts > ranger to vrange, will further clean this space by removing some > unnecessary casts. > > Tested on x86-64 Linux and ppc64le Linux. > > * gimple-range-cache.cc (sbr_vector::sbr_vector): Adjust for > vrange allocator. > (sbr_vector::grow): Same. > (sbr_vector::set_bb_range): Same. > (sbr_sparse_bitmap::sbr_sparse_bitmap): Same. > (sbr_sparse_bitmap::set_bb_range): Same. > (block_range_cache::~block_range_cache): Same. > (block_range_cache::set_bb_range): Same. > (ssa_global_cache::ssa_global_cache): Same. > (ssa_global_cache::~ssa_global_cache): Same. > (ssa_global_cache::set_global_range): Same. > * gimple-range-cache.h (block_range_cache): Same. > (ssa_global_cache): Same. > * gimple-range-edge.cc > (gimple_outgoing_range::calc_switch_ranges): Same. > * gimple-range-edge.h (gimple_outgoing_range): Same. > * gimple-range-side-effect.cc (side_effect_manager::get_nonzero): > Same. > (side_effect_manager::add_range): Same. > * gimple-range-side-effect.h (class side_effect_manager): Same. > * value-range.h (class irange_allocator): Rename to... > (class vrange_allocator): ...this. > (irange_allocator::irange_allocator): New. > (vrange_allocator::vrange_allocator): New. > (irange_allocator::~irange_allocator): New. > (vrange_allocator::~vrange_allocator): New. > (irange_allocator::get_memory): Rename to... > (vrange_allocator::alloc): ...this. > (vrange_allocator::alloc_vrange): Rename from... > (irange_allocator::allocate): ...this. > (vrange_allocator::alloc_irange): New. > --- > gcc/gimple-range-cache.cc | 55 +++++++++++----------- > gcc/gimple-range-cache.h | 4 +- > gcc/gimple-range-edge.cc | 4 +- > gcc/gimple-range-edge.h | 2 +- > gcc/gimple-range-side-effect.cc | 13 ++++-- > gcc/gimple-range-side-effect.h | 2 +- > gcc/value-range.h | 82 +++++++++++++++++++++------------ > 7 files changed, 96 insertions(+), 66 deletions(-) > > diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc > index c726393b380..9c541993fb6 100644 > --- a/gcc/gimple-range-cache.cc > +++ b/gcc/gimple-range-cache.cc > @@ -75,7 +75,7 @@ ssa_block_ranges::dump (FILE *f) > class sbr_vector : public ssa_block_ranges > { > public: > - sbr_vector (tree t, irange_allocator *allocator); > + sbr_vector (tree t, vrange_allocator *allocator); > > virtual bool set_bb_range (const_basic_block bb, const irange &r) override; > virtual bool get_bb_range (irange &r, const_basic_block bb) override; > @@ -86,20 +86,21 @@ protected: > int_range<2> m_varying; > int_range<2> m_undefined; > tree m_type; > - irange_allocator *m_irange_allocator; > + vrange_allocator *m_range_allocator; > void grow (); > }; > > > // Initialize a block cache for an ssa_name of type T. > > -sbr_vector::sbr_vector (tree t, irange_allocator *allocator) > +sbr_vector::sbr_vector (tree t, vrange_allocator *allocator) > { > gcc_checking_assert (TYPE_P (t)); > m_type = t; > - m_irange_allocator = allocator; > + m_range_allocator = allocator; > m_tab_size = last_basic_block_for_fn (cfun) + 1; > - m_tab = (irange **)allocator->get_memory (m_tab_size * sizeof (irange *)); > + m_tab = static_cast > + (allocator->alloc (m_tab_size * sizeof (irange *))); > memset (m_tab, 0, m_tab_size * sizeof (irange *)); > > // Create the cached type range. > @@ -121,8 +122,8 @@ sbr_vector::grow () > int new_size = inc + curr_bb_size; > > // Allocate new memory, copy the old vector and clear the new space. > - irange **t = (irange **)m_irange_allocator->get_memory (new_size > - * sizeof (irange *)); > + irange **t = static_cast > + (m_range_allocator->alloc (new_size * sizeof (irange *))); > memcpy (t, m_tab, m_tab_size * sizeof (irange *)); > memset (t + m_tab_size, 0, (new_size - m_tab_size) * sizeof (irange *)); > > @@ -143,7 +144,7 @@ sbr_vector::set_bb_range (const_basic_block bb, const irange &r) > else if (r.undefined_p ()) > m = &m_undefined; > else > - m = m_irange_allocator->allocate (r); > + m = m_range_allocator->clone (r); > m_tab[bb->index] = m; > return true; > } > @@ -191,14 +192,14 @@ sbr_vector::bb_range_p (const_basic_block bb) > class sbr_sparse_bitmap : public ssa_block_ranges > { > public: > - sbr_sparse_bitmap (tree t, irange_allocator *allocator, bitmap_obstack *bm); > + sbr_sparse_bitmap (tree t, vrange_allocator *allocator, bitmap_obstack *bm); > virtual bool set_bb_range (const_basic_block bb, const irange &r) override; > virtual bool get_bb_range (irange &r, const_basic_block bb) override; > virtual bool bb_range_p (const_basic_block bb) override; > private: > void bitmap_set_quad (bitmap head, int quad, int quad_value); > int bitmap_get_quad (const_bitmap head, int quad); > - irange_allocator *m_irange_allocator; > + vrange_allocator *m_range_allocator; > irange *m_range[SBR_NUM]; > bitmap_head bitvec; > tree m_type; > @@ -206,23 +207,25 @@ private: > > // Initialize a block cache for an ssa_name of type T. > > -sbr_sparse_bitmap::sbr_sparse_bitmap (tree t, irange_allocator *allocator, > - bitmap_obstack *bm) > +sbr_sparse_bitmap::sbr_sparse_bitmap (tree t, vrange_allocator *allocator, > + bitmap_obstack *bm) > { > gcc_checking_assert (TYPE_P (t)); > m_type = t; > bitmap_initialize (&bitvec, bm); > bitmap_tree_view (&bitvec); > - m_irange_allocator = allocator; > + m_range_allocator = allocator; > // Pre-cache varying. > - m_range[0] = m_irange_allocator->allocate (2); > + m_range[0] = static_cast (m_range_allocator->alloc_vrange (t)); > m_range[0]->set_varying (t); > // Pre-cache zero and non-zero values for pointers. > if (POINTER_TYPE_P (t)) > { > - m_range[1] = m_irange_allocator->allocate (2); > + m_range[1] > + = static_cast (m_range_allocator->alloc_vrange (t)); > m_range[1]->set_nonzero (t); > - m_range[2] = m_irange_allocator->allocate (2); > + m_range[2] > + = static_cast (m_range_allocator->alloc_vrange (t)); > m_range[2]->set_zero (t); > } > else > @@ -267,7 +270,7 @@ sbr_sparse_bitmap::set_bb_range (const_basic_block bb, const irange &r) > if (!m_range[x] || r == *(m_range[x])) > { > if (!m_range[x]) > - m_range[x] = m_irange_allocator->allocate (r); > + m_range[x] = m_range_allocator->clone (r); > bitmap_set_quad (&bitvec, bb->index, x + 1); > return true; > } > @@ -312,14 +315,14 @@ block_range_cache::block_range_cache () > bitmap_obstack_initialize (&m_bitmaps); > m_ssa_ranges.create (0); > m_ssa_ranges.safe_grow_cleared (num_ssa_names); > - m_irange_allocator = new irange_allocator; > + m_range_allocator = new vrange_allocator; > } > > // Remove any m_block_caches which have been created. > > block_range_cache::~block_range_cache () > { > - delete m_irange_allocator; > + delete m_range_allocator; > // Release the vector itself. > m_ssa_ranges.release (); > bitmap_obstack_release (&m_bitmaps); > @@ -341,17 +344,17 @@ block_range_cache::set_bb_range (tree name, const_basic_block bb, > // Use sparse representation if there are too many basic blocks. > if (last_basic_block_for_fn (cfun) > param_evrp_sparse_threshold) > { > - void *r = m_irange_allocator->get_memory (sizeof (sbr_sparse_bitmap)); > + void *r = m_range_allocator->alloc (sizeof (sbr_sparse_bitmap)); > m_ssa_ranges[v] = new (r) sbr_sparse_bitmap (TREE_TYPE (name), > - m_irange_allocator, > + m_range_allocator, > &m_bitmaps); > } > else > { > // Otherwise use the default vector implemntation. > - void *r = m_irange_allocator->get_memory (sizeof (sbr_vector)); > + void *r = m_range_allocator->alloc (sizeof (sbr_vector)); > m_ssa_ranges[v] = new (r) sbr_vector (TREE_TYPE (name), > - m_irange_allocator); > + m_range_allocator); > } > } > return m_ssa_ranges[v]->set_bb_range (bb, r); > @@ -467,7 +470,7 @@ block_range_cache::dump (FILE *f, basic_block bb, bool print_varying) > ssa_global_cache::ssa_global_cache () > { > m_tab.create (0); > - m_irange_allocator = new irange_allocator; > + m_range_allocator = new vrange_allocator; > } > > // Deconstruct a global cache. > @@ -475,7 +478,7 @@ ssa_global_cache::ssa_global_cache () > ssa_global_cache::~ssa_global_cache () > { > m_tab.release (); > - delete m_irange_allocator; > + delete m_range_allocator; > } > > // Retrieve the global range of NAME from cache memory if it exists. > @@ -509,7 +512,7 @@ ssa_global_cache::set_global_range (tree name, const irange &r) > if (m && m->fits_p (r)) > *m = r; > else > - m_tab[v] = m_irange_allocator->allocate (r); > + m_tab[v] = m_range_allocator->clone (r); > return m != NULL; > } > > diff --git a/gcc/gimple-range-cache.h b/gcc/gimple-range-cache.h > index 555fe32513f..2472cd04f47 100644 > --- a/gcc/gimple-range-cache.h > +++ b/gcc/gimple-range-cache.h > @@ -44,7 +44,7 @@ private: > vec m_ssa_ranges; > ssa_block_ranges &get_block_ranges (tree name); > ssa_block_ranges *query_block_ranges (tree name); > - irange_allocator *m_irange_allocator; > + vrange_allocator *m_range_allocator; > bitmap_obstack m_bitmaps; > }; > > @@ -64,7 +64,7 @@ public: > void dump (FILE *f = stderr); > private: > vec m_tab; > - class irange_allocator *m_irange_allocator; > + vrange_allocator *m_range_allocator; > }; > > // This class provides all the caches a global ranger may need, and makes > diff --git a/gcc/gimple-range-edge.cc b/gcc/gimple-range-edge.cc > index 5bbe23ae03d..5264e627c9a 100644 > --- a/gcc/gimple-range-edge.cc > +++ b/gcc/gimple-range-edge.cc > @@ -166,13 +166,13 @@ gimple_outgoing_range::calc_switch_ranges (gswitch *sw) > // If there was an existing range and it doesn't fit, we lose the memory. > // It'll get reclaimed when the obstack is freed. This seems less > // intrusive than allocating max ranges for each case. > - slot = m_range_allocator.allocate (case_range); > + slot = m_range_allocator.clone (case_range); > } > > irange *&slot = m_edge_table->get_or_insert (default_edge, &existed); > // This should be the first call into this switch. > gcc_checking_assert (!existed); > - irange *dr = m_range_allocator.allocate (default_range); > + irange *dr = m_range_allocator.clone (default_range); > slot = dr; > } > > diff --git a/gcc/gimple-range-edge.h b/gcc/gimple-range-edge.h > index c131b3309cc..ce383b0aa6f 100644 > --- a/gcc/gimple-range-edge.h > +++ b/gcc/gimple-range-edge.h > @@ -47,7 +47,7 @@ private: > > int m_max_edges; > hash_map *m_edge_table; > - irange_allocator m_range_allocator; > + vrange_allocator m_range_allocator; > }; > > // If there is a range control statement at the end of block BB, return it. > diff --git a/gcc/gimple-range-side-effect.cc b/gcc/gimple-range-side-effect.cc > index 2c8c77dc569..8d2ac35bc8d 100644 > --- a/gcc/gimple-range-side-effect.cc > +++ b/gcc/gimple-range-side-effect.cc > @@ -189,8 +189,10 @@ side_effect_manager::get_nonzero (tree name) > m_nonzero.safe_grow_cleared (num_ssa_names + 20); > if (!m_nonzero[v]) > { > - m_nonzero[v] = m_range_allocator.allocate (2); > - m_nonzero[v]->set_nonzero (TREE_TYPE (name)); > + tree type = TREE_TYPE (name); > + m_nonzero[v] > + = static_cast (m_range_allocator.alloc_vrange (type)); > + m_nonzero[v]->set_nonzero (type); > } > return *(m_nonzero[v]); > } > @@ -259,14 +261,17 @@ side_effect_manager::add_range (tree name, basic_block bb, const irange &r) > if (ptr->range->fits_p (cur)) > *(ptr->range) = cur; > else > - ptr->range = m_range_allocator.allocate (cur); > + { > + vrange &v = cur; > + ptr->range = static_cast (m_range_allocator.clone (v)); > + } > return; > } > > // Otherwise create a record. > bitmap_set_bit (m_on_exit[bb->index].m_names, SSA_NAME_VERSION (name)); > ptr = (exit_range *)obstack_alloc (&m_list_obstack, sizeof (exit_range)); > - ptr->range = m_range_allocator.allocate (r); > + ptr->range = m_range_allocator.clone (r); > ptr->name = name; > ptr->next = m_on_exit[bb->index].head; > m_on_exit[bb->index].head = ptr; > diff --git a/gcc/gimple-range-side-effect.h b/gcc/gimple-range-side-effect.h > index 848d94ba6d7..d76d6eb34f2 100644 > --- a/gcc/gimple-range-side-effect.h > +++ b/gcc/gimple-range-side-effect.h > @@ -76,7 +76,7 @@ private: > bitmap m_seen; > bitmap_obstack m_bitmaps; > struct obstack m_list_obstack; > - irange_allocator m_range_allocator; > + vrange_allocator m_range_allocator; > }; > > #endif // GCC_GIMPLE_RANGE_SIDE_H > diff --git a/gcc/value-range.h b/gcc/value-range.h > index d51998145da..a5da53f595e 100644 > --- a/gcc/value-range.h > +++ b/gcc/value-range.h > @@ -92,7 +92,7 @@ protected: > > class GTY((user)) irange : public vrange > { > - friend class irange_allocator; > + friend class vrange_allocator; > public: > // In-place setters. > virtual void set (tree, tree, value_range_kind = VR_RANGE) override; > @@ -892,56 +892,63 @@ vrp_val_min (const_tree type) > return NULL_TREE; > } > > -// This is the irange storage class. It is used to allocate the > -// minimum amount of storage needed for a given irange. Storage is > -// automatically freed at destruction of the storage class. > -// > -// It is meant for long term storage, as opposed to int_range_max > -// which is meant for intermediate temporary results on the stack. > -// > -// The newly allocated irange is initialized to the empty set > -// (undefined_p() is true). > +// This is the range storage class. It is used to allocate the > +// minimum amount of storage needed for a given range. Storage is > +// automatically freed at destruction of the class. > > -class irange_allocator > +class vrange_allocator > { > public: > - irange_allocator (); > - ~irange_allocator (); > - // Return a new range with NUM_PAIRS. > - irange *allocate (unsigned num_pairs); > - // Return a copy of SRC with the minimum amount of sub-ranges needed > - // to represent it. > - irange *allocate (const irange &src); > - void *get_memory (unsigned num_bytes); > + vrange_allocator (); > + ~vrange_allocator (); > + // Allocate a range of TYPE. > + vrange *alloc_vrange (tree type); > + // Allocate a memory block of BYTES. > + void *alloc (unsigned bytes); > + // Return a clone of SRC. > + template T *clone (const T &src); > private: > - DISABLE_COPY_AND_ASSIGN (irange_allocator); > + irange *alloc_irange (unsigned pairs); > + DISABLE_COPY_AND_ASSIGN (vrange_allocator); > struct obstack m_obstack; > }; > > inline > -irange_allocator::irange_allocator () > +vrange_allocator::vrange_allocator () > { > obstack_init (&m_obstack); > } > > inline > -irange_allocator::~irange_allocator () > +vrange_allocator::~vrange_allocator () > { > obstack_free (&m_obstack, NULL); > } > > // Provide a hunk of memory from the obstack. > + > inline void * > -irange_allocator::get_memory (unsigned num_bytes) > +vrange_allocator::alloc (unsigned bytes) > { > - void *r = obstack_alloc (&m_obstack, num_bytes); > - return r; > + return obstack_alloc (&m_obstack, bytes); > +} > + > +// Return a new range to hold ranges of TYPE. The newly allocated > +// range is initialized to VR_UNDEFINED. > + > +inline vrange * > +vrange_allocator::alloc_vrange (tree type) > +{ > + if (irange::supports_type_p (type)) > + return alloc_irange (2); > + > + gcc_unreachable (); > } > > // Return a new range with NUM_PAIRS. > > inline irange * > -irange_allocator::allocate (unsigned num_pairs) > +vrange_allocator::alloc_irange (unsigned num_pairs) > { > // Never allocate 0 pairs. > // Don't allocate 1 either, or we get legacy value_range's. > @@ -951,17 +958,32 @@ irange_allocator::allocate (unsigned num_pairs) > size_t nbytes = sizeof (tree) * 2 * num_pairs; > > // Allocate the irange and required memory for the vector. > - void *r = obstack_alloc (&m_obstack, sizeof (irange)); > - tree *mem = (tree *) obstack_alloc (&m_obstack, nbytes); > + void *r = alloc (sizeof (irange)); > + tree *mem = static_cast (alloc (nbytes)); > return new (r) irange (mem, num_pairs); > } > > +// Return a clone of an irange. > + > +template <> > inline irange * > -irange_allocator::allocate (const irange &src) > +vrange_allocator::clone (const irange &src) > { > - irange *r = allocate (src.num_pairs ()); > + irange *r = alloc_irange (src.num_pairs ()); > *r = src; > return r; > } > > +// Return a clone of a vrange. > + > +template <> > +inline vrange * > +vrange_allocator::clone (const vrange &src) > +{ > + if (is_a (src)) > + return clone (as_a (src)); > + > + gcc_unreachable (); > +} > + > #endif // GCC_VALUE_RANGE_H > -- > 2.36.1 > --0000000000006e912205e05f26bb Content-Type: text/x-patch; charset="US-ASCII"; name="0004-Revamp-irange_allocator-to-handle-vranges.patch" Content-Disposition: attachment; filename="0004-Revamp-irange_allocator-to-handle-vranges.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_l3vd1a230 RnJvbSBmMWMyZWQ2OGJmMWFmNDNiYjgzNmI5MWZhN2E1ZjEzYjBjY2Q4MDA2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbGR5IEhlcm5hbmRleiA8YWxkeWhAcmVkaGF0LmNvbT4KRGF0 ZTogU3VuLCAyMiBNYXkgMjAyMiAyMDoxNzozOSArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIFJldmFt cCBpcmFuZ2VfYWxsb2NhdG9yIHRvIGhhbmRsZSB2cmFuZ2VzLgoKVGhpcyBwYXRjaCByZXZhbXBz IHRoZSByYW5nZSBhbGxvY2F0b3IgdG8gaGFuZGxlIGdlbmVyaWMgdnJhbmdlJ3MuCkkndmUgY2xl YW5lZCBpdCB1cCBzb21laG93IHRvIG1ha2UgaXQgb2J2aW91cyB0aGUgdmFyaW91cyB0aGluZ3Mg eW91CmNhbiBhbGxvY2F0ZSB3aXRoIGl0LiAgSSd2ZSBhbHNvIG1vdmVkIGF3YXkgZnJvbSBvdmVy bG9hZHMgaW50bwpkaXN0aW5jdCBuYW1lcyB3aGVuIGFwcHJvcHJpYXRlLgoKVGhlIHZhcmlvdXMg ZW50cnkgcG9pbnRzIGFyZSBub3c6CgogIC8vIEFsbG9jYXRlIGEgcmFuZ2Ugb2YgVFlQRS4KICB2 cmFuZ2UgKmFsbG9jX3ZyYW5nZSAodHJlZSB0eXBlKTsKICAvLyBBbGxvY2F0ZSBhIG1lbW9yeSBi bG9jayBvZiBCWVRFUy4KICB2b2lkICphbGxvYyAodW5zaWduZWQgYnl0ZXMpOwogIC8vIFJldHVy biBhIGNsb25lIG9mIFNSQy4KICB0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4gVCAqY2xvbmUgKGNvbnN0 IFQgJnNyYyk7CgpJdCBpcyBub3cgcG9zc2libGUgdG8gYWxsb2NhdGUgYSBjbG9uZSBvZiBhbiBp cmFuZ2UsIG9yIGFueSBmdXR1cmUKcmFuZ2UgdHlwZXM6CgogICAgICBpcmFuZ2UgKmkgPSBhbGxv Y2F0b3IuY2xvbmUgPGlyYW5nZT4gKHNvbWVfaXJhbmdlKTsKICAgICAgZnJhbmdlICpmID0gYWxs b2NhdG9yLmNsb25lIDxmcmFuZ2U+IChzb21lX2ZyYW5nZSk7CgpZb3UgY2FuIGFjdHVhbGx5IGRv IHNvIHdpdGhvdXQgdGhlIDw+LCBidXQgSSBmaW5kIGl0IGNsZWFyZXIgdG8Kc3BlY2lmeSB0aGUg dnJhbmdlIHR5cGUuCgpTbyB3aXRoIGl0IHlvdSBjYW4gYWxsb2NhdGUgYSBzcGVjaWZpYyByYW5n ZSB0eXBlLCBvciB2cmFuZ2UsIG9yIGEKYmxvY2sgb2YgbWVtb3J5LgoKSSBoYXZlIHJld3JpdHRl biB0aGUgQyBzdHlsZSBjYXN0cyB0byBDKysgY2FzdHMsIHNpbmNlIGNhc3RzIHRlbmQgdG8KYmUg aGludHMgb2YgcHJvYmxlbWF0aWMgZGVzaWducy4gIFdpdGggdGhlIEMrKyBjYXN0cyB5b3UgY2Fu IGF0IGxlYXN0CmdyZXAgZm9yIHRoZW0gZWFzaWVyLiAgU3BlYWsgb2Ygd2hpY2gsIHRoZSBuZXh0 IHBhdGNoLCB3aGljaCBjb252ZXJ0cwpyYW5nZXIgdG8gdnJhbmdlLCB3aWxsIGZ1cnRoZXIgY2xl YW4gdGhpcyBzcGFjZSBieSByZW1vdmluZyBzb21lCnVubmVjZXNzYXJ5IGNhc3RzLgoKVGVzdGVk IG9uIHg4Ni02NCBMaW51eCBhbmQgcHBjNjRsZSBMaW51eC4KCgkqIGdpbXBsZS1yYW5nZS1jYWNo ZS5jYyAoc2JyX3ZlY3Rvcjo6c2JyX3ZlY3Rvcik6IEFkanVzdCBmb3IKCXZyYW5nZSBhbGxvY2F0 b3IuCgkoc2JyX3ZlY3Rvcjo6Z3Jvdyk6IFNhbWUuCgkoc2JyX3ZlY3Rvcjo6c2V0X2JiX3Jhbmdl KTogU2FtZS4KCShzYnJfc3BhcnNlX2JpdG1hcDo6c2JyX3NwYXJzZV9iaXRtYXApOiBTYW1lLgoJ KHNicl9zcGFyc2VfYml0bWFwOjpzZXRfYmJfcmFuZ2UpOiBTYW1lLgoJKGJsb2NrX3JhbmdlX2Nh Y2hlOjp+YmxvY2tfcmFuZ2VfY2FjaGUpOiBTYW1lLgoJKGJsb2NrX3JhbmdlX2NhY2hlOjpzZXRf YmJfcmFuZ2UpOiBTYW1lLgoJKHNzYV9nbG9iYWxfY2FjaGU6OnNzYV9nbG9iYWxfY2FjaGUpOiBT YW1lLgoJKHNzYV9nbG9iYWxfY2FjaGU6On5zc2FfZ2xvYmFsX2NhY2hlKTogU2FtZS4KCShzc2Ff Z2xvYmFsX2NhY2hlOjpzZXRfZ2xvYmFsX3JhbmdlKTogU2FtZS4KCSogZ2ltcGxlLXJhbmdlLWNh Y2hlLmggKGJsb2NrX3JhbmdlX2NhY2hlKTogU2FtZS4KCShzc2FfZ2xvYmFsX2NhY2hlKTogU2Ft ZS4KCSogZ2ltcGxlLXJhbmdlLWVkZ2UuY2MKCShnaW1wbGVfb3V0Z29pbmdfcmFuZ2U6OmNhbGNf c3dpdGNoX3Jhbmdlcyk6IFNhbWUuCgkqIGdpbXBsZS1yYW5nZS1lZGdlLmggKGdpbXBsZV9vdXRn b2luZ19yYW5nZSk6IFNhbWUuCgkqIGdpbXBsZS1yYW5nZS1zaWRlLWVmZmVjdC5jYyAoc2lkZV9l ZmZlY3RfbWFuYWdlcjo6Z2V0X25vbnplcm8pOgoJU2FtZS4KCShzaWRlX2VmZmVjdF9tYW5hZ2Vy OjphZGRfcmFuZ2UpOiBTYW1lLgoJKiBnaW1wbGUtcmFuZ2Utc2lkZS1lZmZlY3QuaCAoY2xhc3Mg c2lkZV9lZmZlY3RfbWFuYWdlcik6IFNhbWUuCgkqIHZhbHVlLXJhbmdlLmggKGNsYXNzIGlyYW5n ZV9hbGxvY2F0b3IpOiBSZW5hbWUgdG8uLi4KCShjbGFzcyB2cmFuZ2VfYWxsb2NhdG9yKTogLi4u dGhpcy4KCShpcmFuZ2VfYWxsb2NhdG9yOjppcmFuZ2VfYWxsb2NhdG9yKTogTmV3LgoJKHZyYW5n ZV9hbGxvY2F0b3I6OnZyYW5nZV9hbGxvY2F0b3IpOiBOZXcuCgkoaXJhbmdlX2FsbG9jYXRvcjo6 fmlyYW5nZV9hbGxvY2F0b3IpOiBOZXcuCgkodnJhbmdlX2FsbG9jYXRvcjo6fnZyYW5nZV9hbGxv Y2F0b3IpOiBOZXcuCgkoaXJhbmdlX2FsbG9jYXRvcjo6Z2V0X21lbW9yeSk6IFJlbmFtZSB0by4u LgoJKHZyYW5nZV9hbGxvY2F0b3I6OmFsbG9jKTogLi4udGhpcy4KCSh2cmFuZ2VfYWxsb2NhdG9y OjphbGxvY192cmFuZ2UpOiBSZW5hbWUgZnJvbS4uLgoJKGlyYW5nZV9hbGxvY2F0b3I6OmFsbG9j YXRlKTogLi4udGhpcy4KCSh2cmFuZ2VfYWxsb2NhdG9yOjphbGxvY19pcmFuZ2UpOiBOZXcuCi0t LQogZ2NjL2dpbXBsZS1yYW5nZS1jYWNoZS5jYyB8IDU1ICsrKysrKysrKysrKystLS0tLS0tLS0t LS0tCiBnY2MvZ2ltcGxlLXJhbmdlLWNhY2hlLmggIHwgIDQgKy0KIGdjYy9naW1wbGUtcmFuZ2Ut ZWRnZS5jYyAgfCAgNCArLQogZ2NjL2dpbXBsZS1yYW5nZS1lZGdlLmggICB8ICAyICstCiBnY2Mv Z2ltcGxlLXJhbmdlLWluZmVyLmNjIHwgMTMgKysrKystLQogZ2NjL2dpbXBsZS1yYW5nZS1pbmZl ci5oICB8ICAyICstCiBnY2MvdmFsdWUtcmFuZ2UuaCAgICAgICAgIHwgODIgKysrKysrKysrKysr KysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tCiA3IGZpbGVzIGNoYW5nZWQsIDk2IGluc2VydGlv bnMoKyksIDY2IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2djYy9naW1wbGUtcmFuZ2UtY2Fj aGUuY2MgYi9nY2MvZ2ltcGxlLXJhbmdlLWNhY2hlLmNjCmluZGV4IDZlNzNhYzcwNmFjLi4yNWFk ZTEzMDBhZiAxMDA2NDQKLS0tIGEvZ2NjL2dpbXBsZS1yYW5nZS1jYWNoZS5jYworKysgYi9nY2Mv Z2ltcGxlLXJhbmdlLWNhY2hlLmNjCkBAIC03NSw3ICs3NSw3IEBAIHNzYV9ibG9ja19yYW5nZXM6 OmR1bXAgKEZJTEUgKmYpCiBjbGFzcyBzYnJfdmVjdG9yIDogcHVibGljIHNzYV9ibG9ja19yYW5n ZXMKIHsKIHB1YmxpYzoKLSAgc2JyX3ZlY3RvciAodHJlZSB0LCBpcmFuZ2VfYWxsb2NhdG9yICph bGxvY2F0b3IpOworICBzYnJfdmVjdG9yICh0cmVlIHQsIHZyYW5nZV9hbGxvY2F0b3IgKmFsbG9j YXRvcik7CiAKICAgdmlydHVhbCBib29sIHNldF9iYl9yYW5nZSAoY29uc3RfYmFzaWNfYmxvY2sg YmIsIGNvbnN0IGlyYW5nZSAmcikgb3ZlcnJpZGU7CiAgIHZpcnR1YWwgYm9vbCBnZXRfYmJfcmFu Z2UgKGlyYW5nZSAmciwgY29uc3RfYmFzaWNfYmxvY2sgYmIpIG92ZXJyaWRlOwpAQCAtODYsMjAg Kzg2LDIxIEBAIHByb3RlY3RlZDoKICAgaW50X3JhbmdlPDI+IG1fdmFyeWluZzsKICAgaW50X3Jh bmdlPDI+IG1fdW5kZWZpbmVkOwogICB0cmVlIG1fdHlwZTsKLSAgaXJhbmdlX2FsbG9jYXRvciAq bV9pcmFuZ2VfYWxsb2NhdG9yOworICB2cmFuZ2VfYWxsb2NhdG9yICptX3JhbmdlX2FsbG9jYXRv cjsKICAgdm9pZCBncm93ICgpOwogfTsKIAogCiAvLyBJbml0aWFsaXplIGEgYmxvY2sgY2FjaGUg Zm9yIGFuIHNzYV9uYW1lIG9mIHR5cGUgVC4KIAotc2JyX3ZlY3Rvcjo6c2JyX3ZlY3RvciAodHJl ZSB0LCBpcmFuZ2VfYWxsb2NhdG9yICphbGxvY2F0b3IpCitzYnJfdmVjdG9yOjpzYnJfdmVjdG9y ICh0cmVlIHQsIHZyYW5nZV9hbGxvY2F0b3IgKmFsbG9jYXRvcikKIHsKICAgZ2NjX2NoZWNraW5n X2Fzc2VydCAoVFlQRV9QICh0KSk7CiAgIG1fdHlwZSA9IHQ7Ci0gIG1faXJhbmdlX2FsbG9jYXRv ciA9IGFsbG9jYXRvcjsKKyAgbV9yYW5nZV9hbGxvY2F0b3IgPSBhbGxvY2F0b3I7CiAgIG1fdGFi X3NpemUgPSBsYXN0X2Jhc2ljX2Jsb2NrX2Zvcl9mbiAoY2Z1bikgKyAxOwotICBtX3RhYiA9IChp cmFuZ2UgKiopYWxsb2NhdG9yLT5nZXRfbWVtb3J5IChtX3RhYl9zaXplICogc2l6ZW9mIChpcmFu Z2UgKikpOworICBtX3RhYiA9IHN0YXRpY19jYXN0IDxpcmFuZ2UgKio+CisgICAgKGFsbG9jYXRv ci0+YWxsb2MgKG1fdGFiX3NpemUgKiBzaXplb2YgKGlyYW5nZSAqKSkpOwogICBtZW1zZXQgKG1f dGFiLCAwLCBtX3RhYl9zaXplICogc2l6ZW9mIChpcmFuZ2UgKikpOwogCiAgIC8vIENyZWF0ZSB0 aGUgY2FjaGVkIHR5cGUgcmFuZ2UuCkBAIC0xMjEsOCArMTIyLDggQEAgc2JyX3ZlY3Rvcjo6Z3Jv dyAoKQogICBpbnQgbmV3X3NpemUgPSBpbmMgKyBjdXJyX2JiX3NpemU7CiAKICAgLy8gQWxsb2Nh dGUgbmV3IG1lbW9yeSwgY29weSB0aGUgb2xkIHZlY3RvciBhbmQgY2xlYXIgdGhlIG5ldyBzcGFj ZS4KLSAgaXJhbmdlICoqdCA9IChpcmFuZ2UgKiopbV9pcmFuZ2VfYWxsb2NhdG9yLT5nZXRfbWVt b3J5IChuZXdfc2l6ZQotCQkJCQkJCSAgKiBzaXplb2YgKGlyYW5nZSAqKSk7CisgIGlyYW5nZSAq KnQgPSBzdGF0aWNfY2FzdCA8aXJhbmdlICoqPgorICAgIChtX3JhbmdlX2FsbG9jYXRvci0+YWxs b2MgKG5ld19zaXplICogc2l6ZW9mIChpcmFuZ2UgKikpKTsKICAgbWVtY3B5ICh0LCBtX3RhYiwg bV90YWJfc2l6ZSAqIHNpemVvZiAoaXJhbmdlICopKTsKICAgbWVtc2V0ICh0ICsgbV90YWJfc2l6 ZSwgMCwgKG5ld19zaXplIC0gbV90YWJfc2l6ZSkgKiBzaXplb2YgKGlyYW5nZSAqKSk7CiAKQEAg LTE0Myw3ICsxNDQsNyBAQCBzYnJfdmVjdG9yOjpzZXRfYmJfcmFuZ2UgKGNvbnN0X2Jhc2ljX2Js b2NrIGJiLCBjb25zdCBpcmFuZ2UgJnIpCiAgIGVsc2UgaWYgKHIudW5kZWZpbmVkX3AgKCkpCiAg ICAgbSA9ICZtX3VuZGVmaW5lZDsKICAgZWxzZQotICAgIG0gPSBtX2lyYW5nZV9hbGxvY2F0b3It PmFsbG9jYXRlIChyKTsKKyAgICBtID0gbV9yYW5nZV9hbGxvY2F0b3ItPmNsb25lIChyKTsKICAg bV90YWJbYmItPmluZGV4XSA9IG07CiAgIHJldHVybiB0cnVlOwogfQpAQCAtMTkxLDE0ICsxOTIs MTQgQEAgc2JyX3ZlY3Rvcjo6YmJfcmFuZ2VfcCAoY29uc3RfYmFzaWNfYmxvY2sgYmIpCiBjbGFz cyBzYnJfc3BhcnNlX2JpdG1hcCA6IHB1YmxpYyBzc2FfYmxvY2tfcmFuZ2VzCiB7CiBwdWJsaWM6 Ci0gIHNicl9zcGFyc2VfYml0bWFwICh0cmVlIHQsIGlyYW5nZV9hbGxvY2F0b3IgKmFsbG9jYXRv ciwgYml0bWFwX29ic3RhY2sgKmJtKTsKKyAgc2JyX3NwYXJzZV9iaXRtYXAgKHRyZWUgdCwgdnJh bmdlX2FsbG9jYXRvciAqYWxsb2NhdG9yLCBiaXRtYXBfb2JzdGFjayAqYm0pOwogICB2aXJ0dWFs IGJvb2wgc2V0X2JiX3JhbmdlIChjb25zdF9iYXNpY19ibG9jayBiYiwgY29uc3QgaXJhbmdlICZy KSBvdmVycmlkZTsKICAgdmlydHVhbCBib29sIGdldF9iYl9yYW5nZSAoaXJhbmdlICZyLCBjb25z dF9iYXNpY19ibG9jayBiYikgb3ZlcnJpZGU7CiAgIHZpcnR1YWwgYm9vbCBiYl9yYW5nZV9wIChj b25zdF9iYXNpY19ibG9jayBiYikgb3ZlcnJpZGU7CiBwcml2YXRlOgogICB2b2lkIGJpdG1hcF9z ZXRfcXVhZCAoYml0bWFwIGhlYWQsIGludCBxdWFkLCBpbnQgcXVhZF92YWx1ZSk7CiAgIGludCBi aXRtYXBfZ2V0X3F1YWQgKGNvbnN0X2JpdG1hcCBoZWFkLCBpbnQgcXVhZCk7Ci0gIGlyYW5nZV9h bGxvY2F0b3IgKm1faXJhbmdlX2FsbG9jYXRvcjsKKyAgdnJhbmdlX2FsbG9jYXRvciAqbV9yYW5n ZV9hbGxvY2F0b3I7CiAgIGlyYW5nZSAqbV9yYW5nZVtTQlJfTlVNXTsKICAgYml0bWFwX2hlYWQg Yml0dmVjOwogICB0cmVlIG1fdHlwZTsKQEAgLTIwNiwyMyArMjA3LDI1IEBAIHByaXZhdGU6CiAK IC8vIEluaXRpYWxpemUgYSBibG9jayBjYWNoZSBmb3IgYW4gc3NhX25hbWUgb2YgdHlwZSBULgog Ci1zYnJfc3BhcnNlX2JpdG1hcDo6c2JyX3NwYXJzZV9iaXRtYXAgKHRyZWUgdCwgaXJhbmdlX2Fs bG9jYXRvciAqYWxsb2NhdG9yLAotCQkJCWJpdG1hcF9vYnN0YWNrICpibSkKK3Nicl9zcGFyc2Vf Yml0bWFwOjpzYnJfc3BhcnNlX2JpdG1hcCAodHJlZSB0LCB2cmFuZ2VfYWxsb2NhdG9yICphbGxv Y2F0b3IsCisJCQkJICAgICAgYml0bWFwX29ic3RhY2sgKmJtKQogewogICBnY2NfY2hlY2tpbmdf YXNzZXJ0IChUWVBFX1AgKHQpKTsKICAgbV90eXBlID0gdDsKICAgYml0bWFwX2luaXRpYWxpemUg KCZiaXR2ZWMsIGJtKTsKICAgYml0bWFwX3RyZWVfdmlldyAoJmJpdHZlYyk7Ci0gIG1faXJhbmdl X2FsbG9jYXRvciA9IGFsbG9jYXRvcjsKKyAgbV9yYW5nZV9hbGxvY2F0b3IgPSBhbGxvY2F0b3I7 CiAgIC8vIFByZS1jYWNoZSB2YXJ5aW5nLgotICBtX3JhbmdlWzBdID0gbV9pcmFuZ2VfYWxsb2Nh dG9yLT5hbGxvY2F0ZSAoMik7CisgIG1fcmFuZ2VbMF0gPSBzdGF0aWNfY2FzdCA8aXJhbmdlICo+ IChtX3JhbmdlX2FsbG9jYXRvci0+YWxsb2NfdnJhbmdlICh0KSk7CiAgIG1fcmFuZ2VbMF0tPnNl dF92YXJ5aW5nICh0KTsKICAgLy8gUHJlLWNhY2hlIHplcm8gYW5kIG5vbi16ZXJvIHZhbHVlcyBm b3IgcG9pbnRlcnMuCiAgIGlmIChQT0lOVEVSX1RZUEVfUCAodCkpCiAgICAgewotICAgICAgbV9y YW5nZVsxXSA9IG1faXJhbmdlX2FsbG9jYXRvci0+YWxsb2NhdGUgKDIpOworICAgICAgbV9yYW5n ZVsxXQorCT0gc3RhdGljX2Nhc3QgPGlyYW5nZSAqPiAobV9yYW5nZV9hbGxvY2F0b3ItPmFsbG9j X3ZyYW5nZSAodCkpOwogICAgICAgbV9yYW5nZVsxXS0+c2V0X25vbnplcm8gKHQpOwotICAgICAg bV9yYW5nZVsyXSA9IG1faXJhbmdlX2FsbG9jYXRvci0+YWxsb2NhdGUgKDIpOworICAgICAgbV9y YW5nZVsyXQorCT0gc3RhdGljX2Nhc3QgPGlyYW5nZSAqPiAobV9yYW5nZV9hbGxvY2F0b3ItPmFs bG9jX3ZyYW5nZSAodCkpOwogICAgICAgbV9yYW5nZVsyXS0+c2V0X3plcm8gKHQpOwogICAgIH0K ICAgZWxzZQpAQCAtMjY3LDcgKzI3MCw3IEBAIHNicl9zcGFyc2VfYml0bWFwOjpzZXRfYmJfcmFu Z2UgKGNvbnN0X2Jhc2ljX2Jsb2NrIGJiLCBjb25zdCBpcmFuZ2UgJnIpCiAgICAgaWYgKCFtX3Jh bmdlW3hdIHx8IHIgPT0gKihtX3JhbmdlW3hdKSkKICAgICAgIHsKIAlpZiAoIW1fcmFuZ2VbeF0p Ci0JICBtX3JhbmdlW3hdID0gbV9pcmFuZ2VfYWxsb2NhdG9yLT5hbGxvY2F0ZSAocik7CisJICBt X3JhbmdlW3hdID0gbV9yYW5nZV9hbGxvY2F0b3ItPmNsb25lIChyKTsKIAliaXRtYXBfc2V0X3F1 YWQgKCZiaXR2ZWMsIGJiLT5pbmRleCwgeCArIDEpOwogCXJldHVybiB0cnVlOwogICAgICAgfQpA QCAtMzEyLDE0ICszMTUsMTQgQEAgYmxvY2tfcmFuZ2VfY2FjaGU6OmJsb2NrX3JhbmdlX2NhY2hl ICgpCiAgIGJpdG1hcF9vYnN0YWNrX2luaXRpYWxpemUgKCZtX2JpdG1hcHMpOwogICBtX3NzYV9y YW5nZXMuY3JlYXRlICgwKTsKICAgbV9zc2FfcmFuZ2VzLnNhZmVfZ3Jvd19jbGVhcmVkIChudW1f c3NhX25hbWVzKTsKLSAgbV9pcmFuZ2VfYWxsb2NhdG9yID0gbmV3IGlyYW5nZV9hbGxvY2F0b3I7 CisgIG1fcmFuZ2VfYWxsb2NhdG9yID0gbmV3IHZyYW5nZV9hbGxvY2F0b3I7CiB9CiAKIC8vIFJl bW92ZSBhbnkgbV9ibG9ja19jYWNoZXMgd2hpY2ggaGF2ZSBiZWVuIGNyZWF0ZWQuCiAKIGJsb2Nr X3JhbmdlX2NhY2hlOjp+YmxvY2tfcmFuZ2VfY2FjaGUgKCkKIHsKLSAgZGVsZXRlIG1faXJhbmdl X2FsbG9jYXRvcjsKKyAgZGVsZXRlIG1fcmFuZ2VfYWxsb2NhdG9yOwogICAvLyBSZWxlYXNlIHRo ZSB2ZWN0b3IgaXRzZWxmLgogICBtX3NzYV9yYW5nZXMucmVsZWFzZSAoKTsKICAgYml0bWFwX29i c3RhY2tfcmVsZWFzZSAoJm1fYml0bWFwcyk7CkBAIC0zNDEsMTcgKzM0NCwxNyBAQCBibG9ja19y YW5nZV9jYWNoZTo6c2V0X2JiX3JhbmdlICh0cmVlIG5hbWUsIGNvbnN0X2Jhc2ljX2Jsb2NrIGJi LAogICAgICAgLy8gVXNlIHNwYXJzZSByZXByZXNlbnRhdGlvbiBpZiB0aGVyZSBhcmUgdG9vIG1h bnkgYmFzaWMgYmxvY2tzLgogICAgICAgaWYgKGxhc3RfYmFzaWNfYmxvY2tfZm9yX2ZuIChjZnVu KSA+IHBhcmFtX2V2cnBfc3BhcnNlX3RocmVzaG9sZCkKIAl7Ci0JICB2b2lkICpyID0gbV9pcmFu Z2VfYWxsb2NhdG9yLT5nZXRfbWVtb3J5IChzaXplb2YgKHNicl9zcGFyc2VfYml0bWFwKSk7CisJ ICB2b2lkICpyID0gbV9yYW5nZV9hbGxvY2F0b3ItPmFsbG9jIChzaXplb2YgKHNicl9zcGFyc2Vf Yml0bWFwKSk7CiAJICBtX3NzYV9yYW5nZXNbdl0gPSBuZXcgKHIpIHNicl9zcGFyc2VfYml0bWFw IChUUkVFX1RZUEUgKG5hbWUpLAotCQkJCQkJICAgICAgIG1faXJhbmdlX2FsbG9jYXRvciwKKwkJ CQkJCSAgICAgICBtX3JhbmdlX2FsbG9jYXRvciwKIAkJCQkJCSAgICAgICAmbV9iaXRtYXBzKTsK IAl9CiAgICAgICBlbHNlCiAJewogCSAgLy8gT3RoZXJ3aXNlIHVzZSB0aGUgZGVmYXVsdCB2ZWN0 b3IgaW1wbGVtbnRhdGlvbi4KLQkgIHZvaWQgKnIgPSBtX2lyYW5nZV9hbGxvY2F0b3ItPmdldF9t ZW1vcnkgKHNpemVvZiAoc2JyX3ZlY3RvcikpOworCSAgdm9pZCAqciA9IG1fcmFuZ2VfYWxsb2Nh dG9yLT5hbGxvYyAoc2l6ZW9mIChzYnJfdmVjdG9yKSk7CiAJICBtX3NzYV9yYW5nZXNbdl0gPSBu ZXcgKHIpIHNicl92ZWN0b3IgKFRSRUVfVFlQRSAobmFtZSksCi0JCQkJCQltX2lyYW5nZV9hbGxv Y2F0b3IpOworCQkJCQkJbV9yYW5nZV9hbGxvY2F0b3IpOwogCX0KICAgICB9CiAgIHJldHVybiBt X3NzYV9yYW5nZXNbdl0tPnNldF9iYl9yYW5nZSAoYmIsIHIpOwpAQCAtNDY3LDcgKzQ3MCw3IEBA IGJsb2NrX3JhbmdlX2NhY2hlOjpkdW1wIChGSUxFICpmLCBiYXNpY19ibG9jayBiYiwgYm9vbCBw cmludF92YXJ5aW5nKQogc3NhX2dsb2JhbF9jYWNoZTo6c3NhX2dsb2JhbF9jYWNoZSAoKQogewog ICBtX3RhYi5jcmVhdGUgKDApOwotICBtX2lyYW5nZV9hbGxvY2F0b3IgPSBuZXcgaXJhbmdlX2Fs bG9jYXRvcjsKKyAgbV9yYW5nZV9hbGxvY2F0b3IgPSBuZXcgdnJhbmdlX2FsbG9jYXRvcjsKIH0K IAogLy8gRGVjb25zdHJ1Y3QgYSBnbG9iYWwgY2FjaGUuCkBAIC00NzUsNyArNDc4LDcgQEAgc3Nh X2dsb2JhbF9jYWNoZTo6c3NhX2dsb2JhbF9jYWNoZSAoKQogc3NhX2dsb2JhbF9jYWNoZTo6fnNz YV9nbG9iYWxfY2FjaGUgKCkKIHsKICAgbV90YWIucmVsZWFzZSAoKTsKLSAgZGVsZXRlIG1faXJh bmdlX2FsbG9jYXRvcjsKKyAgZGVsZXRlIG1fcmFuZ2VfYWxsb2NhdG9yOwogfQogCiAvLyBSZXRy aWV2ZSB0aGUgZ2xvYmFsIHJhbmdlIG9mIE5BTUUgZnJvbSBjYWNoZSBtZW1vcnkgaWYgaXQgZXhp c3RzLiAKQEAgLTUwOSw3ICs1MTIsNyBAQCBzc2FfZ2xvYmFsX2NhY2hlOjpzZXRfZ2xvYmFsX3Jh bmdlICh0cmVlIG5hbWUsIGNvbnN0IGlyYW5nZSAmcikKICAgaWYgKG0gJiYgbS0+Zml0c19wIChy KSkKICAgICAqbSA9IHI7CiAgIGVsc2UKLSAgICBtX3RhYlt2XSA9IG1faXJhbmdlX2FsbG9jYXRv ci0+YWxsb2NhdGUgKHIpOworICAgIG1fdGFiW3ZdID0gbV9yYW5nZV9hbGxvY2F0b3ItPmNsb25l IChyKTsKICAgcmV0dXJuIG0gIT0gTlVMTDsKIH0KIApkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1y YW5nZS1jYWNoZS5oIGIvZ2NjL2dpbXBsZS1yYW5nZS1jYWNoZS5oCmluZGV4IGQ1NmU1NmMyMDFj Li43M2QxMmYzNWFiZSAxMDA2NDQKLS0tIGEvZ2NjL2dpbXBsZS1yYW5nZS1jYWNoZS5oCisrKyBi L2djYy9naW1wbGUtcmFuZ2UtY2FjaGUuaApAQCAtNDQsNyArNDQsNyBAQCBwcml2YXRlOgogICB2 ZWM8Y2xhc3Mgc3NhX2Jsb2NrX3JhbmdlcyAqPiBtX3NzYV9yYW5nZXM7CiAgIHNzYV9ibG9ja19y YW5nZXMgJmdldF9ibG9ja19yYW5nZXMgKHRyZWUgbmFtZSk7CiAgIHNzYV9ibG9ja19yYW5nZXMg KnF1ZXJ5X2Jsb2NrX3JhbmdlcyAodHJlZSBuYW1lKTsKLSAgaXJhbmdlX2FsbG9jYXRvciAqbV9p cmFuZ2VfYWxsb2NhdG9yOworICB2cmFuZ2VfYWxsb2NhdG9yICptX3JhbmdlX2FsbG9jYXRvcjsK ICAgYml0bWFwX29ic3RhY2sgbV9iaXRtYXBzOwogfTsKIApAQCAtNjQsNyArNjQsNyBAQCBwdWJs aWM6CiAgIHZvaWQgZHVtcCAoRklMRSAqZiA9IHN0ZGVycik7CiBwcml2YXRlOgogICB2ZWM8aXJh bmdlICo+IG1fdGFiOwotICBjbGFzcyBpcmFuZ2VfYWxsb2NhdG9yICptX2lyYW5nZV9hbGxvY2F0 b3I7CisgIHZyYW5nZV9hbGxvY2F0b3IgKm1fcmFuZ2VfYWxsb2NhdG9yOwogfTsKIAogLy8gVGhp cyBjbGFzcyBwcm92aWRlcyBhbGwgdGhlIGNhY2hlcyBhIGdsb2JhbCByYW5nZXIgbWF5IG5lZWQs IGFuZCBtYWtlcyAKZGlmZiAtLWdpdCBhL2djYy9naW1wbGUtcmFuZ2UtZWRnZS5jYyBiL2djYy9n aW1wbGUtcmFuZ2UtZWRnZS5jYwppbmRleCA1YmJlMjNhZTAzZC4uNTI2NGU2MjdjOWEgMTAwNjQ0 Ci0tLSBhL2djYy9naW1wbGUtcmFuZ2UtZWRnZS5jYworKysgYi9nY2MvZ2ltcGxlLXJhbmdlLWVk Z2UuY2MKQEAgLTE2NiwxMyArMTY2LDEzIEBAIGdpbXBsZV9vdXRnb2luZ19yYW5nZTo6Y2FsY19z d2l0Y2hfcmFuZ2VzIChnc3dpdGNoICpzdykKICAgICAgIC8vIElmIHRoZXJlIHdhcyBhbiBleGlz dGluZyByYW5nZSBhbmQgaXQgZG9lc24ndCBmaXQsIHdlIGxvc2UgdGhlIG1lbW9yeS4KICAgICAg IC8vIEl0J2xsIGdldCByZWNsYWltZWQgd2hlbiB0aGUgb2JzdGFjayBpcyBmcmVlZC4gIFRoaXMg c2VlbXMgbGVzcwogICAgICAgLy8gaW50cnVzaXZlIHRoYW4gYWxsb2NhdGluZyBtYXggcmFuZ2Vz IGZvciBlYWNoIGNhc2UuCi0gICAgICBzbG90ID0gbV9yYW5nZV9hbGxvY2F0b3IuYWxsb2NhdGUg KGNhc2VfcmFuZ2UpOworICAgICAgc2xvdCA9IG1fcmFuZ2VfYWxsb2NhdG9yLmNsb25lIDxpcmFu Z2U+IChjYXNlX3JhbmdlKTsKICAgICB9CiAKICAgaXJhbmdlIComc2xvdCA9IG1fZWRnZV90YWJs ZS0+Z2V0X29yX2luc2VydCAoZGVmYXVsdF9lZGdlLCAmZXhpc3RlZCk7CiAgIC8vIFRoaXMgc2hv dWxkIGJlIHRoZSBmaXJzdCBjYWxsIGludG8gdGhpcyBzd2l0Y2guCiAgIGdjY19jaGVja2luZ19h c3NlcnQgKCFleGlzdGVkKTsKLSAgaXJhbmdlICpkciA9IG1fcmFuZ2VfYWxsb2NhdG9yLmFsbG9j YXRlIChkZWZhdWx0X3JhbmdlKTsKKyAgaXJhbmdlICpkciA9IG1fcmFuZ2VfYWxsb2NhdG9yLmNs b25lIDxpcmFuZ2U+IChkZWZhdWx0X3JhbmdlKTsKICAgc2xvdCA9IGRyOwogfQogCmRpZmYgLS1n aXQgYS9nY2MvZ2ltcGxlLXJhbmdlLWVkZ2UuaCBiL2djYy9naW1wbGUtcmFuZ2UtZWRnZS5oCmlu ZGV4IGMxMzFiMzMwOWNjLi5jZTM4M2IwYWE2ZiAxMDA2NDQKLS0tIGEvZ2NjL2dpbXBsZS1yYW5n ZS1lZGdlLmgKKysrIGIvZ2NjL2dpbXBsZS1yYW5nZS1lZGdlLmgKQEAgLTQ3LDcgKzQ3LDcgQEAg cHJpdmF0ZToKIAogICBpbnQgbV9tYXhfZWRnZXM7CiAgIGhhc2hfbWFwPGVkZ2UsIGlyYW5nZSAq PiAqbV9lZGdlX3RhYmxlOwotICBpcmFuZ2VfYWxsb2NhdG9yIG1fcmFuZ2VfYWxsb2NhdG9yOwor ICB2cmFuZ2VfYWxsb2NhdG9yIG1fcmFuZ2VfYWxsb2NhdG9yOwogfTsKIAogLy8gSWYgdGhlcmUg aXMgYSByYW5nZSBjb250cm9sIHN0YXRlbWVudCBhdCB0aGUgZW5kIG9mIGJsb2NrIEJCLCByZXR1 cm4gaXQuCmRpZmYgLS1naXQgYS9nY2MvZ2ltcGxlLXJhbmdlLWluZmVyLmNjIGIvZ2NjL2dpbXBs ZS1yYW5nZS1pbmZlci5jYwppbmRleCA1NDVkNGYyZGUzZC4uMTRkZGZiODAzZDggMTAwNjQ0Ci0t LSBhL2djYy9naW1wbGUtcmFuZ2UtaW5mZXIuY2MKKysrIGIvZ2NjL2dpbXBsZS1yYW5nZS1pbmZl ci5jYwpAQCAtMTg5LDggKzE4OSwxMCBAQCBpbmZlcl9yYW5nZV9tYW5hZ2VyOjpnZXRfbm9uemVy byAodHJlZSBuYW1lKQogICAgIG1fbm9uemVyby5zYWZlX2dyb3dfY2xlYXJlZCAobnVtX3NzYV9u YW1lcyArIDIwKTsKICAgaWYgKCFtX25vbnplcm9bdl0pCiAgICAgewotICAgICAgbV9ub256ZXJv W3ZdID0gbV9yYW5nZV9hbGxvY2F0b3IuYWxsb2NhdGUgKDIpOwotICAgICAgbV9ub256ZXJvW3Zd LT5zZXRfbm9uemVybyAoVFJFRV9UWVBFIChuYW1lKSk7CisgICAgICB0cmVlIHR5cGUgPSBUUkVF X1RZUEUgKG5hbWUpOworICAgICAgbV9ub256ZXJvW3ZdCisJPSBzdGF0aWNfY2FzdCA8aXJhbmdl ICo+IChtX3JhbmdlX2FsbG9jYXRvci5hbGxvY192cmFuZ2UgKHR5cGUpKTsKKyAgICAgIG1fbm9u emVyb1t2XS0+c2V0X25vbnplcm8gKHR5cGUpOwogICAgIH0KICAgcmV0dXJuICoobV9ub256ZXJv W3ZdKTsKIH0KQEAgLTI1OSwxNCArMjYxLDE3IEBAIGluZmVyX3JhbmdlX21hbmFnZXI6OmFkZF9y YW5nZSAodHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYiwgY29uc3QgaXJhbmdlICZyKQogICAgICAg aWYgKHB0ci0+cmFuZ2UtPmZpdHNfcCAoY3VyKSkKIAkqKHB0ci0+cmFuZ2UpID0gY3VyOwogICAg ICAgZWxzZQotCXB0ci0+cmFuZ2UgPSBtX3JhbmdlX2FsbG9jYXRvci5hbGxvY2F0ZSAoY3VyKTsK Kwl7CisJICB2cmFuZ2UgJnYgPSBjdXI7CisJICBwdHItPnJhbmdlID0gc3RhdGljX2Nhc3QgPGly YW5nZSAqPiAobV9yYW5nZV9hbGxvY2F0b3IuY2xvbmUgKHYpKTsKKwl9CiAgICAgICByZXR1cm47 CiAgICAgfQogCiAgIC8vIE90aGVyd2lzZSBjcmVhdGUgYSByZWNvcmQuCiAgIGJpdG1hcF9zZXRf Yml0IChtX29uX2V4aXRbYmItPmluZGV4XS5tX25hbWVzLCBTU0FfTkFNRV9WRVJTSU9OIChuYW1l KSk7CiAgIHB0ciA9IChleGl0X3JhbmdlICopb2JzdGFja19hbGxvYyAoJm1fbGlzdF9vYnN0YWNr LCBzaXplb2YgKGV4aXRfcmFuZ2UpKTsKLSAgcHRyLT5yYW5nZSA9IG1fcmFuZ2VfYWxsb2NhdG9y LmFsbG9jYXRlIChyKTsKKyAgcHRyLT5yYW5nZSA9IG1fcmFuZ2VfYWxsb2NhdG9yLmNsb25lIChy KTsKICAgcHRyLT5uYW1lID0gbmFtZTsKICAgcHRyLT5uZXh0ID0gbV9vbl9leGl0W2JiLT5pbmRl eF0uaGVhZDsKICAgbV9vbl9leGl0W2JiLT5pbmRleF0uaGVhZCA9IHB0cjsKZGlmZiAtLWdpdCBh L2djYy9naW1wbGUtcmFuZ2UtaW5mZXIuaCBiL2djYy9naW1wbGUtcmFuZ2UtaW5mZXIuaAppbmRl eCA0MTI5NThmZTI4ZS4uNjVmNmU4MzgwOWQgMTAwNjQ0Ci0tLSBhL2djYy9naW1wbGUtcmFuZ2Ut aW5mZXIuaAorKysgYi9nY2MvZ2ltcGxlLXJhbmdlLWluZmVyLmgKQEAgLTc4LDcgKzc4LDcgQEAg cHJpdmF0ZToKICAgYml0bWFwIG1fc2VlbjsKICAgYml0bWFwX29ic3RhY2sgbV9iaXRtYXBzOwog ICBzdHJ1Y3Qgb2JzdGFjayBtX2xpc3Rfb2JzdGFjazsKLSAgaXJhbmdlX2FsbG9jYXRvciBtX3Jh bmdlX2FsbG9jYXRvcjsKKyAgdnJhbmdlX2FsbG9jYXRvciBtX3JhbmdlX2FsbG9jYXRvcjsKIH07 CiAKICNlbmRpZiAvLyBHQ0NfR0lNUExFX1JBTkdFX1NJREVfSApkaWZmIC0tZ2l0IGEvZ2NjL3Zh bHVlLXJhbmdlLmggYi9nY2MvdmFsdWUtcmFuZ2UuaAppbmRleCBiN2VhOGM3NmY4Ny4uNWNkMGUw ZWY3NmEgMTAwNjQ0Ci0tLSBhL2djYy92YWx1ZS1yYW5nZS5oCisrKyBiL2djYy92YWx1ZS1yYW5n ZS5oCkBAIC05Miw3ICs5Miw3IEBAIHByb3RlY3RlZDoKIAogY2xhc3MgR1RZKCh1c2VyKSkgaXJh bmdlIDogcHVibGljIHZyYW5nZQogewotICBmcmllbmQgY2xhc3MgaXJhbmdlX2FsbG9jYXRvcjsK KyAgZnJpZW5kIGNsYXNzIHZyYW5nZV9hbGxvY2F0b3I7CiBwdWJsaWM6CiAgIC8vIEluLXBsYWNl IHNldHRlcnMuCiAgIHZpcnR1YWwgdm9pZCBzZXQgKHRyZWUsIHRyZWUsIHZhbHVlX3JhbmdlX2tp bmQgPSBWUl9SQU5HRSkgb3ZlcnJpZGU7CkBAIC04OTcsNTYgKzg5Nyw2MyBAQCB2cnBfdmFsX21p biAoY29uc3RfdHJlZSB0eXBlKQogICByZXR1cm4gTlVMTF9UUkVFOwogfQogCi0vLyBUaGlzIGlz IHRoZSBpcmFuZ2Ugc3RvcmFnZSBjbGFzcy4gIEl0IGlzIHVzZWQgdG8gYWxsb2NhdGUgdGhlCi0v LyBtaW5pbXVtIGFtb3VudCBvZiBzdG9yYWdlIG5lZWRlZCBmb3IgYSBnaXZlbiBpcmFuZ2UuICBT dG9yYWdlIGlzCi0vLyBhdXRvbWF0aWNhbGx5IGZyZWVkIGF0IGRlc3RydWN0aW9uIG9mIHRoZSBz dG9yYWdlIGNsYXNzLgotLy8KLS8vIEl0IGlzIG1lYW50IGZvciBsb25nIHRlcm0gc3RvcmFnZSwg YXMgb3Bwb3NlZCB0byBpbnRfcmFuZ2VfbWF4Ci0vLyB3aGljaCBpcyBtZWFudCBmb3IgaW50ZXJt ZWRpYXRlIHRlbXBvcmFyeSByZXN1bHRzIG9uIHRoZSBzdGFjay4KLS8vCi0vLyBUaGUgbmV3bHkg YWxsb2NhdGVkIGlyYW5nZSBpcyBpbml0aWFsaXplZCB0byB0aGUgZW1wdHkgc2V0Ci0vLyAodW5k ZWZpbmVkX3AoKSBpcyB0cnVlKS4KKy8vIFRoaXMgaXMgdGhlIHJhbmdlIHN0b3JhZ2UgY2xhc3Mu ICBJdCBpcyB1c2VkIHRvIGFsbG9jYXRlIHRoZQorLy8gbWluaW11bSBhbW91bnQgb2Ygc3RvcmFn ZSBuZWVkZWQgZm9yIGEgZ2l2ZW4gcmFuZ2UuICBTdG9yYWdlIGlzCisvLyBhdXRvbWF0aWNhbGx5 IGZyZWVkIGF0IGRlc3RydWN0aW9uIG9mIHRoZSBjbGFzcy4KIAotY2xhc3MgaXJhbmdlX2FsbG9j YXRvcgorY2xhc3MgdnJhbmdlX2FsbG9jYXRvcgogewogcHVibGljOgotICBpcmFuZ2VfYWxsb2Nh dG9yICgpOwotICB+aXJhbmdlX2FsbG9jYXRvciAoKTsKLSAgLy8gUmV0dXJuIGEgbmV3IHJhbmdl IHdpdGggTlVNX1BBSVJTLgotICBpcmFuZ2UgKmFsbG9jYXRlICh1bnNpZ25lZCBudW1fcGFpcnMp OwotICAvLyBSZXR1cm4gYSBjb3B5IG9mIFNSQyB3aXRoIHRoZSBtaW5pbXVtIGFtb3VudCBvZiBz dWItcmFuZ2VzIG5lZWRlZAotICAvLyB0byByZXByZXNlbnQgaXQuCi0gIGlyYW5nZSAqYWxsb2Nh dGUgKGNvbnN0IGlyYW5nZSAmc3JjKTsKLSAgdm9pZCAqZ2V0X21lbW9yeSAodW5zaWduZWQgbnVt X2J5dGVzKTsKKyAgdnJhbmdlX2FsbG9jYXRvciAoKTsKKyAgfnZyYW5nZV9hbGxvY2F0b3IgKCk7 CisgIC8vIEFsbG9jYXRlIGEgcmFuZ2Ugb2YgVFlQRS4KKyAgdnJhbmdlICphbGxvY192cmFuZ2Ug KHRyZWUgdHlwZSk7CisgIC8vIEFsbG9jYXRlIGEgbWVtb3J5IGJsb2NrIG9mIEJZVEVTLgorICB2 b2lkICphbGxvYyAodW5zaWduZWQgYnl0ZXMpOworICAvLyBSZXR1cm4gYSBjbG9uZSBvZiBTUkMu CisgIHRlbXBsYXRlIDx0eXBlbmFtZSBUPiBUICpjbG9uZSAoY29uc3QgVCAmc3JjKTsKIHByaXZh dGU6Ci0gIERJU0FCTEVfQ09QWV9BTkRfQVNTSUdOIChpcmFuZ2VfYWxsb2NhdG9yKTsKKyAgaXJh bmdlICphbGxvY19pcmFuZ2UgKHVuc2lnbmVkIHBhaXJzKTsKKyAgRElTQUJMRV9DT1BZX0FORF9B U1NJR04gKHZyYW5nZV9hbGxvY2F0b3IpOwogICBzdHJ1Y3Qgb2JzdGFjayBtX29ic3RhY2s7CiB9 OwogCiBpbmxpbmUKLWlyYW5nZV9hbGxvY2F0b3I6OmlyYW5nZV9hbGxvY2F0b3IgKCkKK3ZyYW5n ZV9hbGxvY2F0b3I6OnZyYW5nZV9hbGxvY2F0b3IgKCkKIHsKICAgb2JzdGFja19pbml0ICgmbV9v YnN0YWNrKTsKIH0KIAogaW5saW5lCi1pcmFuZ2VfYWxsb2NhdG9yOjp+aXJhbmdlX2FsbG9jYXRv ciAoKQordnJhbmdlX2FsbG9jYXRvcjo6fnZyYW5nZV9hbGxvY2F0b3IgKCkKIHsKICAgb2JzdGFj a19mcmVlICgmbV9vYnN0YWNrLCBOVUxMKTsKIH0KIAogLy8gUHJvdmlkZSBhIGh1bmsgb2YgbWVt b3J5IGZyb20gdGhlIG9ic3RhY2suCisKIGlubGluZSB2b2lkICoKLWlyYW5nZV9hbGxvY2F0b3I6 OmdldF9tZW1vcnkgKHVuc2lnbmVkIG51bV9ieXRlcykKK3ZyYW5nZV9hbGxvY2F0b3I6OmFsbG9j ICh1bnNpZ25lZCBieXRlcykKIHsKLSAgdm9pZCAqciA9IG9ic3RhY2tfYWxsb2MgKCZtX29ic3Rh Y2ssIG51bV9ieXRlcyk7Ci0gIHJldHVybiByOworICByZXR1cm4gb2JzdGFja19hbGxvYyAoJm1f b2JzdGFjaywgYnl0ZXMpOworfQorCisvLyBSZXR1cm4gYSBuZXcgcmFuZ2UgdG8gaG9sZCByYW5n ZXMgb2YgVFlQRS4gIFRoZSBuZXdseSBhbGxvY2F0ZWQKKy8vIHJhbmdlIGlzIGluaXRpYWxpemVk IHRvIFZSX1VOREVGSU5FRC4KKworaW5saW5lIHZyYW5nZSAqCit2cmFuZ2VfYWxsb2NhdG9yOjph bGxvY192cmFuZ2UgKHRyZWUgdHlwZSkKK3sKKyAgaWYgKGlyYW5nZTo6c3VwcG9ydHNfdHlwZV9w ICh0eXBlKSkKKyAgICByZXR1cm4gYWxsb2NfaXJhbmdlICgyKTsKKworICBnY2NfdW5yZWFjaGFi bGUgKCk7CiB9CiAKIC8vIFJldHVybiBhIG5ldyByYW5nZSB3aXRoIE5VTV9QQUlSUy4KIAogaW5s aW5lIGlyYW5nZSAqCi1pcmFuZ2VfYWxsb2NhdG9yOjphbGxvY2F0ZSAodW5zaWduZWQgbnVtX3Bh aXJzKQordnJhbmdlX2FsbG9jYXRvcjo6YWxsb2NfaXJhbmdlICh1bnNpZ25lZCBudW1fcGFpcnMp CiB7CiAgIC8vIE5ldmVyIGFsbG9jYXRlIDAgcGFpcnMuCiAgIC8vIERvbid0IGFsbG9jYXRlIDEg ZWl0aGVyLCBvciB3ZSBnZXQgbGVnYWN5IHZhbHVlX3JhbmdlJ3MuCkBAIC05NTYsMTcgKzk2Mywz MiBAQCBpcmFuZ2VfYWxsb2NhdG9yOjphbGxvY2F0ZSAodW5zaWduZWQgbnVtX3BhaXJzKQogICBz aXplX3QgbmJ5dGVzID0gc2l6ZW9mICh0cmVlKSAqIDIgKiBudW1fcGFpcnM7CiAKICAgLy8gQWxs b2NhdGUgdGhlIGlyYW5nZSBhbmQgcmVxdWlyZWQgbWVtb3J5IGZvciB0aGUgdmVjdG9yLgotICB2 b2lkICpyID0gb2JzdGFja19hbGxvYyAoJm1fb2JzdGFjaywgc2l6ZW9mIChpcmFuZ2UpKTsKLSAg dHJlZSAqbWVtID0gKHRyZWUgKikgb2JzdGFja19hbGxvYyAoJm1fb2JzdGFjaywgbmJ5dGVzKTsK KyAgdm9pZCAqciA9IGFsbG9jIChzaXplb2YgKGlyYW5nZSkpOworICB0cmVlICptZW0gPSBzdGF0 aWNfY2FzdCA8dHJlZSAqPiAoYWxsb2MgKG5ieXRlcykpOwogICByZXR1cm4gbmV3IChyKSBpcmFu Z2UgKG1lbSwgbnVtX3BhaXJzKTsKIH0KIAorLy8gUmV0dXJuIGEgY2xvbmUgb2YgYW4gaXJhbmdl LgorCit0ZW1wbGF0ZSA8PgogaW5saW5lIGlyYW5nZSAqCi1pcmFuZ2VfYWxsb2NhdG9yOjphbGxv Y2F0ZSAoY29uc3QgaXJhbmdlICZzcmMpCit2cmFuZ2VfYWxsb2NhdG9yOjpjbG9uZSA8aXJhbmdl PiAoY29uc3QgaXJhbmdlICZzcmMpCiB7Ci0gIGlyYW5nZSAqciA9IGFsbG9jYXRlIChzcmMubnVt X3BhaXJzICgpKTsKKyAgaXJhbmdlICpyID0gYWxsb2NfaXJhbmdlIChzcmMubnVtX3BhaXJzICgp KTsKICAgKnIgPSBzcmM7CiAgIHJldHVybiByOwogfQogCisvLyBSZXR1cm4gYSBjbG9uZSBvZiBh IHZyYW5nZS4KKwordGVtcGxhdGUgPD4KK2lubGluZSB2cmFuZ2UgKgordnJhbmdlX2FsbG9jYXRv cjo6Y2xvbmUgPHZyYW5nZT4gKGNvbnN0IHZyYW5nZSAmc3JjKQoreworICBpZiAoaXNfYSA8aXJh bmdlPiAoc3JjKSkKKyAgICByZXR1cm4gY2xvbmUgPGlyYW5nZT4gKGFzX2EgPGlyYW5nZT4gKHNy YykpOworCisgIGdjY191bnJlYWNoYWJsZSAoKTsKK30KKwogI2VuZGlmIC8vIEdDQ19WQUxVRV9S QU5HRV9ICi0tIAoyLjM2LjEKCg== --0000000000006e912205e05f26bb--