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 5F24538344C0 for ; Wed, 1 Jun 2022 09:05:11 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 5F24538344C0 Received: from mail-oo1-f72.google.com (mail-oo1-f72.google.com [209.85.161.72]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-534-4i3mjeV3O4mTUZ1_2pPAoQ-1; Wed, 01 Jun 2022 05:05:09 -0400 X-MC-Unique: 4i3mjeV3O4mTUZ1_2pPAoQ-1 Received: by mail-oo1-f72.google.com with SMTP id j15-20020a4a888f000000b00321764d8f14so737262ooa.14 for ; Wed, 01 Jun 2022 02:05:09 -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=PEvdAaxN0v1ifjBn7ADXrJfi8dDDpjzwCBN6C8Kr58g=; b=pEsW6p45iX0Lp0Hn7VVB0XXVlYDbyV82vahXXZvsMH18AiXjnzPKi9T7ZI7biq35XS YqNY22R2Zrq+B6GUH6oZP/1N5vs9vR7WsnxDIaXrx5m75xADB70pm6uNvYHRGTiUUFPC UCVG7lGScfECZQdWlh0hkKBQd8Ue0cj6YRHhg5UWWKCINz6Se8rm0IVD5rm1i/u+V/rF eogxsTfqRDJPq3I2By7KTEujkoWRBSL/GFEMQbXS3TubK5KldoCuAuNnrlxNPBAOnFNq Xh8kXVSYkGoc3LmJe3KyKL6Cpk20JMvNSl420dyr6C4fSyeWnLPDFAkjKng6B2lcseke ZYPw== X-Gm-Message-State: AOAM5337BkG9/4ik0ilOTmA8TWIThh4M1vgHovbuFCwhHdblmfGLkNBc vMT7HLZdg1hMaubHoGAYhRV+upfM0fZNBSv/vyYCogcd3KZfclNVTe2CuAYHsazCpJF8I44eySw 0y54WJWvmXVIs3YQL4bfboClEaoQ1e0ypFg== X-Received: by 2002:a05:6808:13ce:b0:328:da83:aba3 with SMTP id d14-20020a05680813ce00b00328da83aba3mr14646817oiw.265.1654074307062; Wed, 01 Jun 2022 02:05:07 -0700 (PDT) X-Google-Smtp-Source: ABdhPJw94nGMOaMoMvtM3YC+dwsVG+7N5y9imwm24qeuZ78Qm5Au/WaKvLUB9ODWfg7qRNZMRXFccI5guAy+M8aVCZw= X-Received: by 2002:a05:6808:13ce:b0:328:da83:aba3 with SMTP id d14-20020a05680813ce00b00328da83aba3mr14646729oiw.265.1654074304750; Wed, 01 Jun 2022 02:05:04 -0700 (PDT) MIME-Version: 1.0 References: <20220530132751.1752112-1-aldyh@redhat.com> <20220530132751.1752112-5-aldyh@redhat.com> In-Reply-To: <20220530132751.1752112-5-aldyh@redhat.com> From: Aldy Hernandez Date: Wed, 1 Jun 2022 11:04:52 +0200 Message-ID: Subject: Re: [PATCH 5/5] Convert ranger and clients to vrange. To: GCC patches X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: multipart/mixed; boundary="0000000000005e8d0d05e05f2f4b" X-Spam-Status: No, score=-12.1 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_NONE, TXREP, 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:05:22 -0000 --0000000000005e8d0d05e05f2f4b Content-Type: text/plain; charset="UTF-8" Final patch committed. All users but one of Value_Range::set_type() have been removed in favor of using a constructor taking a type. We still need to delay initialization for one use in gimple_infer_range, as it has an array of temporaries for which the type is not known until later. Re-tested on x86-64 Linux. On Mon, May 30, 2022 at 3:28 PM Aldy Hernandez wrote: > > Finally, the meat of the work. Convert ranger and associated clients > to vrange. > > Everything's relatively mechanical given the previous patches. I did > include a minor cleanup in the edge code. There's no need to check > that the type of the switch is an integer as non-integer switches are > invalid. I verified this with an appropriately coded assert. > > Tested on x86-64 & ppc64le Linux. > > gcc/ChangeLog: > > * gimple-range-cache.cc (ssa_block_ranges::dump): Convert to vrange. > (sbr_vector::sbr_vector): Same. > (sbr_vector::grow): Same. > (sbr_vector::set_bb_range): Same. > (sbr_vector::get_bb_range): Same. > (sbr_sparse_bitmap::sbr_sparse_bitmap): Same. > (sbr_sparse_bitmap::set_bb_range): Same. > (sbr_sparse_bitmap::get_bb_range): Same. > (block_range_cache::set_bb_range): Same. > (block_range_cache::get_bb_range): Same. > (block_range_cache::dump): Same. > (ssa_global_cache::get_global_range): Same. > (ssa_global_cache::set_global_range): Same. > (ssa_global_cache::clear): Same. > (ssa_global_cache::dump): Same. > (ranger_cache::get_global_range): Same. > (ranger_cache::set_global_range): Same. > (ranger_cache::range_of_def): Same. > (ranger_cache::entry_range): Same. > (ranger_cache::exit_range): Same. > (ranger_cache::edge_range): Same. > (ranger_cache::range_of_expr): Same. > (ranger_cache::range_on_edge): Same. > (ranger_cache::block_range): Same. > (ranger_cache::propagate_cache): Same. > (ranger_cache::fill_block_cache): Same. > (ranger_cache::range_from_dom): Same. > * gimple-range-cache.h: Same. > * gimple-range-edge.cc (gimple_outgoing_range::get_edge_range): > Same. > (gimple_outgoing_range::switch_edge_range): Same. > (gimple_outgoing_range::edge_range_p): Same. > * gimple-range-edge.h: Same. > * gimple-range-fold.cc (fur_source::get_operand): Same. > (fur_source::get_phi_operand): Same. > (fur_edge::get_operand): Same. > (fur_edge::get_phi_operand): Same. > (fur_stmt::get_operand): Same. > (fur_stmt::get_phi_operand): Same. > (fur_list::fur_list): Same. > (fur_list::get_operand): Same. > (fur_list::get_phi_operand): Same. > (fold_range): Same. > (adjust_imagpart_expr): Same. > (adjust_realpart_expr): Same. > (gimple_range_adjustment): Same. > (fold_using_range::fold_stmt): Same. > (fold_using_range::range_of_range_op): Same. > (fold_using_range::range_of_address): Same. > (fold_using_range::range_of_phi): Same. > (fold_using_range::range_of_call): Same. > (fold_using_range::range_of_builtin_call): Same. > (fold_using_range::range_of_builtin_int_call): Same. > (fold_using_range::range_of_cond_expr): Same. > (fur_source::register_outgoing_edges): Same. > * gimple-range-fold.h (fold_range): Same. > (gimple_range_type): Same. > (gimple_range_ssa_p): Same. > * gimple-range-gori.cc (gimple_range_calc_op1): Same. > (gimple_range_calc_op2): Same. > (gori_compute::compute_operand_range_switch): Same. > (gori_compute::compute_operand_range): Same. > (gori_compute::logical_combine): Same. > (gori_compute::compute_logical_operands): Same. > (gori_compute::compute_operand1_range): Same. > (gori_compute::compute_operand2_range): Same. > (gori_compute::compute_operand1_and_operand2_range): Same. > (gori_compute::outgoing_edge_range_p): Same. > (gori_compute::condexpr_adjust): Same. > * gimple-range-gori.h (gimple_range_calc_op1): Same. > (gimple_range_calc_op2): Same. > * gimple-range-path.cc (path_range_query::get_cache): Same. > (path_range_query::set_cache): Same. > (path_range_query::range_on_path_entry): Same. > (path_range_query::internal_range_of_expr): Same. > (path_range_query::range_of_expr): Same. > (path_range_query::ssa_range_in_phi): Same. > (path_range_query::range_defined_in_block): Same. > (path_range_query::compute_ranges_in_phis): Same. > (path_range_query::compute_ranges_in_block): Same. > (path_range_query::add_to_imports): Same. > (path_range_query::range_of_stmt): Same. > * gimple-range-path.h: Same. > * gimple-range-side-effect.cc (stmt_side_effects::add_range): Same. > (side_effect_manager::~side_effect_manager): Same. > (side_effect_manager::get_nonzero): Same. > (side_effect_manager::maybe_adjust_range): Same. > (side_effect_manager::add_range): Same. > * gimple-range-side-effect.h: Same. > * gimple-range-tests.cc: Same. > * gimple-range-trace.cc (range_tracer::trailer): Same. > (debug_seed_ranger): Same. > * gimple-range-trace.h: Same. > * gimple-range.cc (gimple_ranger::range_of_expr): Same. > (gimple_ranger::range_on_entry): Same. > (gimple_ranger::range_on_exit): Same. > (gimple_ranger::range_on_edge): Same. > (gimple_ranger::fold_range_internal): Same. > (gimple_ranger::range_of_stmt): Same. > (gimple_ranger::prefill_name): Same. > (gimple_ranger::prefill_stmt_dependencies): Same. > (gimple_ranger::export_global_ranges): Same. > (gimple_ranger::dump_bb): Same. > * gimple-range.h: Same. > * gimple-ssa-warn-access.cc (check_nul_terminated_array): Same. > (memmodel_to_uhwi): Same. > * tree-ssa-loop-niter.cc (refine_value_range_using_guard): Same. > (determine_value_range): Same. > (record_nonwrapping_iv): Same. > (infer_loop_bounds_from_signedness): Same. > (scev_var_range_cant_overflow): Same. > * tree-ssa-threadedge.cc (hybrid_jt_simplifier::simplify): Same. > * value-query.cc (range_query::range_on_edge): Same. > (range_query::range_of_stmt): Same. > (range_query::value_of_expr): Same. > (range_query::value_on_edge): Same. > (range_query::value_of_stmt): Same. > (range_query::get_tree_range): Same. > (update_global_range): Same. > (get_range_global): Same. > (gimple_range_global): Same. > (global_range_query::range_of_expr): Same. > (range_query::query_relation): Same. > * value-query.h (gimple_range_global): Same. > (update_global_range): Same. > * vr-values.cc (vr_values::range_of_expr): Same. > (bounds_of_var_in_loop): Same. > (simplify_using_ranges::vrp_visit_cond_stmt): Same. > * vr-values.h (class vr_values): Same. > --- > gcc/gimple-range-cache.cc | 136 ++++++++++++++++-------------- > gcc/gimple-range-cache.h | 32 +++---- > gcc/gimple-range-edge.cc | 12 +-- > gcc/gimple-range-edge.h | 2 +- > gcc/gimple-range-fold.cc | 144 +++++++++++++++++++------------- > gcc/gimple-range-fold.h | 37 ++++---- > gcc/gimple-range-gori.cc | 116 ++++++++++++++----------- > gcc/gimple-range-gori.h | 42 +++++----- > gcc/gimple-range-path.cc | 47 ++++++----- > gcc/gimple-range-path.h | 16 ++-- > gcc/gimple-range-side-effect.cc | 20 ++--- > gcc/gimple-range-side-effect.h | 14 ++-- > gcc/gimple-range-tests.cc | 3 +- > gcc/gimple-range-trace.cc | 9 +- > gcc/gimple-range-trace.h | 2 +- > gcc/gimple-range.cc | 44 ++++++---- > gcc/gimple-range.h | 14 ++-- > gcc/gimple-ssa-warn-access.cc | 7 +- > gcc/tree-ssa-loop-niter.cc | 16 ++-- > gcc/tree-ssa-threadedge.cc | 4 +- > gcc/value-query.cc | 73 ++++++++-------- > gcc/value-query.h | 16 ++-- > gcc/vr-values.cc | 29 ++++--- > gcc/vr-values.h | 2 +- > 24 files changed, 457 insertions(+), 380 deletions(-) > > diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc > index 9c541993fb6..4983e4d3aa7 100644 > --- a/gcc/gimple-range-cache.cc > +++ b/gcc/gimple-range-cache.cc > @@ -44,11 +44,14 @@ along with GCC; see the file COPYING3. If not see > class ssa_block_ranges > { > public: > - virtual bool set_bb_range (const_basic_block bb, const irange &r) = 0; > - virtual bool get_bb_range (irange &r, const_basic_block bb) = 0; > + ssa_block_ranges (tree t) : m_type (t) { } > + virtual bool set_bb_range (const_basic_block bb, const vrange &r) = 0; > + virtual bool get_bb_range (vrange &r, const_basic_block bb) = 0; > virtual bool bb_range_p (const_basic_block bb) = 0; > > void dump(FILE *f); > +private: > + tree m_type; > }; > > // Print the list of known ranges for file F in a nice format. > @@ -57,7 +60,7 @@ void > ssa_block_ranges::dump (FILE *f) > { > basic_block bb; > - int_range_max r; > + tmp_range r (m_type); > > FOR_EACH_BB_FN (bb, cfun) > if (get_bb_range (r, bb)) > @@ -77,14 +80,14 @@ class sbr_vector : public ssa_block_ranges > public: > 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; > + virtual bool set_bb_range (const_basic_block bb, const vrange &r) override; > + virtual bool get_bb_range (vrange &r, const_basic_block bb) override; > virtual bool bb_range_p (const_basic_block bb) override; > protected: > - irange **m_tab; // Non growing vector. > + vrange **m_tab; // Non growing vector. > int m_tab_size; > - int_range<2> m_varying; > - int_range<2> m_undefined; > + vrange *m_varying; > + vrange *m_undefined; > tree m_type; > vrange_allocator *m_range_allocator; > void grow (); > @@ -94,18 +97,21 @@ protected: > // Initialize a block cache for an ssa_name of type T. > > sbr_vector::sbr_vector (tree t, vrange_allocator *allocator) > + : ssa_block_ranges (t) > { > gcc_checking_assert (TYPE_P (t)); > m_type = t; > m_range_allocator = allocator; > m_tab_size = last_basic_block_for_fn (cfun) + 1; > - m_tab = static_cast > - (allocator->alloc (m_tab_size * sizeof (irange *))); > - memset (m_tab, 0, m_tab_size * sizeof (irange *)); > + m_tab = static_cast > + (allocator->alloc (m_tab_size * sizeof (vrange *))); > + memset (m_tab, 0, m_tab_size * sizeof (vrange *)); > > // Create the cached type range. > - m_varying.set_varying (t); > - m_undefined.set_undefined (); > + m_varying = m_range_allocator->alloc_vrange (t); > + m_undefined = m_range_allocator->alloc_vrange (t); > + m_varying->set_varying (t); > + m_undefined->set_undefined (); > } > > // Grow the vector when the CFG has increased in size. > @@ -122,10 +128,10 @@ sbr_vector::grow () > int new_size = inc + curr_bb_size; > > // Allocate new memory, copy the old vector and clear the new space. > - 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 *)); > + vrange **t = static_cast > + (m_range_allocator->alloc (new_size * sizeof (vrange *))); > + memcpy (t, m_tab, m_tab_size * sizeof (vrange *)); > + memset (t + m_tab_size, 0, (new_size - m_tab_size) * sizeof (vrange *)); > > m_tab = t; > m_tab_size = new_size; > @@ -134,15 +140,15 @@ sbr_vector::grow () > // Set the range for block BB to be R. > > bool > -sbr_vector::set_bb_range (const_basic_block bb, const irange &r) > +sbr_vector::set_bb_range (const_basic_block bb, const vrange &r) > { > - irange *m; > + vrange *m; > if (bb->index >= m_tab_size) > grow (); > if (r.varying_p ()) > - m = &m_varying; > + m = m_varying; > else if (r.undefined_p ()) > - m = &m_undefined; > + m = m_undefined; > else > m = m_range_allocator->clone (r); > m_tab[bb->index] = m; > @@ -153,11 +159,11 @@ sbr_vector::set_bb_range (const_basic_block bb, const irange &r) > // there is no range. > > bool > -sbr_vector::get_bb_range (irange &r, const_basic_block bb) > +sbr_vector::get_bb_range (vrange &r, const_basic_block bb) > { > if (bb->index >= m_tab_size) > return false; > - irange *m = m_tab[bb->index]; > + vrange *m = m_tab[bb->index]; > if (m) > { > r = *m; > @@ -193,14 +199,14 @@ class sbr_sparse_bitmap : public ssa_block_ranges > { > public: > 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 set_bb_range (const_basic_block bb, const vrange &r) override; > + virtual bool get_bb_range (vrange &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); > vrange_allocator *m_range_allocator; > - irange *m_range[SBR_NUM]; > + vrange *m_range[SBR_NUM]; > bitmap_head bitvec; > tree m_type; > }; > @@ -209,6 +215,7 @@ private: > > sbr_sparse_bitmap::sbr_sparse_bitmap (tree t, vrange_allocator *allocator, > bitmap_obstack *bm) > + : ssa_block_ranges (t) > { > gcc_checking_assert (TYPE_P (t)); > m_type = t; > @@ -216,16 +223,14 @@ sbr_sparse_bitmap::sbr_sparse_bitmap (tree t, vrange_allocator *allocator, > bitmap_tree_view (&bitvec); > m_range_allocator = allocator; > // Pre-cache varying. > - m_range[0] = static_cast (m_range_allocator->alloc_vrange (t)); > + m_range[0] = 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] > - = static_cast (m_range_allocator->alloc_vrange (t)); > + m_range[1] = m_range_allocator->alloc_vrange (t); > m_range[1]->set_nonzero (t); > - m_range[2] > - = static_cast (m_range_allocator->alloc_vrange (t)); > + m_range[2] = m_range_allocator->alloc_vrange (t); > m_range[2]->set_zero (t); > } > else > @@ -257,7 +262,7 @@ sbr_sparse_bitmap::bitmap_get_quad (const_bitmap head, int quad) > // Set the range on entry to basic block BB to R. > > bool > -sbr_sparse_bitmap::set_bb_range (const_basic_block bb, const irange &r) > +sbr_sparse_bitmap::set_bb_range (const_basic_block bb, const vrange &r) > { > if (r.undefined_p ()) > { > @@ -283,7 +288,7 @@ sbr_sparse_bitmap::set_bb_range (const_basic_block bb, const irange &r) > // there is no range. > > bool > -sbr_sparse_bitmap::get_bb_range (irange &r, const_basic_block bb) > +sbr_sparse_bitmap::get_bb_range (vrange &r, const_basic_block bb) > { > int value = bitmap_get_quad (&bitvec, bb->index); > > @@ -333,7 +338,7 @@ block_range_cache::~block_range_cache () > > bool > block_range_cache::set_bb_range (tree name, const_basic_block bb, > - const irange &r) > + const vrange &r) > { > unsigned v = SSA_NAME_VERSION (name); > if (v >= m_ssa_ranges.length ()) > @@ -379,7 +384,7 @@ block_range_cache::query_block_ranges (tree name) > // is one. > > bool > -block_range_cache::get_bb_range (irange &r, tree name, const_basic_block bb) > +block_range_cache::get_bb_range (vrange &r, tree name, const_basic_block bb) > { > ssa_block_ranges *ptr = query_block_ranges (name); > if (ptr) > @@ -423,12 +428,13 @@ void > block_range_cache::dump (FILE *f, basic_block bb, bool print_varying) > { > unsigned x; > - int_range_max r; > bool summarize_varying = false; > for (x = 1; x < m_ssa_ranges.length (); ++x) > { > if (!gimple_range_ssa_p (ssa_name (x))) > continue; > + > + tmp_range r (TREE_TYPE (ssa_name (x))); > if (m_ssa_ranges[x] && m_ssa_ranges[x]->get_bb_range (r, bb)) > { > if (!print_varying && r.varying_p ()) > @@ -450,6 +456,8 @@ block_range_cache::dump (FILE *f, basic_block bb, bool print_varying) > { > if (!gimple_range_ssa_p (ssa_name (x))) > continue; > + > + tmp_range r (TREE_TYPE (ssa_name (x))); > if (m_ssa_ranges[x] && m_ssa_ranges[x]->get_bb_range (r, bb)) > { > if (r.varying_p ()) > @@ -485,13 +493,13 @@ ssa_global_cache::~ssa_global_cache () > // Return the value in R. > > bool > -ssa_global_cache::get_global_range (irange &r, tree name) const > +ssa_global_cache::get_global_range (vrange &r, tree name) const > { > unsigned v = SSA_NAME_VERSION (name); > if (v >= m_tab.length ()) > return false; > > - irange *stow = m_tab[v]; > + vrange *stow = m_tab[v]; > if (!stow) > return false; > r = *stow; > @@ -502,13 +510,13 @@ ssa_global_cache::get_global_range (irange &r, tree name) const > // Return TRUE if there was already a range set, otherwise false. > > bool > -ssa_global_cache::set_global_range (tree name, const irange &r) > +ssa_global_cache::set_global_range (tree name, const vrange &r) > { > unsigned v = SSA_NAME_VERSION (name); > if (v >= m_tab.length ()) > m_tab.safe_grow_cleared (num_ssa_names + 1); > > - irange *m = m_tab[v]; > + vrange *m = m_tab[v]; > if (m && m->fits_p (r)) > *m = r; > else > @@ -533,7 +541,7 @@ void > ssa_global_cache::clear () > { > if (m_tab.address ()) > - memset (m_tab.address(), 0, m_tab.length () * sizeof (irange *)); > + memset (m_tab.address(), 0, m_tab.length () * sizeof (vrange *)); > } > > // Dump the contents of the global cache to F. > @@ -545,8 +553,9 @@ ssa_global_cache::dump (FILE *f) > bool print_header = true; > for (unsigned x = 1; x < num_ssa_names; x++) > { > - int_range_max r; > + tmp_range r; > if (gimple_range_ssa_p (ssa_name (x)) && > + r.init (TREE_TYPE (ssa_name (x))) && > get_global_range (r, ssa_name (x)) && !r.varying_p ()) > { > if (print_header) > @@ -809,11 +818,11 @@ ranger_cache::dump_bb (FILE *f, basic_block bb) > // global range is not set, and return the legacy global value in R. > > bool > -ranger_cache::get_global_range (irange &r, tree name) const > +ranger_cache::get_global_range (vrange &r, tree name) const > { > if (m_globals.get_global_range (r, name)) > return true; > - r = gimple_range_global (name); > + gimple_range_global (r, name); > return false; > } > > @@ -825,7 +834,7 @@ ranger_cache::get_global_range (irange &r, tree name) const > // After this call, the global cache will have a value. > > bool > -ranger_cache::get_global_range (irange &r, tree name, bool ¤t_p) > +ranger_cache::get_global_range (vrange &r, tree name, bool ¤t_p) > { > bool had_global = get_global_range (r, name); > > @@ -847,7 +856,7 @@ ranger_cache::get_global_range (irange &r, tree name, bool ¤t_p) > // Set the global range of NAME to R and give it a timestamp. > > void > -ranger_cache::set_global_range (tree name, const irange &r) > +ranger_cache::set_global_range (tree name, const vrange &r) > { > if (m_globals.set_global_range (name, r)) > { > @@ -882,7 +891,7 @@ ranger_cache::set_global_range (tree name, const irange &r) > // get the best global value available. > > void > -ranger_cache::range_of_def (irange &r, tree name, basic_block bb) > +ranger_cache::range_of_def (vrange &r, tree name, basic_block bb) > { > gcc_checking_assert (gimple_range_ssa_p (name)); > gcc_checking_assert (!bb || bb == gimple_bb (SSA_NAME_DEF_STMT (name))); > @@ -895,7 +904,7 @@ ranger_cache::range_of_def (irange &r, tree name, basic_block bb) > if (gimple_get_lhs (s) == name) > fold_range (r, s, get_global_range_query ()); > else > - r = gimple_range_global (name); > + gimple_range_global (r, name); > } > } > > @@ -903,12 +912,12 @@ ranger_cache::range_of_def (irange &r, tree name, basic_block bb) > // lookups. > > void > -ranger_cache::entry_range (irange &r, tree name, basic_block bb, > +ranger_cache::entry_range (vrange &r, tree name, basic_block bb, > enum rfd_mode mode) > { > if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)) > { > - r = gimple_range_global (name); > + gimple_range_global (r, name); > return; > } > > @@ -923,12 +932,12 @@ ranger_cache::entry_range (irange &r, tree name, basic_block bb, > // lookups. > > void > -ranger_cache::exit_range (irange &r, tree name, basic_block bb, > +ranger_cache::exit_range (vrange &r, tree name, basic_block bb, > enum rfd_mode mode) > { > if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)) > { > - r = gimple_range_global (name); > + gimple_range_global (r, name); > return; > } > > @@ -944,7 +953,7 @@ ranger_cache::exit_range (irange &r, tree name, basic_block bb, > // Always returns a range and true. > > bool > -ranger_cache::edge_range (irange &r, edge e, tree name, enum rfd_mode mode) > +ranger_cache::edge_range (vrange &r, edge e, tree name, enum rfd_mode mode) > { > exit_range (r, name, e->src, mode); > // If this is not an abnormal edge, check for side effects on exit. > @@ -961,7 +970,7 @@ ranger_cache::edge_range (irange &r, edge e, tree name, enum rfd_mode mode) > // Implement range_of_expr. > > bool > -ranger_cache::range_of_expr (irange &r, tree name, gimple *stmt) > +ranger_cache::range_of_expr (vrange &r, tree name, gimple *stmt) > { > if (!gimple_range_ssa_p (name)) > { > @@ -985,7 +994,7 @@ ranger_cache::range_of_expr (irange &r, tree name, gimple *stmt) > // the current cache values. > > bool > -ranger_cache::range_on_edge (irange &r, edge e, tree expr) > +ranger_cache::range_on_edge (vrange &r, edge e, tree expr) > { > if (gimple_range_ssa_p (expr)) > return edge_range (r, e, expr, RFD_NONE); > @@ -997,7 +1006,7 @@ ranger_cache::range_on_edge (irange &r, edge e, tree expr) > // def block for NAME. Otherwise, return false if the cache is empty. > > bool > -ranger_cache::block_range (irange &r, basic_block bb, tree name, bool calc) > +ranger_cache::block_range (vrange &r, basic_block bb, tree name, bool calc) > { > gcc_checking_assert (gimple_range_ssa_p (name)); > > @@ -1041,9 +1050,10 @@ ranger_cache::propagate_cache (tree name) > basic_block bb; > edge_iterator ei; > edge e; > - int_range_max new_range; > - int_range_max current_range; > - int_range_max e_range; > + tree type = TREE_TYPE (name); > + tmp_range new_range (type); > + tmp_range current_range (type); > + tmp_range e_range (type); > > // Process each block by seeing if its calculated range on entry is > // the same as its cached value. If there is a difference, update > @@ -1178,8 +1188,8 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) > { > edge_iterator ei; > edge e; > - int_range_max block_result; > - int_range_max undefined; > + tmp_range block_result (TREE_TYPE (name)); > + tmp_range undefined (TREE_TYPE (name)); > > // At this point we shouldn't be looking at the def, entry or exit block. > gcc_checking_assert (bb != def_bb && bb != ENTRY_BLOCK_PTR_FOR_FN (cfun) && > @@ -1232,7 +1242,7 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) > FOR_EACH_EDGE (e, ei, node->preds) > { > basic_block pred = e->src; > - int_range_max r; > + tmp_range r (TREE_TYPE (name)); > > if (DEBUG_RANGE_CACHE) > fprintf (dump_file, " %d->%d ",e->src->index, e->dest->index); > @@ -1306,7 +1316,7 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb) > // dominator tree based on MODE. > > bool > -ranger_cache::range_from_dom (irange &r, tree name, basic_block start_bb, > +ranger_cache::range_from_dom (vrange &r, tree name, basic_block start_bb, > enum rfd_mode mode) > { > if (mode == RFD_NONE || !dom_info_available_p (CDI_DOMINATORS)) > diff --git a/gcc/gimple-range-cache.h b/gcc/gimple-range-cache.h > index 2472cd04f47..d17950c7154 100644 > --- a/gcc/gimple-range-cache.h > +++ b/gcc/gimple-range-cache.h > @@ -34,8 +34,8 @@ public: > block_range_cache (); > ~block_range_cache (); > > - bool set_bb_range (tree name, const_basic_block bb, const irange &r); > - bool get_bb_range (irange &r, tree name, const_basic_block bb); > + bool set_bb_range (tree name, const_basic_block bb, const vrange &v); > + bool get_bb_range (vrange &v, tree name, const_basic_block bb); > bool bb_range_p (tree name, const_basic_block bb); > > void dump (FILE *f); > @@ -57,13 +57,13 @@ class ssa_global_cache > public: > ssa_global_cache (); > ~ssa_global_cache (); > - bool get_global_range (irange &r, tree name) const; > - bool set_global_range (tree name, const irange &r); > + bool get_global_range (vrange &r, tree name) const; > + bool set_global_range (tree name, const vrange &r); > void clear_global_range (tree name); > void clear (); > void dump (FILE *f = stderr); > private: > - vec m_tab; > + vec m_tab; > vrange_allocator *m_range_allocator; > }; > > @@ -77,13 +77,13 @@ public: > ranger_cache (int not_executable_flag, bool use_imm_uses); > ~ranger_cache (); > > - virtual bool range_of_expr (irange &r, tree name, gimple *stmt); > - virtual bool range_on_edge (irange &r, edge e, tree expr); > - bool block_range (irange &r, basic_block bb, tree name, bool calc = true); > + virtual bool range_of_expr (vrange &r, tree name, gimple *stmt); > + virtual bool range_on_edge (vrange &r, edge e, tree expr); > + bool block_range (vrange &r, basic_block bb, tree name, bool calc = true); > > - bool get_global_range (irange &r, tree name) const; > - bool get_global_range (irange &r, tree name, bool ¤t_p); > - void set_global_range (tree name, const irange &r); > + bool get_global_range (vrange &r, tree name) const; > + bool get_global_range (vrange &r, tree name, bool ¤t_p); > + void set_global_range (tree name, const vrange &r); > > void propagate_updated_value (tree name, basic_block bb); > > @@ -106,11 +106,11 @@ private: > RFD_READ_ONLY, // Scan DOM tree, do not write to cache. > RFD_FILL // Scan DOM tree, updating important nodes. > }; > - bool range_from_dom (irange &r, tree name, basic_block bb, enum rfd_mode); > - void range_of_def (irange &r, tree name, basic_block bb = NULL); > - void entry_range (irange &r, tree expr, basic_block bb, enum rfd_mode); > - void exit_range (irange &r, tree expr, basic_block bb, enum rfd_mode); > - bool edge_range (irange &r, edge e, tree name, enum rfd_mode); > + bool range_from_dom (vrange &r, tree name, basic_block bb, enum rfd_mode); > + void range_of_def (vrange &r, tree name, basic_block bb = NULL); > + void entry_range (vrange &r, tree expr, basic_block bb, enum rfd_mode); > + void exit_range (vrange &r, tree expr, basic_block bb, enum rfd_mode); > + bool edge_range (vrange &r, edge e, tree name, enum rfd_mode); > > vec m_workback; > class update_list *m_update; > diff --git a/gcc/gimple-range-edge.cc b/gcc/gimple-range-edge.cc > index 5264e627c9a..6fe33408f7e 100644 > --- a/gcc/gimple-range-edge.cc > +++ b/gcc/gimple-range-edge.cc > @@ -83,11 +83,8 @@ gimple_outgoing_range::~gimple_outgoing_range () > // Use a cached value if it exists, or calculate it if not. > > bool > -gimple_outgoing_range::get_edge_range (irange &r, gimple *s, edge e) > +gimple_outgoing_range::switch_edge_range (irange &r, gswitch *sw, edge e) > { > - gcc_checking_assert (is_a (s)); > - gswitch *sw = as_a (s); > - > // ADA currently has cases where the index is 64 bits and the case > // arguments are 32 bit, causing a trap when we create a case_range. > // Until this is resolved (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87798) > @@ -204,12 +201,9 @@ gimple_outgoing_range::edge_range_p (irange &r, edge e) > > gcc_checking_assert (is_a (s)); > gswitch *sw = as_a (s); > - tree type = TREE_TYPE (gimple_switch_index (sw)); > - > - if (!irange::supports_type_p (type)) > - return NULL; > > - if (get_edge_range (r, sw, e)) > + // Switches can only be integers. > + if (switch_edge_range (as_a (r), sw, e)) > return s; > > return NULL; > diff --git a/gcc/gimple-range-edge.h b/gcc/gimple-range-edge.h > index ce383b0aa6f..a9c4af8715b 100644 > --- a/gcc/gimple-range-edge.h > +++ b/gcc/gimple-range-edge.h > @@ -43,7 +43,7 @@ public: > gimple *edge_range_p (irange &r, edge e); > private: > void calc_switch_ranges (gswitch *sw); > - bool get_edge_range (irange &r, gimple *s, edge e); > + bool switch_edge_range (irange &r, gswitch *sw, edge e); > > int m_max_edges; > hash_map *m_edge_table; > diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc > index c53d2863d5e..7fed5a99513 100644 > --- a/gcc/gimple-range-fold.cc > +++ b/gcc/gimple-range-fold.cc > @@ -60,7 +60,7 @@ fur_source::fur_source (range_query *q) > // Invoke range_of_expr on EXPR. > > bool > -fur_source::get_operand (irange &r, tree expr) > +fur_source::get_operand (vrange &r, tree expr) > { > return m_query->range_of_expr (r, expr); > } > @@ -69,7 +69,7 @@ fur_source::get_operand (irange &r, tree expr) > // range_query to get the range on the edge. > > bool > -fur_source::get_phi_operand (irange &r, tree expr, edge e) > +fur_source::get_phi_operand (vrange &r, tree expr, edge e) > { > return m_query->range_on_edge (r, e, expr); > } > @@ -109,8 +109,8 @@ class fur_edge : public fur_source > { > public: > fur_edge (edge e, range_query *q = NULL); > - virtual bool get_operand (irange &r, tree expr) override; > - virtual bool get_phi_operand (irange &r, tree expr, edge e) override; > + virtual bool get_operand (vrange &r, tree expr) override; > + virtual bool get_phi_operand (vrange &r, tree expr, edge e) override; > private: > edge m_edge; > }; > @@ -126,7 +126,7 @@ fur_edge::fur_edge (edge e, range_query *q) : fur_source (q) > // Get the value of EXPR on edge m_edge. > > bool > -fur_edge::get_operand (irange &r, tree expr) > +fur_edge::get_operand (vrange &r, tree expr) > { > return m_query->range_on_edge (r, m_edge, expr); > } > @@ -135,7 +135,7 @@ fur_edge::get_operand (irange &r, tree expr) > // range_query to get the range on the edge. > > bool > -fur_edge::get_phi_operand (irange &r, tree expr, edge e) > +fur_edge::get_phi_operand (vrange &r, tree expr, edge e) > { > // Edge to edge recalculations not supoprted yet, until we sort it out. > gcc_checking_assert (e == m_edge); > @@ -152,7 +152,7 @@ fur_stmt::fur_stmt (gimple *s, range_query *q) : fur_source (q) > // Retreive range of EXPR as it occurs as a use on stmt M_STMT. > > bool > -fur_stmt::get_operand (irange &r, tree expr) > +fur_stmt::get_operand (vrange &r, tree expr) > { > return m_query->range_of_expr (r, expr, m_stmt); > } > @@ -161,7 +161,7 @@ fur_stmt::get_operand (irange &r, tree expr) > // range_query to get the range on the edge. > > bool > -fur_stmt::get_phi_operand (irange &r, tree expr, edge e) > +fur_stmt::get_phi_operand (vrange &r, tree expr, edge e) > { > // Pick up the range of expr from edge E. > fur_edge e_src (e, m_query); > @@ -214,42 +214,42 @@ fur_depend::register_relation (edge e, relation_kind k, tree op1, tree op2) > class fur_list : public fur_source > { > public: > - fur_list (irange &r1); > - fur_list (irange &r1, irange &r2); > - fur_list (unsigned num, irange *list); > - virtual bool get_operand (irange &r, tree expr) override; > - virtual bool get_phi_operand (irange &r, tree expr, edge e) override; > + fur_list (vrange &r1); > + fur_list (vrange &r1, vrange &r2); > + fur_list (unsigned num, vrange **list); > + virtual bool get_operand (vrange &r, tree expr) override; > + virtual bool get_phi_operand (vrange &r, tree expr, edge e) override; > private: > - int_range_max m_local[2]; > - irange *m_list; > + vrange *m_local[2]; > + vrange **m_list; > unsigned m_index; > unsigned m_limit; > }; > > // One range supplied for unary operations. > > -fur_list::fur_list (irange &r1) : fur_source (NULL) > +fur_list::fur_list (vrange &r1) : fur_source (NULL) > { > m_list = m_local; > m_index = 0; > m_limit = 1; > - m_local[0] = r1; > + m_local[0] = &r1; > } > > // Two ranges supplied for binary operations. > > -fur_list::fur_list (irange &r1, irange &r2) : fur_source (NULL) > +fur_list::fur_list (vrange &r1, vrange &r2) : fur_source (NULL) > { > m_list = m_local; > m_index = 0; > m_limit = 2; > - m_local[0] = r1; > - m_local[1] = r2; > + m_local[0] = &r1; > + m_local[1] = &r2; > } > > // Arbitrary number of ranges in a vector. > > -fur_list::fur_list (unsigned num, irange *list) : fur_source (NULL) > +fur_list::fur_list (unsigned num, vrange **list) : fur_source (NULL) > { > m_list = list; > m_index = 0; > @@ -259,18 +259,18 @@ fur_list::fur_list (unsigned num, irange *list) : fur_source (NULL) > // Get the next operand from the vector, ensure types are compatible. > > bool > -fur_list::get_operand (irange &r, tree expr) > +fur_list::get_operand (vrange &r, tree expr) > { > if (m_index >= m_limit) > return m_query->range_of_expr (r, expr); > - r = m_list[m_index++]; > + r = *m_list[m_index++]; > gcc_checking_assert (range_compatible_p (TREE_TYPE (expr), r.type ())); > return true; > } > > // This will simply pick the next operand from the vector. > bool > -fur_list::get_phi_operand (irange &r, tree expr, edge e ATTRIBUTE_UNUSED) > +fur_list::get_phi_operand (vrange &r, tree expr, edge e ATTRIBUTE_UNUSED) > { > return get_operand (r, expr); > } > @@ -278,7 +278,7 @@ fur_list::get_phi_operand (irange &r, tree expr, edge e ATTRIBUTE_UNUSED) > // Fold stmt S into range R using R1 as the first operand. > > bool > -fold_range (irange &r, gimple *s, irange &r1) > +fold_range (vrange &r, gimple *s, vrange &r1) > { > fold_using_range f; > fur_list src (r1); > @@ -288,7 +288,7 @@ fold_range (irange &r, gimple *s, irange &r1) > // Fold stmt S into range R using R1 and R2 as the first two operands. > > bool > -fold_range (irange &r, gimple *s, irange &r1, irange &r2) > +fold_range (vrange &r, gimple *s, vrange &r1, vrange &r2) > { > fold_using_range f; > fur_list src (r1, r2); > @@ -299,7 +299,7 @@ fold_range (irange &r, gimple *s, irange &r1, irange &r2) > // operands encountered. > > bool > -fold_range (irange &r, gimple *s, unsigned num_elements, irange *vector) > +fold_range (vrange &r, gimple *s, unsigned num_elements, vrange **vector) > { > fold_using_range f; > fur_list src (num_elements, vector); > @@ -309,7 +309,7 @@ fold_range (irange &r, gimple *s, unsigned num_elements, irange *vector) > // Fold stmt S into range R using range query Q. > > bool > -fold_range (irange &r, gimple *s, range_query *q) > +fold_range (vrange &r, gimple *s, range_query *q) > { > fold_using_range f; > fur_stmt src (s, q); > @@ -319,7 +319,7 @@ fold_range (irange &r, gimple *s, range_query *q) > // Recalculate stmt S into R using range query Q as if it were on edge ON_EDGE. > > bool > -fold_range (irange &r, gimple *s, edge on_edge, range_query *q) > +fold_range (vrange &r, gimple *s, edge on_edge, range_query *q) > { > fold_using_range f; > fur_edge src (on_edge, q); > @@ -370,7 +370,7 @@ adjust_pointer_diff_expr (irange &res, const gimple *diff_stmt) > // Adjust the range for an IMAGPART_EXPR. > > static void > -adjust_imagpart_expr (irange &res, const gimple *stmt) > +adjust_imagpart_expr (vrange &res, const gimple *stmt) > { > tree name = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0); > > @@ -413,7 +413,7 @@ adjust_imagpart_expr (irange &res, const gimple *stmt) > // Adjust the range for a REALPART_EXPR. > > static void > -adjust_realpart_expr (irange &res, const gimple *stmt) > +adjust_realpart_expr (vrange &res, const gimple *stmt) > { > tree name = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0); > > @@ -442,12 +442,12 @@ adjust_realpart_expr (irange &res, const gimple *stmt) > // this statement. > > static void > -gimple_range_adjustment (irange &res, const gimple *stmt) > +gimple_range_adjustment (vrange &res, const gimple *stmt) > { > switch (gimple_expr_code (stmt)) > { > case POINTER_DIFF_EXPR: > - adjust_pointer_diff_expr (res, stmt); > + adjust_pointer_diff_expr (as_a (res), stmt); > return; > > case IMAGPART_EXPR: > @@ -536,7 +536,7 @@ gimple_range_operand2 (const gimple *stmt) > // be calculated, return false. > > bool > -fold_using_range::fold_stmt (irange &r, gimple *s, fur_source &src, tree name) > +fold_using_range::fold_stmt (vrange &r, gimple *s, fur_source &src, tree name) > { > bool res = false; > // If name and S are specified, make sure it is an LHS of S. > @@ -549,7 +549,7 @@ fold_using_range::fold_stmt (irange &r, gimple *s, fur_source &src, tree name) > // Process addresses. > if (gimple_code (s) == GIMPLE_ASSIGN > && gimple_assign_rhs_code (s) == ADDR_EXPR) > - return range_of_address (r, s, src); > + return range_of_address (as_a (r), s, src); > > if (range_op_handler (s)) > res = range_of_range_op (r, s, src); > @@ -566,7 +566,7 @@ fold_using_range::fold_stmt (irange &r, gimple *s, fur_source &src, tree name) > if (!name || !gimple_range_ssa_p (name)) > return false; > // We don't understand the stmt, so return the global range. > - r = gimple_range_global (name); > + gimple_range_global (r, name); > return true; > } > > @@ -587,9 +587,8 @@ fold_using_range::fold_stmt (irange &r, gimple *s, fur_source &src, tree name) > // If a range cannot be calculated, return false. > > bool > -fold_using_range::range_of_range_op (irange &r, gimple *s, fur_source &src) > +fold_using_range::range_of_range_op (vrange &r, gimple *s, fur_source &src) > { > - int_range_max range1, range2; > tree type = gimple_range_type (s); > if (!type) > return false; > @@ -599,13 +598,16 @@ fold_using_range::range_of_range_op (irange &r, gimple *s, fur_source &src) > tree lhs = gimple_get_lhs (s); > tree op1 = gimple_range_operand1 (s); > tree op2 = gimple_range_operand2 (s); > + tmp_range range1 (TREE_TYPE (op1)); > + tmp_range range2; > > if (src.get_operand (range1, op1)) > { > if (!op2) > { > // Fold range, and register any dependency if available. > - int_range<2> r2 (type); > + tmp_range r2 (type); > + r2.set_varying (type); > handler.fold_range (r, type, range1, r2); > if (lhs && gimple_range_ssa_p (op1)) > { > @@ -617,7 +619,8 @@ fold_using_range::range_of_range_op (irange &r, gimple *s, fur_source &src) > src.register_relation (s, rel, lhs, op1); > } > } > - else if (src.get_operand (range2, op2)) > + else if (range2.init (TREE_TYPE (op2)) > + && src.get_operand (range2, op2)) > { > relation_kind rel = src.query_relation (op1, op2); > if (dump_file && (dump_flags & TDF_DETAILS) && rel != VREL_VARYING) > @@ -630,7 +633,8 @@ fold_using_range::range_of_range_op (irange &r, gimple *s, fur_source &src) > } > // Fold range, and register any dependency if available. > handler.fold_range (r, type, range1, range2, rel); > - relation_fold_and_or (r, s, src); > + if (irange::supports_type_p (type)) > + relation_fold_and_or (as_a (r), s, src); > if (lhs) > { > if (src.gori ()) > @@ -663,7 +667,8 @@ fold_using_range::range_of_range_op (irange &r, gimple *s, fur_source &src) > e0 = NULL; > if (!single_pred_p (e1->dest)) > e1 = NULL; > - src.register_outgoing_edges (as_a (s), r, e0, e1); > + src.register_outgoing_edges (as_a (s), > + as_a (r), e0, e1); > } > } > else > @@ -729,12 +734,12 @@ fold_using_range::range_of_address (irange &r, gimple *stmt, fur_source &src) > { > /* For -fdelete-null-pointer-checks -fno-wrapv-pointer we don't > allow going from non-NULL pointer to NULL. */ > - if (!range_includes_zero_p (&r)) > + if (r.undefined_p () || !r.contains_p (build_zero_cst (r.type ()))) > { > /* We could here instead adjust r by off >> LOG2_BITS_PER_UNIT > using POINTER_PLUS_EXPR if off_cst and just fall back to > this. */ > - r = range_nonzero (TREE_TYPE (gimple_assign_rhs1 (stmt))); > + r.set_nonzero (TREE_TYPE (gimple_assign_rhs1 (stmt))); > return true; > } > } > @@ -746,22 +751,22 @@ fold_using_range::range_of_address (irange &r, gimple *stmt, fur_source &src) > && known_ne (off, 0) > && (flag_delete_null_pointer_checks || known_gt (off, 0))) > { > - r = range_nonzero (TREE_TYPE (gimple_assign_rhs1 (stmt))); > + r.set_nonzero (TREE_TYPE (gimple_assign_rhs1 (stmt))); > return true; > } > - r = int_range<2> (TREE_TYPE (gimple_assign_rhs1 (stmt))); > + r.set_varying (TREE_TYPE (gimple_assign_rhs1 (stmt))); > return true; > } > > // Handle "= &a". > if (tree_single_nonzero_warnv_p (expr, &strict_overflow_p)) > { > - r = range_nonzero (TREE_TYPE (gimple_assign_rhs1 (stmt))); > + r.set_nonzero (TREE_TYPE (gimple_assign_rhs1 (stmt))); > return true; > } > > // Otherwise return varying. > - r = int_range<2> (TREE_TYPE (gimple_assign_rhs1 (stmt))); > + r.set_varying (TREE_TYPE (gimple_assign_rhs1 (stmt))); > return true; > } > > @@ -769,12 +774,12 @@ fold_using_range::range_of_address (irange &r, gimple *stmt, fur_source &src) > // If a range cannot be calculated, return false. > > bool > -fold_using_range::range_of_phi (irange &r, gphi *phi, fur_source &src) > +fold_using_range::range_of_phi (vrange &r, gphi *phi, fur_source &src) > { > tree phi_def = gimple_phi_result (phi); > tree type = gimple_range_type (phi); > - int_range_max arg_range; > - int_range_max equiv_range; > + tmp_range arg_range (type); > + tmp_range equiv_range (type); > unsigned x; > > if (!type) > @@ -881,7 +886,7 @@ fold_using_range::range_of_phi (irange &r, gphi *phi, fur_source &src) > // If a range cannot be calculated, return false. > > bool > -fold_using_range::range_of_call (irange &r, gcall *call, fur_source &src) > +fold_using_range::range_of_call (vrange &r, gcall *call, fur_source &src) > { > tree type = gimple_range_type (call); > if (!type) > @@ -893,18 +898,18 @@ fold_using_range::range_of_call (irange &r, gcall *call, fur_source &src) > if (range_of_builtin_call (r, call, src)) > ; > else if (gimple_stmt_nonnegative_warnv_p (call, &strict_overflow_p)) > - r.set (build_int_cst (type, 0), TYPE_MAX_VALUE (type)); > + r.set_nonnegative (type); > else if (gimple_call_nonnull_result_p (call) > || gimple_call_nonnull_arg (call)) > - r = range_nonzero (type); > + r.set_nonzero (type); > else > r.set_varying (type); > > // If there is an LHS, intersect that with what is known. > if (lhs) > { > - value_range def; > - def = gimple_range_global (lhs); > + tmp_range def (TREE_TYPE (lhs)); > + gimple_range_global (def, lhs); > r.intersect (def); > } > return true; > @@ -971,13 +976,30 @@ get_letter_range (tree type, irange &lowers, irange &uppers) > // TRUE. Otherwise return FALSE. > > bool > -fold_using_range::range_of_builtin_call (irange &r, gcall *call, > +fold_using_range::range_of_builtin_call (vrange &r, gcall *call, > fur_source &src) > { > combined_fn func = gimple_call_combined_fn (call); > if (func == CFN_LAST) > return false; > > + tree type = gimple_range_type (call); > + gcc_checking_assert (type); > + > + if (irange::supports_type_p (type)) > + return range_of_builtin_int_call (as_a (r), call, src); > + > + return false; > +} > + > +bool > +fold_using_range::range_of_builtin_int_call (irange &r, gcall *call, > + fur_source &src) > +{ > + combined_fn func = gimple_call_combined_fn (call); > + if (func == CFN_LAST) > + return false; > + > tree type = gimple_range_type (call); > tree arg; > int mini, maxi, zerov = 0, prec; > @@ -1256,9 +1278,8 @@ fold_using_range::range_of_builtin_call (irange &r, gcall *call, > // If a range cannot be calculated, return false. > > bool > -fold_using_range::range_of_cond_expr (irange &r, gassign *s, fur_source &src) > +fold_using_range::range_of_cond_expr (vrange &r, gassign *s, fur_source &src) > { > - int_range_max cond_range, range1, range2; > tree cond = gimple_assign_rhs1 (s); > tree op1 = gimple_assign_rhs2 (s); > tree op2 = gimple_assign_rhs3 (s); > @@ -1267,6 +1288,9 @@ fold_using_range::range_of_cond_expr (irange &r, gassign *s, fur_source &src) > if (!type) > return false; > > + tmp_range range1 (TREE_TYPE (op1)); > + tmp_range range2 (TREE_TYPE (op2)); > + tmp_range cond_range (TREE_TYPE (cond)); > gcc_checking_assert (gimple_assign_rhs_code (s) == COND_EXPR); > gcc_checking_assert (range_compatible_p (TREE_TYPE (op1), TREE_TYPE (op2))); > src.get_operand (cond_range, cond); > @@ -1438,7 +1462,6 @@ fold_using_range::relation_fold_and_or (irange& lhs_range, gimple *s, > void > fur_source::register_outgoing_edges (gcond *s, irange &lhs_range, edge e0, edge e1) > { > - int_range_max r; > int_range<2> e0_range, e1_range; > tree name; > basic_block bb = gimple_bb (s); > @@ -1505,6 +1528,7 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range, edge e0, edge > continue; > tree ssa1 = gimple_range_ssa_p (gimple_range_operand1 (stmt)); > tree ssa2 = gimple_range_ssa_p (gimple_range_operand2 (stmt)); > + tmp_range r (TREE_TYPE (name)); > if (ssa1 && ssa2) > { > if (e0 && gori ()->outgoing_edge_range_p (r, e0, name, *m_query) > diff --git a/gcc/gimple-range-fold.h b/gcc/gimple-range-fold.h > index 4b5d4b6e0b8..df24280ee40 100644 > --- a/gcc/gimple-range-fold.h > +++ b/gcc/gimple-range-fold.h > @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see > #define GCC_GIMPLE_RANGE_FOLD_H > > // This file is the main include point for gimple range folding. > -// These routines will fold stmt S into the result irange R. > +// These routines will fold stmt S into the result range R. > // Any ssa_names on the stmt will be calculated using the range_query > // parameter via a call to range_of_expr. > // If no range_query is provided, current global range info will be used. > @@ -31,15 +31,15 @@ along with GCC; see the file COPYING3. If not see > // it appeared on that edge. > > // Fold stmt S into range R using range query Q. > -bool fold_range (irange &r, gimple *s, range_query *q = NULL); > +bool fold_range (vrange &r, gimple *s, range_query *q = NULL); > // Recalculate stmt S into R using range query Q as if it were on edge ON_EDGE. > -bool fold_range (irange &r, gimple *s, edge on_edge, range_query *q = NULL); > +bool fold_range (vrange &v, gimple *s, edge on_edge, range_query *q = NULL); > > // These routines the operands to be specified when manually folding. > // Any excess queries will be drawn from the current range_query. > -bool fold_range (irange &r, gimple *s, irange &r1); > -bool fold_range (irange &r, gimple *s, irange &r1, irange &r2); > -bool fold_range (irange &r, gimple *s, unsigned num_elements, irange *vector); > +bool fold_range (vrange &r, gimple *s, vrange &r1); > +bool fold_range (vrange &r, gimple *s, vrange &r1, vrange &r2); > +bool fold_range (vrange &r, gimple *s, unsigned num_elements, vrange **vector); > > // Return the type of range which statement S calculates. If the type is > // unsupported or no type can be determined, return NULL_TREE. > @@ -66,7 +66,7 @@ gimple_range_type (const gimple *s) > type = TREE_TYPE (type); > } > } > - if (type && irange::supports_type_p (type)) > + if (type && vrange::supports_type_p (type)) > return type; > return NULL_TREE; > } > @@ -79,7 +79,7 @@ gimple_range_ssa_p (tree exp) > if (exp && TREE_CODE (exp) == SSA_NAME && > !SSA_NAME_IS_VIRTUAL_OPERAND (exp) && > !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (exp) && > - irange::supports_type_p (TREE_TYPE (exp))) > + vrange::supports_type_p (TREE_TYPE (exp))) > return exp; > return NULL_TREE; > } > @@ -108,8 +108,8 @@ public: > fur_source (range_query *q = NULL); > inline range_query *query () { return m_query; } > inline class gori_compute *gori () { return m_gori; }; > - virtual bool get_operand (irange &r, tree expr); > - virtual bool get_phi_operand (irange &r, tree expr, edge e); > + virtual bool get_operand (vrange &r, tree expr); > + virtual bool get_phi_operand (vrange &r, tree expr, edge e); > virtual relation_kind query_relation (tree op1, tree op2); > virtual void register_relation (gimple *stmt, relation_kind k, tree op1, > tree op2); > @@ -128,8 +128,8 @@ class fur_stmt : public fur_source > { > public: > fur_stmt (gimple *s, range_query *q = NULL); > - virtual bool get_operand (irange &r, tree expr) override; > - virtual bool get_phi_operand (irange &r, tree expr, edge e) override; > + virtual bool get_operand (vrange &r, tree expr) override; > + virtual bool get_phi_operand (vrange &r, tree expr, edge e) override; > virtual relation_kind query_relation (tree op1, tree op2) override; > private: > gimple *m_stmt; > @@ -161,17 +161,18 @@ extern tree gimple_range_operand2 (const gimple *s); > class fold_using_range > { > public: > - bool fold_stmt (irange &r, gimple *s, class fur_source &src, > + bool fold_stmt (vrange &r, gimple *s, class fur_source &src, > tree name = NULL_TREE); > protected: > - bool range_of_range_op (irange &r, gimple *s, fur_source &src); > - bool range_of_call (irange &r, gcall *call, fur_source &src); > - bool range_of_cond_expr (irange &r, gassign* cond, fur_source &src); > + bool range_of_range_op (vrange &r, gimple *s, fur_source &src); > + bool range_of_call (vrange &r, gcall *call, fur_source &src); > + bool range_of_cond_expr (vrange &r, gassign* cond, fur_source &src); > bool range_of_address (irange &r, gimple *s, fur_source &src); > - bool range_of_builtin_call (irange &r, gcall *call, fur_source &src); > + bool range_of_builtin_call (vrange &r, gcall *call, fur_source &src); > + bool range_of_builtin_int_call (irange &r, gcall *call, fur_source &src); > void range_of_builtin_ubsan_call (irange &r, gcall *call, tree_code code, > fur_source &src); > - bool range_of_phi (irange &r, gphi *phi, fur_source &src); > + bool range_of_phi (vrange &r, gphi *phi, fur_source &src); > void range_of_ssa_name_with_loop_info (irange &, tree, class loop *, gphi *, > fur_source &src); > void relation_fold_and_or (irange& lhs_range, gimple *s, fur_source &src); > diff --git a/gcc/gimple-range-gori.cc b/gcc/gimple-range-gori.cc > index 0e0cf2128e7..47d0dab8cb9 100644 > --- a/gcc/gimple-range-gori.cc > +++ b/gcc/gimple-range-gori.cc > @@ -34,7 +34,7 @@ along with GCC; see the file COPYING3. If not see > // LHS_RANGE. Return false if nothing can be determined. > > bool > -gimple_range_calc_op1 (irange &r, const gimple *stmt, const irange &lhs_range) > +gimple_range_calc_op1 (vrange &r, const gimple *stmt, const vrange &lhs_range) > { > gcc_checking_assert (gimple_num_ops (stmt) < 3); > // Give up on empty ranges. > @@ -55,8 +55,8 @@ gimple_range_calc_op1 (irange &r, const gimple *stmt, const irange &lhs_range) > // nothing can be determined. > > bool > -gimple_range_calc_op1 (irange &r, const gimple *stmt, > - const irange &lhs_range, const irange &op2_range) > +gimple_range_calc_op1 (vrange &r, const gimple *stmt, > + const vrange &lhs_range, const vrange &op2_range) > { > // Give up on empty ranges. > if (lhs_range.undefined_p ()) > @@ -86,8 +86,8 @@ gimple_range_calc_op1 (irange &r, const gimple *stmt, > // nothing can be determined. > > bool > -gimple_range_calc_op2 (irange &r, const gimple *stmt, > - const irange &lhs_range, const irange &op1_range) > +gimple_range_calc_op2 (vrange &r, const gimple *stmt, > + const vrange &lhs_range, const vrange &op1_range) > { > // Give up on empty ranges. > if (lhs_range.undefined_p ()) > @@ -663,8 +663,8 @@ gori_compute::gori_compute (int not_executable_flag) > // was not resolvable. > > bool > -gori_compute::compute_operand_range_switch (irange &r, gswitch *s, > - const irange &lhs, > +gori_compute::compute_operand_range_switch (vrange &r, gswitch *s, > + const vrange &lhs, > tree name, fur_source &src) > { > tree op1 = gimple_switch_index (s); > @@ -691,8 +691,8 @@ gori_compute::compute_operand_range_switch (irange &r, gswitch *s, > // store the evaluation in R, otherwise return FALSE. > > bool > -gori_compute::compute_operand_range (irange &r, gimple *stmt, > - const irange &lhs, tree name, > +gori_compute::compute_operand_range (vrange &r, gimple *stmt, > + const vrange &lhs, tree name, > fur_source &src) > { > // If the lhs doesn't tell us anything, neither will unwinding further. > @@ -743,13 +743,18 @@ gori_compute::compute_operand_range (irange &r, gimple *stmt, > print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); > } > > - int_range_max op1_trange, op1_frange; > - int_range_max op2_trange, op2_frange; > - compute_logical_operands (op1_trange, op1_frange, stmt, lhs, > + tree type = TREE_TYPE (name); > + tmp_range op1_trange (type), op1_frange (type); > + tmp_range op2_trange (type), op2_frange (type); > + compute_logical_operands (op1_trange, op1_frange, stmt, > + as_a (lhs), > name, src, op1, op1_in_chain); > - compute_logical_operands (op2_trange, op2_frange, stmt, lhs, > + compute_logical_operands (op2_trange, op2_frange, stmt, > + as_a (lhs), > name, src, op2, op2_in_chain); > - res = logical_combine (r, gimple_expr_code (stmt), lhs, > + res = logical_combine (r, > + gimple_expr_code (stmt), > + as_a (lhs), > op1_trange, op1_frange, op2_trange, op2_frange); > if (idx) > tracer.trailer (idx, "compute_operand", res, name, r); > @@ -789,10 +794,10 @@ range_is_either_true_or_false (const irange &r) > // the LHS. > > bool > -gori_compute::logical_combine (irange &r, enum tree_code code, > +gori_compute::logical_combine (vrange &r, enum tree_code code, > const irange &lhs, > - const irange &op1_true, const irange &op1_false, > - const irange &op2_true, const irange &op2_false) > + const vrange &op1_true, const vrange &op1_false, > + const vrange &op2_true, const vrange &op2_false) > { > if (op1_true.varying_p () && op1_false.varying_p () > && op2_true.varying_p () && op2_false.varying_p ()) > @@ -868,7 +873,7 @@ gori_compute::logical_combine (irange &r, enum tree_code code, > if (!range_is_either_true_or_false (lhs)) > { > bool res; > - int_range_max r1; > + tmp_range r1 (r); > if (logical_combine (r1, code, m_bool_zero, op1_true, op1_false, > op2_true, op2_false) > && logical_combine (r, code, m_bool_one, op1_true, op1_false, > @@ -898,11 +903,11 @@ gori_compute::logical_combine (irange &r, enum tree_code code, > else > { > // The FALSE side is the union of the other 3 cases. > - int_range_max ff (op1_false); > + tmp_range ff (op1_false); > ff.intersect (op2_false); > - int_range_max tf (op1_true); > + tmp_range tf (op1_true); > tf.intersect (op2_false); > - int_range_max ft (op1_false); > + tmp_range ft (op1_false); > ft.intersect (op2_true); > r = ff; > r.union_ (tf); > @@ -925,11 +930,11 @@ gori_compute::logical_combine (irange &r, enum tree_code code, > { > // The TRUE side of an OR operation will be the union of > // the other three combinations. > - int_range_max tt (op1_true); > + tmp_range tt (op1_true); > tt.intersect (op2_true); > - int_range_max tf (op1_true); > + tmp_range tf (op1_true); > tf.intersect (op2_false); > - int_range_max ft (op1_false); > + tmp_range ft (op1_false); > ft.intersect (op2_true); > r = tt; > r.union_ (tf); > @@ -951,7 +956,7 @@ gori_compute::logical_combine (irange &r, enum tree_code code, > // OP_IN_CHAIN is true. > > void > -gori_compute::compute_logical_operands (irange &true_range, irange &false_range, > +gori_compute::compute_logical_operands (vrange &true_range, vrange &false_range, > gimple *stmt, > const irange &lhs, > tree name, fur_source &src, > @@ -1007,13 +1012,15 @@ gori_compute::compute_logical_operands (irange &true_range, irange &false_range, > // R, or false if no range could be calculated. > > bool > -gori_compute::compute_operand1_range (irange &r, gimple *stmt, > - const irange &lhs, tree name, > +gori_compute::compute_operand1_range (vrange &r, gimple *stmt, > + const vrange &lhs, tree name, > fur_source &src) > { > - int_range_max op1_range, op2_range; > tree op1 = gimple_range_operand1 (stmt); > tree op2 = gimple_range_operand2 (stmt); > + tmp_range op1_range (TREE_TYPE (op1)); > + tmp_range tmp (TREE_TYPE (op1)); > + tmp_range op2_range; > > // Fetch the known range for op1 in this block. > src.get_operand (op1_range, op1); > @@ -1021,8 +1028,9 @@ gori_compute::compute_operand1_range (irange &r, gimple *stmt, > // Now range-op calcuate and put that result in r. > if (op2) > { > + op2_range.init (TREE_TYPE (op2)); > src.get_operand (op2_range, op2); > - if (!gimple_range_calc_op1 (r, stmt, lhs, op2_range)) > + if (!gimple_range_calc_op1 (tmp, stmt, lhs, op2_range)) > return false; > } > else > @@ -1030,7 +1038,7 @@ gori_compute::compute_operand1_range (irange &r, gimple *stmt, > // We pass op1_range to the unary operation. Nomally it's a > // hidden range_for_type parameter, but sometimes having the > // actual range can result in better information. > - if (!gimple_range_calc_op1 (r, stmt, lhs, op1_range)) > + if (!gimple_range_calc_op1 (tmp, stmt, lhs, op1_range)) > return false; > } > > @@ -1053,7 +1061,7 @@ gori_compute::compute_operand1_range (irange &r, gimple *stmt, > tracer.print (idx, "Computes "); > print_generic_expr (dump_file, op1, TDF_SLIM); > fprintf (dump_file, " = "); > - r.dump (dump_file); > + tmp.dump (dump_file); > fprintf (dump_file, " intersect Known range : "); > op1_range.dump (dump_file); > fputc ('\n', dump_file); > @@ -1061,13 +1069,14 @@ gori_compute::compute_operand1_range (irange &r, gimple *stmt, > // Intersect the calculated result with the known result and return if done. > if (op1 == name) > { > - r.intersect (op1_range); > + tmp.intersect (op1_range); > + r = tmp; > if (idx) > tracer.trailer (idx, "produces ", true, name, r); > return true; > } > // If the calculation continues, we're using op1_range as the new LHS. > - op1_range.intersect (r); > + op1_range.intersect (tmp); > > if (idx) > tracer.trailer (idx, "produces ", true, op1, op1_range); > @@ -1084,19 +1093,21 @@ gori_compute::compute_operand1_range (irange &r, gimple *stmt, > // R, or false if no range could be calculated. > > bool > -gori_compute::compute_operand2_range (irange &r, gimple *stmt, > - const irange &lhs, tree name, > +gori_compute::compute_operand2_range (vrange &r, gimple *stmt, > + const vrange &lhs, tree name, > fur_source &src) > { > - int_range_max op1_range, op2_range; > tree op1 = gimple_range_operand1 (stmt); > tree op2 = gimple_range_operand2 (stmt); > + tmp_range op1_range (TREE_TYPE (op1)); > + tmp_range op2_range (TREE_TYPE (op2)); > + tmp_range tmp (TREE_TYPE (op2)); > > src.get_operand (op1_range, op1); > src.get_operand (op2_range, op2); > > // Intersect with range for op2 based on lhs and op1. > - if (!gimple_range_calc_op2 (r, stmt, lhs, op1_range)) > + if (!gimple_range_calc_op2 (tmp, stmt, lhs, op1_range)) > return false; > > unsigned idx; > @@ -1118,7 +1129,7 @@ gori_compute::compute_operand2_range (irange &r, gimple *stmt, > tracer.print (idx, "Computes "); > print_generic_expr (dump_file, op2, TDF_SLIM); > fprintf (dump_file, " = "); > - r.dump (dump_file); > + tmp.dump (dump_file); > fprintf (dump_file, " intersect Known range : "); > op2_range.dump (dump_file); > fputc ('\n', dump_file); > @@ -1126,13 +1137,14 @@ gori_compute::compute_operand2_range (irange &r, gimple *stmt, > // Intersect the calculated result with the known result and return if done. > if (op2 == name) > { > - r.intersect (op2_range); > + tmp.intersect (op2_range); > + r = tmp; > if (idx) > tracer.trailer (idx, " produces ", true, NULL_TREE, r); > return true; > } > // If the calculation continues, we're using op2_range as the new LHS. > - op2_range.intersect (r); > + op2_range.intersect (tmp); > > if (idx) > tracer.trailer (idx, " produces ", true, op2, op2_range); > @@ -1149,13 +1161,13 @@ gori_compute::compute_operand2_range (irange &r, gimple *stmt, > // R, or false if no range could be calculated. > > bool > -gori_compute::compute_operand1_and_operand2_range (irange &r, > +gori_compute::compute_operand1_and_operand2_range (vrange &r, > gimple *stmt, > - const irange &lhs, > + const vrange &lhs, > tree name, > fur_source &src) > { > - int_range_max op_range; > + tmp_range op_range (TREE_TYPE (name)); > > // Calculate a good a range for op2. Since op1 == op2, this will > // have already included whatever the actual range of name is. > @@ -1236,10 +1248,9 @@ gori_compute::has_edge_range_p (tree name, edge e) > // control edge or NAME is not defined by this edge. > > bool > -gori_compute::outgoing_edge_range_p (irange &r, edge e, tree name, > +gori_compute::outgoing_edge_range_p (vrange &r, edge e, tree name, > range_query &q) > { > - int_range_max lhs; > unsigned idx; > > if ((e->flags & m_not_executable_flag)) > @@ -1252,6 +1263,7 @@ gori_compute::outgoing_edge_range_p (irange &r, edge e, tree name, > } > > gcc_checking_assert (gimple_range_ssa_p (name)); > + int_range_max lhs; > // Determine if there is an outgoing edge. > gimple *stmt = outgoing.edge_range_p (lhs, e); > if (!stmt) > @@ -1312,10 +1324,9 @@ gori_compute::outgoing_edge_range_p (irange &r, edge e, tree name, > // edge and OP2 on the false edge. > > bool > -gori_compute::condexpr_adjust (irange &r1, irange &r2, gimple *, tree cond, > +gori_compute::condexpr_adjust (vrange &r1, vrange &r2, gimple *, tree cond, > tree op1, tree op2, fur_source &src) > { > - int_range_max tmp, cond_true, cond_false; > tree ssa1 = gimple_range_ssa_p (op1); > tree ssa2 = gimple_range_ssa_p (op2); > if (!ssa1 && !ssa2) > @@ -1341,15 +1352,19 @@ gori_compute::condexpr_adjust (irange &r1, irange &r2, gimple *, tree cond, > return false; > > // Pick up the current values of each part of the condition. > - int_range_max cl, cr; > - src.get_operand (cl, gimple_assign_rhs1 (cond_def)); > - src.get_operand (cr, gimple_assign_rhs2 (cond_def)); > + tree rhs1 = gimple_assign_rhs1 (cond_def); > + tree rhs2 = gimple_assign_rhs2 (cond_def); > + tmp_range cl (TREE_TYPE (rhs1)); > + tmp_range cr (TREE_TYPE (rhs2)); > + src.get_operand (cl, rhs1); > + src.get_operand (cr, rhs2); > > tree cond_name = c1 ? c1 : c2; > gimple *def_stmt = SSA_NAME_DEF_STMT (cond_name); > > // Evaluate the value of COND_NAME on the true and false edges, using either > // the op1 or op2 routines based on its location. > + tmp_range cond_true (type), cond_false (type); > if (c1) > { > if (!hand.op1_range (cond_false, type, m_bool_zero, cr)) > @@ -1380,6 +1395,7 @@ gori_compute::condexpr_adjust (irange &r1, irange &r2, gimple *, tree cond, > } > > // Now solve for SSA1 or SSA2 if they are in the dependency chain. > + tmp_range tmp (type); > if (ssa1 && in_chain_p (ssa1, cond_name)) > { > if (compute_operand_range (tmp, def_stmt, cond_true, ssa1, src)) > diff --git a/gcc/gimple-range-gori.h b/gcc/gimple-range-gori.h > index 605884e2e53..f5f691fe424 100644 > --- a/gcc/gimple-range-gori.h > +++ b/gcc/gimple-range-gori.h > @@ -121,7 +121,7 @@ private: > // on *ANY* edge that has been seen. FALSE indicates that the global value > // is applicable everywhere that has been processed. > // > -// outgoing_edge_range_p (irange &range, edge e, tree name) > +// outgoing_edge_range_p (vrange &range, edge e, tree name) > // Actually does the calculation of RANGE for name on E > // This represents application of whatever static range effect edge E > // may have on NAME, not any cumulative effect. > @@ -157,8 +157,8 @@ class gori_compute : public gori_map > { > public: > gori_compute (int not_executable_flag = 0); > - bool outgoing_edge_range_p (irange &r, edge e, tree name, range_query &q); > - bool condexpr_adjust (irange &r1, irange &r2, gimple *s, tree cond, tree op1, > + bool outgoing_edge_range_p (vrange &r, edge e, tree name, range_query &q); > + bool condexpr_adjust (vrange &r1, vrange &r2, gimple *s, tree cond, tree op1, > tree op2, fur_source &src); > bool has_edge_range_p (tree name, basic_block bb = NULL); > bool has_edge_range_p (tree name, edge e); > @@ -166,24 +166,24 @@ public: > private: > bool may_recompute_p (tree name, edge e); > bool may_recompute_p (tree name, basic_block bb = NULL); > - bool compute_operand_range (irange &r, gimple *stmt, const irange &lhs, > + bool compute_operand_range (vrange &r, gimple *stmt, const vrange &lhs, > tree name, class fur_source &src); > - bool compute_operand_range_switch (irange &r, gswitch *s, const irange &lhs, > + bool compute_operand_range_switch (vrange &r, gswitch *s, const vrange &lhs, > tree name, fur_source &src); > - bool compute_operand1_range (irange &r, gimple *stmt, const irange &lhs, > + bool compute_operand1_range (vrange &r, gimple *stmt, const vrange &lhs, > tree name, fur_source &src); > - bool compute_operand2_range (irange &r, gimple *stmt, const irange &lhs, > + bool compute_operand2_range (vrange &r, gimple *stmt, const vrange &lhs, > tree name, fur_source &src); > - bool compute_operand1_and_operand2_range (irange &r, gimple *stmt, > - const irange &lhs, tree name, > + bool compute_operand1_and_operand2_range (vrange &r, gimple *stmt, > + const vrange &lhs, tree name, > fur_source &src); > - void compute_logical_operands (irange &true_range, irange &false_range, > + void compute_logical_operands (vrange &true_range, vrange &false_range, > gimple *stmt, const irange &lhs, > tree name, fur_source &src, tree op, > bool op_in_chain); > - bool logical_combine (irange &r, enum tree_code code, const irange &lhs, > - const irange &op1_true, const irange &op1_false, > - const irange &op2_true, const irange &op2_false); > + bool logical_combine (vrange &r, enum tree_code code, const irange &lhs, > + const vrange &op1_true, const vrange &op1_false, > + const vrange &op2_true, const vrange &op2_false); > int_range<2> m_bool_zero; // Boolean false cached. > int_range<2> m_bool_one; // Boolean true cached. > > @@ -193,14 +193,14 @@ private: > }; > > // These routines provide a GIMPLE interface to the range-ops code. > -extern bool gimple_range_calc_op1 (irange &r, const gimple *s, > - const irange &lhs_range); > -extern bool gimple_range_calc_op1 (irange &r, const gimple *s, > - const irange &lhs_range, > - const irange &op2_range); > -extern bool gimple_range_calc_op2 (irange &r, const gimple *s, > - const irange &lhs_range, > - const irange &op1_range); > +extern bool gimple_range_calc_op1 (vrange &r, const gimple *s, > + const vrange &lhs_range); > +extern bool gimple_range_calc_op1 (vrange &r, const gimple *s, > + const vrange &lhs_range, > + const vrange &op2_range); > +extern bool gimple_range_calc_op2 (vrange &r, const gimple *s, > + const vrange &lhs_range, > + const vrange &op1_range); > > // For each name that is an import into BB's exports.. > #define FOR_EACH_GORI_IMPORT_NAME(gori, bb, name) \ > diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc > index 66f433dd1d5..4819332f358 100644 > --- a/gcc/gimple-range-path.cc > +++ b/gcc/gimple-range-path.cc > @@ -83,7 +83,7 @@ path_range_query::clear_cache (tree name) > // If NAME has a cache entry, return it in R, and return TRUE. > > inline bool > -path_range_query::get_cache (irange &r, tree name) > +path_range_query::get_cache (vrange &r, tree name) > { > if (!gimple_range_ssa_p (name)) > return get_global_range_query ()->range_of_expr (r, name); > @@ -98,7 +98,7 @@ path_range_query::get_cache (irange &r, tree name) > // Set the cache entry for NAME to R. > > void > -path_range_query::set_cache (const irange &r, tree name) > +path_range_query::set_cache (const vrange &r, tree name) > { > unsigned v = SSA_NAME_VERSION (name); > bitmap_set_bit (m_has_cache_entry, v); > @@ -149,7 +149,7 @@ path_range_query::defined_outside_path (tree name) > // Return the range of NAME on entry to the path. > > void > -path_range_query::range_on_path_entry (irange &r, tree name) > +path_range_query::range_on_path_entry (vrange &r, tree name) > { > gcc_checking_assert (defined_outside_path (name)); > basic_block entry = entry_bb (); > @@ -168,7 +168,7 @@ path_range_query::range_on_path_entry (irange &r, tree name) > // block. This can happen when we're querying a block with only an > // outgoing edge (no statement but the fall through edge), but for > // which we can determine a range on entry to the block. > - int_range_max tmp; > + tmp_range tmp (TREE_TYPE (name)); > bool changed = false; > r.set_undefined (); > for (unsigned i = 0; i < EDGE_COUNT (entry->preds); ++i) > @@ -190,9 +190,9 @@ path_range_query::range_on_path_entry (irange &r, tree name) > // Return the range of NAME at the end of the path being analyzed. > > bool > -path_range_query::internal_range_of_expr (irange &r, tree name, gimple *stmt) > +path_range_query::internal_range_of_expr (vrange &r, tree name, gimple *stmt) > { > - if (!irange::supports_type_p (TREE_TYPE (name))) > + if (!vrange::supports_type_p (TREE_TYPE (name))) > return false; > > if (get_cache (r, name)) > @@ -209,18 +209,22 @@ path_range_query::internal_range_of_expr (irange &r, tree name, gimple *stmt) > && range_defined_in_block (r, name, gimple_bb (stmt))) > { > if (TREE_CODE (name) == SSA_NAME) > - r.intersect (gimple_range_global (name)); > + { > + tmp_range glob (TREE_TYPE (name)); > + gimple_range_global (glob, name); > + r.intersect (glob); > + } > > set_cache (r, name); > return true; > } > > - r = gimple_range_global (name); > + gimple_range_global (r, name); > return true; > } > > bool > -path_range_query::range_of_expr (irange &r, tree name, gimple *stmt) > +path_range_query::range_of_expr (vrange &r, tree name, gimple *stmt) > { > if (internal_range_of_expr (r, name, stmt)) > { > @@ -269,7 +273,7 @@ path_range_query::ssa_defined_in_bb (tree name, basic_block bb) > // calculating the PHI's range must not trigger additional lookups. > > void > -path_range_query::ssa_range_in_phi (irange &r, gphi *phi) > +path_range_query::ssa_range_in_phi (vrange &r, gphi *phi) > { > tree name = gimple_phi_result (phi); > basic_block bb = gimple_bb (phi); > @@ -283,7 +287,7 @@ path_range_query::ssa_range_in_phi (irange &r, gphi *phi) > // Try to fold the phi exclusively with global or cached values. > // This will get things like PHI <5(99), 6(88)>. We do this by > // calling range_of_expr with no context. > - int_range_max arg_range; > + tmp_range arg_range (TREE_TYPE (name)); > r.set_undefined (); > for (size_t i = 0; i < nargs; ++i) > { > @@ -312,7 +316,7 @@ path_range_query::ssa_range_in_phi (irange &r, gphi *phi) > { > if (m_resolve) > { > - int_range_max tmp; > + tmp_range tmp (TREE_TYPE (name)); > // Using both the range on entry to the path, and the > // range on this edge yields significantly better > // results. > @@ -335,7 +339,7 @@ path_range_query::ssa_range_in_phi (irange &r, gphi *phi) > // TRUE. Otherwise, return FALSE. > > bool > -path_range_query::range_defined_in_block (irange &r, tree name, basic_block bb) > +path_range_query::range_defined_in_block (vrange &r, tree name, basic_block bb) > { > gimple *def_stmt = SSA_NAME_DEF_STMT (name); > basic_block def_bb = gimple_bb (def_stmt); > @@ -377,7 +381,6 @@ path_range_query::range_defined_in_block (irange &r, tree name, basic_block bb) > void > path_range_query::compute_ranges_in_phis (basic_block bb) > { > - int_range_max r; > auto_bitmap phi_set; > > // PHIs must be resolved simultaneously on entry to the block > @@ -390,7 +393,11 @@ path_range_query::compute_ranges_in_phis (basic_block bb) > gphi *phi = iter.phi (); > tree name = gimple_phi_result (phi); > > - if (import_p (name) && range_defined_in_block (r, name, bb)) > + if (!import_p (name)) > + continue; > + > + tmp_range r (TREE_TYPE (name)); > + if (range_defined_in_block (r, name, bb)) > { > unsigned v = SSA_NAME_VERSION (name); > set_cache (r, name); > @@ -423,7 +430,6 @@ void > path_range_query::compute_ranges_in_block (basic_block bb) > { > bitmap_iterator bi; > - int_range_max r, cached_range; > unsigned i; > > if (m_resolve && !at_entry ()) > @@ -444,6 +450,7 @@ path_range_query::compute_ranges_in_block (basic_block bb) > EXECUTE_IF_SET_IN_BITMAP (m_imports, 0, i, bi) > { > tree name = ssa_name (i); > + tmp_range r (TREE_TYPE (name)); > > if (gimple_code (SSA_NAME_DEF_STMT (name)) != GIMPLE_PHI > && range_defined_in_block (r, name, bb)) > @@ -480,8 +487,10 @@ path_range_query::compute_ranges_in_block (basic_block bb) > > if (bitmap_bit_p (exports, i)) > { > + tmp_range r (TREE_TYPE (name)); > if (g.outgoing_edge_range_p (r, e, name, *this)) > { > + tmp_range cached_range (TREE_TYPE (name)); > if (get_cache (cached_range, name)) > r.intersect (cached_range); > > @@ -539,7 +548,7 @@ bool > path_range_query::add_to_imports (tree name, bitmap imports) > { > if (TREE_CODE (name) == SSA_NAME > - && irange::supports_type_p (TREE_TYPE (name))) > + && vrange::supports_type_p (TREE_TYPE (name))) > return bitmap_set_bit (imports, SSA_NAME_VERSION (name)); > return false; > } > @@ -751,11 +760,11 @@ jt_fur_source::query_relation (tree op1, tree op2) > // Return the range of STMT at the end of the path being analyzed. > > bool > -path_range_query::range_of_stmt (irange &r, gimple *stmt, tree) > +path_range_query::range_of_stmt (vrange &r, gimple *stmt, tree) > { > tree type = gimple_range_type (stmt); > > - if (!type || !irange::supports_type_p (type)) > + if (!type || !vrange::supports_type_p (type)) > return false; > > // If resolving unknowns, fold the statement making use of any > diff --git a/gcc/gimple-range-path.h b/gcc/gimple-range-path.h > index 914983bb0aa..2c4624e4cef 100644 > --- a/gcc/gimple-range-path.h > +++ b/gcc/gimple-range-path.h > @@ -38,29 +38,29 @@ public: > const bitmap_head *imports = NULL); > void compute_ranges (edge e); > void compute_imports (bitmap imports, basic_block exit); > - bool range_of_expr (irange &r, tree name, gimple * = NULL) override; > - bool range_of_stmt (irange &r, gimple *, tree name = NULL) override; > + bool range_of_expr (vrange &r, tree name, gimple * = NULL) override; > + bool range_of_stmt (vrange &r, gimple *, tree name = NULL) override; > bool unreachable_path_p (); > void dump (FILE *) override; > void debug (); > > private: > - bool internal_range_of_expr (irange &r, tree name, gimple *); > + bool internal_range_of_expr (vrange &r, tree name, gimple *); > bool defined_outside_path (tree name); > - void range_on_path_entry (irange &r, tree name); > + void range_on_path_entry (vrange &r, tree name); > path_oracle *get_path_oracle () { return (path_oracle *)m_oracle; } > > // Cache manipulation. > - void set_cache (const irange &r, tree name); > - bool get_cache (irange &r, tree name); > + void set_cache (const vrange &r, tree name); > + bool get_cache (vrange &r, tree name); > void clear_cache (tree name); > > // Methods to compute ranges for the given path. > - bool range_defined_in_block (irange &, tree name, basic_block bb); > + bool range_defined_in_block (vrange &, tree name, basic_block bb); > void compute_ranges_in_block (basic_block bb); > void compute_ranges_in_phis (basic_block bb); > void adjust_for_non_null_uses (basic_block bb); > - void ssa_range_in_phi (irange &r, gphi *phi); > + void ssa_range_in_phi (vrange &r, gphi *phi); > void compute_outgoing_relations (basic_block bb, basic_block next); > void compute_phi_relations (basic_block bb, basic_block prev); > void maybe_register_phi_relation (gphi *, edge e); > diff --git a/gcc/gimple-range-side-effect.cc b/gcc/gimple-range-side-effect.cc > index 8d2ac35bc8d..aae087b7227 100644 > --- a/gcc/gimple-range-side-effect.cc > +++ b/gcc/gimple-range-side-effect.cc > @@ -58,7 +58,7 @@ non_null_loadstore (gimple *, tree op, tree, void *data) > // Add NAME and RANGE to the the side effect summary. > > void > -stmt_side_effects::add_range (tree name, irange &range) > +stmt_side_effects::add_range (tree name, vrange &range) > { > m_names[num_args] = name; > m_ranges[num_args] = range; > @@ -126,7 +126,7 @@ class exit_range > { > public: > tree name; > - irange *range; > + vrange *range; > exit_range *next; > }; > > @@ -181,7 +181,7 @@ side_effect_manager::~side_effect_manager () > // Return a non-zero range value of the appropriate type for NAME from > // the cache, creating it if necessary. > > -const irange& > +const vrange& > side_effect_manager::get_nonzero (tree name) > { > unsigned v = SSA_NAME_VERSION (name); > @@ -189,10 +189,8 @@ side_effect_manager::get_nonzero (tree name) > m_nonzero.safe_grow_cleared (num_ssa_names + 20); > if (!m_nonzero[v]) > { > - tree type = TREE_TYPE (name); > - m_nonzero[v] > - = static_cast (m_range_allocator.alloc_vrange (type)); > - m_nonzero[v]->set_nonzero (type); > + m_nonzero[v] = m_range_allocator.alloc_vrange (TREE_TYPE (name)); > + m_nonzero[v]->set_nonzero (TREE_TYPE (name)); > } > return *(m_nonzero[v]); > } > @@ -219,7 +217,7 @@ side_effect_manager::has_range_p (tree name, basic_block bb) > // to include it. > > bool > -side_effect_manager::maybe_adjust_range (irange &r, tree name, basic_block bb) > +side_effect_manager::maybe_adjust_range (vrange &r, tree name, basic_block bb) > { > if (!has_range_p (name, bb)) > return false; > @@ -232,7 +230,7 @@ side_effect_manager::maybe_adjust_range (irange &r, tree name, basic_block bb) > // Add range R as a side effect for NAME in block BB. > > void > -side_effect_manager::add_range (tree name, basic_block bb, const irange &r) > +side_effect_manager::add_range (tree name, basic_block bb, const vrange &r) > { > if (bb->index >= (int)m_on_exit.length ()) > m_on_exit.safe_grow_cleared (last_basic_block_for_fn (cfun) + 1); > @@ -254,7 +252,7 @@ side_effect_manager::add_range (tree name, basic_block bb, const irange &r) > exit_range *ptr = m_on_exit[bb->index].find_ptr (name); > if (ptr) > { > - int_range_max cur = r; > + tmp_range cur (r); > // If no new info is added, just return. > if (!cur.intersect (*(ptr->range))) > return; > @@ -263,7 +261,7 @@ side_effect_manager::add_range (tree name, basic_block bb, const irange &r) > else > { > vrange &v = cur; > - ptr->range = static_cast (m_range_allocator.clone (v)); > + ptr->range = m_range_allocator.clone (v); > } > return; > } > diff --git a/gcc/gimple-range-side-effect.h b/gcc/gimple-range-side-effect.h > index d76d6eb34f2..a7625646ed1 100644 > --- a/gcc/gimple-range-side-effect.h > +++ b/gcc/gimple-range-side-effect.h > @@ -33,15 +33,15 @@ public: > inline unsigned num () const { return num_args; } > inline tree name (unsigned index) const > { gcc_checking_assert (index < num_args); return m_names[index]; } > - inline const irange& range (unsigned index) const > + inline const vrange& range (unsigned index) const > { gcc_checking_assert (index < num_args); return m_ranges[index]; } > - void add_range (tree name, irange &range); > + void add_range (tree name, vrange &range); > void add_nonzero (tree name); > private: > unsigned num_args; > static const int size_limit = 10; > tree m_names[size_limit]; > - int_range<3> m_ranges[size_limit]; > + tmp_range m_ranges[size_limit]; > inline void bump_index () { if (num_args < size_limit - 1) num_args++; } > }; > > @@ -56,10 +56,10 @@ class side_effect_manager > public: > side_effect_manager (bool do_search); > ~side_effect_manager (); > - void add_range (tree name, basic_block bb, const irange &r); > + void add_range (tree name, basic_block bb, const vrange &r); > void add_nonzero (tree name, basic_block bb); > bool has_range_p (tree name, basic_block bb); > - bool maybe_adjust_range (irange &r, tree name, basic_block bb); > + bool maybe_adjust_range (vrange &r, tree name, basic_block bb); > private: > class exit_range_head > { > @@ -71,8 +71,8 @@ private: > }; > void register_all_uses (tree name); > vec m_on_exit; > - const irange &get_nonzero (tree name); > - vec m_nonzero; > + const vrange &get_nonzero (tree name); > + vec m_nonzero; > bitmap m_seen; > bitmap_obstack m_bitmaps; > struct obstack m_list_obstack; > diff --git a/gcc/gimple-range-tests.cc b/gcc/gimple-range-tests.cc > index 572acd33d7f..84ecc486889 100644 > --- a/gcc/gimple-range-tests.cc > +++ b/gcc/gimple-range-tests.cc > @@ -42,8 +42,9 @@ public: > ASSERT_TRUE (r == expect); > } > > - virtual bool range_of_expr (irange &r, tree expr, gimple * = NULL) override > + virtual bool range_of_expr (vrange &v, tree expr, gimple * = NULL) override > { > + irange &r = as_a (v); > if (expr == op0) > { > r.set (build_int_cst (type, 5), build_int_cst (type, 10)); > diff --git a/gcc/gimple-range-trace.cc b/gcc/gimple-range-trace.cc > index 39971093e6d..37cf37ca885 100644 > --- a/gcc/gimple-range-trace.cc > +++ b/gcc/gimple-range-trace.cc > @@ -102,7 +102,7 @@ range_tracer::print (unsigned counter, const char *str) > > void > range_tracer::trailer (unsigned counter, const char *caller, bool result, > - tree name, const irange &r) > + tree name, const vrange &r) > { > gcc_checking_assert (tracing && counter != 0); > > @@ -141,7 +141,6 @@ debug_seed_ranger (gimple_ranger &ranger) > } > > basic_block bb; > - int_range_max r; > gimple_stmt_iterator gsi; > FOR_EACH_BB_FN (bb, cfun) > for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) > @@ -151,7 +150,11 @@ debug_seed_ranger (gimple_ranger &ranger) > if (is_gimple_debug (stmt)) > continue; > > - ranger.range_of_stmt (r, stmt); > + if (tree type = gimple_range_type (stmt)) > + { > + tmp_range r (type); > + ranger.range_of_stmt (r, stmt); > + } > } > } > > diff --git a/gcc/gimple-range-trace.h b/gcc/gimple-range-trace.h > index 302afda3104..3f92e51803b 100644 > --- a/gcc/gimple-range-trace.h > +++ b/gcc/gimple-range-trace.h > @@ -32,7 +32,7 @@ public: > range_tracer (const char *name = ""); > unsigned header (const char *str); > void trailer (unsigned counter, const char *caller, bool result, tree name, > - const irange &r); > + const vrange &r); > void print (unsigned counter, const char *str); > inline void enable_trace () { tracing = true; } > inline void disable_trace () { tracing = false; } > diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc > index 32d57c9e3db..1118feb41a5 100644 > --- a/gcc/gimple-range.cc > +++ b/gcc/gimple-range.cc > @@ -71,7 +71,7 @@ gimple_ranger::~gimple_ranger () > } > > bool > -gimple_ranger::range_of_expr (irange &r, tree expr, gimple *stmt) > +gimple_ranger::range_of_expr (vrange &r, tree expr, gimple *stmt) > { > unsigned idx; > if (!gimple_range_ssa_p (expr)) > @@ -93,7 +93,7 @@ gimple_ranger::range_of_expr (irange &r, tree expr, gimple *stmt) > // If there is no statement, just get the global value. > if (!stmt) > { > - int_range_max tmp; > + tmp_range tmp (TREE_TYPE (expr)); > m_cache.get_global_range (r, expr); > // Pick up implied context information from the on-entry cache > // if current_bb is set. Do not attempt any new calculations. > @@ -137,9 +137,9 @@ gimple_ranger::range_of_expr (irange &r, tree expr, gimple *stmt) > // Return the range of NAME on entry to block BB in R. > > void > -gimple_ranger::range_on_entry (irange &r, basic_block bb, tree name) > +gimple_ranger::range_on_entry (vrange &r, basic_block bb, tree name) > { > - int_range_max entry_range; > + tmp_range entry_range (TREE_TYPE (name)); > gcc_checking_assert (gimple_range_ssa_p (name)); > > unsigned idx; > @@ -164,7 +164,7 @@ gimple_ranger::range_on_entry (irange &r, basic_block bb, tree name) > // Return false if no range can be calculated. > > void > -gimple_ranger::range_on_exit (irange &r, basic_block bb, tree name) > +gimple_ranger::range_on_exit (vrange &r, basic_block bb, tree name) > { > // on-exit from the exit block? > gcc_checking_assert (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)); > @@ -198,10 +198,10 @@ gimple_ranger::range_on_exit (irange &r, basic_block bb, tree name) > // Calculate a range for NAME on edge E and return it in R. > > bool > -gimple_ranger::range_on_edge (irange &r, edge e, tree name) > +gimple_ranger::range_on_edge (vrange &r, edge e, tree name) > { > - int_range_max edge_range; > - gcc_checking_assert (irange::supports_type_p (TREE_TYPE (name))); > + tmp_range edge_range (TREE_TYPE (name)); > + gcc_checking_assert (vrange::supports_type_p (TREE_TYPE (name))); > > // Do not process values along abnormal edges. > if (e->flags & EDGE_ABNORMAL) > @@ -249,7 +249,7 @@ gimple_ranger::range_on_edge (irange &r, edge e, tree name) > // fold_range wrapper for range_of_stmt to use as an internal client. > > bool > -gimple_ranger::fold_range_internal (irange &r, gimple *s, tree name) > +gimple_ranger::fold_range_internal (vrange &r, gimple *s, tree name) > { > fold_using_range f; > fur_depend src (s, &(gori ()), this); > @@ -263,7 +263,7 @@ gimple_ranger::fold_range_internal (irange &r, gimple *s, tree name) > // avoided. If a range cannot be calculated, return false and UNDEFINED. > > bool > -gimple_ranger::range_of_stmt (irange &r, gimple *s, tree name) > +gimple_ranger::range_of_stmt (vrange &r, gimple *s, tree name) > { > bool res; > r.set_undefined (); > @@ -313,7 +313,7 @@ gimple_ranger::range_of_stmt (irange &r, gimple *s, tree name) > prefill_stmt_dependencies (name); > > // Calculate a new value. > - int_range_max tmp; > + tmp_range tmp (TREE_TYPE (name)); > fold_range_internal (tmp, s, name); > > // Combine the new value with the old value. This is required because > @@ -334,7 +334,7 @@ gimple_ranger::range_of_stmt (irange &r, gimple *s, tree name) > // stack if so. R is a scratch range. > > inline void > -gimple_ranger::prefill_name (irange &r, tree name) > +gimple_ranger::prefill_name (tmp_range &r, tree name) > { > if (!gimple_range_ssa_p (name)) > return; > @@ -343,6 +343,7 @@ gimple_ranger::prefill_name (irange &r, tree name) > return; > > bool current; > + r.init (TREE_TYPE (name)); > // If this op has not been processed yet, then push it on the stack > if (!m_cache.get_global_range (r, name, current)) > m_stmt_list.safe_push (name); > @@ -357,7 +358,7 @@ gimple_ranger::prefill_stmt_dependencies (tree ssa) > if (SSA_NAME_IS_DEFAULT_DEF (ssa)) > return; > > - int_range_max r; > + tmp_range r; > unsigned idx; > gimple *stmt = SSA_NAME_DEF_STMT (ssa); > gcc_checking_assert (stmt && gimple_bb (stmt)); > @@ -388,6 +389,7 @@ gimple_ranger::prefill_stmt_dependencies (tree ssa) > { > // Fold and save the value for NAME. > stmt = SSA_NAME_DEF_STMT (name); > + r.init (TREE_TYPE (name)); > fold_range_internal (r, stmt, name); > // Make sure we don't lose any current global info. > int_range_max tmp; > @@ -488,10 +490,11 @@ gimple_ranger::export_global_ranges () > bool print_header = true; > for (unsigned x = 1; x < num_ssa_names; x++) > { > - int_range_max r; > + tmp_range r; > tree name = ssa_name (x); > if (name && !SSA_NAME_IN_FREE_LIST (name) > && gimple_range_ssa_p (name) > + && r.init (TREE_TYPE (name)) > && m_cache.get_global_range (r, name) > && !r.varying_p()) > { > @@ -508,13 +511,17 @@ gimple_ranger::export_global_ranges () > print_header = false; > } > > - value_range vr = r; > + if (!irange::supports_type_p (TREE_TYPE (name))) > + continue; > + > + vrange &v = r; > + value_range vr = as_a (v); > print_generic_expr (dump_file, name , TDF_SLIM); > fprintf (dump_file, " : "); > vr.dump (dump_file); > fprintf (dump_file, "\n"); > int_range_max same = vr; > - if (same != r) > + if (same != as_a (v)) > { > fprintf (dump_file, " irange : "); > r.dump (dump_file); > @@ -532,7 +539,7 @@ gimple_ranger::dump_bb (FILE *f, basic_block bb) > unsigned x; > edge_iterator ei; > edge e; > - int_range_max range, tmp_range; > + tmp_range range, tmp_range; > fprintf (f, "\n=========== BB %d ============\n", bb->index); > m_cache.dump_bb (f, bb); > > @@ -543,6 +550,7 @@ gimple_ranger::dump_bb (FILE *f, basic_block bb) > { > tree name = ssa_name (x); > if (gimple_range_ssa_p (name) && SSA_NAME_DEF_STMT (name) && > + range.init (TREE_TYPE (name)) && > gimple_bb (SSA_NAME_DEF_STMT (name)) == bb && > m_cache.get_global_range (range, name)) > { > @@ -564,9 +572,11 @@ gimple_ranger::dump_bb (FILE *f, basic_block bb) > { > tree name = gimple_range_ssa_p (ssa_name (x)); > if (name && gori ().has_edge_range_p (name, e) > + && range.init (TREE_TYPE (name)) > && m_cache.range_on_edge (range, e, name)) > { > gimple *s = SSA_NAME_DEF_STMT (name); > + tmp_range.init (TREE_TYPE (name)); > // Only print the range if this is the def block, or > // the on entry cache for either end of the edge is > // set. > diff --git a/gcc/gimple-range.h b/gcc/gimple-range.h > index 13d4c77883e..ca5a33e65c6 100644 > --- a/gcc/gimple-range.h > +++ b/gcc/gimple-range.h > @@ -48,11 +48,11 @@ class gimple_ranger : public range_query > public: > gimple_ranger (bool use_imm_uses = true); > ~gimple_ranger (); > - virtual bool range_of_stmt (irange &r, gimple *, tree name = NULL) override; > - virtual bool range_of_expr (irange &r, tree name, gimple * = NULL) override; > - virtual bool range_on_edge (irange &r, edge e, tree name) override; > - void range_on_entry (irange &r, basic_block bb, tree name); > - void range_on_exit (irange &r, basic_block bb, tree name); > + virtual bool range_of_stmt (vrange &r, gimple *, tree name = NULL) override; > + virtual bool range_of_expr (vrange &r, tree name, gimple * = NULL) override; > + virtual bool range_on_edge (vrange &r, edge e, tree name) override; > + void range_on_entry (vrange &r, basic_block bb, tree name); > + void range_on_exit (vrange &r, basic_block bb, tree name); > void export_global_ranges (); > inline gori_compute &gori () { return m_cache.m_gori; } > virtual void dump (FILE *f) override; > @@ -62,8 +62,8 @@ public: > bool fold_stmt (gimple_stmt_iterator *gsi, tree (*) (tree)); > void register_side_effects (gimple *s); > protected: > - bool fold_range_internal (irange &r, gimple *s, tree name); > - void prefill_name (irange &r, tree name); > + bool fold_range_internal (vrange &r, gimple *s, tree name); > + void prefill_name (tmp_range &r, tree name); > void prefill_stmt_dependencies (tree ssa); > ranger_cache m_cache; > range_tracer tracer; > diff --git a/gcc/gimple-ssa-warn-access.cc b/gcc/gimple-ssa-warn-access.cc > index 9357a4e576a..132d82a5240 100644 > --- a/gcc/gimple-ssa-warn-access.cc > +++ b/gcc/gimple-ssa-warn-access.cc > @@ -328,11 +328,11 @@ check_nul_terminated_array (GimpleOrTree expr, tree src, tree bound) > wide_int bndrng[2]; > if (bound) > { > - value_range r; > + tmp_range r (TREE_TYPE (bound)); > > get_global_range_query ()->range_of_expr (r, bound); > > - if (r.kind () != VR_RANGE) > + if (r.undefined_p () || r.varying_p ()) > return true; > > bndrng[0] = r.lower_bound (); > @@ -2790,9 +2790,8 @@ memmodel_to_uhwi (tree ord, gimple *stmt, unsigned HOST_WIDE_INT *cstval) > { > /* Use the range query to determine constant values in the absence > of constant propagation (such as at -O0). */ > - value_range rng; > + tmp_range rng (TREE_TYPE (ord)); > if (!get_range_query (cfun)->range_of_expr (rng, ord, stmt) > - || !rng.constant_p () > || !rng.singleton_p (&ord)) > return false; > > diff --git a/gcc/tree-ssa-loop-niter.cc b/gcc/tree-ssa-loop-niter.cc > index afa51064953..8907e310c19 100644 > --- a/gcc/tree-ssa-loop-niter.cc > +++ b/gcc/tree-ssa-loop-niter.cc > @@ -221,7 +221,7 @@ refine_value_range_using_guard (tree type, tree var, > get_type_static_bounds (type, mint, maxt); > mpz_init (minc1); > mpz_init (maxc1); > - value_range r; > + tmp_range r (TREE_TYPE (varc1)); > /* Setup range information for varc1. */ > if (integer_zerop (varc1)) > { > @@ -374,7 +374,7 @@ determine_value_range (class loop *loop, tree type, tree var, mpz_t off, > gphi_iterator gsi; > > /* Either for VAR itself... */ > - value_range var_range; > + tmp_range var_range (TREE_TYPE (var)); > get_range_query (cfun)->range_of_expr (var_range, var); > rtype = var_range.kind (); > if (!var_range.undefined_p ()) > @@ -385,10 +385,10 @@ determine_value_range (class loop *loop, tree type, tree var, mpz_t off, > > /* Or for PHI results in loop->header where VAR is used as > PHI argument from the loop preheader edge. */ > + tmp_range phi_range (TREE_TYPE (var)); > for (gsi = gsi_start_phis (loop->header); !gsi_end_p (gsi); gsi_next (&gsi)) > { > gphi *phi = gsi.phi (); > - value_range phi_range; > if (PHI_ARG_DEF_FROM_EDGE (phi, e) == var > && get_range_query (cfun)->range_of_expr (phi_range, > gimple_phi_result (phi)) > @@ -410,7 +410,7 @@ determine_value_range (class loop *loop, tree type, tree var, mpz_t off, > involved. */ > if (wi::gt_p (minv, maxv, sgn)) > { > - value_range vr; > + tmp_range vr (TREE_TYPE (var)); > get_range_query (cfun)->range_of_expr (vr, var); > rtype = vr.kind (); > if (!vr.undefined_p ()) > @@ -3650,7 +3650,7 @@ record_nonwrapping_iv (class loop *loop, tree base, tree step, gimple *stmt, > if (tree_int_cst_sign_bit (step)) > { > wide_int max; > - value_range base_range; > + tmp_range base_range (TREE_TYPE (orig_base)); > if (get_range_query (cfun)->range_of_expr (base_range, orig_base) > && !base_range.undefined_p ()) > max = base_range.upper_bound (); > @@ -3672,7 +3672,7 @@ record_nonwrapping_iv (class loop *loop, tree base, tree step, gimple *stmt, > else > { > wide_int min; > - value_range base_range; > + tmp_range base_range (TREE_TYPE (orig_base)); > if (get_range_query (cfun)->range_of_expr (base_range, orig_base) > && !base_range.undefined_p ()) > min = base_range.lower_bound (); > @@ -3947,7 +3947,7 @@ infer_loop_bounds_from_signedness (class loop *loop, gimple *stmt) > > low = lower_bound_in_type (type, type); > high = upper_bound_in_type (type, type); > - value_range r; > + tmp_range r (TREE_TYPE (def)); > get_range_query (cfun)->range_of_expr (r, def); > if (r.kind () == VR_RANGE) > { > @@ -4997,7 +4997,7 @@ scev_var_range_cant_overflow (tree var, tree step, class loop *loop) > if (!def_bb || !dominated_by_p (CDI_DOMINATORS, loop->latch, def_bb)) > return false; > > - value_range r; > + tmp_range r (TREE_TYPE (var)); > get_range_query (cfun)->range_of_expr (r, var); > if (r.kind () != VR_RANGE) > return false; > diff --git a/gcc/tree-ssa-threadedge.cc b/gcc/tree-ssa-threadedge.cc > index 4eb65ca7cac..d5e285d5d4d 100644 > --- a/gcc/tree-ssa-threadedge.cc > +++ b/gcc/tree-ssa-threadedge.cc > @@ -1409,19 +1409,19 @@ tree > hybrid_jt_simplifier::simplify (gimple *stmt, gimple *, basic_block, > jt_state *state) > { > - int_range_max r; > - > compute_ranges_from_state (stmt, state); > > if (gimple_code (stmt) == GIMPLE_COND > || gimple_code (stmt) == GIMPLE_ASSIGN) > { > + tmp_range r (gimple_range_type (stmt)); > tree ret; > if (m_query->range_of_stmt (r, stmt) && r.singleton_p (&ret)) > return ret; > } > else if (gimple_code (stmt) == GIMPLE_SWITCH) > { > + int_range_max r; > gswitch *switch_stmt = dyn_cast (stmt); > tree index = gimple_switch_index (switch_stmt); > if (m_query->range_of_expr (r, index, stmt)) > diff --git a/gcc/value-query.cc b/gcc/value-query.cc > index 31e56eeae53..463ac179a00 100644 > --- a/gcc/value-query.cc > +++ b/gcc/value-query.cc > @@ -57,13 +57,13 @@ value_query::value_of_stmt (gimple *stmt, tree name) > // range_query default methods. > > bool > -range_query::range_on_edge (irange &r, edge, tree expr) > +range_query::range_on_edge (vrange &r, edge, tree expr) > { > return range_of_expr (r, expr); > } > > bool > -range_query::range_of_stmt (irange &r, gimple *stmt, tree name) > +range_query::range_of_stmt (vrange &r, gimple *stmt, tree name) > { > if (!name) > name = gimple_get_lhs (stmt); > @@ -79,11 +79,12 @@ tree > range_query::value_of_expr (tree expr, gimple *stmt) > { > tree t; > - int_range_max r; > > - if (!irange::supports_type_p (TREE_TYPE (expr))) > + if (!vrange::supports_type_p (TREE_TYPE (expr))) > return NULL_TREE; > > + tmp_range r (TREE_TYPE (expr)); > + > if (range_of_expr (r, expr, stmt)) > { > // A constant used in an unreachable block oftens returns as UNDEFINED. > @@ -100,10 +101,10 @@ tree > range_query::value_on_edge (edge e, tree expr) > { > tree t; > - int_range_max r; > > - if (!irange::supports_type_p (TREE_TYPE (expr))) > + if (!vrange::supports_type_p (TREE_TYPE (expr))) > return NULL_TREE; > + tmp_range r (TREE_TYPE (expr)); > if (range_on_edge (r, e, expr)) > { > // A constant used in an unreachable block oftens returns as UNDEFINED. > @@ -121,15 +122,15 @@ tree > range_query::value_of_stmt (gimple *stmt, tree name) > { > tree t; > - int_range_max r; > > if (!name) > name = gimple_get_lhs (stmt); > > gcc_checking_assert (!name || name == gimple_get_lhs (stmt)); > > - if (!name || !irange::supports_type_p (TREE_TYPE (name))) > + if (!name || !vrange::supports_type_p (TREE_TYPE (name))) > return NULL_TREE; > + tmp_range r (TREE_TYPE (name)); > if (range_of_stmt (r, stmt, name) && r.singleton_p (&t)) > return t; > return NULL_TREE; > @@ -187,7 +188,7 @@ range_query::~range_query () > // representable, and UNDEFINED/false if not. > > bool > -range_query::get_tree_range (irange &r, tree expr, gimple *stmt) > +range_query::get_tree_range (vrange &r, tree expr, gimple *stmt) > { > tree type; > if (TYPE_P (expr)) > @@ -195,7 +196,7 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt) > else > type = TREE_TYPE (expr); > > - if (!irange::supports_type_p (type)) > + if (!vrange::supports_type_p (type)) > { > r.set_undefined (); > return false; > @@ -214,7 +215,7 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt) > return true; > > case SSA_NAME: > - r = gimple_range_global (expr); > + gimple_range_global (r, expr); > return true; > > case ADDR_EXPR: > @@ -223,7 +224,7 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt) > bool ov; > if (tree_single_nonzero_warnv_p (expr, &ov)) > { > - r = range_nonzero (type); > + r.set_nonzero (type); > return true; > } > break; > @@ -237,7 +238,8 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt) > range_op_handler op (TREE_CODE (expr), type); > if (op) > { > - int_range_max r0, r1; > + tmp_range r0 (TREE_TYPE (TREE_OPERAND (expr, 0))); > + tmp_range r1 (TREE_TYPE (TREE_OPERAND (expr, 1))); > range_of_expr (r0, TREE_OPERAND (expr, 0), stmt); > range_of_expr (r1, TREE_OPERAND (expr, 1), stmt); > op.fold_range (r, type, r0, r1); > @@ -250,11 +252,13 @@ range_query::get_tree_range (irange &r, tree expr, gimple *stmt) > { > range_op_handler op (TREE_CODE (expr), type); > tree op0_type = TREE_TYPE (TREE_OPERAND (expr, 0)); > - if (op && irange::supports_type_p (op0_type)) > + if (op && vrange::supports_type_p (op0_type)) > { > - int_range_max r0; > + tmp_range r0 (TREE_TYPE (TREE_OPERAND (expr, 0))); > + tmp_range r1 (type); > + r1.set_varying (type); > range_of_expr (r0, TREE_OPERAND (expr, 0), stmt); > - op.fold_range (r, type, r0, int_range<1> (type)); > + op.fold_range (r, type, r0, r1); > } > else > r.set_varying (type); > @@ -311,7 +315,7 @@ get_ssa_name_ptr_info_nonnull (const_tree name) > // updated. > > bool > -update_global_range (irange &r, tree name) > +update_global_range (vrange &r, tree name) > { > tree type = TREE_TYPE (name); > > @@ -330,8 +334,7 @@ update_global_range (irange &r, tree name) > if (r.undefined_p ()) > return false; > > - value_range vr = r; > - set_range_info (name, vr); > + set_range_info (name, as_a (r)); > return true; > } > else if (POINTER_TYPE_P (type)) > @@ -349,7 +352,7 @@ update_global_range (irange &r, tree name) > // return VARYING. > > static void > -get_range_global (irange &r, tree name) > +get_range_global (vrange &r, tree name) > { > tree type = TREE_TYPE (name); > > @@ -369,7 +372,7 @@ get_range_global (irange &r, tree name) > r.set_nonzero (type); > else if (INTEGRAL_TYPE_P (type)) > { > - get_ssa_name_range_info (r, name); > + get_ssa_name_range_info (as_a (r), name); > if (r.undefined_p ()) > r.set_varying (type); > } > @@ -384,7 +387,8 @@ get_range_global (irange &r, tree name) > } > else if (!POINTER_TYPE_P (type) && SSA_NAME_RANGE_INFO (name)) > { > - get_ssa_name_range_info (r, name); > + gcc_checking_assert (irange::supports_type_p (TREE_TYPE (name))); > + get_ssa_name_range_info (as_a (r), name); > if (r.undefined_p ()) > r.set_varying (type); > } > @@ -414,21 +418,19 @@ get_range_global (irange &r, tree name) > // See discussion here: > // https://gcc.gnu.org/pipermail/gcc-patches/2021-June/571709.html > > -value_range > -gimple_range_global (tree name) > +void > +gimple_range_global (vrange &r, tree name) > { > tree type = TREE_TYPE (name); > - gcc_checking_assert (TREE_CODE (name) == SSA_NAME > - && irange::supports_type_p (type)); > + gcc_checking_assert (TREE_CODE (name) == SSA_NAME); > > if (SSA_NAME_IS_DEFAULT_DEF (name) || (cfun && cfun->after_inlining) > || is_a (SSA_NAME_DEF_STMT (name))) > { > - value_range vr; > - get_range_global (vr, name); > - return vr; > + get_range_global (r, name); > + return; > } > - return value_range (type); > + r.set_varying (type); > } > > // ---------------------------------------------- > @@ -437,7 +439,7 @@ gimple_range_global (tree name) > global_range_query global_ranges; > > bool > -global_range_query::range_of_expr (irange &r, tree expr, gimple *stmt) > +global_range_query::range_of_expr (vrange &r, tree expr, gimple *stmt) > { > tree type = TREE_TYPE (expr); > > @@ -456,15 +458,16 @@ global_range_query::range_of_expr (irange &r, tree expr, gimple *stmt) > relation_kind > range_query::query_relation (gimple *s, tree ssa1, tree ssa2, bool get_range) > { > - int_range_max tmp; > if (!m_oracle || TREE_CODE (ssa1) != SSA_NAME || TREE_CODE (ssa2) != SSA_NAME) > return VREL_VARYING; > > // Ensure ssa1 and ssa2 have both been evaluated. > if (get_range) > { > - range_of_expr (tmp, ssa1, s); > - range_of_expr (tmp, ssa2, s); > + tmp_range tmp1 (TREE_TYPE (ssa1)); > + tmp_range tmp2 (TREE_TYPE (ssa2)); > + range_of_expr (tmp1, ssa1, s); > + range_of_expr (tmp2, ssa2, s); > } > return m_oracle->query_relation (gimple_bb (s), ssa1, ssa2); > } > @@ -477,7 +480,6 @@ relation_kind > range_query::query_relation (edge e, tree ssa1, tree ssa2, bool get_range) > { > basic_block bb; > - int_range_max tmp; > if (!m_oracle || TREE_CODE (ssa1) != SSA_NAME || TREE_CODE (ssa2) != SSA_NAME) > return VREL_VARYING; > > @@ -492,6 +494,7 @@ range_query::query_relation (edge e, tree ssa1, tree ssa2, bool get_range) > // Ensure ssa1 and ssa2 have both been evaluated. > if (get_range) > { > + tmp_range tmp (TREE_TYPE (ssa1)); > range_on_edge (tmp, e, ssa1); > range_on_edge (tmp, e, ssa2); > } > diff --git a/gcc/value-query.h b/gcc/value-query.h > index cf1a1d74de3..280e47e3f6b 100644 > --- a/gcc/value-query.h > +++ b/gcc/value-query.h > @@ -89,9 +89,9 @@ public: > // > // Note that range_of_expr must always return TRUE unless ranges are > // unsupported for EXPR's type (supports_type_p is false). > - virtual bool range_of_expr (irange &r, tree expr, gimple * = NULL) = 0; > - virtual bool range_on_edge (irange &r, edge, tree expr); > - virtual bool range_of_stmt (irange &r, gimple *, tree name = NULL); > + virtual bool range_of_expr (vrange &r, tree expr, gimple * = NULL) = 0; > + virtual bool range_on_edge (vrange &r, edge, tree expr); > + virtual bool range_of_stmt (vrange &r, gimple *, tree name = NULL); > > // Query if there is any relation between SSA1 and SSA2. > relation_kind query_relation (gimple *s, tree ssa1, tree ssa2, > @@ -110,8 +110,8 @@ public: > protected: > class value_range_equiv *allocate_value_range_equiv (); > void free_value_range_equiv (class value_range_equiv *); > - bool get_tree_range (irange &r, tree expr, gimple *stmt); > - bool get_arith_expr_range (irange &r, tree expr, gimple *stmt); > + bool get_tree_range (vrange &v, tree expr, gimple *stmt); > + bool get_arith_expr_range (vrange &r, tree expr, gimple *stmt); > relation_oracle *m_oracle; > > private: > @@ -123,7 +123,7 @@ private: > class global_range_query : public range_query > { > public: > - bool range_of_expr (irange &r, tree expr, gimple * = NULL) override; > + bool range_of_expr (vrange &r, tree expr, gimple * = NULL) override; > }; > > extern global_range_query global_ranges; > @@ -143,7 +143,7 @@ get_range_query (const struct function *fun) > return fun->x_range_query ? fun->x_range_query : &global_ranges; > } > > -extern value_range gimple_range_global (tree name); > -extern bool update_global_range (irange &r, tree name); > +extern void gimple_range_global (vrange &v, tree name); > +extern bool update_global_range (vrange &v, tree name); > > #endif // GCC_QUERY_H > diff --git a/gcc/vr-values.cc b/gcc/vr-values.cc > index 6f8583c8d01..9b681a46905 100644 > --- a/gcc/vr-values.cc > +++ b/gcc/vr-values.cc > @@ -177,7 +177,7 @@ vr_values::get_value_range (const_tree var, > } > > bool > -vr_values::range_of_expr (irange &r, tree expr, gimple *stmt) > +vr_values::range_of_expr (vrange &r, tree expr, gimple *stmt) > { > if (!gimple_range_ssa_p (expr)) > return get_tree_range (r, expr, stmt); > @@ -1640,6 +1640,8 @@ bounds_of_var_in_loop (tree *min, tree *max, range_query *query, > { > tree init, step, chrec, tmin, tmax, type = TREE_TYPE (var); > enum ev_direction dir; > + tmp_range trange; > + int_range<2> r; > > chrec = instantiate_parameters (loop, analyze_scalar_evolution (loop, var)); > > @@ -1661,11 +1663,15 @@ bounds_of_var_in_loop (tree *min, tree *max, range_query *query, > > /* If INIT is an SSA with a singleton range, set INIT to said > singleton, otherwise leave INIT alone. */ > - if (TREE_CODE (init) == SSA_NAME) > - query->get_value_range (init, stmt)->singleton_p (&init); > + if (TREE_CODE (init) == SSA_NAME > + && trange.init (TREE_TYPE (init)) > + && query->range_of_expr (trange, init, stmt)) > + trange.singleton_p (&init); > /* Likewise for step. */ > - if (TREE_CODE (step) == SSA_NAME) > - query->get_value_range (step, stmt)->singleton_p (&step); > + if (TREE_CODE (step) == SSA_NAME > + && trange.init (TREE_TYPE (step)) > + && query->range_of_expr (trange, step, stmt)) > + trange.singleton_p (&step); > > /* If STEP is symbolic, we can't know whether INIT will be the > minimum or maximum value in the range. Also, unless INIT is > @@ -1699,7 +1705,8 @@ bounds_of_var_in_loop (tree *min, tree *max, range_query *query, > if (TREE_CODE (step) == INTEGER_CST > && is_gimple_val (init) > && (TREE_CODE (init) != SSA_NAME > - || query->get_value_range (init, stmt)->kind () == VR_RANGE)) > + || (query->range_of_expr (r, init, stmt) > + && r.kind () == VR_RANGE))) > { > widest_int nit; > > @@ -1724,7 +1731,7 @@ bounds_of_var_in_loop (tree *min, tree *max, range_query *query, > { > value_range maxvr, vr0, vr1; > if (TREE_CODE (init) == SSA_NAME) > - vr0 = *(query->get_value_range (init, stmt)); > + query->range_of_expr (vr0, init, stmt); > else if (is_gimple_min_invariant (init)) > vr0.set (init); > else > @@ -1737,10 +1744,10 @@ bounds_of_var_in_loop (tree *min, tree *max, range_query *query, > /* Likewise if the addition did. */ > if (maxvr.kind () == VR_RANGE) > { > - value_range initvr; > + int_range<2> initvr; > > if (TREE_CODE (init) == SSA_NAME) > - initvr = *(query->get_value_range (init, stmt)); > + query->range_of_expr (initvr, init, stmt); > else if (is_gimple_min_invariant (init)) > initvr.set (init); > else > @@ -2446,7 +2453,9 @@ simplify_using_ranges::vrp_visit_cond_stmt (gcond *stmt, edge *taken_edge_p) > fprintf (dump_file, "\t"); > print_generic_expr (dump_file, use); > fprintf (dump_file, ": "); > - dump_value_range (dump_file, query->get_value_range (use, stmt)); > + tmp_range r (TREE_TYPE (use)); > + query->range_of_expr (r, use, stmt); > + r.dump (dump_file); > } > > fprintf (dump_file, "\n"); > diff --git a/gcc/vr-values.h b/gcc/vr-values.h > index 7a377cebd01..f018d0dfc4b 100644 > --- a/gcc/vr-values.h > +++ b/gcc/vr-values.h > @@ -109,7 +109,7 @@ class vr_values : public range_query > vr_values (void); > ~vr_values (void); > > - virtual bool range_of_expr (irange &r, tree expr, gimple *stmt) override; > + virtual bool range_of_expr (vrange &r, tree expr, gimple *stmt) override; > virtual tree value_of_expr (tree, gimple * = NULL) override; > virtual tree value_on_edge (edge, tree) override; > virtual tree value_of_stmt (gimple *, tree = NULL_TREE) override; > -- > 2.36.1 > --0000000000005e8d0d05e05f2f4b Content-Type: text/x-patch; charset="US-ASCII"; name="0005-Convert-ranger-and-clients-to-vrange.patch" Content-Disposition: attachment; filename="0005-Convert-ranger-and-clients-to-vrange.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_l3vd4i6d0 RnJvbSA2MWExYzg2MjJhMWJjNjViYzMxZDQ1NGM5MjY0MjhjYjIwMWU0MzUyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbGR5IEhlcm5hbmRleiA8YWxkeWhAcmVkaGF0LmNvbT4KRGF0 ZTogU3VuLCAyMiBNYXkgMjAyMiAyMDoxNzo0MCArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIENvbnZl cnQgcmFuZ2VyIGFuZCBjbGllbnRzIHRvIHZyYW5nZS4KCkZpbmFsbHksIHRoZSBtZWF0IG9mIHRo ZSB3b3JrLiAgQ29udmVydCByYW5nZXIgYW5kIGFzc29jaWF0ZWQgY2xpZW50cwp0byB2cmFuZ2Uu CgpFdmVyeXRoaW5nJ3MgcmVsYXRpdmVseSBtZWNoYW5pY2FsIGdpdmVuIHRoZSBwcmV2aW91cyBw YXRjaGVzLiAgSSBkaWQKaW5jbHVkZSBhIG1pbm9yIGNsZWFudXAgaW4gdGhlIGVkZ2UgY29kZS4g IFRoZXJlJ3Mgbm8gbmVlZCB0byBjaGVjawp0aGF0IHRoZSB0eXBlIG9mIHRoZSBzd2l0Y2ggaXMg YW4gaW50ZWdlciBhcyBub24taW50ZWdlciBzd2l0Y2hlcyBhcmUKaW52YWxpZC4gIEkgdmVyaWZp ZWQgdGhpcyB3aXRoIGFuIGFwcHJvcHJpYXRlbHkgY29kZWQgYXNzZXJ0LgoKVGVzdGVkIG9uIHg4 Ni02NCAmIHBwYzY0bGUgTGludXguCgpnY2MvQ2hhbmdlTG9nOgoKCSogZ2ltcGxlLXJhbmdlLWNh Y2hlLmNjIChzc2FfYmxvY2tfcmFuZ2VzOjpkdW1wKTogQ29udmVydCB0byB2cmFuZ2UuCgkoc2Jy X3ZlY3Rvcjo6c2JyX3ZlY3Rvcik6IFNhbWUuCgkoc2JyX3ZlY3Rvcjo6Z3Jvdyk6IFNhbWUuCgko c2JyX3ZlY3Rvcjo6c2V0X2JiX3JhbmdlKTogU2FtZS4KCShzYnJfdmVjdG9yOjpnZXRfYmJfcmFu Z2UpOiBTYW1lLgoJKHNicl9zcGFyc2VfYml0bWFwOjpzYnJfc3BhcnNlX2JpdG1hcCk6IFNhbWUu Cgkoc2JyX3NwYXJzZV9iaXRtYXA6OnNldF9iYl9yYW5nZSk6IFNhbWUuCgkoc2JyX3NwYXJzZV9i aXRtYXA6OmdldF9iYl9yYW5nZSk6IFNhbWUuCgkoYmxvY2tfcmFuZ2VfY2FjaGU6OnNldF9iYl9y YW5nZSk6IFNhbWUuCgkoYmxvY2tfcmFuZ2VfY2FjaGU6OmdldF9iYl9yYW5nZSk6IFNhbWUuCgko YmxvY2tfcmFuZ2VfY2FjaGU6OmR1bXApOiBTYW1lLgoJKHNzYV9nbG9iYWxfY2FjaGU6OmdldF9n bG9iYWxfcmFuZ2UpOiBTYW1lLgoJKHNzYV9nbG9iYWxfY2FjaGU6OnNldF9nbG9iYWxfcmFuZ2Up OiBTYW1lLgoJKHNzYV9nbG9iYWxfY2FjaGU6OmNsZWFyKTogU2FtZS4KCShzc2FfZ2xvYmFsX2Nh Y2hlOjpkdW1wKTogU2FtZS4KCShyYW5nZXJfY2FjaGU6OmdldF9nbG9iYWxfcmFuZ2UpOiBTYW1l LgoJKHJhbmdlcl9jYWNoZTo6c2V0X2dsb2JhbF9yYW5nZSk6IFNhbWUuCgkocmFuZ2VyX2NhY2hl OjpyYW5nZV9vZl9kZWYpOiBTYW1lLgoJKHJhbmdlcl9jYWNoZTo6ZW50cnlfcmFuZ2UpOiBTYW1l LgoJKHJhbmdlcl9jYWNoZTo6ZXhpdF9yYW5nZSk6IFNhbWUuCgkocmFuZ2VyX2NhY2hlOjplZGdl X3JhbmdlKTogU2FtZS4KCShyYW5nZXJfY2FjaGU6OnJhbmdlX29mX2V4cHIpOiBTYW1lLgoJKHJh bmdlcl9jYWNoZTo6cmFuZ2Vfb25fZWRnZSk6IFNhbWUuCgkocmFuZ2VyX2NhY2hlOjpibG9ja19y YW5nZSk6IFNhbWUuCgkocmFuZ2VyX2NhY2hlOjpwcm9wYWdhdGVfY2FjaGUpOiBTYW1lLgoJKHJh bmdlcl9jYWNoZTo6ZmlsbF9ibG9ja19jYWNoZSk6IFNhbWUuCgkocmFuZ2VyX2NhY2hlOjpyYW5n ZV9mcm9tX2RvbSk6IFNhbWUuCgkqIGdpbXBsZS1yYW5nZS1jYWNoZS5oOiBTYW1lLgoJKiBnaW1w bGUtcmFuZ2UtZWRnZS5jYyAoZ2ltcGxlX291dGdvaW5nX3JhbmdlOjpnZXRfZWRnZV9yYW5nZSk6 CglTYW1lLgoJKGdpbXBsZV9vdXRnb2luZ19yYW5nZTo6c3dpdGNoX2VkZ2VfcmFuZ2UpOiBTYW1l LgoJKGdpbXBsZV9vdXRnb2luZ19yYW5nZTo6ZWRnZV9yYW5nZV9wKTogU2FtZS4KCSogZ2ltcGxl LXJhbmdlLWVkZ2UuaDogU2FtZS4KCSogZ2ltcGxlLXJhbmdlLWZvbGQuY2MgKGZ1cl9zb3VyY2U6 OmdldF9vcGVyYW5kKTogU2FtZS4KCShmdXJfc291cmNlOjpnZXRfcGhpX29wZXJhbmQpOiBTYW1l LgoJKGZ1cl9lZGdlOjpnZXRfb3BlcmFuZCk6IFNhbWUuCgkoZnVyX2VkZ2U6OmdldF9waGlfb3Bl cmFuZCk6IFNhbWUuCgkoZnVyX3N0bXQ6OmdldF9vcGVyYW5kKTogU2FtZS4KCShmdXJfc3RtdDo6 Z2V0X3BoaV9vcGVyYW5kKTogU2FtZS4KCShmdXJfbGlzdDo6ZnVyX2xpc3QpOiBTYW1lLgoJKGZ1 cl9saXN0OjpnZXRfb3BlcmFuZCk6IFNhbWUuCgkoZnVyX2xpc3Q6OmdldF9waGlfb3BlcmFuZCk6 IFNhbWUuCgkoZm9sZF9yYW5nZSk6IFNhbWUuCgkoYWRqdXN0X2ltYWdwYXJ0X2V4cHIpOiBTYW1l LgoJKGFkanVzdF9yZWFscGFydF9leHByKTogU2FtZS4KCShnaW1wbGVfcmFuZ2VfYWRqdXN0bWVu dCk6IFNhbWUuCgkoZm9sZF91c2luZ19yYW5nZTo6Zm9sZF9zdG10KTogU2FtZS4KCShmb2xkX3Vz aW5nX3JhbmdlOjpyYW5nZV9vZl9yYW5nZV9vcCk6IFNhbWUuCgkoZm9sZF91c2luZ19yYW5nZTo6 cmFuZ2Vfb2ZfYWRkcmVzcyk6IFNhbWUuCgkoZm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfcGhp KTogU2FtZS4KCShmb2xkX3VzaW5nX3JhbmdlOjpyYW5nZV9vZl9jYWxsKTogU2FtZS4KCShmb2xk X3VzaW5nX3JhbmdlOjpyYW5nZV9vZl9idWlsdGluX2NhbGwpOiBTYW1lLgoJKGZvbGRfdXNpbmdf cmFuZ2U6OnJhbmdlX29mX2J1aWx0aW5faW50X2NhbGwpOiBTYW1lLgoJKGZvbGRfdXNpbmdfcmFu Z2U6OnJhbmdlX29mX2NvbmRfZXhwcik6IFNhbWUuCgkoZnVyX3NvdXJjZTo6cmVnaXN0ZXJfb3V0 Z29pbmdfZWRnZXMpOiBTYW1lLgoJKiBnaW1wbGUtcmFuZ2UtZm9sZC5oIChmb2xkX3JhbmdlKTog U2FtZS4KCShnaW1wbGVfcmFuZ2VfdHlwZSk6IFNhbWUuCgkoZ2ltcGxlX3JhbmdlX3NzYV9wKTog U2FtZS4KCSogZ2ltcGxlLXJhbmdlLWdvcmkuY2MgKGdpbXBsZV9yYW5nZV9jYWxjX29wMSk6IFNh bWUuCgkoZ2ltcGxlX3JhbmdlX2NhbGNfb3AyKTogU2FtZS4KCShnb3JpX2NvbXB1dGU6OmNvbXB1 dGVfb3BlcmFuZF9yYW5nZV9zd2l0Y2gpOiBTYW1lLgoJKGdvcmlfY29tcHV0ZTo6Y29tcHV0ZV9v cGVyYW5kX3JhbmdlKTogU2FtZS4KCShnb3JpX2NvbXB1dGU6OmxvZ2ljYWxfY29tYmluZSk6IFNh bWUuCgkoZ29yaV9jb21wdXRlOjpjb21wdXRlX2xvZ2ljYWxfb3BlcmFuZHMpOiBTYW1lLgoJKGdv cmlfY29tcHV0ZTo6Y29tcHV0ZV9vcGVyYW5kMV9yYW5nZSk6IFNhbWUuCgkoZ29yaV9jb21wdXRl Ojpjb21wdXRlX29wZXJhbmQyX3JhbmdlKTogU2FtZS4KCShnb3JpX2NvbXB1dGU6OmNvbXB1dGVf b3BlcmFuZDFfYW5kX29wZXJhbmQyX3JhbmdlKTogU2FtZS4KCShnb3JpX2NvbXB1dGU6Om91dGdv aW5nX2VkZ2VfcmFuZ2VfcCk6IFNhbWUuCgkoZ29yaV9jb21wdXRlOjpjb25kZXhwcl9hZGp1c3Qp OiBTYW1lLgoJKiBnaW1wbGUtcmFuZ2UtZ29yaS5oIChnaW1wbGVfcmFuZ2VfY2FsY19vcDEpOiBT YW1lLgoJKGdpbXBsZV9yYW5nZV9jYWxjX29wMik6IFNhbWUuCgkqIGdpbXBsZS1yYW5nZS1wYXRo LmNjIChwYXRoX3JhbmdlX3F1ZXJ5OjpnZXRfY2FjaGUpOiBTYW1lLgoJKHBhdGhfcmFuZ2VfcXVl cnk6OnNldF9jYWNoZSk6IFNhbWUuCgkocGF0aF9yYW5nZV9xdWVyeTo6cmFuZ2Vfb25fcGF0aF9l bnRyeSk6IFNhbWUuCgkocGF0aF9yYW5nZV9xdWVyeTo6aW50ZXJuYWxfcmFuZ2Vfb2ZfZXhwcik6 IFNhbWUuCgkocGF0aF9yYW5nZV9xdWVyeTo6cmFuZ2Vfb2ZfZXhwcik6IFNhbWUuCgkocGF0aF9y YW5nZV9xdWVyeTo6c3NhX3JhbmdlX2luX3BoaSk6IFNhbWUuCgkocGF0aF9yYW5nZV9xdWVyeTo6 cmFuZ2VfZGVmaW5lZF9pbl9ibG9jayk6IFNhbWUuCgkocGF0aF9yYW5nZV9xdWVyeTo6Y29tcHV0 ZV9yYW5nZXNfaW5fcGhpcyk6IFNhbWUuCgkocGF0aF9yYW5nZV9xdWVyeTo6Y29tcHV0ZV9yYW5n ZXNfaW5fYmxvY2spOiBTYW1lLgoJKHBhdGhfcmFuZ2VfcXVlcnk6OmFkZF90b19pbXBvcnRzKTog U2FtZS4KCShwYXRoX3JhbmdlX3F1ZXJ5OjpyYW5nZV9vZl9zdG10KTogU2FtZS4KCSogZ2ltcGxl LXJhbmdlLXBhdGguaDogU2FtZS4KCSogZ2ltcGxlLXJhbmdlLXNpZGUtZWZmZWN0LmNjIChnaW1w bGVfaW5mZXJfcmFuZ2U6OmFkZF9yYW5nZSk6IFNhbWUuCgkoZ2ltcGxlX2luZmVyX3JhbmdlOjp+ c2lkZV9lZmZlY3RfbWFuYWdlcik6IFNhbWUuCgkoZ2ltcGxlX2luZmVyX3JhbmdlOjpnZXRfbm9u emVybyk6IFNhbWUuCgkoZ2ltcGxlX2luZmVyX3JhbmdlOjptYXliZV9hZGp1c3RfcmFuZ2UpOiBT YW1lLgoJKGdpbXBsZV9pbmZlcl9yYW5nZTo6YWRkX3JhbmdlKTogU2FtZS4KCSogZ2ltcGxlLXJh bmdlLWluZmVyLmg6IFNhbWUuCgkqIGdpbXBsZS1yYW5nZS10ZXN0cy5jYzogU2FtZS4KCSogZ2lt cGxlLXJhbmdlLXRyYWNlLmNjIChyYW5nZV90cmFjZXI6OnRyYWlsZXIpOiBTYW1lLgoJKGRlYnVn X3NlZWRfcmFuZ2VyKTogU2FtZS4KCSogZ2ltcGxlLXJhbmdlLXRyYWNlLmg6IFNhbWUuCgkqIGdp bXBsZS1yYW5nZS5jYyAoZ2ltcGxlX3Jhbmdlcjo6cmFuZ2Vfb2ZfZXhwcik6IFNhbWUuCgkoZ2lt cGxlX3Jhbmdlcjo6cmFuZ2Vfb25fZW50cnkpOiBTYW1lLgoJKGdpbXBsZV9yYW5nZXI6OnJhbmdl X29uX2V4aXQpOiBTYW1lLgoJKGdpbXBsZV9yYW5nZXI6OnJhbmdlX29uX2VkZ2UpOiBTYW1lLgoJ KGdpbXBsZV9yYW5nZXI6OmZvbGRfcmFuZ2VfaW50ZXJuYWwpOiBTYW1lLgoJKGdpbXBsZV9yYW5n ZXI6OnJhbmdlX29mX3N0bXQpOiBTYW1lLgoJKGdpbXBsZV9yYW5nZXI6OnByZWZpbGxfbmFtZSk6 IFNhbWUuCgkoZ2ltcGxlX3Jhbmdlcjo6cHJlZmlsbF9zdG10X2RlcGVuZGVuY2llcyk6IFNhbWUu CgkoZ2ltcGxlX3Jhbmdlcjo6ZXhwb3J0X2dsb2JhbF9yYW5nZXMpOiBTYW1lLgoJKGdpbXBsZV9y YW5nZXI6OmR1bXBfYmIpOiBTYW1lLgoJKiBnaW1wbGUtcmFuZ2UuaDogU2FtZS4KCSogZ2ltcGxl LXNzYS13YXJuLWFjY2Vzcy5jYyAoY2hlY2tfbnVsX3Rlcm1pbmF0ZWRfYXJyYXkpOiBTYW1lLgoJ KG1lbW1vZGVsX3RvX3Vod2kpOiBTYW1lLgoJKiB0cmVlLXNzYS1sb29wLW5pdGVyLmNjIChyZWZp bmVfdmFsdWVfcmFuZ2VfdXNpbmdfZ3VhcmQpOiBTYW1lLgoJKGRldGVybWluZV92YWx1ZV9yYW5n ZSk6IFNhbWUuCgkocmVjb3JkX25vbndyYXBwaW5nX2l2KTogU2FtZS4KCShpbmZlcl9sb29wX2Jv dW5kc19mcm9tX3NpZ25lZG5lc3MpOiBTYW1lLgoJKHNjZXZfdmFyX3JhbmdlX2NhbnRfb3ZlcmZs b3cpOiBTYW1lLgoJKiB0cmVlLXNzYS10aHJlYWRlZGdlLmNjIChoeWJyaWRfanRfc2ltcGxpZmll cjo6c2ltcGxpZnkpOiBTYW1lLgoJKiB2YWx1ZS1xdWVyeS5jYyAocmFuZ2VfcXVlcnk6OnJhbmdl X29uX2VkZ2UpOiBTYW1lLgoJKHJhbmdlX3F1ZXJ5OjpyYW5nZV9vZl9zdG10KTogU2FtZS4KCShy YW5nZV9xdWVyeTo6dmFsdWVfb2ZfZXhwcik6IFNhbWUuCgkocmFuZ2VfcXVlcnk6OnZhbHVlX29u X2VkZ2UpOiBTYW1lLgoJKHJhbmdlX3F1ZXJ5Ojp2YWx1ZV9vZl9zdG10KTogU2FtZS4KCShyYW5n ZV9xdWVyeTo6Z2V0X3RyZWVfcmFuZ2UpOiBTYW1lLgoJKHVwZGF0ZV9nbG9iYWxfcmFuZ2UpOiBT YW1lLgoJKGdldF9yYW5nZV9nbG9iYWwpOiBTYW1lLgoJKGdpbXBsZV9yYW5nZV9nbG9iYWwpOiBT YW1lLgoJKGdsb2JhbF9yYW5nZV9xdWVyeTo6cmFuZ2Vfb2ZfZXhwcik6IFNhbWUuCgkocmFuZ2Vf cXVlcnk6OnF1ZXJ5X3JlbGF0aW9uKTogU2FtZS4KCSogdmFsdWUtcXVlcnkuaCAoZ2ltcGxlX3Jh bmdlX2dsb2JhbCk6IFNhbWUuCgkodXBkYXRlX2dsb2JhbF9yYW5nZSk6IFNhbWUuCgkqIHZyLXZh bHVlcy5jYyAodnJfdmFsdWVzOjpyYW5nZV9vZl9leHByKTogU2FtZS4KCShib3VuZHNfb2ZfdmFy X2luX2xvb3ApOiBTYW1lLgoJKHNpbXBsaWZ5X3VzaW5nX3Jhbmdlczo6dnJwX3Zpc2l0X2NvbmRf c3RtdCk6IFNhbWUuCgkqIHZyLXZhbHVlcy5oIChjbGFzcyB2cl92YWx1ZXMpOiBTYW1lLgoJKiB0 cmVlLXNzYS1sb29wLXVuc3dpdGNoLmNjICh1bnN3aXRjaF9wcmVkaWNhdGUpOiBTYW1lLgotLS0K IGdjYy9naW1wbGUtcmFuZ2UtY2FjaGUuY2MgICAgIHwgMTQwICsrKysrKysrKysrKysrKysrLS0t LS0tLS0tLS0tLS0tLQogZ2NjL2dpbXBsZS1yYW5nZS1jYWNoZS5oICAgICAgfCAgMzIgKysrKy0t LS0KIGdjYy9naW1wbGUtcmFuZ2UtZWRnZS5jYyAgICAgIHwgIDEyICstLQogZ2NjL2dpbXBsZS1y YW5nZS1lZGdlLmggICAgICAgfCAgIDIgKy0KIGdjYy9naW1wbGUtcmFuZ2UtZm9sZC5jYyAgICAg IHwgMTQxICsrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0KIGdjYy9naW1wbGUtcmFu Z2UtZm9sZC5oICAgICAgIHwgIDM3ICsrKystLS0tLQogZ2NjL2dpbXBsZS1yYW5nZS1nb3JpLmNj ICAgICAgfCAxMTUgKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tCiBnY2MvZ2ltcGxlLXJhbmdl LWdvcmkuaCAgICAgICB8ICA0MiArKysrKy0tLS0tCiBnY2MvZ2ltcGxlLXJhbmdlLWluZmVyLmNj ICAgICB8ICAyMCArKystLQogZ2NjL2dpbXBsZS1yYW5nZS1pbmZlci5oICAgICAgfCAgMTQgKyst LQogZ2NjL2dpbXBsZS1yYW5nZS1wYXRoLmNjICAgICAgfCAgNDcgKysrKysrKy0tLS0tCiBnY2Mv Z2ltcGxlLXJhbmdlLXBhdGguaCAgICAgICB8ICAxNiArKy0tCiBnY2MvZ2ltcGxlLXJhbmdlLXRl c3RzLmNjICAgICB8ICAgMyArLQogZ2NjL2dpbXBsZS1yYW5nZS10cmFjZS5jYyAgICAgfCAgIDkg KystCiBnY2MvZ2ltcGxlLXJhbmdlLXRyYWNlLmggICAgICB8ICAgMiArLQogZ2NjL2dpbXBsZS1y YW5nZS5jYyAgICAgICAgICAgfCAgNjQgKysrKysrKysrLS0tLS0tCiBnY2MvZ2ltcGxlLXJhbmdl LmggICAgICAgICAgICB8ICAxNCArKy0tCiBnY2MvZ2ltcGxlLXNzYS13YXJuLWFjY2Vzcy5jYyB8 ICAgNyArLQogZ2NjL3RyZWUtc3NhLWxvb3Atbml0ZXIuY2MgICAgfCAgMTYgKystLQogZ2NjL3Ry ZWUtc3NhLWxvb3AtdW5zd2l0Y2guY2MgfCAgMTQgKystLQogZ2NjL3RyZWUtc3NhLXRocmVhZGVk Z2UuY2MgICAgfCAgIDQgKy0KIGdjYy92YWx1ZS1xdWVyeS5jYyAgICAgICAgICAgIHwgIDczICsr KysrKysrKy0tLS0tLS0tLQogZ2NjL3ZhbHVlLXF1ZXJ5LmggICAgICAgICAgICAgfCAgMTYgKyst LQogZ2NjL3ZyLXZhbHVlcy5jYyAgICAgICAgICAgICAgfCAgNTYgKysrKysrKysrLS0tLS0KIGdj Yy92ci12YWx1ZXMuaCAgICAgICAgICAgICAgIHwgICAyICstCiAyNSBmaWxlcyBjaGFuZ2VkLCA0 OTIgaW5zZXJ0aW9ucygrKSwgNDA2IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2djYy9naW1w bGUtcmFuZ2UtY2FjaGUuY2MgYi9nY2MvZ2ltcGxlLXJhbmdlLWNhY2hlLmNjCmluZGV4IDI1YWRl MTMwMGFmLi44NWVlZDQ0MjFmNCAxMDA2NDQKLS0tIGEvZ2NjL2dpbXBsZS1yYW5nZS1jYWNoZS5j YworKysgYi9nY2MvZ2ltcGxlLXJhbmdlLWNhY2hlLmNjCkBAIC00NCwxMSArNDQsMTQgQEAgYWxv bmcgd2l0aCBHQ0M7IHNlZSB0aGUgZmlsZSBDT1BZSU5HMy4gIElmIG5vdCBzZWUKIGNsYXNzIHNz YV9ibG9ja19yYW5nZXMKIHsKIHB1YmxpYzoKLSAgdmlydHVhbCBib29sIHNldF9iYl9yYW5nZSAo Y29uc3RfYmFzaWNfYmxvY2sgYmIsIGNvbnN0IGlyYW5nZSAmcikgPSAwOwotICB2aXJ0dWFsIGJv b2wgZ2V0X2JiX3JhbmdlIChpcmFuZ2UgJnIsIGNvbnN0X2Jhc2ljX2Jsb2NrIGJiKSA9IDA7Cisg IHNzYV9ibG9ja19yYW5nZXMgKHRyZWUgdCkgOiBtX3R5cGUgKHQpIHsgfQorICB2aXJ0dWFsIGJv b2wgc2V0X2JiX3JhbmdlIChjb25zdF9iYXNpY19ibG9jayBiYiwgY29uc3QgdnJhbmdlICZyKSA9 IDA7CisgIHZpcnR1YWwgYm9vbCBnZXRfYmJfcmFuZ2UgKHZyYW5nZSAmciwgY29uc3RfYmFzaWNf YmxvY2sgYmIpID0gMDsKICAgdmlydHVhbCBib29sIGJiX3JhbmdlX3AgKGNvbnN0X2Jhc2ljX2Js b2NrIGJiKSA9IDA7CiAKICAgdm9pZCBkdW1wKEZJTEUgKmYpOworcHJpdmF0ZToKKyAgdHJlZSBt X3R5cGU7CiB9OwogCiAvLyBQcmludCB0aGUgbGlzdCBvZiBrbm93biByYW5nZXMgZm9yIGZpbGUg RiBpbiBhIG5pY2UgZm9ybWF0LgpAQCAtNTcsNyArNjAsNyBAQCB2b2lkCiBzc2FfYmxvY2tfcmFu Z2VzOjpkdW1wIChGSUxFICpmKQogewogICBiYXNpY19ibG9jayBiYjsKLSAgaW50X3JhbmdlX21h eCByOworICBWYWx1ZV9SYW5nZSByIChtX3R5cGUpOwogCiAgIEZPUl9FQUNIX0JCX0ZOIChiYiwg Y2Z1bikKICAgICBpZiAoZ2V0X2JiX3JhbmdlIChyLCBiYikpCkBAIC03NywxNCArODAsMTQgQEAg Y2xhc3Mgc2JyX3ZlY3RvciA6IHB1YmxpYyBzc2FfYmxvY2tfcmFuZ2VzCiBwdWJsaWM6CiAgIHNi cl92ZWN0b3IgKHRyZWUgdCwgdnJhbmdlX2FsbG9jYXRvciAqYWxsb2NhdG9yKTsKIAotICB2aXJ0 dWFsIGJvb2wgc2V0X2JiX3JhbmdlIChjb25zdF9iYXNpY19ibG9jayBiYiwgY29uc3QgaXJhbmdl ICZyKSBvdmVycmlkZTsKLSAgdmlydHVhbCBib29sIGdldF9iYl9yYW5nZSAoaXJhbmdlICZyLCBj b25zdF9iYXNpY19ibG9jayBiYikgb3ZlcnJpZGU7CisgIHZpcnR1YWwgYm9vbCBzZXRfYmJfcmFu Z2UgKGNvbnN0X2Jhc2ljX2Jsb2NrIGJiLCBjb25zdCB2cmFuZ2UgJnIpIG92ZXJyaWRlOworICB2 aXJ0dWFsIGJvb2wgZ2V0X2JiX3JhbmdlICh2cmFuZ2UgJnIsIGNvbnN0X2Jhc2ljX2Jsb2NrIGJi KSBvdmVycmlkZTsKICAgdmlydHVhbCBib29sIGJiX3JhbmdlX3AgKGNvbnN0X2Jhc2ljX2Jsb2Nr IGJiKSBvdmVycmlkZTsKIHByb3RlY3RlZDoKLSAgaXJhbmdlICoqbV90YWI7CS8vIE5vbiBncm93 aW5nIHZlY3Rvci4KKyAgdnJhbmdlICoqbV90YWI7CS8vIE5vbiBncm93aW5nIHZlY3Rvci4KICAg aW50IG1fdGFiX3NpemU7Ci0gIGludF9yYW5nZTwyPiBtX3Zhcnlpbmc7Ci0gIGludF9yYW5nZTwy PiBtX3VuZGVmaW5lZDsKKyAgdnJhbmdlICptX3Zhcnlpbmc7CisgIHZyYW5nZSAqbV91bmRlZmlu ZWQ7CiAgIHRyZWUgbV90eXBlOwogICB2cmFuZ2VfYWxsb2NhdG9yICptX3JhbmdlX2FsbG9jYXRv cjsKICAgdm9pZCBncm93ICgpOwpAQCAtOTQsMTggKzk3LDIxIEBAIHByb3RlY3RlZDoKIC8vIElu aXRpYWxpemUgYSBibG9jayBjYWNoZSBmb3IgYW4gc3NhX25hbWUgb2YgdHlwZSBULgogCiBzYnJf dmVjdG9yOjpzYnJfdmVjdG9yICh0cmVlIHQsIHZyYW5nZV9hbGxvY2F0b3IgKmFsbG9jYXRvcikK KyAgOiBzc2FfYmxvY2tfcmFuZ2VzICh0KQogewogICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChUWVBF X1AgKHQpKTsKICAgbV90eXBlID0gdDsKICAgbV9yYW5nZV9hbGxvY2F0b3IgPSBhbGxvY2F0b3I7 CiAgIG1fdGFiX3NpemUgPSBsYXN0X2Jhc2ljX2Jsb2NrX2Zvcl9mbiAoY2Z1bikgKyAxOwotICBt X3RhYiA9IHN0YXRpY19jYXN0IDxpcmFuZ2UgKio+Ci0gICAgKGFsbG9jYXRvci0+YWxsb2MgKG1f dGFiX3NpemUgKiBzaXplb2YgKGlyYW5nZSAqKSkpOwotICBtZW1zZXQgKG1fdGFiLCAwLCBtX3Rh Yl9zaXplICogc2l6ZW9mIChpcmFuZ2UgKikpOworICBtX3RhYiA9IHN0YXRpY19jYXN0IDx2cmFu Z2UgKio+CisgICAgKGFsbG9jYXRvci0+YWxsb2MgKG1fdGFiX3NpemUgKiBzaXplb2YgKHZyYW5n ZSAqKSkpOworICBtZW1zZXQgKG1fdGFiLCAwLCBtX3RhYl9zaXplICogc2l6ZW9mICh2cmFuZ2Ug KikpOwogCiAgIC8vIENyZWF0ZSB0aGUgY2FjaGVkIHR5cGUgcmFuZ2UuCi0gIG1fdmFyeWluZy5z ZXRfdmFyeWluZyAodCk7Ci0gIG1fdW5kZWZpbmVkLnNldF91bmRlZmluZWQgKCk7CisgIG1fdmFy eWluZyA9IG1fcmFuZ2VfYWxsb2NhdG9yLT5hbGxvY192cmFuZ2UgKHQpOworICBtX3VuZGVmaW5l ZCA9IG1fcmFuZ2VfYWxsb2NhdG9yLT5hbGxvY192cmFuZ2UgKHQpOworICBtX3ZhcnlpbmctPnNl dF92YXJ5aW5nICh0KTsKKyAgbV91bmRlZmluZWQtPnNldF91bmRlZmluZWQgKCk7CiB9CiAKIC8v IEdyb3cgdGhlIHZlY3RvciB3aGVuIHRoZSBDRkcgaGFzIGluY3JlYXNlZCBpbiBzaXplLgpAQCAt MTIyLDEwICsxMjgsMTAgQEAgc2JyX3ZlY3Rvcjo6Z3JvdyAoKQogICBpbnQgbmV3X3NpemUgPSBp bmMgKyBjdXJyX2JiX3NpemU7CiAKICAgLy8gQWxsb2NhdGUgbmV3IG1lbW9yeSwgY29weSB0aGUg b2xkIHZlY3RvciBhbmQgY2xlYXIgdGhlIG5ldyBzcGFjZS4KLSAgaXJhbmdlICoqdCA9IHN0YXRp Y19jYXN0IDxpcmFuZ2UgKio+Ci0gICAgKG1fcmFuZ2VfYWxsb2NhdG9yLT5hbGxvYyAobmV3X3Np emUgKiBzaXplb2YgKGlyYW5nZSAqKSkpOwotICBtZW1jcHkgKHQsIG1fdGFiLCBtX3RhYl9zaXpl ICogc2l6ZW9mIChpcmFuZ2UgKikpOwotICBtZW1zZXQgKHQgKyBtX3RhYl9zaXplLCAwLCAobmV3 X3NpemUgLSBtX3RhYl9zaXplKSAqIHNpemVvZiAoaXJhbmdlICopKTsKKyAgdnJhbmdlICoqdCA9 IHN0YXRpY19jYXN0IDx2cmFuZ2UgKio+CisgICAgKG1fcmFuZ2VfYWxsb2NhdG9yLT5hbGxvYyAo bmV3X3NpemUgKiBzaXplb2YgKHZyYW5nZSAqKSkpOworICBtZW1jcHkgKHQsIG1fdGFiLCBtX3Rh Yl9zaXplICogc2l6ZW9mICh2cmFuZ2UgKikpOworICBtZW1zZXQgKHQgKyBtX3RhYl9zaXplLCAw LCAobmV3X3NpemUgLSBtX3RhYl9zaXplKSAqIHNpemVvZiAodnJhbmdlICopKTsKIAogICBtX3Rh YiA9IHQ7CiAgIG1fdGFiX3NpemUgPSBuZXdfc2l6ZTsKQEAgLTEzNCwxNSArMTQwLDE1IEBAIHNi cl92ZWN0b3I6Omdyb3cgKCkKIC8vIFNldCB0aGUgcmFuZ2UgZm9yIGJsb2NrIEJCIHRvIGJlIFIu CiAKIGJvb2wKLXNicl92ZWN0b3I6OnNldF9iYl9yYW5nZSAoY29uc3RfYmFzaWNfYmxvY2sgYmIs IGNvbnN0IGlyYW5nZSAmcikKK3Nicl92ZWN0b3I6OnNldF9iYl9yYW5nZSAoY29uc3RfYmFzaWNf YmxvY2sgYmIsIGNvbnN0IHZyYW5nZSAmcikKIHsKLSAgaXJhbmdlICptOworICB2cmFuZ2UgKm07 CiAgIGlmIChiYi0+aW5kZXggPj0gbV90YWJfc2l6ZSkKICAgICBncm93ICgpOwogICBpZiAoci52 YXJ5aW5nX3AgKCkpCi0gICAgbSA9ICZtX3Zhcnlpbmc7CisgICAgbSA9IG1fdmFyeWluZzsKICAg ZWxzZSBpZiAoci51bmRlZmluZWRfcCAoKSkKLSAgICBtID0gJm1fdW5kZWZpbmVkOworICAgIG0g PSBtX3VuZGVmaW5lZDsKICAgZWxzZQogICAgIG0gPSBtX3JhbmdlX2FsbG9jYXRvci0+Y2xvbmUg KHIpOwogICBtX3RhYltiYi0+aW5kZXhdID0gbTsKQEAgLTE1MywxMSArMTU5LDExIEBAIHNicl92 ZWN0b3I6OnNldF9iYl9yYW5nZSAoY29uc3RfYmFzaWNfYmxvY2sgYmIsIGNvbnN0IGlyYW5nZSAm cikKIC8vIHRoZXJlIGlzIG5vIHJhbmdlLgogCiBib29sCi1zYnJfdmVjdG9yOjpnZXRfYmJfcmFu Z2UgKGlyYW5nZSAmciwgY29uc3RfYmFzaWNfYmxvY2sgYmIpCitzYnJfdmVjdG9yOjpnZXRfYmJf cmFuZ2UgKHZyYW5nZSAmciwgY29uc3RfYmFzaWNfYmxvY2sgYmIpCiB7CiAgIGlmIChiYi0+aW5k ZXggPj0gbV90YWJfc2l6ZSkKICAgICByZXR1cm4gZmFsc2U7Ci0gIGlyYW5nZSAqbSA9IG1fdGFi W2JiLT5pbmRleF07CisgIHZyYW5nZSAqbSA9IG1fdGFiW2JiLT5pbmRleF07CiAgIGlmIChtKQog ICAgIHsKICAgICAgIHIgPSAqbTsKQEAgLTE5MywxNCArMTk5LDE0IEBAIGNsYXNzIHNicl9zcGFy c2VfYml0bWFwIDogcHVibGljIHNzYV9ibG9ja19yYW5nZXMKIHsKIHB1YmxpYzoKICAgc2JyX3Nw YXJzZV9iaXRtYXAgKHRyZWUgdCwgdnJhbmdlX2FsbG9jYXRvciAqYWxsb2NhdG9yLCBiaXRtYXBf b2JzdGFjayAqYm0pOwotICB2aXJ0dWFsIGJvb2wgc2V0X2JiX3JhbmdlIChjb25zdF9iYXNpY19i bG9jayBiYiwgY29uc3QgaXJhbmdlICZyKSBvdmVycmlkZTsKLSAgdmlydHVhbCBib29sIGdldF9i Yl9yYW5nZSAoaXJhbmdlICZyLCBjb25zdF9iYXNpY19ibG9jayBiYikgb3ZlcnJpZGU7CisgIHZp cnR1YWwgYm9vbCBzZXRfYmJfcmFuZ2UgKGNvbnN0X2Jhc2ljX2Jsb2NrIGJiLCBjb25zdCB2cmFu Z2UgJnIpIG92ZXJyaWRlOworICB2aXJ0dWFsIGJvb2wgZ2V0X2JiX3JhbmdlICh2cmFuZ2UgJnIs IGNvbnN0X2Jhc2ljX2Jsb2NrIGJiKSBvdmVycmlkZTsKICAgdmlydHVhbCBib29sIGJiX3Jhbmdl X3AgKGNvbnN0X2Jhc2ljX2Jsb2NrIGJiKSBvdmVycmlkZTsKIHByaXZhdGU6CiAgIHZvaWQgYml0 bWFwX3NldF9xdWFkIChiaXRtYXAgaGVhZCwgaW50IHF1YWQsIGludCBxdWFkX3ZhbHVlKTsKICAg aW50IGJpdG1hcF9nZXRfcXVhZCAoY29uc3RfYml0bWFwIGhlYWQsIGludCBxdWFkKTsKICAgdnJh bmdlX2FsbG9jYXRvciAqbV9yYW5nZV9hbGxvY2F0b3I7Ci0gIGlyYW5nZSAqbV9yYW5nZVtTQlJf TlVNXTsKKyAgdnJhbmdlICptX3JhbmdlW1NCUl9OVU1dOwogICBiaXRtYXBfaGVhZCBiaXR2ZWM7 CiAgIHRyZWUgbV90eXBlOwogfTsKQEAgLTIwOSw2ICsyMTUsNyBAQCBwcml2YXRlOgogCiBzYnJf c3BhcnNlX2JpdG1hcDo6c2JyX3NwYXJzZV9iaXRtYXAgKHRyZWUgdCwgdnJhbmdlX2FsbG9jYXRv ciAqYWxsb2NhdG9yLAogCQkJCSAgICAgIGJpdG1hcF9vYnN0YWNrICpibSkKKyAgOiBzc2FfYmxv Y2tfcmFuZ2VzICh0KQogewogICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChUWVBFX1AgKHQpKTsKICAg bV90eXBlID0gdDsKQEAgLTIxNiwxNiArMjIzLDE0IEBAIHNicl9zcGFyc2VfYml0bWFwOjpzYnJf c3BhcnNlX2JpdG1hcCAodHJlZSB0LCB2cmFuZ2VfYWxsb2NhdG9yICphbGxvY2F0b3IsCiAgIGJp dG1hcF90cmVlX3ZpZXcgKCZiaXR2ZWMpOwogICBtX3JhbmdlX2FsbG9jYXRvciA9IGFsbG9jYXRv cjsKICAgLy8gUHJlLWNhY2hlIHZhcnlpbmcuCi0gIG1fcmFuZ2VbMF0gPSBzdGF0aWNfY2FzdCA8 aXJhbmdlICo+IChtX3JhbmdlX2FsbG9jYXRvci0+YWxsb2NfdnJhbmdlICh0KSk7CisgIG1fcmFu Z2VbMF0gPSBtX3JhbmdlX2FsbG9jYXRvci0+YWxsb2NfdnJhbmdlICh0KTsKICAgbV9yYW5nZVsw XS0+c2V0X3ZhcnlpbmcgKHQpOwogICAvLyBQcmUtY2FjaGUgemVybyBhbmQgbm9uLXplcm8gdmFs dWVzIGZvciBwb2ludGVycy4KICAgaWYgKFBPSU5URVJfVFlQRV9QICh0KSkKICAgICB7Ci0gICAg ICBtX3JhbmdlWzFdCi0JPSBzdGF0aWNfY2FzdCA8aXJhbmdlICo+IChtX3JhbmdlX2FsbG9jYXRv ci0+YWxsb2NfdnJhbmdlICh0KSk7CisgICAgICBtX3JhbmdlWzFdID0gbV9yYW5nZV9hbGxvY2F0 b3ItPmFsbG9jX3ZyYW5nZSAodCk7CiAgICAgICBtX3JhbmdlWzFdLT5zZXRfbm9uemVybyAodCk7 Ci0gICAgICBtX3JhbmdlWzJdCi0JPSBzdGF0aWNfY2FzdCA8aXJhbmdlICo+IChtX3JhbmdlX2Fs bG9jYXRvci0+YWxsb2NfdnJhbmdlICh0KSk7CisgICAgICBtX3JhbmdlWzJdID0gbV9yYW5nZV9h bGxvY2F0b3ItPmFsbG9jX3ZyYW5nZSAodCk7CiAgICAgICBtX3JhbmdlWzJdLT5zZXRfemVybyAo dCk7CiAgICAgfQogICBlbHNlCkBAIC0yNTcsNyArMjYyLDcgQEAgc2JyX3NwYXJzZV9iaXRtYXA6 OmJpdG1hcF9nZXRfcXVhZCAoY29uc3RfYml0bWFwIGhlYWQsIGludCBxdWFkKQogLy8gU2V0IHRo ZSByYW5nZSBvbiBlbnRyeSB0byBiYXNpYyBibG9jayBCQiB0byBSLgogCiBib29sCi1zYnJfc3Bh cnNlX2JpdG1hcDo6c2V0X2JiX3JhbmdlIChjb25zdF9iYXNpY19ibG9jayBiYiwgY29uc3QgaXJh bmdlICZyKQorc2JyX3NwYXJzZV9iaXRtYXA6OnNldF9iYl9yYW5nZSAoY29uc3RfYmFzaWNfYmxv Y2sgYmIsIGNvbnN0IHZyYW5nZSAmcikKIHsKICAgaWYgKHIudW5kZWZpbmVkX3AgKCkpCiAgICAg ewpAQCAtMjgzLDcgKzI4OCw3IEBAIHNicl9zcGFyc2VfYml0bWFwOjpzZXRfYmJfcmFuZ2UgKGNv bnN0X2Jhc2ljX2Jsb2NrIGJiLCBjb25zdCBpcmFuZ2UgJnIpCiAvLyB0aGVyZSBpcyBubyByYW5n ZS4KIAogYm9vbAotc2JyX3NwYXJzZV9iaXRtYXA6OmdldF9iYl9yYW5nZSAoaXJhbmdlICZyLCBj b25zdF9iYXNpY19ibG9jayBiYikKK3Nicl9zcGFyc2VfYml0bWFwOjpnZXRfYmJfcmFuZ2UgKHZy YW5nZSAmciwgY29uc3RfYmFzaWNfYmxvY2sgYmIpCiB7CiAgIGludCB2YWx1ZSA9IGJpdG1hcF9n ZXRfcXVhZCAoJmJpdHZlYywgYmItPmluZGV4KTsKIApAQCAtMzMzLDcgKzMzOCw3IEBAIGJsb2Nr X3JhbmdlX2NhY2hlOjp+YmxvY2tfcmFuZ2VfY2FjaGUgKCkKIAogYm9vbAogYmxvY2tfcmFuZ2Vf Y2FjaGU6OnNldF9iYl9yYW5nZSAodHJlZSBuYW1lLCBjb25zdF9iYXNpY19ibG9jayBiYiwKLQkJ CQkgY29uc3QgaXJhbmdlICZyKQorCQkJCSBjb25zdCB2cmFuZ2UgJnIpCiB7CiAgIHVuc2lnbmVk IHYgPSBTU0FfTkFNRV9WRVJTSU9OIChuYW1lKTsKICAgaWYgKHYgPj0gbV9zc2FfcmFuZ2VzLmxl bmd0aCAoKSkKQEAgLTM3OSw3ICszODQsNyBAQCBibG9ja19yYW5nZV9jYWNoZTo6cXVlcnlfYmxv Y2tfcmFuZ2VzICh0cmVlIG5hbWUpCiAvLyBpcyBvbmUuCiAKIGJvb2wKLWJsb2NrX3JhbmdlX2Nh Y2hlOjpnZXRfYmJfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSBuYW1lLCBjb25zdF9iYXNpY19ibG9j ayBiYikKK2Jsb2NrX3JhbmdlX2NhY2hlOjpnZXRfYmJfcmFuZ2UgKHZyYW5nZSAmciwgdHJlZSBu YW1lLCBjb25zdF9iYXNpY19ibG9jayBiYikKIHsKICAgc3NhX2Jsb2NrX3JhbmdlcyAqcHRyID0g cXVlcnlfYmxvY2tfcmFuZ2VzIChuYW1lKTsKICAgaWYgKHB0cikKQEAgLTQyMywxMiArNDI4LDEz IEBAIHZvaWQKIGJsb2NrX3JhbmdlX2NhY2hlOjpkdW1wIChGSUxFICpmLCBiYXNpY19ibG9jayBi YiwgYm9vbCBwcmludF92YXJ5aW5nKQogewogICB1bnNpZ25lZCB4OwotICBpbnRfcmFuZ2VfbWF4 IHI7CiAgIGJvb2wgc3VtbWFyaXplX3ZhcnlpbmcgPSBmYWxzZTsKICAgZm9yICh4ID0gMTsgeCA8 IG1fc3NhX3Jhbmdlcy5sZW5ndGggKCk7ICsreCkKICAgICB7CiAgICAgICBpZiAoIWdpbXBsZV9y YW5nZV9zc2FfcCAoc3NhX25hbWUgKHgpKSkKIAljb250aW51ZTsKKworICAgICAgVmFsdWVfUmFu Z2UgciAoVFJFRV9UWVBFIChzc2FfbmFtZSAoeCkpKTsKICAgICAgIGlmIChtX3NzYV9yYW5nZXNb eF0gJiYgbV9zc2FfcmFuZ2VzW3hdLT5nZXRfYmJfcmFuZ2UgKHIsIGJiKSkKIAl7CiAJICBpZiAo IXByaW50X3ZhcnlpbmcgJiYgci52YXJ5aW5nX3AgKCkpCkBAIC00NTAsNiArNDU2LDggQEAgYmxv Y2tfcmFuZ2VfY2FjaGU6OmR1bXAgKEZJTEUgKmYsIGJhc2ljX2Jsb2NrIGJiLCBib29sIHByaW50 X3ZhcnlpbmcpCiAJewogCSAgaWYgKCFnaW1wbGVfcmFuZ2Vfc3NhX3AgKHNzYV9uYW1lICh4KSkp CiAJICAgIGNvbnRpbnVlOworCisJICBWYWx1ZV9SYW5nZSByIChUUkVFX1RZUEUgKHNzYV9uYW1l ICh4KSkpOwogCSAgaWYgKG1fc3NhX3Jhbmdlc1t4XSAmJiBtX3NzYV9yYW5nZXNbeF0tPmdldF9i Yl9yYW5nZSAociwgYmIpKQogCSAgICB7CiAJICAgICAgaWYgKHIudmFyeWluZ19wICgpKQpAQCAt NDg1LDEzICs0OTMsMTMgQEAgc3NhX2dsb2JhbF9jYWNoZTo6fnNzYV9nbG9iYWxfY2FjaGUgKCkK IC8vIFJldHVybiB0aGUgdmFsdWUgaW4gUi4KIAogYm9vbAotc3NhX2dsb2JhbF9jYWNoZTo6Z2V0 X2dsb2JhbF9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIG5hbWUpIGNvbnN0Citzc2FfZ2xvYmFsX2Nh Y2hlOjpnZXRfZ2xvYmFsX3JhbmdlICh2cmFuZ2UgJnIsIHRyZWUgbmFtZSkgY29uc3QKIHsKICAg dW5zaWduZWQgdiA9IFNTQV9OQU1FX1ZFUlNJT04gKG5hbWUpOwogICBpZiAodiA+PSBtX3RhYi5s ZW5ndGggKCkpCiAgICAgcmV0dXJuIGZhbHNlOwogCi0gIGlyYW5nZSAqc3RvdyA9IG1fdGFiW3Zd OworICB2cmFuZ2UgKnN0b3cgPSBtX3RhYlt2XTsKICAgaWYgKCFzdG93KQogICAgIHJldHVybiBm YWxzZTsKICAgciA9ICpzdG93OwpAQCAtNTAyLDEzICs1MTAsMTMgQEAgc3NhX2dsb2JhbF9jYWNo ZTo6Z2V0X2dsb2JhbF9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIG5hbWUpIGNvbnN0CiAvLyBSZXR1 cm4gVFJVRSBpZiB0aGVyZSB3YXMgYWxyZWFkeSBhIHJhbmdlIHNldCwgb3RoZXJ3aXNlIGZhbHNl LgogCiBib29sCi1zc2FfZ2xvYmFsX2NhY2hlOjpzZXRfZ2xvYmFsX3JhbmdlICh0cmVlIG5hbWUs IGNvbnN0IGlyYW5nZSAmcikKK3NzYV9nbG9iYWxfY2FjaGU6OnNldF9nbG9iYWxfcmFuZ2UgKHRy ZWUgbmFtZSwgY29uc3QgdnJhbmdlICZyKQogewogICB1bnNpZ25lZCB2ID0gU1NBX05BTUVfVkVS U0lPTiAobmFtZSk7CiAgIGlmICh2ID49IG1fdGFiLmxlbmd0aCAoKSkKICAgICBtX3RhYi5zYWZl X2dyb3dfY2xlYXJlZCAobnVtX3NzYV9uYW1lcyArIDEpOwogCi0gIGlyYW5nZSAqbSA9IG1fdGFi W3ZdOworICB2cmFuZ2UgKm0gPSBtX3RhYlt2XTsKICAgaWYgKG0gJiYgbS0+Zml0c19wIChyKSkK ICAgICAqbSA9IHI7CiAgIGVsc2UKQEAgLTUzMyw3ICs1NDEsNyBAQCB2b2lkCiBzc2FfZ2xvYmFs X2NhY2hlOjpjbGVhciAoKQogewogICBpZiAobV90YWIuYWRkcmVzcyAoKSkKLSAgICBtZW1zZXQg KG1fdGFiLmFkZHJlc3MoKSwgMCwgbV90YWIubGVuZ3RoICgpICogc2l6ZW9mIChpcmFuZ2UgKikp OworICAgIG1lbXNldCAobV90YWIuYWRkcmVzcygpLCAwLCBtX3RhYi5sZW5ndGggKCkgKiBzaXpl b2YgKHZyYW5nZSAqKSk7CiB9CiAKIC8vIER1bXAgdGhlIGNvbnRlbnRzIG9mIHRoZSBnbG9iYWwg Y2FjaGUgdG8gRi4KQEAgLTU0NSw5ICs1NTMsMTAgQEAgc3NhX2dsb2JhbF9jYWNoZTo6ZHVtcCAo RklMRSAqZikKICAgYm9vbCBwcmludF9oZWFkZXIgPSB0cnVlOwogICBmb3IgKHVuc2lnbmVkIHgg PSAxOyB4IDwgbnVtX3NzYV9uYW1lczsgeCsrKQogICAgIHsKLSAgICAgIGludF9yYW5nZV9tYXgg cjsKLSAgICAgIGlmIChnaW1wbGVfcmFuZ2Vfc3NhX3AgKHNzYV9uYW1lICh4KSkgJiYKLQkgIGdl dF9nbG9iYWxfcmFuZ2UgKHIsIHNzYV9uYW1lICh4KSkgICYmICFyLnZhcnlpbmdfcCAoKSkKKyAg ICAgIGlmICghZ2ltcGxlX3JhbmdlX3NzYV9wIChzc2FfbmFtZSAoeCkpKQorCWNvbnRpbnVlOwor ICAgICAgVmFsdWVfUmFuZ2UgciAoVFJFRV9UWVBFIChzc2FfbmFtZSAoeCkpKTsKKyAgICAgIGlm IChnZXRfZ2xvYmFsX3JhbmdlIChyLCBzc2FfbmFtZSAoeCkpICYmICFyLnZhcnlpbmdfcCAoKSkK IAl7CiAJICBpZiAocHJpbnRfaGVhZGVyKQogCSAgICB7CkBAIC04MDksMTEgKzgxOCwxMSBAQCBy YW5nZXJfY2FjaGU6OmR1bXBfYmIgKEZJTEUgKmYsIGJhc2ljX2Jsb2NrIGJiKQogLy8gZ2xvYmFs IHJhbmdlIGlzIG5vdCBzZXQsIGFuZCByZXR1cm4gdGhlIGxlZ2FjeSBnbG9iYWwgdmFsdWUgaW4g Ui4KIAogYm9vbAotcmFuZ2VyX2NhY2hlOjpnZXRfZ2xvYmFsX3JhbmdlIChpcmFuZ2UgJnIsIHRy ZWUgbmFtZSkgY29uc3QKK3Jhbmdlcl9jYWNoZTo6Z2V0X2dsb2JhbF9yYW5nZSAodnJhbmdlICZy LCB0cmVlIG5hbWUpIGNvbnN0CiB7CiAgIGlmIChtX2dsb2JhbHMuZ2V0X2dsb2JhbF9yYW5nZSAo ciwgbmFtZSkpCiAgICAgcmV0dXJuIHRydWU7Ci0gIHIgPSBnaW1wbGVfcmFuZ2VfZ2xvYmFsIChu YW1lKTsKKyAgZ2ltcGxlX3JhbmdlX2dsb2JhbCAociwgbmFtZSk7CiAgIHJldHVybiBmYWxzZTsK IH0KIApAQCAtODI1LDcgKzgzNCw3IEBAIHJhbmdlcl9jYWNoZTo6Z2V0X2dsb2JhbF9yYW5nZSAo aXJhbmdlICZyLCB0cmVlIG5hbWUpIGNvbnN0CiAvLyBBZnRlciB0aGlzIGNhbGwsIHRoZSBnbG9i YWwgY2FjaGUgd2lsbCBoYXZlIGEgdmFsdWUuCiAKIGJvb2wKLXJhbmdlcl9jYWNoZTo6Z2V0X2ds b2JhbF9yYW5nZSAoaXJhbmdlICZyLCB0cmVlIG5hbWUsIGJvb2wgJmN1cnJlbnRfcCkKK3Jhbmdl cl9jYWNoZTo6Z2V0X2dsb2JhbF9yYW5nZSAodnJhbmdlICZyLCB0cmVlIG5hbWUsIGJvb2wgJmN1 cnJlbnRfcCkKIHsKICAgYm9vbCBoYWRfZ2xvYmFsID0gZ2V0X2dsb2JhbF9yYW5nZSAociwgbmFt ZSk7CiAKQEAgLTg0Nyw3ICs4NTYsNyBAQCByYW5nZXJfY2FjaGU6OmdldF9nbG9iYWxfcmFuZ2Ug KGlyYW5nZSAmciwgdHJlZSBuYW1lLCBib29sICZjdXJyZW50X3ApCiAvLyAgU2V0IHRoZSBnbG9i YWwgcmFuZ2Ugb2YgTkFNRSB0byBSIGFuZCBnaXZlIGl0IGEgdGltZXN0YW1wLgogCiB2b2lkCi1y YW5nZXJfY2FjaGU6OnNldF9nbG9iYWxfcmFuZ2UgKHRyZWUgbmFtZSwgY29uc3QgaXJhbmdlICZy KQorcmFuZ2VyX2NhY2hlOjpzZXRfZ2xvYmFsX3JhbmdlICh0cmVlIG5hbWUsIGNvbnN0IHZyYW5n ZSAmcikKIHsKICAgaWYgKG1fZ2xvYmFscy5zZXRfZ2xvYmFsX3JhbmdlIChuYW1lLCByKSkKICAg ICB7CkBAIC04ODIsNyArODkxLDcgQEAgcmFuZ2VyX2NhY2hlOjpzZXRfZ2xvYmFsX3JhbmdlICh0 cmVlIG5hbWUsIGNvbnN0IGlyYW5nZSAmcikKIC8vIGdldCB0aGUgYmVzdCBnbG9iYWwgdmFsdWUg YXZhaWxhYmxlLgogCiB2b2lkCi1yYW5nZXJfY2FjaGU6OnJhbmdlX29mX2RlZiAoaXJhbmdlICZy LCB0cmVlIG5hbWUsIGJhc2ljX2Jsb2NrIGJiKQorcmFuZ2VyX2NhY2hlOjpyYW5nZV9vZl9kZWYg KHZyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYikKIHsKICAgZ2NjX2NoZWNraW5n X2Fzc2VydCAoZ2ltcGxlX3JhbmdlX3NzYV9wIChuYW1lKSk7CiAgIGdjY19jaGVja2luZ19hc3Nl cnQgKCFiYiB8fCBiYiA9PSBnaW1wbGVfYmIgKFNTQV9OQU1FX0RFRl9TVE1UIChuYW1lKSkpOwpA QCAtODk1LDcgKzkwNCw3IEBAIHJhbmdlcl9jYWNoZTo6cmFuZ2Vfb2ZfZGVmIChpcmFuZ2UgJnIs IHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sgYmIpCiAgICAgICBpZiAoZ2ltcGxlX2dldF9saHMgKHMp ID09IG5hbWUpCiAJZm9sZF9yYW5nZSAociwgcywgZ2V0X2dsb2JhbF9yYW5nZV9xdWVyeSAoKSk7 CiAgICAgICBlbHNlCi0JciA9IGdpbXBsZV9yYW5nZV9nbG9iYWwgKG5hbWUpOworCWdpbXBsZV9y YW5nZV9nbG9iYWwgKHIsIG5hbWUpOwogICAgIH0KIH0KIApAQCAtOTAzLDEyICs5MTIsMTIgQEAg cmFuZ2VyX2NhY2hlOjpyYW5nZV9vZl9kZWYgKGlyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19i bG9jayBiYikKIC8vIGxvb2t1cHMuCiAKIHZvaWQKLXJhbmdlcl9jYWNoZTo6ZW50cnlfcmFuZ2Ug KGlyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYiwKK3Jhbmdlcl9jYWNoZTo6ZW50 cnlfcmFuZ2UgKHZyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYiwKIAkJCSAgIGVu dW0gcmZkX21vZGUgbW9kZSkKIHsKICAgaWYgKGJiID09IEVOVFJZX0JMT0NLX1BUUl9GT1JfRk4g KGNmdW4pKQogICAgIHsKLSAgICAgIHIgPSBnaW1wbGVfcmFuZ2VfZ2xvYmFsIChuYW1lKTsKKyAg ICAgIGdpbXBsZV9yYW5nZV9nbG9iYWwgKHIsIG5hbWUpOwogICAgICAgcmV0dXJuOwogICAgIH0K IApAQCAtOTIzLDEyICs5MzIsMTIgQEAgcmFuZ2VyX2NhY2hlOjplbnRyeV9yYW5nZSAoaXJhbmdl ICZyLCB0cmVlIG5hbWUsIGJhc2ljX2Jsb2NrIGJiLAogLy8gbG9va3Vwcy4KIAogdm9pZAotcmFu Z2VyX2NhY2hlOjpleGl0X3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sg YmIsCityYW5nZXJfY2FjaGU6OmV4aXRfcmFuZ2UgKHZyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNp Y19ibG9jayBiYiwKIAkJCSAgZW51bSByZmRfbW9kZSBtb2RlKQogewogICBpZiAoYmIgPT0gRU5U UllfQkxPQ0tfUFRSX0ZPUl9GTiAoY2Z1bikpCiAgICAgewotICAgICAgciA9IGdpbXBsZV9yYW5n ZV9nbG9iYWwgKG5hbWUpOworICAgICAgZ2ltcGxlX3JhbmdlX2dsb2JhbCAociwgbmFtZSk7CiAg ICAgICByZXR1cm47CiAgICAgfQogCkBAIC05NDQsNyArOTUzLDcgQEAgcmFuZ2VyX2NhY2hlOjpl eGl0X3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sgYmIsCiAvLyBBbHdh eXMgcmV0dXJucyBhIHJhbmdlIGFuZCB0cnVlLgogCiBib29sCi1yYW5nZXJfY2FjaGU6OmVkZ2Vf cmFuZ2UgKGlyYW5nZSAmciwgZWRnZSBlLCB0cmVlIG5hbWUsIGVudW0gcmZkX21vZGUgbW9kZSkK K3Jhbmdlcl9jYWNoZTo6ZWRnZV9yYW5nZSAodnJhbmdlICZyLCBlZGdlIGUsIHRyZWUgbmFtZSwg ZW51bSByZmRfbW9kZSBtb2RlKQogewogICBleGl0X3JhbmdlIChyLCBuYW1lLCBlLT5zcmMsIG1v ZGUpOwogICAvLyBJZiB0aGlzIGlzIG5vdCBhbiBhYm5vcm1hbCBlZGdlLCBjaGVjayBmb3IgaW5m ZXJyZWQgcmFuZ2VzIG9uIGV4aXQuCkBAIC05NjEsNyArOTcwLDcgQEAgcmFuZ2VyX2NhY2hlOjpl ZGdlX3JhbmdlIChpcmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBuYW1lLCBlbnVtIHJmZF9tb2RlIG1v ZGUpCiAvLyBJbXBsZW1lbnQgcmFuZ2Vfb2ZfZXhwci4KIAogYm9vbAotcmFuZ2VyX2NhY2hlOjpy YW5nZV9vZl9leHByIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSwgZ2ltcGxlICpzdG10KQorcmFuZ2Vy X2NhY2hlOjpyYW5nZV9vZl9leHByICh2cmFuZ2UgJnIsIHRyZWUgbmFtZSwgZ2ltcGxlICpzdG10 KQogewogICBpZiAoIWdpbXBsZV9yYW5nZV9zc2FfcCAobmFtZSkpCiAgICAgewpAQCAtOTg1LDcg Kzk5NCw3IEBAIHJhbmdlcl9jYWNoZTo6cmFuZ2Vfb2ZfZXhwciAoaXJhbmdlICZyLCB0cmVlIG5h bWUsIGdpbXBsZSAqc3RtdCkKIC8vIHRoZSBjdXJyZW50IGNhY2hlIHZhbHVlcy4KIAogYm9vbAot cmFuZ2VyX2NhY2hlOjpyYW5nZV9vbl9lZGdlIChpcmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBleHBy KQorcmFuZ2VyX2NhY2hlOjpyYW5nZV9vbl9lZGdlICh2cmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBl eHByKQogewogICBpZiAoZ2ltcGxlX3JhbmdlX3NzYV9wIChleHByKSkKICAgICByZXR1cm4gZWRn ZV9yYW5nZSAociwgZSwgZXhwciwgUkZEX05PTkUpOwpAQCAtOTk3LDcgKzEwMDYsNyBAQCByYW5n ZXJfY2FjaGU6OnJhbmdlX29uX2VkZ2UgKGlyYW5nZSAmciwgZWRnZSBlLCB0cmVlIGV4cHIpCiAv LyBkZWYgYmxvY2sgZm9yIE5BTUUuICBPdGhlcndpc2UsIHJldHVybiBmYWxzZSBpZiB0aGUgY2Fj aGUgaXMgZW1wdHkuCiAKIGJvb2wKLXJhbmdlcl9jYWNoZTo6YmxvY2tfcmFuZ2UgKGlyYW5nZSAm ciwgYmFzaWNfYmxvY2sgYmIsIHRyZWUgbmFtZSwgYm9vbCBjYWxjKQorcmFuZ2VyX2NhY2hlOjpi bG9ja19yYW5nZSAodnJhbmdlICZyLCBiYXNpY19ibG9jayBiYiwgdHJlZSBuYW1lLCBib29sIGNh bGMpCiB7CiAgIGdjY19jaGVja2luZ19hc3NlcnQgKGdpbXBsZV9yYW5nZV9zc2FfcCAobmFtZSkp OwogCkBAIC0xMDQxLDkgKzEwNTAsMTAgQEAgcmFuZ2VyX2NhY2hlOjpwcm9wYWdhdGVfY2FjaGUg KHRyZWUgbmFtZSkKICAgYmFzaWNfYmxvY2sgYmI7CiAgIGVkZ2VfaXRlcmF0b3IgZWk7CiAgIGVk Z2UgZTsKLSAgaW50X3JhbmdlX21heCBuZXdfcmFuZ2U7Ci0gIGludF9yYW5nZV9tYXggY3VycmVu dF9yYW5nZTsKLSAgaW50X3JhbmdlX21heCBlX3JhbmdlOworICB0cmVlIHR5cGUgPSBUUkVFX1RZ UEUgKG5hbWUpOworICBWYWx1ZV9SYW5nZSBuZXdfcmFuZ2UgKHR5cGUpOworICBWYWx1ZV9SYW5n ZSBjdXJyZW50X3JhbmdlICh0eXBlKTsKKyAgVmFsdWVfUmFuZ2UgZV9yYW5nZSAodHlwZSk7CiAK ICAgLy8gUHJvY2VzcyBlYWNoIGJsb2NrIGJ5IHNlZWluZyBpZiBpdHMgY2FsY3VsYXRlZCByYW5n ZSBvbiBlbnRyeSBpcwogICAvLyB0aGUgc2FtZSBhcyBpdHMgY2FjaGVkIHZhbHVlLiBJZiB0aGVy ZSBpcyBhIGRpZmZlcmVuY2UsIHVwZGF0ZQpAQCAtMTE3OCw4ICsxMTg4LDggQEAgcmFuZ2VyX2Nh Y2hlOjpmaWxsX2Jsb2NrX2NhY2hlICh0cmVlIG5hbWUsIGJhc2ljX2Jsb2NrIGJiLCBiYXNpY19i bG9jayBkZWZfYmIpCiB7CiAgIGVkZ2VfaXRlcmF0b3IgZWk7CiAgIGVkZ2UgZTsKLSAgaW50X3Jh bmdlX21heCBibG9ja19yZXN1bHQ7Ci0gIGludF9yYW5nZV9tYXggdW5kZWZpbmVkOworICBWYWx1 ZV9SYW5nZSBibG9ja19yZXN1bHQgKFRSRUVfVFlQRSAobmFtZSkpOworICBWYWx1ZV9SYW5nZSB1 bmRlZmluZWQgKFRSRUVfVFlQRSAobmFtZSkpOwogCiAgIC8vIEF0IHRoaXMgcG9pbnQgd2Ugc2hv dWxkbid0IGJlIGxvb2tpbmcgYXQgdGhlIGRlZiwgZW50cnkgb3IgZXhpdCBibG9jay4KICAgZ2Nj X2NoZWNraW5nX2Fzc2VydCAoYmIgIT0gZGVmX2JiICYmIGJiICE9IEVOVFJZX0JMT0NLX1BUUl9G T1JfRk4gKGNmdW4pICYmCkBAIC0xMjMyLDcgKzEyNDIsNyBAQCByYW5nZXJfY2FjaGU6OmZpbGxf YmxvY2tfY2FjaGUgKHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sgYmIsIGJhc2ljX2Jsb2NrIGRlZl9i YikKICAgICAgIEZPUl9FQUNIX0VER0UgKGUsIGVpLCBub2RlLT5wcmVkcykKIAl7CiAJICBiYXNp Y19ibG9jayBwcmVkID0gZS0+c3JjOwotCSAgaW50X3JhbmdlX21heCByOworCSAgVmFsdWVfUmFu Z2UgciAoVFJFRV9UWVBFIChuYW1lKSk7CiAKIAkgIGlmIChERUJVR19SQU5HRV9DQUNIRSkKIAkg ICAgZnByaW50ZiAoZHVtcF9maWxlLCAiICAlZC0+JWQgIixlLT5zcmMtPmluZGV4LCBlLT5kZXN0 LT5pbmRleCk7CkBAIC0xMzA2LDcgKzEzMTYsNyBAQCByYW5nZXJfY2FjaGU6OmZpbGxfYmxvY2tf Y2FjaGUgKHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sgYmIsIGJhc2ljX2Jsb2NrIGRlZl9iYikKIC8v IGRvbWluYXRvciB0cmVlIGJhc2VkIG9uIE1PREUuCiAKIGJvb2wKLXJhbmdlcl9jYWNoZTo6cmFu Z2VfZnJvbV9kb20gKGlyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBzdGFydF9iYiwK K3Jhbmdlcl9jYWNoZTo6cmFuZ2VfZnJvbV9kb20gKHZyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNp Y19ibG9jayBzdGFydF9iYiwKIAkJCSAgICAgIGVudW0gcmZkX21vZGUgbW9kZSkKIHsKICAgaWYg KG1vZGUgPT0gUkZEX05PTkUgfHwgIWRvbV9pbmZvX2F2YWlsYWJsZV9wIChDRElfRE9NSU5BVE9S UykpCmRpZmYgLS1naXQgYS9nY2MvZ2ltcGxlLXJhbmdlLWNhY2hlLmggYi9nY2MvZ2ltcGxlLXJh bmdlLWNhY2hlLmgKaW5kZXggNzNkMTJmMzVhYmUuLjFlNGI1YjMwNTY1IDEwMDY0NAotLS0gYS9n Y2MvZ2ltcGxlLXJhbmdlLWNhY2hlLmgKKysrIGIvZ2NjL2dpbXBsZS1yYW5nZS1jYWNoZS5oCkBA IC0zNCw4ICszNCw4IEBAIHB1YmxpYzoKICAgYmxvY2tfcmFuZ2VfY2FjaGUgKCk7CiAgIH5ibG9j a19yYW5nZV9jYWNoZSAoKTsKIAotICBib29sIHNldF9iYl9yYW5nZSAodHJlZSBuYW1lLCBjb25z dF9iYXNpY19ibG9jayBiYiwgY29uc3QgaXJhbmdlICZyKTsKLSAgYm9vbCBnZXRfYmJfcmFuZ2Ug KGlyYW5nZSAmciwgdHJlZSBuYW1lLCBjb25zdF9iYXNpY19ibG9jayBiYik7CisgIGJvb2wgc2V0 X2JiX3JhbmdlICh0cmVlIG5hbWUsIGNvbnN0X2Jhc2ljX2Jsb2NrIGJiLCBjb25zdCB2cmFuZ2Ug JnYpOworICBib29sIGdldF9iYl9yYW5nZSAodnJhbmdlICZ2LCB0cmVlIG5hbWUsIGNvbnN0X2Jh c2ljX2Jsb2NrIGJiKTsKICAgYm9vbCBiYl9yYW5nZV9wICh0cmVlIG5hbWUsIGNvbnN0X2Jhc2lj X2Jsb2NrIGJiKTsKIAogICB2b2lkIGR1bXAgKEZJTEUgKmYpOwpAQCAtNTcsMTMgKzU3LDEzIEBA IGNsYXNzIHNzYV9nbG9iYWxfY2FjaGUKIHB1YmxpYzoKICAgc3NhX2dsb2JhbF9jYWNoZSAoKTsK ICAgfnNzYV9nbG9iYWxfY2FjaGUgKCk7Ci0gIGJvb2wgZ2V0X2dsb2JhbF9yYW5nZSAoaXJhbmdl ICZyLCB0cmVlIG5hbWUpIGNvbnN0OwotICBib29sIHNldF9nbG9iYWxfcmFuZ2UgKHRyZWUgbmFt ZSwgY29uc3QgaXJhbmdlICZyKTsKKyAgYm9vbCBnZXRfZ2xvYmFsX3JhbmdlICh2cmFuZ2UgJnIs IHRyZWUgbmFtZSkgY29uc3Q7CisgIGJvb2wgc2V0X2dsb2JhbF9yYW5nZSAodHJlZSBuYW1lLCBj b25zdCB2cmFuZ2UgJnIpOwogICB2b2lkIGNsZWFyX2dsb2JhbF9yYW5nZSAodHJlZSBuYW1lKTsK ICAgdm9pZCBjbGVhciAoKTsKICAgdm9pZCBkdW1wIChGSUxFICpmID0gc3RkZXJyKTsKIHByaXZh dGU6Ci0gIHZlYzxpcmFuZ2UgKj4gbV90YWI7CisgIHZlYzx2cmFuZ2UgKj4gbV90YWI7CiAgIHZy YW5nZV9hbGxvY2F0b3IgKm1fcmFuZ2VfYWxsb2NhdG9yOwogfTsKIApAQCAtNzcsMTMgKzc3LDEz IEBAIHB1YmxpYzoKICAgcmFuZ2VyX2NhY2hlIChpbnQgbm90X2V4ZWN1dGFibGVfZmxhZywgYm9v bCB1c2VfaW1tX3VzZXMpOwogICB+cmFuZ2VyX2NhY2hlICgpOwogCi0gIHZpcnR1YWwgYm9vbCBy YW5nZV9vZl9leHByIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSwgZ2ltcGxlICpzdG10KTsKLSAgdmly dHVhbCBib29sIHJhbmdlX29uX2VkZ2UgKGlyYW5nZSAmciwgZWRnZSBlLCB0cmVlIGV4cHIpOwot ICBib29sIGJsb2NrX3JhbmdlIChpcmFuZ2UgJnIsIGJhc2ljX2Jsb2NrIGJiLCB0cmVlIG5hbWUs IGJvb2wgY2FsYyA9IHRydWUpOworICB2aXJ0dWFsIGJvb2wgcmFuZ2Vfb2ZfZXhwciAodnJhbmdl ICZyLCB0cmVlIG5hbWUsIGdpbXBsZSAqc3RtdCk7CisgIHZpcnR1YWwgYm9vbCByYW5nZV9vbl9l ZGdlICh2cmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBleHByKTsKKyAgYm9vbCBibG9ja19yYW5nZSAo dnJhbmdlICZyLCBiYXNpY19ibG9jayBiYiwgdHJlZSBuYW1lLCBib29sIGNhbGMgPSB0cnVlKTsK IAotICBib29sIGdldF9nbG9iYWxfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSBuYW1lKSBjb25zdDsK LSAgYm9vbCBnZXRfZ2xvYmFsX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSwgYm9vbCAmY3Vy cmVudF9wKTsKLSAgdm9pZCBzZXRfZ2xvYmFsX3JhbmdlICh0cmVlIG5hbWUsIGNvbnN0IGlyYW5n ZSAmcik7CisgIGJvb2wgZ2V0X2dsb2JhbF9yYW5nZSAodnJhbmdlICZyLCB0cmVlIG5hbWUpIGNv bnN0OworICBib29sIGdldF9nbG9iYWxfcmFuZ2UgKHZyYW5nZSAmciwgdHJlZSBuYW1lLCBib29s ICZjdXJyZW50X3ApOworICB2b2lkIHNldF9nbG9iYWxfcmFuZ2UgKHRyZWUgbmFtZSwgY29uc3Qg dnJhbmdlICZyKTsKIAogICB2b2lkIHByb3BhZ2F0ZV91cGRhdGVkX3ZhbHVlICh0cmVlIG5hbWUs IGJhc2ljX2Jsb2NrIGJiKTsKIApAQCAtMTA2LDExICsxMDYsMTEgQEAgcHJpdmF0ZToKICAgICAg IFJGRF9SRUFEX09OTFksCS8vIFNjYW4gRE9NIHRyZWUsIGRvIG5vdCB3cml0ZSB0byBjYWNoZS4K ICAgICAgIFJGRF9GSUxMCQkvLyBTY2FuIERPTSB0cmVlLCB1cGRhdGluZyBpbXBvcnRhbnQgbm9k ZXMuCiAgICAgfTsKLSAgYm9vbCByYW5nZV9mcm9tX2RvbSAoaXJhbmdlICZyLCB0cmVlIG5hbWUs IGJhc2ljX2Jsb2NrIGJiLCBlbnVtIHJmZF9tb2RlKTsKLSAgdm9pZCByYW5nZV9vZl9kZWYgKGly YW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYiA9IE5VTEwpOwotICB2b2lkIGVudHJ5 X3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgZXhwciwgYmFzaWNfYmxvY2sgYmIsIGVudW0gcmZkX21v ZGUpOwotICB2b2lkIGV4aXRfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSBleHByLCBiYXNpY19ibG9j ayBiYiwgZW51bSByZmRfbW9kZSk7Ci0gIGJvb2wgZWRnZV9yYW5nZSAoaXJhbmdlICZyLCBlZGdl IGUsIHRyZWUgbmFtZSwgZW51bSByZmRfbW9kZSk7CisgIGJvb2wgcmFuZ2VfZnJvbV9kb20gKHZy YW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYiwgZW51bSByZmRfbW9kZSk7CisgIHZv aWQgcmFuZ2Vfb2ZfZGVmICh2cmFuZ2UgJnIsIHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sgYmIgPSBO VUxMKTsKKyAgdm9pZCBlbnRyeV9yYW5nZSAodnJhbmdlICZyLCB0cmVlIGV4cHIsIGJhc2ljX2Js b2NrIGJiLCBlbnVtIHJmZF9tb2RlKTsKKyAgdm9pZCBleGl0X3JhbmdlICh2cmFuZ2UgJnIsIHRy ZWUgZXhwciwgYmFzaWNfYmxvY2sgYmIsIGVudW0gcmZkX21vZGUpOworICBib29sIGVkZ2VfcmFu Z2UgKHZyYW5nZSAmciwgZWRnZSBlLCB0cmVlIG5hbWUsIGVudW0gcmZkX21vZGUpOwogCiAgIHZl YzxiYXNpY19ibG9jaz4gbV93b3JrYmFjazsKICAgY2xhc3MgdXBkYXRlX2xpc3QgKm1fdXBkYXRl OwpkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1yYW5nZS1lZGdlLmNjIGIvZ2NjL2dpbXBsZS1yYW5n ZS1lZGdlLmNjCmluZGV4IDUyNjRlNjI3YzlhLi42ZmUzMzQwOGY3ZSAxMDA2NDQKLS0tIGEvZ2Nj L2dpbXBsZS1yYW5nZS1lZGdlLmNjCisrKyBiL2djYy9naW1wbGUtcmFuZ2UtZWRnZS5jYwpAQCAt ODMsMTEgKzgzLDggQEAgZ2ltcGxlX291dGdvaW5nX3JhbmdlOjp+Z2ltcGxlX291dGdvaW5nX3Jh bmdlICgpCiAvLyBVc2UgYSBjYWNoZWQgdmFsdWUgaWYgaXQgZXhpc3RzLCBvciBjYWxjdWxhdGUg aXQgaWYgbm90LgogCiBib29sCi1naW1wbGVfb3V0Z29pbmdfcmFuZ2U6OmdldF9lZGdlX3Jhbmdl IChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgZWRnZSBlKQorZ2ltcGxlX291dGdvaW5nX3JhbmdlOjpz d2l0Y2hfZWRnZV9yYW5nZSAoaXJhbmdlICZyLCBnc3dpdGNoICpzdywgZWRnZSBlKQogewotICBn Y2NfY2hlY2tpbmdfYXNzZXJ0IChpc19hPGdzd2l0Y2ggKj4gKHMpKTsKLSAgZ3N3aXRjaCAqc3cg PSBhc19hPGdzd2l0Y2ggKj4gKHMpOwotCiAgIC8vIEFEQSBjdXJyZW50bHkgaGFzIGNhc2VzIHdo ZXJlIHRoZSBpbmRleCBpcyA2NCBiaXRzIGFuZCB0aGUgY2FzZQogICAvLyBhcmd1bWVudHMgYXJl IDMyIGJpdCwgY2F1c2luZyBhIHRyYXAgd2hlbiB3ZSBjcmVhdGUgYSBjYXNlX3JhbmdlLgogICAv LyBVbnRpbCB0aGlzIGlzIHJlc29sdmVkIChodHRwczovL2djYy5nbnUub3JnL2J1Z3ppbGxhL3No b3dfYnVnLmNnaT9pZD04Nzc5OCkKQEAgLTIwNCwxMiArMjAxLDkgQEAgZ2ltcGxlX291dGdvaW5n X3JhbmdlOjplZGdlX3JhbmdlX3AgKGlyYW5nZSAmciwgZWRnZSBlKQogCiAgIGdjY19jaGVja2lu Z19hc3NlcnQgKGlzX2E8Z3N3aXRjaCAqPiAocykpOwogICBnc3dpdGNoICpzdyA9IGFzX2E8Z3N3 aXRjaCAqPiAocyk7Ci0gIHRyZWUgdHlwZSA9IFRSRUVfVFlQRSAoZ2ltcGxlX3N3aXRjaF9pbmRl eCAoc3cpKTsKLQotICBpZiAoIWlyYW5nZTo6c3VwcG9ydHNfdHlwZV9wICh0eXBlKSkKLSAgICBy ZXR1cm4gTlVMTDsKIAotICBpZiAoZ2V0X2VkZ2VfcmFuZ2UgKHIsIHN3LCBlKSkKKyAgLy8gU3dp dGNoZXMgY2FuIG9ubHkgYmUgaW50ZWdlcnMuCisgIGlmIChzd2l0Y2hfZWRnZV9yYW5nZSAoYXNf YSA8aXJhbmdlPiAociksIHN3LCBlKSkKICAgICByZXR1cm4gczsKIAogICByZXR1cm4gTlVMTDsK ZGlmZiAtLWdpdCBhL2djYy9naW1wbGUtcmFuZ2UtZWRnZS5oIGIvZ2NjL2dpbXBsZS1yYW5nZS1l ZGdlLmgKaW5kZXggY2UzODNiMGFhNmYuLmE5YzRhZjg3MTViIDEwMDY0NAotLS0gYS9nY2MvZ2lt cGxlLXJhbmdlLWVkZ2UuaAorKysgYi9nY2MvZ2ltcGxlLXJhbmdlLWVkZ2UuaApAQCAtNDMsNyAr NDMsNyBAQCBwdWJsaWM6CiAgIGdpbXBsZSAqZWRnZV9yYW5nZV9wIChpcmFuZ2UgJnIsIGVkZ2Ug ZSk7CiBwcml2YXRlOgogICB2b2lkIGNhbGNfc3dpdGNoX3JhbmdlcyAoZ3N3aXRjaCAqc3cpOwot ICBib29sIGdldF9lZGdlX3JhbmdlIChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgZWRnZSBlKTsKKyAg Ym9vbCBzd2l0Y2hfZWRnZV9yYW5nZSAoaXJhbmdlICZyLCBnc3dpdGNoICpzdywgZWRnZSBlKTsK IAogICBpbnQgbV9tYXhfZWRnZXM7CiAgIGhhc2hfbWFwPGVkZ2UsIGlyYW5nZSAqPiAqbV9lZGdl X3RhYmxlOwpkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1yYW5nZS1mb2xkLmNjIGIvZ2NjL2dpbXBs ZS1yYW5nZS1mb2xkLmNjCmluZGV4IGM1M2QyODYzZDVlLi5jMWE4MDE2NjhjNCAxMDA2NDQKLS0t IGEvZ2NjL2dpbXBsZS1yYW5nZS1mb2xkLmNjCisrKyBiL2djYy9naW1wbGUtcmFuZ2UtZm9sZC5j YwpAQCAtNjAsNyArNjAsNyBAQCBmdXJfc291cmNlOjpmdXJfc291cmNlIChyYW5nZV9xdWVyeSAq cSkKIC8vIEludm9rZSByYW5nZV9vZl9leHByIG9uIEVYUFIuCiAKIGJvb2wKLWZ1cl9zb3VyY2U6 OmdldF9vcGVyYW5kIChpcmFuZ2UgJnIsIHRyZWUgZXhwcikKK2Z1cl9zb3VyY2U6OmdldF9vcGVy YW5kICh2cmFuZ2UgJnIsIHRyZWUgZXhwcikKIHsKICAgcmV0dXJuIG1fcXVlcnktPnJhbmdlX29m X2V4cHIgKHIsIGV4cHIpOwogfQpAQCAtNjksNyArNjksNyBAQCBmdXJfc291cmNlOjpnZXRfb3Bl cmFuZCAoaXJhbmdlICZyLCB0cmVlIGV4cHIpCiAvLyByYW5nZV9xdWVyeSB0byBnZXQgdGhlIHJh bmdlIG9uIHRoZSBlZGdlLgogCiBib29sCi1mdXJfc291cmNlOjpnZXRfcGhpX29wZXJhbmQgKGly YW5nZSAmciwgdHJlZSBleHByLCBlZGdlIGUpCitmdXJfc291cmNlOjpnZXRfcGhpX29wZXJhbmQg KHZyYW5nZSAmciwgdHJlZSBleHByLCBlZGdlIGUpCiB7CiAgIHJldHVybiBtX3F1ZXJ5LT5yYW5n ZV9vbl9lZGdlIChyLCBlLCBleHByKTsKIH0KQEAgLTEwOSw4ICsxMDksOCBAQCBjbGFzcyBmdXJf ZWRnZSA6IHB1YmxpYyBmdXJfc291cmNlCiB7CiBwdWJsaWM6CiAgIGZ1cl9lZGdlIChlZGdlIGUs IHJhbmdlX3F1ZXJ5ICpxID0gTlVMTCk7Ci0gIHZpcnR1YWwgYm9vbCBnZXRfb3BlcmFuZCAoaXJh bmdlICZyLCB0cmVlIGV4cHIpIG92ZXJyaWRlOwotICB2aXJ0dWFsIGJvb2wgZ2V0X3BoaV9vcGVy YW5kIChpcmFuZ2UgJnIsIHRyZWUgZXhwciwgZWRnZSBlKSBvdmVycmlkZTsKKyAgdmlydHVhbCBi b29sIGdldF9vcGVyYW5kICh2cmFuZ2UgJnIsIHRyZWUgZXhwcikgb3ZlcnJpZGU7CisgIHZpcnR1 YWwgYm9vbCBnZXRfcGhpX29wZXJhbmQgKHZyYW5nZSAmciwgdHJlZSBleHByLCBlZGdlIGUpIG92 ZXJyaWRlOwogcHJpdmF0ZToKICAgZWRnZSBtX2VkZ2U7CiB9OwpAQCAtMTI2LDcgKzEyNiw3IEBA IGZ1cl9lZGdlOjpmdXJfZWRnZSAoZWRnZSBlLCByYW5nZV9xdWVyeSAqcSkgOiBmdXJfc291cmNl IChxKQogLy8gR2V0IHRoZSB2YWx1ZSBvZiBFWFBSIG9uIGVkZ2UgbV9lZGdlLgogCiBib29sCi1m dXJfZWRnZTo6Z2V0X29wZXJhbmQgKGlyYW5nZSAmciwgdHJlZSBleHByKQorZnVyX2VkZ2U6Omdl dF9vcGVyYW5kICh2cmFuZ2UgJnIsIHRyZWUgZXhwcikKIHsKICAgcmV0dXJuIG1fcXVlcnktPnJh bmdlX29uX2VkZ2UgKHIsIG1fZWRnZSwgZXhwcik7CiB9CkBAIC0xMzUsNyArMTM1LDcgQEAgZnVy X2VkZ2U6OmdldF9vcGVyYW5kIChpcmFuZ2UgJnIsIHRyZWUgZXhwcikKIC8vIHJhbmdlX3F1ZXJ5 IHRvIGdldCB0aGUgcmFuZ2Ugb24gdGhlIGVkZ2UuCiAKIGJvb2wKLWZ1cl9lZGdlOjpnZXRfcGhp X29wZXJhbmQgKGlyYW5nZSAmciwgdHJlZSBleHByLCBlZGdlIGUpCitmdXJfZWRnZTo6Z2V0X3Bo aV9vcGVyYW5kICh2cmFuZ2UgJnIsIHRyZWUgZXhwciwgZWRnZSBlKQogewogICAvLyBFZGdlIHRv IGVkZ2UgcmVjYWxjdWxhdGlvbnMgbm90IHN1cG9wcnRlZCB5ZXQsIHVudGlsIHdlIHNvcnQgaXQg b3V0LgogICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChlID09IG1fZWRnZSk7CkBAIC0xNTIsNyArMTUy LDcgQEAgZnVyX3N0bXQ6OmZ1cl9zdG10IChnaW1wbGUgKnMsIHJhbmdlX3F1ZXJ5ICpxKSA6IGZ1 cl9zb3VyY2UgKHEpCiAvLyBSZXRyZWl2ZSByYW5nZSBvZiBFWFBSIGFzIGl0IG9jY3VycyBhcyBh IHVzZSBvbiBzdG10IE1fU1RNVC4KIAogYm9vbAotZnVyX3N0bXQ6OmdldF9vcGVyYW5kIChpcmFu Z2UgJnIsIHRyZWUgZXhwcikKK2Z1cl9zdG10OjpnZXRfb3BlcmFuZCAodnJhbmdlICZyLCB0cmVl IGV4cHIpCiB7CiAgIHJldHVybiBtX3F1ZXJ5LT5yYW5nZV9vZl9leHByIChyLCBleHByLCBtX3N0 bXQpOwogfQpAQCAtMTYxLDcgKzE2MSw3IEBAIGZ1cl9zdG10OjpnZXRfb3BlcmFuZCAoaXJhbmdl ICZyLCB0cmVlIGV4cHIpCiAvLyByYW5nZV9xdWVyeSB0byBnZXQgdGhlIHJhbmdlIG9uIHRoZSBl ZGdlLgogCiBib29sCi1mdXJfc3RtdDo6Z2V0X3BoaV9vcGVyYW5kIChpcmFuZ2UgJnIsIHRyZWUg ZXhwciwgZWRnZSBlKQorZnVyX3N0bXQ6OmdldF9waGlfb3BlcmFuZCAodnJhbmdlICZyLCB0cmVl IGV4cHIsIGVkZ2UgZSkKIHsKICAgLy8gUGljayB1cCB0aGUgcmFuZ2Ugb2YgZXhwciBmcm9tIGVk Z2UgRS4KICAgZnVyX2VkZ2UgZV9zcmMgKGUsIG1fcXVlcnkpOwpAQCAtMjE0LDQyICsyMTQsNDIg QEAgZnVyX2RlcGVuZDo6cmVnaXN0ZXJfcmVsYXRpb24gKGVkZ2UgZSwgcmVsYXRpb25fa2luZCBr LCB0cmVlIG9wMSwgdHJlZSBvcDIpCiBjbGFzcyBmdXJfbGlzdCA6IHB1YmxpYyBmdXJfc291cmNl CiB7CiBwdWJsaWM6Ci0gIGZ1cl9saXN0IChpcmFuZ2UgJnIxKTsKLSAgZnVyX2xpc3QgKGlyYW5n ZSAmcjEsIGlyYW5nZSAmcjIpOwotICBmdXJfbGlzdCAodW5zaWduZWQgbnVtLCBpcmFuZ2UgKmxp c3QpOwotICB2aXJ0dWFsIGJvb2wgZ2V0X29wZXJhbmQgKGlyYW5nZSAmciwgdHJlZSBleHByKSBv dmVycmlkZTsKLSAgdmlydHVhbCBib29sIGdldF9waGlfb3BlcmFuZCAoaXJhbmdlICZyLCB0cmVl IGV4cHIsIGVkZ2UgZSkgb3ZlcnJpZGU7CisgIGZ1cl9saXN0ICh2cmFuZ2UgJnIxKTsKKyAgZnVy X2xpc3QgKHZyYW5nZSAmcjEsIHZyYW5nZSAmcjIpOworICBmdXJfbGlzdCAodW5zaWduZWQgbnVt LCB2cmFuZ2UgKipsaXN0KTsKKyAgdmlydHVhbCBib29sIGdldF9vcGVyYW5kICh2cmFuZ2UgJnIs IHRyZWUgZXhwcikgb3ZlcnJpZGU7CisgIHZpcnR1YWwgYm9vbCBnZXRfcGhpX29wZXJhbmQgKHZy YW5nZSAmciwgdHJlZSBleHByLCBlZGdlIGUpIG92ZXJyaWRlOwogcHJpdmF0ZToKLSAgaW50X3Jh bmdlX21heCBtX2xvY2FsWzJdOwotICBpcmFuZ2UgKm1fbGlzdDsKKyAgdnJhbmdlICptX2xvY2Fs WzJdOworICB2cmFuZ2UgKiptX2xpc3Q7CiAgIHVuc2lnbmVkIG1faW5kZXg7CiAgIHVuc2lnbmVk IG1fbGltaXQ7CiB9OwogCiAvLyBPbmUgcmFuZ2Ugc3VwcGxpZWQgZm9yIHVuYXJ5IG9wZXJhdGlv bnMuCiAKLWZ1cl9saXN0OjpmdXJfbGlzdCAoaXJhbmdlICZyMSkgOiBmdXJfc291cmNlIChOVUxM KQorZnVyX2xpc3Q6OmZ1cl9saXN0ICh2cmFuZ2UgJnIxKSA6IGZ1cl9zb3VyY2UgKE5VTEwpCiB7 CiAgIG1fbGlzdCA9IG1fbG9jYWw7CiAgIG1faW5kZXggPSAwOwogICBtX2xpbWl0ID0gMTsKLSAg bV9sb2NhbFswXSA9IHIxOworICBtX2xvY2FsWzBdID0gJnIxOwogfQogCiAvLyBUd28gcmFuZ2Vz IHN1cHBsaWVkIGZvciBiaW5hcnkgb3BlcmF0aW9ucy4KIAotZnVyX2xpc3Q6OmZ1cl9saXN0IChp cmFuZ2UgJnIxLCBpcmFuZ2UgJnIyKSA6IGZ1cl9zb3VyY2UgKE5VTEwpCitmdXJfbGlzdDo6ZnVy X2xpc3QgKHZyYW5nZSAmcjEsIHZyYW5nZSAmcjIpIDogZnVyX3NvdXJjZSAoTlVMTCkKIHsKICAg bV9saXN0ID0gbV9sb2NhbDsKICAgbV9pbmRleCA9IDA7CiAgIG1fbGltaXQgPSAyOwotICBtX2xv Y2FsWzBdID0gcjE7Ci0gIG1fbG9jYWxbMV0gPSByMjsKKyAgbV9sb2NhbFswXSA9ICZyMTsKKyAg bV9sb2NhbFsxXSA9ICZyMjsKIH0KIAogLy8gQXJiaXRyYXJ5IG51bWJlciBvZiByYW5nZXMgaW4g YSB2ZWN0b3IuCiAKLWZ1cl9saXN0OjpmdXJfbGlzdCAodW5zaWduZWQgbnVtLCBpcmFuZ2UgKmxp c3QpIDogZnVyX3NvdXJjZSAoTlVMTCkKK2Z1cl9saXN0OjpmdXJfbGlzdCAodW5zaWduZWQgbnVt LCB2cmFuZ2UgKipsaXN0KSA6IGZ1cl9zb3VyY2UgKE5VTEwpCiB7CiAgIG1fbGlzdCA9IGxpc3Q7 CiAgIG1faW5kZXggPSAwOwpAQCAtMjU5LDE4ICsyNTksMTggQEAgZnVyX2xpc3Q6OmZ1cl9saXN0 ICh1bnNpZ25lZCBudW0sIGlyYW5nZSAqbGlzdCkgOiBmdXJfc291cmNlIChOVUxMKQogLy8gR2V0 IHRoZSBuZXh0IG9wZXJhbmQgZnJvbSB0aGUgdmVjdG9yLCBlbnN1cmUgdHlwZXMgYXJlIGNvbXBh dGlibGUuCiAKIGJvb2wKLWZ1cl9saXN0OjpnZXRfb3BlcmFuZCAoaXJhbmdlICZyLCB0cmVlIGV4 cHIpCitmdXJfbGlzdDo6Z2V0X29wZXJhbmQgKHZyYW5nZSAmciwgdHJlZSBleHByKQogewogICBp ZiAobV9pbmRleCA+PSBtX2xpbWl0KQogICAgIHJldHVybiBtX3F1ZXJ5LT5yYW5nZV9vZl9leHBy IChyLCBleHByKTsKLSAgciA9IG1fbGlzdFttX2luZGV4KytdOworICByID0gKm1fbGlzdFttX2lu ZGV4KytdOwogICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChyYW5nZV9jb21wYXRpYmxlX3AgKFRSRUVf VFlQRSAoZXhwciksIHIudHlwZSAoKSkpOwogICByZXR1cm4gdHJ1ZTsKIH0KIAogLy8gVGhpcyB3 aWxsIHNpbXBseSBwaWNrIHRoZSBuZXh0IG9wZXJhbmQgZnJvbSB0aGUgdmVjdG9yLgogYm9vbAot ZnVyX2xpc3Q6OmdldF9waGlfb3BlcmFuZCAoaXJhbmdlICZyLCB0cmVlIGV4cHIsIGVkZ2UgZSBB VFRSSUJVVEVfVU5VU0VEKQorZnVyX2xpc3Q6OmdldF9waGlfb3BlcmFuZCAodnJhbmdlICZyLCB0 cmVlIGV4cHIsIGVkZ2UgZSBBVFRSSUJVVEVfVU5VU0VEKQogewogICByZXR1cm4gZ2V0X29wZXJh bmQgKHIsIGV4cHIpOwogfQpAQCAtMjc4LDcgKzI3OCw3IEBAIGZ1cl9saXN0OjpnZXRfcGhpX29w ZXJhbmQgKGlyYW5nZSAmciwgdHJlZSBleHByLCBlZGdlIGUgQVRUUklCVVRFX1VOVVNFRCkKIC8v IEZvbGQgc3RtdCBTIGludG8gcmFuZ2UgUiB1c2luZyBSMSBhcyB0aGUgZmlyc3Qgb3BlcmFuZC4K IAogYm9vbAotZm9sZF9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnMsIGlyYW5nZSAmcjEpCitm b2xkX3JhbmdlICh2cmFuZ2UgJnIsIGdpbXBsZSAqcywgdnJhbmdlICZyMSkKIHsKICAgZm9sZF91 c2luZ19yYW5nZSBmOwogICBmdXJfbGlzdCBzcmMgKHIxKTsKQEAgLTI4OCw3ICsyODgsNyBAQCBm b2xkX3JhbmdlIChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgaXJhbmdlICZyMSkKIC8vIEZvbGQgc3Rt dCBTIGludG8gcmFuZ2UgUiB1c2luZyBSMSAgYW5kIFIyIGFzIHRoZSBmaXJzdCB0d28gb3BlcmFu ZHMuCiAKIGJvb2wKLWZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgZ2ltcGxlICpzLCBpcmFuZ2UgJnIx LCBpcmFuZ2UgJnIyKQorZm9sZF9yYW5nZSAodnJhbmdlICZyLCBnaW1wbGUgKnMsIHZyYW5nZSAm cjEsIHZyYW5nZSAmcjIpCiB7CiAgIGZvbGRfdXNpbmdfcmFuZ2UgZjsKICAgZnVyX2xpc3Qgc3Jj IChyMSwgcjIpOwpAQCAtMjk5LDcgKzI5OSw3IEBAIGZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgZ2lt cGxlICpzLCBpcmFuZ2UgJnIxLCBpcmFuZ2UgJnIyKQogLy8gb3BlcmFuZHMgZW5jb3VudGVyZWQu CiAKIGJvb2wKLWZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgZ2ltcGxlICpzLCB1bnNpZ25lZCBudW1f ZWxlbWVudHMsIGlyYW5nZSAqdmVjdG9yKQorZm9sZF9yYW5nZSAodnJhbmdlICZyLCBnaW1wbGUg KnMsIHVuc2lnbmVkIG51bV9lbGVtZW50cywgdnJhbmdlICoqdmVjdG9yKQogewogICBmb2xkX3Vz aW5nX3JhbmdlIGY7CiAgIGZ1cl9saXN0IHNyYyAobnVtX2VsZW1lbnRzLCB2ZWN0b3IpOwpAQCAt MzA5LDcgKzMwOSw3IEBAIGZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgZ2ltcGxlICpzLCB1bnNpZ25l ZCBudW1fZWxlbWVudHMsIGlyYW5nZSAqdmVjdG9yKQogLy8gRm9sZCBzdG10IFMgaW50byByYW5n ZSBSIHVzaW5nIHJhbmdlIHF1ZXJ5IFEuCiAKIGJvb2wKLWZvbGRfcmFuZ2UgKGlyYW5nZSAmciwg Z2ltcGxlICpzLCByYW5nZV9xdWVyeSAqcSkKK2ZvbGRfcmFuZ2UgKHZyYW5nZSAmciwgZ2ltcGxl ICpzLCByYW5nZV9xdWVyeSAqcSkKIHsKICAgZm9sZF91c2luZ19yYW5nZSBmOwogICBmdXJfc3Rt dCBzcmMgKHMsIHEpOwpAQCAtMzE5LDcgKzMxOSw3IEBAIGZvbGRfcmFuZ2UgKGlyYW5nZSAmciwg Z2ltcGxlICpzLCByYW5nZV9xdWVyeSAqcSkKIC8vIFJlY2FsY3VsYXRlIHN0bXQgUyBpbnRvIFIg dXNpbmcgcmFuZ2UgcXVlcnkgUSBhcyBpZiBpdCB3ZXJlIG9uIGVkZ2UgT05fRURHRS4KIAogYm9v bAotZm9sZF9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnMsIGVkZ2Ugb25fZWRnZSwgcmFuZ2Vf cXVlcnkgKnEpCitmb2xkX3JhbmdlICh2cmFuZ2UgJnIsIGdpbXBsZSAqcywgZWRnZSBvbl9lZGdl LCByYW5nZV9xdWVyeSAqcSkKIHsKICAgZm9sZF91c2luZ19yYW5nZSBmOwogICBmdXJfZWRnZSBz cmMgKG9uX2VkZ2UsIHEpOwpAQCAtMzcwLDcgKzM3MCw3IEBAIGFkanVzdF9wb2ludGVyX2RpZmZf ZXhwciAoaXJhbmdlICZyZXMsIGNvbnN0IGdpbXBsZSAqZGlmZl9zdG10KQogLy8gQWRqdXN0IHRo ZSByYW5nZSBmb3IgYW4gSU1BR1BBUlRfRVhQUi4KIAogc3RhdGljIHZvaWQKLWFkanVzdF9pbWFn cGFydF9leHByIChpcmFuZ2UgJnJlcywgY29uc3QgZ2ltcGxlICpzdG10KQorYWRqdXN0X2ltYWdw YXJ0X2V4cHIgKHZyYW5nZSAmcmVzLCBjb25zdCBnaW1wbGUgKnN0bXQpCiB7CiAgIHRyZWUgbmFt ZSA9IFRSRUVfT1BFUkFORCAoZ2ltcGxlX2Fzc2lnbl9yaHMxIChzdG10KSwgMCk7CiAKQEAgLTQx Myw3ICs0MTMsNyBAQCBhZGp1c3RfaW1hZ3BhcnRfZXhwciAoaXJhbmdlICZyZXMsIGNvbnN0IGdp bXBsZSAqc3RtdCkKIC8vIEFkanVzdCB0aGUgcmFuZ2UgZm9yIGEgUkVBTFBBUlRfRVhQUi4KIAog c3RhdGljIHZvaWQKLWFkanVzdF9yZWFscGFydF9leHByIChpcmFuZ2UgJnJlcywgY29uc3QgZ2lt cGxlICpzdG10KQorYWRqdXN0X3JlYWxwYXJ0X2V4cHIgKHZyYW5nZSAmcmVzLCBjb25zdCBnaW1w bGUgKnN0bXQpCiB7CiAgIHRyZWUgbmFtZSA9IFRSRUVfT1BFUkFORCAoZ2ltcGxlX2Fzc2lnbl9y aHMxIChzdG10KSwgMCk7CiAKQEAgLTQ0MiwxMiArNDQyLDEyIEBAIGFkanVzdF9yZWFscGFydF9l eHByIChpcmFuZ2UgJnJlcywgY29uc3QgZ2ltcGxlICpzdG10KQogLy8gdGhpcyBzdGF0ZW1lbnQu CiAKIHN0YXRpYyB2b2lkCi1naW1wbGVfcmFuZ2VfYWRqdXN0bWVudCAoaXJhbmdlICZyZXMsIGNv bnN0IGdpbXBsZSAqc3RtdCkKK2dpbXBsZV9yYW5nZV9hZGp1c3RtZW50ICh2cmFuZ2UgJnJlcywg Y29uc3QgZ2ltcGxlICpzdG10KQogewogICBzd2l0Y2ggKGdpbXBsZV9leHByX2NvZGUgKHN0bXQp KQogICAgIHsKICAgICBjYXNlIFBPSU5URVJfRElGRl9FWFBSOgotICAgICAgYWRqdXN0X3BvaW50 ZXJfZGlmZl9leHByIChyZXMsIHN0bXQpOworICAgICAgYWRqdXN0X3BvaW50ZXJfZGlmZl9leHBy IChhc19hIDxpcmFuZ2U+IChyZXMpLCBzdG10KTsKICAgICAgIHJldHVybjsKIAogICAgIGNhc2Ug SU1BR1BBUlRfRVhQUjoKQEAgLTUzNiw3ICs1MzYsNyBAQCBnaW1wbGVfcmFuZ2Vfb3BlcmFuZDIg KGNvbnN0IGdpbXBsZSAqc3RtdCkKIC8vIGJlIGNhbGN1bGF0ZWQsIHJldHVybiBmYWxzZS4KIAog Ym9vbAotZm9sZF91c2luZ19yYW5nZTo6Zm9sZF9zdG10IChpcmFuZ2UgJnIsIGdpbXBsZSAqcywg ZnVyX3NvdXJjZSAmc3JjLCB0cmVlIG5hbWUpCitmb2xkX3VzaW5nX3JhbmdlOjpmb2xkX3N0bXQg KHZyYW5nZSAmciwgZ2ltcGxlICpzLCBmdXJfc291cmNlICZzcmMsIHRyZWUgbmFtZSkKIHsKICAg Ym9vbCByZXMgPSBmYWxzZTsKICAgLy8gSWYgbmFtZSBhbmQgUyBhcmUgc3BlY2lmaWVkLCBtYWtl IHN1cmUgaXQgaXMgYW4gTEhTIG9mIFMuCkBAIC01NDksNyArNTQ5LDcgQEAgZm9sZF91c2luZ19y YW5nZTo6Zm9sZF9zdG10IChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgZnVyX3NvdXJjZSAmc3JjLCB0 cmVlIG5hbWUpCiAgIC8vIFByb2Nlc3MgYWRkcmVzc2VzLgogICBpZiAoZ2ltcGxlX2NvZGUgKHMp ID09IEdJTVBMRV9BU1NJR04KICAgICAgICYmIGdpbXBsZV9hc3NpZ25fcmhzX2NvZGUgKHMpID09 IEFERFJfRVhQUikKLSAgICByZXR1cm4gcmFuZ2Vfb2ZfYWRkcmVzcyAociwgcywgc3JjKTsKKyAg ICByZXR1cm4gcmFuZ2Vfb2ZfYWRkcmVzcyAoYXNfYSA8aXJhbmdlPiAociksIHMsIHNyYyk7CiAK ICAgaWYgKHJhbmdlX29wX2hhbmRsZXIgKHMpKQogICAgIHJlcyA9IHJhbmdlX29mX3JhbmdlX29w IChyLCBzLCBzcmMpOwpAQCAtNTY2LDcgKzU2Niw3IEBAIGZvbGRfdXNpbmdfcmFuZ2U6OmZvbGRf c3RtdCAoaXJhbmdlICZyLCBnaW1wbGUgKnMsIGZ1cl9zb3VyY2UgJnNyYywgdHJlZSBuYW1lKQog ICAgICAgaWYgKCFuYW1lIHx8ICFnaW1wbGVfcmFuZ2Vfc3NhX3AgKG5hbWUpKQogCXJldHVybiBm YWxzZTsKICAgICAgIC8vIFdlIGRvbid0IHVuZGVyc3RhbmQgdGhlIHN0bXQsIHNvIHJldHVybiB0 aGUgZ2xvYmFsIHJhbmdlLgotICAgICAgciA9IGdpbXBsZV9yYW5nZV9nbG9iYWwgKG5hbWUpOwor ICAgICAgZ2ltcGxlX3JhbmdlX2dsb2JhbCAociwgbmFtZSk7CiAgICAgICByZXR1cm4gdHJ1ZTsK ICAgICB9CiAKQEAgLTU4Nyw5ICs1ODcsOCBAQCBmb2xkX3VzaW5nX3JhbmdlOjpmb2xkX3N0bXQg KGlyYW5nZSAmciwgZ2ltcGxlICpzLCBmdXJfc291cmNlICZzcmMsIHRyZWUgbmFtZSkKIC8vIElm IGEgcmFuZ2UgY2Fubm90IGJlIGNhbGN1bGF0ZWQsIHJldHVybiBmYWxzZS4KIAogYm9vbAotZm9s ZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfcmFuZ2Vfb3AgKGlyYW5nZSAmciwgZ2ltcGxlICpzLCBm dXJfc291cmNlICZzcmMpCitmb2xkX3VzaW5nX3JhbmdlOjpyYW5nZV9vZl9yYW5nZV9vcCAodnJh bmdlICZyLCBnaW1wbGUgKnMsIGZ1cl9zb3VyY2UgJnNyYykKIHsKLSAgaW50X3JhbmdlX21heCBy YW5nZTEsIHJhbmdlMjsKICAgdHJlZSB0eXBlID0gZ2ltcGxlX3JhbmdlX3R5cGUgKHMpOwogICBp ZiAoIXR5cGUpCiAgICAgcmV0dXJuIGZhbHNlOwpAQCAtNTk5LDEzICs1OTgsMTYgQEAgZm9sZF91 c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfcmFuZ2Vfb3AgKGlyYW5nZSAmciwgZ2ltcGxlICpzLCBmdXJf c291cmNlICZzcmMpCiAgIHRyZWUgbGhzID0gZ2ltcGxlX2dldF9saHMgKHMpOwogICB0cmVlIG9w MSA9IGdpbXBsZV9yYW5nZV9vcGVyYW5kMSAocyk7CiAgIHRyZWUgb3AyID0gZ2ltcGxlX3Jhbmdl X29wZXJhbmQyIChzKTsKKyAgVmFsdWVfUmFuZ2UgcmFuZ2UxIChUUkVFX1RZUEUgKG9wMSkpOwor ICBWYWx1ZV9SYW5nZSByYW5nZTIgKG9wMiA/IFRSRUVfVFlQRSAob3AyKSA6IFRSRUVfVFlQRSAo b3AxKSk7CiAKICAgaWYgKHNyYy5nZXRfb3BlcmFuZCAocmFuZ2UxLCBvcDEpKQogICAgIHsKICAg ICAgIGlmICghb3AyKQogCXsKIAkgIC8vIEZvbGQgcmFuZ2UsIGFuZCByZWdpc3RlciBhbnkgZGVw ZW5kZW5jeSBpZiBhdmFpbGFibGUuCi0JICBpbnRfcmFuZ2U8Mj4gcjIgKHR5cGUpOworCSAgVmFs dWVfUmFuZ2UgcjIgKHR5cGUpOworCSAgcjIuc2V0X3ZhcnlpbmcgKHR5cGUpOwogCSAgaGFuZGxl ci5mb2xkX3JhbmdlIChyLCB0eXBlLCByYW5nZTEsIHIyKTsKIAkgIGlmIChsaHMgJiYgZ2ltcGxl X3JhbmdlX3NzYV9wIChvcDEpKQogCSAgICB7CkBAIC02MzAsNyArNjMyLDggQEAgZm9sZF91c2lu Z19yYW5nZTo6cmFuZ2Vfb2ZfcmFuZ2Vfb3AgKGlyYW5nZSAmciwgZ2ltcGxlICpzLCBmdXJfc291 cmNlICZzcmMpCiAJICAgIH0KIAkgIC8vIEZvbGQgcmFuZ2UsIGFuZCByZWdpc3RlciBhbnkgZGVw ZW5kZW5jeSBpZiBhdmFpbGFibGUuCiAJICBoYW5kbGVyLmZvbGRfcmFuZ2UgKHIsIHR5cGUsIHJh bmdlMSwgcmFuZ2UyLCByZWwpOwotCSAgcmVsYXRpb25fZm9sZF9hbmRfb3IgKHIsIHMsIHNyYyk7 CisJICBpZiAoaXJhbmdlOjpzdXBwb3J0c190eXBlX3AgKHR5cGUpKQorCSAgICByZWxhdGlvbl9m b2xkX2FuZF9vciAoYXNfYSA8aXJhbmdlPiAociksIHMsIHNyYyk7CiAJICBpZiAobGhzKQogCSAg ICB7CiAJICAgICAgaWYgKHNyYy5nb3JpICgpKQpAQCAtNjYzLDcgKzY2Niw4IEBAIGZvbGRfdXNp bmdfcmFuZ2U6OnJhbmdlX29mX3JhbmdlX29wIChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgZnVyX3Nv dXJjZSAmc3JjKQogCQllMCA9IE5VTEw7CiAJICAgICAgaWYgKCFzaW5nbGVfcHJlZF9wIChlMS0+ ZGVzdCkpCiAJCWUxID0gTlVMTDsKLQkgICAgICBzcmMucmVnaXN0ZXJfb3V0Z29pbmdfZWRnZXMg KGFzX2E8Z2NvbmQgKj4gKHMpLCByLCBlMCwgZTEpOworCSAgICAgIHNyYy5yZWdpc3Rlcl9vdXRn b2luZ19lZGdlcyAoYXNfYTxnY29uZCAqPiAocyksCisJCQkJCSAgIGFzX2EgPGlyYW5nZT4gKHIp LCBlMCwgZTEpOwogCSAgICB9CiAJfQogICAgICAgZWxzZQpAQCAtNzI5LDEyICs3MzMsMTIgQEAg Zm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfYWRkcmVzcyAoaXJhbmdlICZyLCBnaW1wbGUgKnN0 bXQsIGZ1cl9zb3VyY2UgJnNyYykKIAl7CiAJICAvKiBGb3IgLWZkZWxldGUtbnVsbC1wb2ludGVy LWNoZWNrcyAtZm5vLXdyYXB2LXBvaW50ZXIgd2UgZG9uJ3QKIAkgICAgIGFsbG93IGdvaW5nIGZy b20gbm9uLU5VTEwgcG9pbnRlciB0byBOVUxMLiAgKi8KLQkgIGlmICghcmFuZ2VfaW5jbHVkZXNf emVyb19wICgmcikpCisJICBpZiAoci51bmRlZmluZWRfcCAoKSB8fCAhci5jb250YWluc19wIChi dWlsZF96ZXJvX2NzdCAoci50eXBlICgpKSkpCiAJICAgIHsKIAkgICAgICAvKiBXZSBjb3VsZCBo ZXJlIGluc3RlYWQgYWRqdXN0IHIgYnkgb2ZmID4+IExPRzJfQklUU19QRVJfVU5JVAogCQkgdXNp bmcgUE9JTlRFUl9QTFVTX0VYUFIgaWYgb2ZmX2NzdCBhbmQganVzdCBmYWxsIGJhY2sgdG8KIAkJ IHRoaXMuICAqLwotCSAgICAgIHIgPSByYW5nZV9ub256ZXJvIChUUkVFX1RZUEUgKGdpbXBsZV9h c3NpZ25fcmhzMSAoc3RtdCkpKTsKKwkgICAgICByLnNldF9ub256ZXJvIChUUkVFX1RZUEUgKGdp bXBsZV9hc3NpZ25fcmhzMSAoc3RtdCkpKTsKIAkgICAgICByZXR1cm4gdHJ1ZTsKIAkgICAgfQog CX0KQEAgLTc0NiwyMiArNzUwLDIyIEBAIGZvbGRfdXNpbmdfcmFuZ2U6OnJhbmdlX29mX2FkZHJl c3MgKGlyYW5nZSAmciwgZ2ltcGxlICpzdG10LCBmdXJfc291cmNlICZzcmMpCiAJICAmJiBrbm93 bl9uZSAob2ZmLCAwKQogCSAgJiYgKGZsYWdfZGVsZXRlX251bGxfcG9pbnRlcl9jaGVja3MgfHwg a25vd25fZ3QgKG9mZiwgMCkpKQogCXsKLQkgIHIgPSByYW5nZV9ub256ZXJvIChUUkVFX1RZUEUg KGdpbXBsZV9hc3NpZ25fcmhzMSAoc3RtdCkpKTsKKwkgIHIuc2V0X25vbnplcm8gKFRSRUVfVFlQ RSAoZ2ltcGxlX2Fzc2lnbl9yaHMxIChzdG10KSkpOwogCSAgcmV0dXJuIHRydWU7CiAJfQotICAg ICAgciA9IGludF9yYW5nZTwyPiAoVFJFRV9UWVBFIChnaW1wbGVfYXNzaWduX3JoczEgKHN0bXQp KSk7CisgICAgICByLnNldF92YXJ5aW5nIChUUkVFX1RZUEUgKGdpbXBsZV9hc3NpZ25fcmhzMSAo c3RtdCkpKTsKICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KIAogICAvLyBIYW5kbGUgIj0gJmEi LgogICBpZiAodHJlZV9zaW5nbGVfbm9uemVyb193YXJudl9wIChleHByLCAmc3RyaWN0X292ZXJm bG93X3ApKQogICAgIHsKLSAgICAgIHIgPSByYW5nZV9ub256ZXJvIChUUkVFX1RZUEUgKGdpbXBs ZV9hc3NpZ25fcmhzMSAoc3RtdCkpKTsKKyAgICAgIHIuc2V0X25vbnplcm8gKFRSRUVfVFlQRSAo Z2ltcGxlX2Fzc2lnbl9yaHMxIChzdG10KSkpOwogICAgICAgcmV0dXJuIHRydWU7CiAgICAgfQog CiAgIC8vIE90aGVyd2lzZSByZXR1cm4gdmFyeWluZy4KLSAgciA9IGludF9yYW5nZTwyPiAoVFJF RV9UWVBFIChnaW1wbGVfYXNzaWduX3JoczEgKHN0bXQpKSk7CisgIHIuc2V0X3ZhcnlpbmcgKFRS RUVfVFlQRSAoZ2ltcGxlX2Fzc2lnbl9yaHMxIChzdG10KSkpOwogICByZXR1cm4gdHJ1ZTsKIH0K IApAQCAtNzY5LDEyICs3NzMsMTIgQEAgZm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfYWRkcmVz cyAoaXJhbmdlICZyLCBnaW1wbGUgKnN0bXQsIGZ1cl9zb3VyY2UgJnNyYykKIC8vIElmIGEgcmFu Z2UgY2Fubm90IGJlIGNhbGN1bGF0ZWQsIHJldHVybiBmYWxzZS4KIAogYm9vbAotZm9sZF91c2lu Z19yYW5nZTo6cmFuZ2Vfb2ZfcGhpIChpcmFuZ2UgJnIsIGdwaGkgKnBoaSwgZnVyX3NvdXJjZSAm c3JjKQorZm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfcGhpICh2cmFuZ2UgJnIsIGdwaGkgKnBo aSwgZnVyX3NvdXJjZSAmc3JjKQogewogICB0cmVlIHBoaV9kZWYgPSBnaW1wbGVfcGhpX3Jlc3Vs dCAocGhpKTsKICAgdHJlZSB0eXBlID0gZ2ltcGxlX3JhbmdlX3R5cGUgKHBoaSk7Ci0gIGludF9y YW5nZV9tYXggYXJnX3JhbmdlOwotICBpbnRfcmFuZ2VfbWF4IGVxdWl2X3JhbmdlOworICBWYWx1 ZV9SYW5nZSBhcmdfcmFuZ2UgKHR5cGUpOworICBWYWx1ZV9SYW5nZSBlcXVpdl9yYW5nZSAodHlw ZSk7CiAgIHVuc2lnbmVkIHg7CiAKICAgaWYgKCF0eXBlKQpAQCAtODgxLDcgKzg4NSw3IEBAIGZv bGRfdXNpbmdfcmFuZ2U6OnJhbmdlX29mX3BoaSAoaXJhbmdlICZyLCBncGhpICpwaGksIGZ1cl9z b3VyY2UgJnNyYykKIC8vIElmIGEgcmFuZ2UgY2Fubm90IGJlIGNhbGN1bGF0ZWQsIHJldHVybiBm YWxzZS4KIAogYm9vbAotZm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfY2FsbCAoaXJhbmdlICZy LCBnY2FsbCAqY2FsbCwgZnVyX3NvdXJjZSAmc3JjKQorZm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vf b2ZfY2FsbCAodnJhbmdlICZyLCBnY2FsbCAqY2FsbCwgZnVyX3NvdXJjZSAmc3JjKQogewogICB0 cmVlIHR5cGUgPSBnaW1wbGVfcmFuZ2VfdHlwZSAoY2FsbCk7CiAgIGlmICghdHlwZSkKQEAgLTg5 MywxOCArODk3LDE4IEBAIGZvbGRfdXNpbmdfcmFuZ2U6OnJhbmdlX29mX2NhbGwgKGlyYW5nZSAm ciwgZ2NhbGwgKmNhbGwsIGZ1cl9zb3VyY2UgJnNyYykKICAgaWYgKHJhbmdlX29mX2J1aWx0aW5f Y2FsbCAociwgY2FsbCwgc3JjKSkKICAgICA7CiAgIGVsc2UgaWYgKGdpbXBsZV9zdG10X25vbm5l Z2F0aXZlX3dhcm52X3AgKGNhbGwsICZzdHJpY3Rfb3ZlcmZsb3dfcCkpCi0gICAgci5zZXQgKGJ1 aWxkX2ludF9jc3QgKHR5cGUsIDApLCBUWVBFX01BWF9WQUxVRSAodHlwZSkpOworICAgIHIuc2V0 X25vbm5lZ2F0aXZlICh0eXBlKTsKICAgZWxzZSBpZiAoZ2ltcGxlX2NhbGxfbm9ubnVsbF9yZXN1 bHRfcCAoY2FsbCkKIAkgICB8fCBnaW1wbGVfY2FsbF9ub25udWxsX2FyZyAoY2FsbCkpCi0gICAg ciA9IHJhbmdlX25vbnplcm8gKHR5cGUpOworICAgIHIuc2V0X25vbnplcm8gKHR5cGUpOwogICBl bHNlCiAgICAgci5zZXRfdmFyeWluZyAodHlwZSk7CiAKICAgLy8gSWYgdGhlcmUgaXMgYW4gTEhT LCBpbnRlcnNlY3QgdGhhdCB3aXRoIHdoYXQgaXMga25vd24uCiAgIGlmIChsaHMpCiAgICAgewot ICAgICAgdmFsdWVfcmFuZ2UgZGVmOwotICAgICAgZGVmID0gZ2ltcGxlX3JhbmdlX2dsb2JhbCAo bGhzKTsKKyAgICAgIFZhbHVlX1JhbmdlIGRlZiAoVFJFRV9UWVBFIChsaHMpKTsKKyAgICAgIGdp bXBsZV9yYW5nZV9nbG9iYWwgKGRlZiwgbGhzKTsKICAgICAgIHIuaW50ZXJzZWN0IChkZWYpOwog ICAgIH0KICAgcmV0dXJuIHRydWU7CkBAIC05NzEsMTMgKzk3NSwzMCBAQCBnZXRfbGV0dGVyX3Jh bmdlICh0cmVlIHR5cGUsIGlyYW5nZSAmbG93ZXJzLCBpcmFuZ2UgJnVwcGVycykKIC8vIFRSVUUu ICBPdGhlcndpc2UgcmV0dXJuIEZBTFNFLgogCiBib29sCi1mb2xkX3VzaW5nX3JhbmdlOjpyYW5n ZV9vZl9idWlsdGluX2NhbGwgKGlyYW5nZSAmciwgZ2NhbGwgKmNhbGwsCitmb2xkX3VzaW5nX3Jh bmdlOjpyYW5nZV9vZl9idWlsdGluX2NhbGwgKHZyYW5nZSAmciwgZ2NhbGwgKmNhbGwsCiAJCQkJ CSBmdXJfc291cmNlICZzcmMpCiB7CiAgIGNvbWJpbmVkX2ZuIGZ1bmMgPSBnaW1wbGVfY2FsbF9j b21iaW5lZF9mbiAoY2FsbCk7CiAgIGlmIChmdW5jID09IENGTl9MQVNUKQogICAgIHJldHVybiBm YWxzZTsKIAorICB0cmVlIHR5cGUgPSBnaW1wbGVfcmFuZ2VfdHlwZSAoY2FsbCk7CisgIGdjY19j aGVja2luZ19hc3NlcnQgKHR5cGUpOworCisgIGlmIChpcmFuZ2U6OnN1cHBvcnRzX3R5cGVfcCAo dHlwZSkpCisgICAgcmV0dXJuIHJhbmdlX29mX2J1aWx0aW5faW50X2NhbGwgKGFzX2EgPGlyYW5n ZT4gKHIpLCBjYWxsLCBzcmMpOworCisgIHJldHVybiBmYWxzZTsKK30KKworYm9vbAorZm9sZF91 c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfYnVpbHRpbl9pbnRfY2FsbCAoaXJhbmdlICZyLCBnY2FsbCAq Y2FsbCwKKwkJCQkJICAgICBmdXJfc291cmNlICZzcmMpCit7CisgIGNvbWJpbmVkX2ZuIGZ1bmMg PSBnaW1wbGVfY2FsbF9jb21iaW5lZF9mbiAoY2FsbCk7CisgIGlmIChmdW5jID09IENGTl9MQVNU KQorICAgIHJldHVybiBmYWxzZTsKKwogICB0cmVlIHR5cGUgPSBnaW1wbGVfcmFuZ2VfdHlwZSAo Y2FsbCk7CiAgIHRyZWUgYXJnOwogICBpbnQgbWluaSwgbWF4aSwgemVyb3YgPSAwLCBwcmVjOwpA QCAtMTI1Niw5ICsxMjc3LDggQEAgZm9sZF91c2luZ19yYW5nZTo6cmFuZ2Vfb2ZfYnVpbHRpbl9j YWxsIChpcmFuZ2UgJnIsIGdjYWxsICpjYWxsLAogLy8gSWYgYSByYW5nZSBjYW5ub3QgYmUgY2Fs Y3VsYXRlZCwgcmV0dXJuIGZhbHNlLgogCiBib29sCi1mb2xkX3VzaW5nX3JhbmdlOjpyYW5nZV9v Zl9jb25kX2V4cHIgIChpcmFuZ2UgJnIsIGdhc3NpZ24gKnMsIGZ1cl9zb3VyY2UgJnNyYykKK2Zv bGRfdXNpbmdfcmFuZ2U6OnJhbmdlX29mX2NvbmRfZXhwciAgKHZyYW5nZSAmciwgZ2Fzc2lnbiAq cywgZnVyX3NvdXJjZSAmc3JjKQogewotICBpbnRfcmFuZ2VfbWF4IGNvbmRfcmFuZ2UsIHJhbmdl MSwgcmFuZ2UyOwogICB0cmVlIGNvbmQgPSBnaW1wbGVfYXNzaWduX3JoczEgKHMpOwogICB0cmVl IG9wMSA9IGdpbXBsZV9hc3NpZ25fcmhzMiAocyk7CiAgIHRyZWUgb3AyID0gZ2ltcGxlX2Fzc2ln bl9yaHMzIChzKTsKQEAgLTEyNjcsNiArMTI4Nyw5IEBAIGZvbGRfdXNpbmdfcmFuZ2U6OnJhbmdl X29mX2NvbmRfZXhwciAgKGlyYW5nZSAmciwgZ2Fzc2lnbiAqcywgZnVyX3NvdXJjZSAmc3JjKQog ICBpZiAoIXR5cGUpCiAgICAgcmV0dXJuIGZhbHNlOwogCisgIFZhbHVlX1JhbmdlIHJhbmdlMSAo VFJFRV9UWVBFIChvcDEpKTsKKyAgVmFsdWVfUmFuZ2UgcmFuZ2UyIChUUkVFX1RZUEUgKG9wMikp OworICBWYWx1ZV9SYW5nZSBjb25kX3JhbmdlIChUUkVFX1RZUEUgKGNvbmQpKTsKICAgZ2NjX2No ZWNraW5nX2Fzc2VydCAoZ2ltcGxlX2Fzc2lnbl9yaHNfY29kZSAocykgPT0gQ09ORF9FWFBSKTsK ICAgZ2NjX2NoZWNraW5nX2Fzc2VydCAocmFuZ2VfY29tcGF0aWJsZV9wIChUUkVFX1RZUEUgKG9w MSksIFRSRUVfVFlQRSAob3AyKSkpOwogICBzcmMuZ2V0X29wZXJhbmQgKGNvbmRfcmFuZ2UsIGNv bmQpOwpAQCAtMTQzOCw3ICsxNDYxLDYgQEAgZm9sZF91c2luZ19yYW5nZTo6cmVsYXRpb25fZm9s ZF9hbmRfb3IgKGlyYW5nZSYgbGhzX3JhbmdlLCBnaW1wbGUgKnMsCiB2b2lkCiBmdXJfc291cmNl OjpyZWdpc3Rlcl9vdXRnb2luZ19lZGdlcyAoZ2NvbmQgKnMsIGlyYW5nZSAmbGhzX3JhbmdlLCBl ZGdlIGUwLCBlZGdlIGUxKQogewotICBpbnRfcmFuZ2VfbWF4IHI7CiAgIGludF9yYW5nZTwyPiBl MF9yYW5nZSwgZTFfcmFuZ2U7CiAgIHRyZWUgbmFtZTsKICAgYmFzaWNfYmxvY2sgYmIgPSBnaW1w bGVfYmIgKHMpOwpAQCAtMTUwNSw2ICsxNTI3LDcgQEAgZnVyX3NvdXJjZTo6cmVnaXN0ZXJfb3V0 Z29pbmdfZWRnZXMgKGdjb25kICpzLCBpcmFuZ2UgJmxoc19yYW5nZSwgZWRnZSBlMCwgZWRnZQog CWNvbnRpbnVlOwogICAgICAgdHJlZSBzc2ExID0gZ2ltcGxlX3JhbmdlX3NzYV9wIChnaW1wbGVf cmFuZ2Vfb3BlcmFuZDEgKHN0bXQpKTsKICAgICAgIHRyZWUgc3NhMiA9IGdpbXBsZV9yYW5nZV9z c2FfcCAoZ2ltcGxlX3JhbmdlX29wZXJhbmQyIChzdG10KSk7CisgICAgICBWYWx1ZV9SYW5nZSBy IChUUkVFX1RZUEUgKG5hbWUpKTsKICAgICAgIGlmIChzc2ExICYmIHNzYTIpCiAJewogCSAgaWYg KGUwICYmIGdvcmkgKCktPm91dGdvaW5nX2VkZ2VfcmFuZ2VfcCAociwgZTAsIG5hbWUsICptX3F1 ZXJ5KQpkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1yYW5nZS1mb2xkLmggYi9nY2MvZ2ltcGxlLXJh bmdlLWZvbGQuaAppbmRleCA0YjVkNGI2ZTBiOC4uZGYyNDI4MGVlNDAgMTAwNjQ0Ci0tLSBhL2dj Yy9naW1wbGUtcmFuZ2UtZm9sZC5oCisrKyBiL2djYy9naW1wbGUtcmFuZ2UtZm9sZC5oCkBAIC0y Myw3ICsyMyw3IEBAIGFsb25nIHdpdGggR0NDOyBzZWUgdGhlIGZpbGUgQ09QWUlORzMuICBJZiBu b3Qgc2VlCiAjZGVmaW5lIEdDQ19HSU1QTEVfUkFOR0VfRk9MRF9ICiAKIC8vIFRoaXMgZmlsZSBp cyB0aGUgbWFpbiBpbmNsdWRlIHBvaW50IGZvciBnaW1wbGUgcmFuZ2UgZm9sZGluZy4KLS8vIFRo ZXNlIHJvdXRpbmVzIHdpbGwgZm9sZCBzdG10IFMgaW50byB0aGUgcmVzdWx0IGlyYW5nZSBSLgor Ly8gVGhlc2Ugcm91dGluZXMgd2lsbCBmb2xkIHN0bXQgUyBpbnRvIHRoZSByZXN1bHQgcmFuZ2Ug Ui4KIC8vIEFueSBzc2FfbmFtZXMgb24gdGhlIHN0bXQgd2lsbCBiZSBjYWxjdWxhdGVkIHVzaW5n IHRoZSByYW5nZV9xdWVyeQogLy8gcGFyYW1ldGVyIHZpYSBhIGNhbGwgdG8gcmFuZ2Vfb2ZfZXhw ci4KIC8vIElmIG5vIHJhbmdlX3F1ZXJ5IGlzIHByb3ZpZGVkLCBjdXJyZW50IGdsb2JhbCByYW5n ZSBpbmZvIHdpbGwgYmUgdXNlZC4KQEAgLTMxLDE1ICszMSwxNSBAQCBhbG9uZyB3aXRoIEdDQzsg c2VlIHRoZSBmaWxlIENPUFlJTkczLiAgSWYgbm90IHNlZQogLy8gaXQgYXBwZWFyZWQgb24gdGhh dCBlZGdlLgogCiAvLyBGb2xkIHN0bXQgUyBpbnRvIHJhbmdlIFIgdXNpbmcgcmFuZ2UgcXVlcnkg US4KLWJvb2wgZm9sZF9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnMsIHJhbmdlX3F1ZXJ5ICpx ID0gTlVMTCk7Citib29sIGZvbGRfcmFuZ2UgKHZyYW5nZSAmciwgZ2ltcGxlICpzLCByYW5nZV9x dWVyeSAqcSA9IE5VTEwpOwogLy8gUmVjYWxjdWxhdGUgc3RtdCBTIGludG8gUiB1c2luZyByYW5n ZSBxdWVyeSBRIGFzIGlmIGl0IHdlcmUgb24gZWRnZSBPTl9FREdFLgotYm9vbCBmb2xkX3Jhbmdl IChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgZWRnZSBvbl9lZGdlLCByYW5nZV9xdWVyeSAqcSA9IE5V TEwpOworYm9vbCBmb2xkX3JhbmdlICh2cmFuZ2UgJnYsIGdpbXBsZSAqcywgZWRnZSBvbl9lZGdl LCByYW5nZV9xdWVyeSAqcSA9IE5VTEwpOwogCiAvLyBUaGVzZSByb3V0aW5lcyB0aGUgb3BlcmFu ZHMgdG8gYmUgc3BlY2lmaWVkIHdoZW4gbWFudWFsbHkgZm9sZGluZy4KIC8vIEFueSBleGNlc3Mg cXVlcmllcyB3aWxsIGJlIGRyYXduIGZyb20gdGhlIGN1cnJlbnQgcmFuZ2VfcXVlcnkuCi1ib29s IGZvbGRfcmFuZ2UgKGlyYW5nZSAmciwgZ2ltcGxlICpzLCBpcmFuZ2UgJnIxKTsKLWJvb2wgZm9s ZF9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnMsIGlyYW5nZSAmcjEsIGlyYW5nZSAmcjIpOwot Ym9vbCBmb2xkX3JhbmdlIChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgdW5zaWduZWQgbnVtX2VsZW1l bnRzLCBpcmFuZ2UgKnZlY3Rvcik7Citib29sIGZvbGRfcmFuZ2UgKHZyYW5nZSAmciwgZ2ltcGxl ICpzLCB2cmFuZ2UgJnIxKTsKK2Jvb2wgZm9sZF9yYW5nZSAodnJhbmdlICZyLCBnaW1wbGUgKnMs IHZyYW5nZSAmcjEsIHZyYW5nZSAmcjIpOworYm9vbCBmb2xkX3JhbmdlICh2cmFuZ2UgJnIsIGdp bXBsZSAqcywgdW5zaWduZWQgbnVtX2VsZW1lbnRzLCB2cmFuZ2UgKip2ZWN0b3IpOwogCiAvLyBS ZXR1cm4gdGhlIHR5cGUgb2YgcmFuZ2Ugd2hpY2ggc3RhdGVtZW50IFMgY2FsY3VsYXRlcy4gIElm IHRoZSB0eXBlIGlzCiAvLyB1bnN1cHBvcnRlZCBvciBubyB0eXBlIGNhbiBiZSBkZXRlcm1pbmVk LCByZXR1cm4gTlVMTF9UUkVFLgpAQCAtNjYsNyArNjYsNyBAQCBnaW1wbGVfcmFuZ2VfdHlwZSAo Y29uc3QgZ2ltcGxlICpzKQogCSAgICB0eXBlID0gVFJFRV9UWVBFICh0eXBlKTsKIAl9CiAgICAg fQotICBpZiAodHlwZSAmJiBpcmFuZ2U6OnN1cHBvcnRzX3R5cGVfcCAodHlwZSkpCisgIGlmICh0 eXBlICYmIHZyYW5nZTo6c3VwcG9ydHNfdHlwZV9wICh0eXBlKSkKICAgICByZXR1cm4gdHlwZTsK ICAgcmV0dXJuIE5VTExfVFJFRTsKIH0KQEAgLTc5LDcgKzc5LDcgQEAgZ2ltcGxlX3JhbmdlX3Nz YV9wICh0cmVlIGV4cCkKICAgaWYgKGV4cCAmJiBUUkVFX0NPREUgKGV4cCkgPT0gU1NBX05BTUUg JiYKICAgICAgICFTU0FfTkFNRV9JU19WSVJUVUFMX09QRVJBTkQgKGV4cCkgJiYKICAgICAgICFT U0FfTkFNRV9PQ0NVUlNfSU5fQUJOT1JNQUxfUEhJIChleHApICYmCi0gICAgICBpcmFuZ2U6OnN1 cHBvcnRzX3R5cGVfcCAoVFJFRV9UWVBFIChleHApKSkKKyAgICAgIHZyYW5nZTo6c3VwcG9ydHNf dHlwZV9wIChUUkVFX1RZUEUgKGV4cCkpKQogICAgIHJldHVybiBleHA7CiAgIHJldHVybiBOVUxM X1RSRUU7CiB9CkBAIC0xMDgsOCArMTA4LDggQEAgcHVibGljOgogICBmdXJfc291cmNlIChyYW5n ZV9xdWVyeSAqcSA9IE5VTEwpOwogICBpbmxpbmUgcmFuZ2VfcXVlcnkgKnF1ZXJ5ICgpIHsgcmV0 dXJuIG1fcXVlcnk7IH0KICAgaW5saW5lIGNsYXNzIGdvcmlfY29tcHV0ZSAqZ29yaSAoKSB7IHJl dHVybiBtX2dvcmk7IH07Ci0gIHZpcnR1YWwgYm9vbCBnZXRfb3BlcmFuZCAoaXJhbmdlICZyLCB0 cmVlIGV4cHIpOwotICB2aXJ0dWFsIGJvb2wgZ2V0X3BoaV9vcGVyYW5kIChpcmFuZ2UgJnIsIHRy ZWUgZXhwciwgZWRnZSBlKTsKKyAgdmlydHVhbCBib29sIGdldF9vcGVyYW5kICh2cmFuZ2UgJnIs IHRyZWUgZXhwcik7CisgIHZpcnR1YWwgYm9vbCBnZXRfcGhpX29wZXJhbmQgKHZyYW5nZSAmciwg dHJlZSBleHByLCBlZGdlIGUpOwogICB2aXJ0dWFsIHJlbGF0aW9uX2tpbmQgcXVlcnlfcmVsYXRp b24gKHRyZWUgb3AxLCB0cmVlIG9wMik7CiAgIHZpcnR1YWwgdm9pZCByZWdpc3Rlcl9yZWxhdGlv biAoZ2ltcGxlICpzdG10LCByZWxhdGlvbl9raW5kIGssIHRyZWUgb3AxLAogCQkJCSAgdHJlZSBv cDIpOwpAQCAtMTI4LDggKzEyOCw4IEBAIGNsYXNzIGZ1cl9zdG10IDogcHVibGljIGZ1cl9zb3Vy Y2UKIHsKIHB1YmxpYzoKICAgZnVyX3N0bXQgKGdpbXBsZSAqcywgcmFuZ2VfcXVlcnkgKnEgPSBO VUxMKTsKLSAgdmlydHVhbCBib29sIGdldF9vcGVyYW5kIChpcmFuZ2UgJnIsIHRyZWUgZXhwcikg b3ZlcnJpZGU7Ci0gIHZpcnR1YWwgYm9vbCBnZXRfcGhpX29wZXJhbmQgKGlyYW5nZSAmciwgdHJl ZSBleHByLCBlZGdlIGUpIG92ZXJyaWRlOworICB2aXJ0dWFsIGJvb2wgZ2V0X29wZXJhbmQgKHZy YW5nZSAmciwgdHJlZSBleHByKSBvdmVycmlkZTsKKyAgdmlydHVhbCBib29sIGdldF9waGlfb3Bl cmFuZCAodnJhbmdlICZyLCB0cmVlIGV4cHIsIGVkZ2UgZSkgb3ZlcnJpZGU7CiAgIHZpcnR1YWwg cmVsYXRpb25fa2luZCBxdWVyeV9yZWxhdGlvbiAodHJlZSBvcDEsIHRyZWUgb3AyKSBvdmVycmlk ZTsKIHByaXZhdGU6CiAgIGdpbXBsZSAqbV9zdG10OwpAQCAtMTYxLDE3ICsxNjEsMTggQEAgZXh0 ZXJuIHRyZWUgZ2ltcGxlX3JhbmdlX29wZXJhbmQyIChjb25zdCBnaW1wbGUgKnMpOwogY2xhc3Mg Zm9sZF91c2luZ19yYW5nZQogewogcHVibGljOgotICBib29sIGZvbGRfc3RtdCAoaXJhbmdlICZy LCBnaW1wbGUgKnMsIGNsYXNzIGZ1cl9zb3VyY2UgJnNyYywKKyAgYm9vbCBmb2xkX3N0bXQgKHZy YW5nZSAmciwgZ2ltcGxlICpzLCBjbGFzcyBmdXJfc291cmNlICZzcmMsCiAJCSAgdHJlZSBuYW1l ID0gTlVMTF9UUkVFKTsKIHByb3RlY3RlZDoKLSAgYm9vbCByYW5nZV9vZl9yYW5nZV9vcCAoaXJh bmdlICZyLCBnaW1wbGUgKnMsIGZ1cl9zb3VyY2UgJnNyYyk7Ci0gIGJvb2wgcmFuZ2Vfb2ZfY2Fs bCAoaXJhbmdlICZyLCBnY2FsbCAqY2FsbCwgZnVyX3NvdXJjZSAmc3JjKTsKLSAgYm9vbCByYW5n ZV9vZl9jb25kX2V4cHIgKGlyYW5nZSAmciwgZ2Fzc2lnbiogY29uZCwgZnVyX3NvdXJjZSAmc3Jj KTsKKyAgYm9vbCByYW5nZV9vZl9yYW5nZV9vcCAodnJhbmdlICZyLCBnaW1wbGUgKnMsIGZ1cl9z b3VyY2UgJnNyYyk7CisgIGJvb2wgcmFuZ2Vfb2ZfY2FsbCAodnJhbmdlICZyLCBnY2FsbCAqY2Fs bCwgZnVyX3NvdXJjZSAmc3JjKTsKKyAgYm9vbCByYW5nZV9vZl9jb25kX2V4cHIgKHZyYW5nZSAm ciwgZ2Fzc2lnbiogY29uZCwgZnVyX3NvdXJjZSAmc3JjKTsKICAgYm9vbCByYW5nZV9vZl9hZGRy ZXNzIChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgZnVyX3NvdXJjZSAmc3JjKTsKLSAgYm9vbCByYW5n ZV9vZl9idWlsdGluX2NhbGwgKGlyYW5nZSAmciwgZ2NhbGwgKmNhbGwsIGZ1cl9zb3VyY2UgJnNy Yyk7CisgIGJvb2wgcmFuZ2Vfb2ZfYnVpbHRpbl9jYWxsICh2cmFuZ2UgJnIsIGdjYWxsICpjYWxs LCBmdXJfc291cmNlICZzcmMpOworICBib29sIHJhbmdlX29mX2J1aWx0aW5faW50X2NhbGwgKGly YW5nZSAmciwgZ2NhbGwgKmNhbGwsIGZ1cl9zb3VyY2UgJnNyYyk7CiAgIHZvaWQgcmFuZ2Vfb2Zf YnVpbHRpbl91YnNhbl9jYWxsIChpcmFuZ2UgJnIsIGdjYWxsICpjYWxsLCB0cmVlX2NvZGUgY29k ZSwKIAkJCQkgICAgZnVyX3NvdXJjZSAmc3JjKTsKLSAgYm9vbCByYW5nZV9vZl9waGkgKGlyYW5n ZSAmciwgZ3BoaSAqcGhpLCBmdXJfc291cmNlICZzcmMpOworICBib29sIHJhbmdlX29mX3BoaSAo dnJhbmdlICZyLCBncGhpICpwaGksIGZ1cl9zb3VyY2UgJnNyYyk7CiAgIHZvaWQgcmFuZ2Vfb2Zf c3NhX25hbWVfd2l0aF9sb29wX2luZm8gKGlyYW5nZSAmLCB0cmVlLCBjbGFzcyBsb29wICosIGdw aGkgKiwKIAkJCQkJIGZ1cl9zb3VyY2UgJnNyYyk7CiAgIHZvaWQgcmVsYXRpb25fZm9sZF9hbmRf b3IgKGlyYW5nZSYgbGhzX3JhbmdlLCBnaW1wbGUgKnMsIGZ1cl9zb3VyY2UgJnNyYyk7CmRpZmYg LS1naXQgYS9nY2MvZ2ltcGxlLXJhbmdlLWdvcmkuY2MgYi9nY2MvZ2ltcGxlLXJhbmdlLWdvcmku Y2MKaW5kZXggNzIwMzIxMzJjYWMuLjBhM2U1NGVhZTRlIDEwMDY0NAotLS0gYS9nY2MvZ2ltcGxl LXJhbmdlLWdvcmkuY2MKKysrIGIvZ2NjL2dpbXBsZS1yYW5nZS1nb3JpLmNjCkBAIC0zNCw3ICsz NCw3IEBAIGFsb25nIHdpdGggR0NDOyBzZWUgdGhlIGZpbGUgQ09QWUlORzMuICBJZiBub3Qgc2Vl CiAvLyBMSFNfUkFOR0UuICBSZXR1cm4gZmFsc2UgaWYgbm90aGluZyBjYW4gYmUgZGV0ZXJtaW5l ZC4KIAogYm9vbAotZ2ltcGxlX3JhbmdlX2NhbGNfb3AxIChpcmFuZ2UgJnIsIGNvbnN0IGdpbXBs ZSAqc3RtdCwgY29uc3QgaXJhbmdlICZsaHNfcmFuZ2UpCitnaW1wbGVfcmFuZ2VfY2FsY19vcDEg KHZyYW5nZSAmciwgY29uc3QgZ2ltcGxlICpzdG10LCBjb25zdCB2cmFuZ2UgJmxoc19yYW5nZSkK IHsKICAgZ2NjX2NoZWNraW5nX2Fzc2VydCAoZ2ltcGxlX251bV9vcHMgKHN0bXQpIDwgMyk7CiAg IC8vIEdpdmUgdXAgb24gZW1wdHkgcmFuZ2VzLgpAQCAtNTUsOCArNTUsOCBAQCBnaW1wbGVfcmFu Z2VfY2FsY19vcDEgKGlyYW5nZSAmciwgY29uc3QgZ2ltcGxlICpzdG10LCBjb25zdCBpcmFuZ2Ug Jmxoc19yYW5nZSkKIC8vIG5vdGhpbmcgY2FuIGJlIGRldGVybWluZWQuCiAKIGJvb2wKLWdpbXBs ZV9yYW5nZV9jYWxjX29wMSAoaXJhbmdlICZyLCBjb25zdCBnaW1wbGUgKnN0bXQsCi0JCSAgICAg ICBjb25zdCBpcmFuZ2UgJmxoc19yYW5nZSwgY29uc3QgaXJhbmdlICZvcDJfcmFuZ2UpCitnaW1w bGVfcmFuZ2VfY2FsY19vcDEgKHZyYW5nZSAmciwgY29uc3QgZ2ltcGxlICpzdG10LAorCQkgICAg ICAgY29uc3QgdnJhbmdlICZsaHNfcmFuZ2UsIGNvbnN0IHZyYW5nZSAmb3AyX3JhbmdlKQogewog ICAvLyBHaXZlIHVwIG9uIGVtcHR5IHJhbmdlcy4KICAgaWYgKGxoc19yYW5nZS51bmRlZmluZWRf cCAoKSkKQEAgLTg2LDggKzg2LDggQEAgZ2ltcGxlX3JhbmdlX2NhbGNfb3AxIChpcmFuZ2UgJnIs IGNvbnN0IGdpbXBsZSAqc3RtdCwKIC8vIG5vdGhpbmcgY2FuIGJlIGRldGVybWluZWQuCiAKIGJv b2wKLWdpbXBsZV9yYW5nZV9jYWxjX29wMiAoaXJhbmdlICZyLCBjb25zdCBnaW1wbGUgKnN0bXQs Ci0JCSAgICAgICBjb25zdCBpcmFuZ2UgJmxoc19yYW5nZSwgY29uc3QgaXJhbmdlICZvcDFfcmFu Z2UpCitnaW1wbGVfcmFuZ2VfY2FsY19vcDIgKHZyYW5nZSAmciwgY29uc3QgZ2ltcGxlICpzdG10 LAorCQkgICAgICAgY29uc3QgdnJhbmdlICZsaHNfcmFuZ2UsIGNvbnN0IHZyYW5nZSAmb3AxX3Jh bmdlKQogewogICAvLyBHaXZlIHVwIG9uIGVtcHR5IHJhbmdlcy4KICAgaWYgKGxoc19yYW5nZS51 bmRlZmluZWRfcCAoKSkKQEAgLTY2Myw4ICs2NjMsOCBAQCBnb3JpX2NvbXB1dGU6OmdvcmlfY29t cHV0ZSAoaW50IG5vdF9leGVjdXRhYmxlX2ZsYWcpCiAvLyB3YXMgbm90IHJlc29sdmFibGUuCiAK IGJvb2wKLWdvcmlfY29tcHV0ZTo6Y29tcHV0ZV9vcGVyYW5kX3JhbmdlX3N3aXRjaCAoaXJhbmdl ICZyLCBnc3dpdGNoICpzLAotCQkJCQkgICAgY29uc3QgaXJhbmdlICZsaHMsCitnb3JpX2NvbXB1 dGU6OmNvbXB1dGVfb3BlcmFuZF9yYW5nZV9zd2l0Y2ggKHZyYW5nZSAmciwgZ3N3aXRjaCAqcywK KwkJCQkJICAgIGNvbnN0IHZyYW5nZSAmbGhzLAogCQkJCQkgICAgdHJlZSBuYW1lLCBmdXJfc291 cmNlICZzcmMpCiB7CiAgIHRyZWUgb3AxID0gZ2ltcGxlX3N3aXRjaF9pbmRleCAocyk7CkBAIC02 OTEsOCArNjkxLDggQEAgZ29yaV9jb21wdXRlOjpjb21wdXRlX29wZXJhbmRfcmFuZ2Vfc3dpdGNo IChpcmFuZ2UgJnIsIGdzd2l0Y2ggKnMsCiAvLyBzdG9yZSB0aGUgZXZhbHVhdGlvbiBpbiBSLCBv dGhlcndpc2UgcmV0dXJuIEZBTFNFLgogCiBib29sCi1nb3JpX2NvbXB1dGU6OmNvbXB1dGVfb3Bl cmFuZF9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnN0bXQsCi0JCQkJICAgICBjb25zdCBpcmFu Z2UgJmxocywgdHJlZSBuYW1lLAorZ29yaV9jb21wdXRlOjpjb21wdXRlX29wZXJhbmRfcmFuZ2Ug KHZyYW5nZSAmciwgZ2ltcGxlICpzdG10LAorCQkJCSAgICAgY29uc3QgdnJhbmdlICZsaHMsIHRy ZWUgbmFtZSwKIAkJCQkgICAgIGZ1cl9zb3VyY2UgJnNyYykKIHsKICAgLy8gSWYgdGhlIGxocyBk b2Vzbid0IHRlbGwgdXMgYW55dGhpbmcsIG5laXRoZXIgd2lsbCB1bndpbmRpbmcgZnVydGhlci4K QEAgLTc0MywxMyArNzQzLDE4IEBAIGdvcmlfY29tcHV0ZTo6Y29tcHV0ZV9vcGVyYW5kX3Jhbmdl IChpcmFuZ2UgJnIsIGdpbXBsZSAqc3RtdCwKIAkgIHByaW50X2dpbXBsZV9zdG10IChkdW1wX2Zp bGUsIHN0bXQsIDAsIFRERl9TTElNKTsKIAl9CiAKLSAgICAgIGludF9yYW5nZV9tYXggb3AxX3Ry YW5nZSwgb3AxX2ZyYW5nZTsKLSAgICAgIGludF9yYW5nZV9tYXggb3AyX3RyYW5nZSwgb3AyX2Zy YW5nZTsKLSAgICAgIGNvbXB1dGVfbG9naWNhbF9vcGVyYW5kcyAob3AxX3RyYW5nZSwgb3AxX2Zy YW5nZSwgc3RtdCwgbGhzLAorICAgICAgdHJlZSB0eXBlID0gVFJFRV9UWVBFIChuYW1lKTsKKyAg ICAgIFZhbHVlX1JhbmdlIG9wMV90cmFuZ2UgKHR5cGUpLCBvcDFfZnJhbmdlICh0eXBlKTsKKyAg ICAgIFZhbHVlX1JhbmdlIG9wMl90cmFuZ2UgKHR5cGUpLCBvcDJfZnJhbmdlICh0eXBlKTsKKyAg ICAgIGNvbXB1dGVfbG9naWNhbF9vcGVyYW5kcyAob3AxX3RyYW5nZSwgb3AxX2ZyYW5nZSwgc3Rt dCwKKwkJCQlhc19hIDxpcmFuZ2U+IChsaHMpLAogCQkJCW5hbWUsIHNyYywgb3AxLCBvcDFfaW5f Y2hhaW4pOwotICAgICAgY29tcHV0ZV9sb2dpY2FsX29wZXJhbmRzIChvcDJfdHJhbmdlLCBvcDJf ZnJhbmdlLCBzdG10LCBsaHMsCisgICAgICBjb21wdXRlX2xvZ2ljYWxfb3BlcmFuZHMgKG9wMl90 cmFuZ2UsIG9wMl9mcmFuZ2UsIHN0bXQsCisJCQkJYXNfYSA8aXJhbmdlPiAobGhzKSwKIAkJCQlu YW1lLCBzcmMsIG9wMiwgb3AyX2luX2NoYWluKTsKLSAgICAgIHJlcyA9IGxvZ2ljYWxfY29tYmlu ZSAociwgZ2ltcGxlX2V4cHJfY29kZSAoc3RtdCksIGxocywKKyAgICAgIHJlcyA9IGxvZ2ljYWxf Y29tYmluZSAociwKKwkJCSAgICAgZ2ltcGxlX2V4cHJfY29kZSAoc3RtdCksCisJCQkgICAgIGFz X2EgPGlyYW5nZT4gKGxocyksCiAJCQkgICAgIG9wMV90cmFuZ2UsIG9wMV9mcmFuZ2UsIG9wMl90 cmFuZ2UsIG9wMl9mcmFuZ2UpOwogICAgICAgaWYgKGlkeCkKIAl0cmFjZXIudHJhaWxlciAoaWR4 LCAiY29tcHV0ZV9vcGVyYW5kIiwgcmVzLCBuYW1lLCByKTsKQEAgLTc4OSwxMCArNzk0LDEwIEBA IHJhbmdlX2lzX2VpdGhlcl90cnVlX29yX2ZhbHNlIChjb25zdCBpcmFuZ2UgJnIpCiAvLyB0aGUg TEhTLgogCiBib29sCi1nb3JpX2NvbXB1dGU6OmxvZ2ljYWxfY29tYmluZSAoaXJhbmdlICZyLCBl bnVtIHRyZWVfY29kZSBjb2RlLAorZ29yaV9jb21wdXRlOjpsb2dpY2FsX2NvbWJpbmUgKHZyYW5n ZSAmciwgZW51bSB0cmVlX2NvZGUgY29kZSwKIAkJCSAgICAgICBjb25zdCBpcmFuZ2UgJmxocywK LQkJCSAgICAgICBjb25zdCBpcmFuZ2UgJm9wMV90cnVlLCBjb25zdCBpcmFuZ2UgJm9wMV9mYWxz ZSwKLQkJCSAgICAgICBjb25zdCBpcmFuZ2UgJm9wMl90cnVlLCBjb25zdCBpcmFuZ2UgJm9wMl9m YWxzZSkKKwkJCSAgICAgICBjb25zdCB2cmFuZ2UgJm9wMV90cnVlLCBjb25zdCB2cmFuZ2UgJm9w MV9mYWxzZSwKKwkJCSAgICAgICBjb25zdCB2cmFuZ2UgJm9wMl90cnVlLCBjb25zdCB2cmFuZ2Ug Jm9wMl9mYWxzZSkKIHsKICAgaWYgKG9wMV90cnVlLnZhcnlpbmdfcCAoKSAmJiBvcDFfZmFsc2Uu dmFyeWluZ19wICgpCiAgICAgICAmJiBvcDJfdHJ1ZS52YXJ5aW5nX3AgKCkgJiYgb3AyX2ZhbHNl LnZhcnlpbmdfcCAoKSkKQEAgLTg2OCw3ICs4NzMsNyBAQCBnb3JpX2NvbXB1dGU6OmxvZ2ljYWxf Y29tYmluZSAoaXJhbmdlICZyLCBlbnVtIHRyZWVfY29kZSBjb2RlLAogICBpZiAoIXJhbmdlX2lz X2VpdGhlcl90cnVlX29yX2ZhbHNlIChsaHMpKQogICAgIHsKICAgICAgIGJvb2wgcmVzOwotICAg ICAgaW50X3JhbmdlX21heCByMTsKKyAgICAgIFZhbHVlX1JhbmdlIHIxIChyKTsKICAgICAgIGlm IChsb2dpY2FsX2NvbWJpbmUgKHIxLCBjb2RlLCBtX2Jvb2xfemVybywgb3AxX3RydWUsIG9wMV9m YWxzZSwKIAkJCSAgIG9wMl90cnVlLCBvcDJfZmFsc2UpCiAJICAmJiBsb2dpY2FsX2NvbWJpbmUg KHIsIGNvZGUsIG1fYm9vbF9vbmUsIG9wMV90cnVlLCBvcDFfZmFsc2UsCkBAIC04OTgsMTEgKzkw MywxMSBAQCBnb3JpX2NvbXB1dGU6OmxvZ2ljYWxfY29tYmluZSAoaXJhbmdlICZyLCBlbnVtIHRy ZWVfY29kZSBjb2RlLAogCWVsc2UKIAkgIHsKIAkgICAgLy8gVGhlIEZBTFNFIHNpZGUgaXMgdGhl IHVuaW9uIG9mIHRoZSBvdGhlciAzIGNhc2VzLgotCSAgICBpbnRfcmFuZ2VfbWF4IGZmIChvcDFf ZmFsc2UpOworCSAgICBWYWx1ZV9SYW5nZSBmZiAob3AxX2ZhbHNlKTsKIAkgICAgZmYuaW50ZXJz ZWN0IChvcDJfZmFsc2UpOwotCSAgICBpbnRfcmFuZ2VfbWF4IHRmIChvcDFfdHJ1ZSk7CisJICAg IFZhbHVlX1JhbmdlIHRmIChvcDFfdHJ1ZSk7CiAJICAgIHRmLmludGVyc2VjdCAob3AyX2ZhbHNl KTsKLQkgICAgaW50X3JhbmdlX21heCBmdCAob3AxX2ZhbHNlKTsKKwkgICAgVmFsdWVfUmFuZ2Ug ZnQgKG9wMV9mYWxzZSk7CiAJICAgIGZ0LmludGVyc2VjdCAob3AyX3RydWUpOwogCSAgICByID0g ZmY7CiAJICAgIHIudW5pb25fICh0Zik7CkBAIC05MjUsMTEgKzkzMCwxMSBAQCBnb3JpX2NvbXB1 dGU6OmxvZ2ljYWxfY29tYmluZSAoaXJhbmdlICZyLCBlbnVtIHRyZWVfY29kZSBjb2RlLAogCSAg ewogCSAgICAvLyBUaGUgVFJVRSBzaWRlIG9mIGFuIE9SIG9wZXJhdGlvbiB3aWxsIGJlIHRoZSB1 bmlvbiBvZgogCSAgICAvLyB0aGUgb3RoZXIgdGhyZWUgY29tYmluYXRpb25zLgotCSAgICBpbnRf cmFuZ2VfbWF4IHR0IChvcDFfdHJ1ZSk7CisJICAgIFZhbHVlX1JhbmdlIHR0IChvcDFfdHJ1ZSk7 CiAJICAgIHR0LmludGVyc2VjdCAob3AyX3RydWUpOwotCSAgICBpbnRfcmFuZ2VfbWF4IHRmIChv cDFfdHJ1ZSk7CisJICAgIFZhbHVlX1JhbmdlIHRmIChvcDFfdHJ1ZSk7CiAJICAgIHRmLmludGVy c2VjdCAob3AyX2ZhbHNlKTsKLQkgICAgaW50X3JhbmdlX21heCBmdCAob3AxX2ZhbHNlKTsKKwkg ICAgVmFsdWVfUmFuZ2UgZnQgKG9wMV9mYWxzZSk7CiAJICAgIGZ0LmludGVyc2VjdCAob3AyX3Ry dWUpOwogCSAgICByID0gdHQ7CiAJICAgIHIudW5pb25fICh0Zik7CkBAIC05NTEsNyArOTU2LDcg QEAgZ29yaV9jb21wdXRlOjpsb2dpY2FsX2NvbWJpbmUgKGlyYW5nZSAmciwgZW51bSB0cmVlX2Nv ZGUgY29kZSwKIC8vIE9QX0lOX0NIQUlOIGlzIHRydWUuCiAKIHZvaWQKLWdvcmlfY29tcHV0ZTo6 Y29tcHV0ZV9sb2dpY2FsX29wZXJhbmRzIChpcmFuZ2UgJnRydWVfcmFuZ2UsIGlyYW5nZSAmZmFs c2VfcmFuZ2UsCitnb3JpX2NvbXB1dGU6OmNvbXB1dGVfbG9naWNhbF9vcGVyYW5kcyAodnJhbmdl ICZ0cnVlX3JhbmdlLCB2cmFuZ2UgJmZhbHNlX3JhbmdlLAogCQkJCQlnaW1wbGUgKnN0bXQsCiAJ CQkJCWNvbnN0IGlyYW5nZSAmbGhzLAogCQkJCQl0cmVlIG5hbWUsIGZ1cl9zb3VyY2UgJnNyYywK QEAgLTEwMDcsMTMgKzEwMTIsMTUgQEAgZ29yaV9jb21wdXRlOjpjb21wdXRlX2xvZ2ljYWxfb3Bl cmFuZHMgKGlyYW5nZSAmdHJ1ZV9yYW5nZSwgaXJhbmdlICZmYWxzZV9yYW5nZSwKIC8vIFIsIG9y IGZhbHNlIGlmIG5vIHJhbmdlIGNvdWxkIGJlIGNhbGN1bGF0ZWQuCiAKIGJvb2wKLWdvcmlfY29t cHV0ZTo6Y29tcHV0ZV9vcGVyYW5kMV9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnN0bXQsCi0J CQkJICAgICAgY29uc3QgaXJhbmdlICZsaHMsIHRyZWUgbmFtZSwKK2dvcmlfY29tcHV0ZTo6Y29t cHV0ZV9vcGVyYW5kMV9yYW5nZSAodnJhbmdlICZyLCBnaW1wbGUgKnN0bXQsCisJCQkJICAgICAg Y29uc3QgdnJhbmdlICZsaHMsIHRyZWUgbmFtZSwKIAkJCQkgICAgICBmdXJfc291cmNlICZzcmMp CiB7Ci0gIGludF9yYW5nZV9tYXggb3AxX3JhbmdlLCBvcDJfcmFuZ2U7CiAgIHRyZWUgb3AxID0g Z2ltcGxlX3JhbmdlX29wZXJhbmQxIChzdG10KTsKICAgdHJlZSBvcDIgPSBnaW1wbGVfcmFuZ2Vf b3BlcmFuZDIgKHN0bXQpOworICBWYWx1ZV9SYW5nZSBvcDFfcmFuZ2UgKFRSRUVfVFlQRSAob3Ax KSk7CisgIFZhbHVlX1JhbmdlIHRtcCAoVFJFRV9UWVBFIChvcDEpKTsKKyAgVmFsdWVfUmFuZ2Ug b3AyX3JhbmdlIChvcDIgPyBUUkVFX1RZUEUgKG9wMikgOiBUUkVFX1RZUEUgKG9wMSkpOwogCiAg IC8vIEZldGNoIHRoZSBrbm93biByYW5nZSBmb3Igb3AxIGluIHRoaXMgYmxvY2suCiAgIHNyYy5n ZXRfb3BlcmFuZCAob3AxX3JhbmdlLCBvcDEpOwpAQCAtMTAyMiw3ICsxMDI5LDcgQEAgZ29yaV9j b21wdXRlOjpjb21wdXRlX29wZXJhbmQxX3JhbmdlIChpcmFuZ2UgJnIsIGdpbXBsZSAqc3RtdCwK ICAgaWYgKG9wMikKICAgICB7CiAgICAgICBzcmMuZ2V0X29wZXJhbmQgKG9wMl9yYW5nZSwgb3Ay KTsKLSAgICAgIGlmICghZ2ltcGxlX3JhbmdlX2NhbGNfb3AxIChyLCBzdG10LCBsaHMsIG9wMl9y YW5nZSkpCisgICAgICBpZiAoIWdpbXBsZV9yYW5nZV9jYWxjX29wMSAodG1wLCBzdG10LCBsaHMs IG9wMl9yYW5nZSkpCiAJcmV0dXJuIGZhbHNlOwogICAgIH0KICAgZWxzZQpAQCAtMTAzMCw3ICsx MDM3LDcgQEAgZ29yaV9jb21wdXRlOjpjb21wdXRlX29wZXJhbmQxX3JhbmdlIChpcmFuZ2UgJnIs IGdpbXBsZSAqc3RtdCwKICAgICAgIC8vIFdlIHBhc3Mgb3AxX3JhbmdlIHRvIHRoZSB1bmFyeSBv cGVyYXRpb24uICBOb21hbGx5IGl0J3MgYQogICAgICAgLy8gaGlkZGVuIHJhbmdlX2Zvcl90eXBl IHBhcmFtZXRlciwgYnV0IHNvbWV0aW1lcyBoYXZpbmcgdGhlCiAgICAgICAvLyBhY3R1YWwgcmFu Z2UgY2FuIHJlc3VsdCBpbiBiZXR0ZXIgaW5mb3JtYXRpb24uCi0gICAgICBpZiAoIWdpbXBsZV9y YW5nZV9jYWxjX29wMSAociwgc3RtdCwgbGhzLCBvcDFfcmFuZ2UpKQorICAgICAgaWYgKCFnaW1w bGVfcmFuZ2VfY2FsY19vcDEgKHRtcCwgc3RtdCwgbGhzLCBvcDFfcmFuZ2UpKQogCXJldHVybiBm YWxzZTsKICAgICB9CiAKQEAgLTEwNTMsNyArMTA2MCw3IEBAIGdvcmlfY29tcHV0ZTo6Y29tcHV0 ZV9vcGVyYW5kMV9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnN0bXQsCiAgICAgICB0cmFjZXIu cHJpbnQgKGlkeCwgIkNvbXB1dGVzICIpOwogICAgICAgcHJpbnRfZ2VuZXJpY19leHByIChkdW1w X2ZpbGUsIG9wMSwgVERGX1NMSU0pOwogICAgICAgZnByaW50ZiAoZHVtcF9maWxlLCAiID0gIik7 Ci0gICAgICByLmR1bXAgKGR1bXBfZmlsZSk7CisgICAgICB0bXAuZHVtcCAoZHVtcF9maWxlKTsK ICAgICAgIGZwcmludGYgKGR1bXBfZmlsZSwgIiBpbnRlcnNlY3QgS25vd24gcmFuZ2UgOiAiKTsK ICAgICAgIG9wMV9yYW5nZS5kdW1wIChkdW1wX2ZpbGUpOwogICAgICAgZnB1dGMgKCdcbicsIGR1 bXBfZmlsZSk7CkBAIC0xMDYxLDEzICsxMDY4LDE0IEBAIGdvcmlfY29tcHV0ZTo6Y29tcHV0ZV9v cGVyYW5kMV9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnN0bXQsCiAgIC8vIEludGVyc2VjdCB0 aGUgY2FsY3VsYXRlZCByZXN1bHQgd2l0aCB0aGUga25vd24gcmVzdWx0IGFuZCByZXR1cm4gaWYg ZG9uZS4KICAgaWYgKG9wMSA9PSBuYW1lKQogICAgIHsKLSAgICAgIHIuaW50ZXJzZWN0IChvcDFf cmFuZ2UpOworICAgICAgdG1wLmludGVyc2VjdCAob3AxX3JhbmdlKTsKKyAgICAgIHIgPSB0bXA7 CiAgICAgICBpZiAoaWR4KQogCXRyYWNlci50cmFpbGVyIChpZHgsICJwcm9kdWNlcyAiLCB0cnVl LCBuYW1lLCByKTsKICAgICAgIHJldHVybiB0cnVlOwogICAgIH0KICAgLy8gSWYgdGhlIGNhbGN1 bGF0aW9uIGNvbnRpbnVlcywgd2UncmUgdXNpbmcgb3AxX3JhbmdlIGFzIHRoZSBuZXcgTEhTLgot ICBvcDFfcmFuZ2UuaW50ZXJzZWN0IChyKTsKKyAgb3AxX3JhbmdlLmludGVyc2VjdCAodG1wKTsK IAogICBpZiAoaWR4KQogICAgIHRyYWNlci50cmFpbGVyIChpZHgsICJwcm9kdWNlcyAiLCB0cnVl LCBvcDEsIG9wMV9yYW5nZSk7CkBAIC0xMDg0LDE5ICsxMDkyLDIxIEBAIGdvcmlfY29tcHV0ZTo6 Y29tcHV0ZV9vcGVyYW5kMV9yYW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnN0bXQsCiAvLyBSLCBv ciBmYWxzZSBpZiBubyByYW5nZSBjb3VsZCBiZSBjYWxjdWxhdGVkLgogCiBib29sCi1nb3JpX2Nv bXB1dGU6OmNvbXB1dGVfb3BlcmFuZDJfcmFuZ2UgKGlyYW5nZSAmciwgZ2ltcGxlICpzdG10LAot CQkJCSAgICAgIGNvbnN0IGlyYW5nZSAmbGhzLCB0cmVlIG5hbWUsCitnb3JpX2NvbXB1dGU6OmNv bXB1dGVfb3BlcmFuZDJfcmFuZ2UgKHZyYW5nZSAmciwgZ2ltcGxlICpzdG10LAorCQkJCSAgICAg IGNvbnN0IHZyYW5nZSAmbGhzLCB0cmVlIG5hbWUsCiAJCQkJICAgICAgZnVyX3NvdXJjZSAmc3Jj KQogewotICBpbnRfcmFuZ2VfbWF4IG9wMV9yYW5nZSwgb3AyX3JhbmdlOwogICB0cmVlIG9wMSA9 IGdpbXBsZV9yYW5nZV9vcGVyYW5kMSAoc3RtdCk7CiAgIHRyZWUgb3AyID0gZ2ltcGxlX3Jhbmdl X29wZXJhbmQyIChzdG10KTsKKyAgVmFsdWVfUmFuZ2Ugb3AxX3JhbmdlIChUUkVFX1RZUEUgKG9w MSkpOworICBWYWx1ZV9SYW5nZSBvcDJfcmFuZ2UgKFRSRUVfVFlQRSAob3AyKSk7CisgIFZhbHVl X1JhbmdlIHRtcCAoVFJFRV9UWVBFIChvcDIpKTsKIAogICBzcmMuZ2V0X29wZXJhbmQgKG9wMV9y YW5nZSwgb3AxKTsKICAgc3JjLmdldF9vcGVyYW5kIChvcDJfcmFuZ2UsIG9wMik7CiAKICAgLy8g SW50ZXJzZWN0IHdpdGggcmFuZ2UgZm9yIG9wMiBiYXNlZCBvbiBsaHMgYW5kIG9wMS4KLSAgaWYg KCFnaW1wbGVfcmFuZ2VfY2FsY19vcDIgKHIsIHN0bXQsIGxocywgb3AxX3JhbmdlKSkKKyAgaWYg KCFnaW1wbGVfcmFuZ2VfY2FsY19vcDIgKHRtcCwgc3RtdCwgbGhzLCBvcDFfcmFuZ2UpKQogICAg IHJldHVybiBmYWxzZTsKIAogICB1bnNpZ25lZCBpZHg7CkBAIC0xMTE4LDcgKzExMjgsNyBAQCBn b3JpX2NvbXB1dGU6OmNvbXB1dGVfb3BlcmFuZDJfcmFuZ2UgKGlyYW5nZSAmciwgZ2ltcGxlICpz dG10LAogICAgICAgdHJhY2VyLnByaW50IChpZHgsICJDb21wdXRlcyAiKTsKICAgICAgIHByaW50 X2dlbmVyaWNfZXhwciAoZHVtcF9maWxlLCBvcDIsIFRERl9TTElNKTsKICAgICAgIGZwcmludGYg KGR1bXBfZmlsZSwgIiA9ICIpOwotICAgICAgci5kdW1wIChkdW1wX2ZpbGUpOworICAgICAgdG1w LmR1bXAgKGR1bXBfZmlsZSk7CiAgICAgICBmcHJpbnRmIChkdW1wX2ZpbGUsICIgaW50ZXJzZWN0 IEtub3duIHJhbmdlIDogIik7CiAgICAgICBvcDJfcmFuZ2UuZHVtcCAoZHVtcF9maWxlKTsKICAg ICAgIGZwdXRjICgnXG4nLCBkdW1wX2ZpbGUpOwpAQCAtMTEyNiwxMyArMTEzNiwxNCBAQCBnb3Jp X2NvbXB1dGU6OmNvbXB1dGVfb3BlcmFuZDJfcmFuZ2UgKGlyYW5nZSAmciwgZ2ltcGxlICpzdG10 LAogICAvLyBJbnRlcnNlY3QgdGhlIGNhbGN1bGF0ZWQgcmVzdWx0IHdpdGggdGhlIGtub3duIHJl c3VsdCBhbmQgcmV0dXJuIGlmIGRvbmUuCiAgIGlmIChvcDIgPT0gbmFtZSkKICAgICB7Ci0gICAg ICByLmludGVyc2VjdCAob3AyX3JhbmdlKTsKKyAgICAgIHRtcC5pbnRlcnNlY3QgKG9wMl9yYW5n ZSk7CisgICAgICByID0gdG1wOwogICAgICAgaWYgKGlkeCkKIAl0cmFjZXIudHJhaWxlciAoaWR4 LCAiIHByb2R1Y2VzICIsIHRydWUsIE5VTExfVFJFRSwgcik7CiAgICAgICByZXR1cm4gdHJ1ZTsK ICAgICB9CiAgIC8vIElmIHRoZSBjYWxjdWxhdGlvbiBjb250aW51ZXMsIHdlJ3JlIHVzaW5nIG9w Ml9yYW5nZSBhcyB0aGUgbmV3IExIUy4KLSAgb3AyX3JhbmdlLmludGVyc2VjdCAocik7CisgIG9w Ml9yYW5nZS5pbnRlcnNlY3QgKHRtcCk7CiAKICAgaWYgKGlkeCkKICAgICB0cmFjZXIudHJhaWxl ciAoaWR4LCAiIHByb2R1Y2VzICIsIHRydWUsIG9wMiwgb3AyX3JhbmdlKTsKQEAgLTExNDksMTMg KzExNjAsMTMgQEAgZ29yaV9jb21wdXRlOjpjb21wdXRlX29wZXJhbmQyX3JhbmdlIChpcmFuZ2Ug JnIsIGdpbXBsZSAqc3RtdCwKIC8vIFIsIG9yIGZhbHNlIGlmIG5vIHJhbmdlIGNvdWxkIGJlIGNh bGN1bGF0ZWQuCiAKIGJvb2wKLWdvcmlfY29tcHV0ZTo6Y29tcHV0ZV9vcGVyYW5kMV9hbmRfb3Bl cmFuZDJfcmFuZ2UgKGlyYW5nZSAmciwKK2dvcmlfY29tcHV0ZTo6Y29tcHV0ZV9vcGVyYW5kMV9h bmRfb3BlcmFuZDJfcmFuZ2UgKHZyYW5nZSAmciwKIAkJCQkJCSAgIGdpbXBsZSAqc3RtdCwKLQkJ CQkJCSAgIGNvbnN0IGlyYW5nZSAmbGhzLAorCQkJCQkJICAgY29uc3QgdnJhbmdlICZsaHMsCiAJ CQkJCQkgICB0cmVlIG5hbWUsCiAJCQkJCQkgICBmdXJfc291cmNlICZzcmMpCiB7Ci0gIGludF9y YW5nZV9tYXggb3BfcmFuZ2U7CisgIFZhbHVlX1JhbmdlIG9wX3JhbmdlIChUUkVFX1RZUEUgKG5h bWUpKTsKIAogICAvLyBDYWxjdWxhdGUgYSBnb29kIGEgcmFuZ2UgZm9yIG9wMi4gIFNpbmNlIG9w MSA9PSBvcDIsIHRoaXMgd2lsbAogICAvLyBoYXZlIGFscmVhZHkgaW5jbHVkZWQgd2hhdGV2ZXIg dGhlIGFjdHVhbCByYW5nZSBvZiBuYW1lIGlzLgpAQCAtMTIzNiwxMCArMTI0Nyw5IEBAIGdvcmlf Y29tcHV0ZTo6aGFzX2VkZ2VfcmFuZ2VfcCAodHJlZSBuYW1lLCBlZGdlIGUpCiAvLyBjb250cm9s IGVkZ2Ugb3IgTkFNRSBpcyBub3QgZGVmaW5lZCBieSB0aGlzIGVkZ2UuCiAKIGJvb2wKLWdvcmlf Y29tcHV0ZTo6b3V0Z29pbmdfZWRnZV9yYW5nZV9wIChpcmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBu YW1lLAorZ29yaV9jb21wdXRlOjpvdXRnb2luZ19lZGdlX3JhbmdlX3AgKHZyYW5nZSAmciwgZWRn ZSBlLCB0cmVlIG5hbWUsCiAJCQkJICAgICByYW5nZV9xdWVyeSAmcSkKIHsKLSAgaW50X3Jhbmdl X21heCBsaHM7CiAgIHVuc2lnbmVkIGlkeDsKIAogICBpZiAoKGUtPmZsYWdzICYgbV9ub3RfZXhl Y3V0YWJsZV9mbGFnKSkKQEAgLTEyNTIsNiArMTI2Miw3IEBAIGdvcmlfY29tcHV0ZTo6b3V0Z29p bmdfZWRnZV9yYW5nZV9wIChpcmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBuYW1lLAogICAgIH0KIAog ICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChnaW1wbGVfcmFuZ2Vfc3NhX3AgKG5hbWUpKTsKKyAgaW50 X3JhbmdlX21heCBsaHM7CiAgIC8vIERldGVybWluZSBpZiB0aGVyZSBpcyBhbiBvdXRnb2luZyBl ZGdlLgogICBnaW1wbGUgKnN0bXQgPSBvdXRnb2luZy5lZGdlX3JhbmdlX3AgKGxocywgZSk7CiAg IGlmICghc3RtdCkKQEAgLTEzMTIsMTAgKzEzMjMsOSBAQCBnb3JpX2NvbXB1dGU6Om91dGdvaW5n X2VkZ2VfcmFuZ2VfcCAoaXJhbmdlICZyLCBlZGdlIGUsIHRyZWUgbmFtZSwKIC8vIGVkZ2UgYW5k IE9QMiBvbiB0aGUgZmFsc2UgZWRnZS4KIAogYm9vbAotZ29yaV9jb21wdXRlOjpjb25kZXhwcl9h ZGp1c3QgKGlyYW5nZSAmcjEsIGlyYW5nZSAmcjIsIGdpbXBsZSAqLCB0cmVlIGNvbmQsCitnb3Jp X2NvbXB1dGU6OmNvbmRleHByX2FkanVzdCAodnJhbmdlICZyMSwgdnJhbmdlICZyMiwgZ2ltcGxl ICosIHRyZWUgY29uZCwKIAkJCSAgICAgICB0cmVlIG9wMSwgdHJlZSBvcDIsIGZ1cl9zb3VyY2Ug JnNyYykKIHsKLSAgaW50X3JhbmdlX21heCB0bXAsIGNvbmRfdHJ1ZSwgY29uZF9mYWxzZTsKICAg dHJlZSBzc2ExID0gZ2ltcGxlX3JhbmdlX3NzYV9wIChvcDEpOwogICB0cmVlIHNzYTIgPSBnaW1w bGVfcmFuZ2Vfc3NhX3AgKG9wMik7CiAgIGlmICghc3NhMSAmJiAhc3NhMikKQEAgLTEzNDEsMTUg KzEzNTEsMTkgQEAgZ29yaV9jb21wdXRlOjpjb25kZXhwcl9hZGp1c3QgKGlyYW5nZSAmcjEsIGly YW5nZSAmcjIsIGdpbXBsZSAqLCB0cmVlIGNvbmQsCiAgICAgcmV0dXJuIGZhbHNlOwogCiAgIC8v IFBpY2sgdXAgdGhlIGN1cnJlbnQgdmFsdWVzIG9mIGVhY2ggcGFydCBvZiB0aGUgY29uZGl0aW9u LgotICBpbnRfcmFuZ2VfbWF4IGNsLCBjcjsKLSAgc3JjLmdldF9vcGVyYW5kIChjbCwgZ2ltcGxl X2Fzc2lnbl9yaHMxIChjb25kX2RlZikpOwotICBzcmMuZ2V0X29wZXJhbmQgKGNyLCBnaW1wbGVf YXNzaWduX3JoczIgKGNvbmRfZGVmKSk7CisgIHRyZWUgcmhzMSA9IGdpbXBsZV9hc3NpZ25fcmhz MSAoY29uZF9kZWYpOworICB0cmVlIHJoczIgPSBnaW1wbGVfYXNzaWduX3JoczIgKGNvbmRfZGVm KTsKKyAgVmFsdWVfUmFuZ2UgY2wgKFRSRUVfVFlQRSAocmhzMSkpOworICBWYWx1ZV9SYW5nZSBj ciAoVFJFRV9UWVBFIChyaHMyKSk7CisgIHNyYy5nZXRfb3BlcmFuZCAoY2wsIHJoczEpOworICBz cmMuZ2V0X29wZXJhbmQgKGNyLCByaHMyKTsKIAogICB0cmVlIGNvbmRfbmFtZSA9IGMxID8gYzEg OiBjMjsKICAgZ2ltcGxlICpkZWZfc3RtdCA9IFNTQV9OQU1FX0RFRl9TVE1UIChjb25kX25hbWUp OwogCiAgIC8vIEV2YWx1YXRlIHRoZSB2YWx1ZSBvZiBDT05EX05BTUUgb24gdGhlIHRydWUgYW5k IGZhbHNlIGVkZ2VzLCB1c2luZyBlaXRoZXIKICAgLy8gdGhlIG9wMSBvciBvcDIgcm91dGluZXMg YmFzZWQgb24gaXRzIGxvY2F0aW9uLgorICBWYWx1ZV9SYW5nZSBjb25kX3RydWUgKHR5cGUpLCBj b25kX2ZhbHNlICh0eXBlKTsKICAgaWYgKGMxKQogICAgIHsKICAgICAgIGlmICghaGFuZC5vcDFf cmFuZ2UgKGNvbmRfZmFsc2UsIHR5cGUsIG1fYm9vbF96ZXJvLCBjcikpCkBAIC0xMzgwLDYgKzEz OTQsNyBAQCBnb3JpX2NvbXB1dGU6OmNvbmRleHByX2FkanVzdCAoaXJhbmdlICZyMSwgaXJhbmdl ICZyMiwgZ2ltcGxlICosIHRyZWUgY29uZCwKICAgICB9CiAKICAgIC8vIE5vdyBzb2x2ZSBmb3Ig U1NBMSBvciBTU0EyIGlmIHRoZXkgYXJlIGluIHRoZSBkZXBlbmRlbmN5IGNoYWluLgorICBWYWx1 ZV9SYW5nZSB0bXAgKHR5cGUpOwogICAgaWYgKHNzYTEgJiYgaW5fY2hhaW5fcCAoc3NhMSwgY29u ZF9uYW1lKSkKICAgICB7CiAgICAgICBpZiAoY29tcHV0ZV9vcGVyYW5kX3JhbmdlICh0bXAsIGRl Zl9zdG10LCBjb25kX3RydWUsIHNzYTEsIHNyYykpCmRpZmYgLS1naXQgYS9nY2MvZ2ltcGxlLXJh bmdlLWdvcmkuaCBiL2djYy9naW1wbGUtcmFuZ2UtZ29yaS5oCmluZGV4IDYwNTg4NGUyZTUzLi5m NWY2OTFmZTQyNCAxMDA2NDQKLS0tIGEvZ2NjL2dpbXBsZS1yYW5nZS1nb3JpLmgKKysrIGIvZ2Nj L2dpbXBsZS1yYW5nZS1nb3JpLmgKQEAgLTEyMSw3ICsxMjEsNyBAQCBwcml2YXRlOgogLy8gICBv biAqQU5ZKiBlZGdlIHRoYXQgaGFzIGJlZW4gc2Vlbi4gIEZBTFNFIGluZGljYXRlcyB0aGF0IHRo ZSBnbG9iYWwgdmFsdWUKIC8vICAgaXMgYXBwbGljYWJsZSBldmVyeXdoZXJlIHRoYXQgaGFzIGJl ZW4gcHJvY2Vzc2VkLgogLy8KLS8vIG91dGdvaW5nX2VkZ2VfcmFuZ2VfcCAoaXJhbmdlICZyYW5n ZSwgZWRnZSBlLCB0cmVlIG5hbWUpCisvLyBvdXRnb2luZ19lZGdlX3JhbmdlX3AgKHZyYW5nZSAm cmFuZ2UsIGVkZ2UgZSwgdHJlZSBuYW1lKQogLy8gICBBY3R1YWxseSBkb2VzIHRoZSBjYWxjdWxh dGlvbiBvZiBSQU5HRSBmb3IgbmFtZSBvbiBFCiAvLyAgIFRoaXMgcmVwcmVzZW50cyBhcHBsaWNh dGlvbiBvZiB3aGF0ZXZlciBzdGF0aWMgcmFuZ2UgZWZmZWN0IGVkZ2UgRQogLy8gICBtYXkgaGF2 ZSBvbiBOQU1FLCBub3QgYW55IGN1bXVsYXRpdmUgZWZmZWN0LgpAQCAtMTU3LDggKzE1Nyw4IEBA IGNsYXNzIGdvcmlfY29tcHV0ZSA6IHB1YmxpYyBnb3JpX21hcAogewogcHVibGljOgogICBnb3Jp X2NvbXB1dGUgKGludCBub3RfZXhlY3V0YWJsZV9mbGFnID0gMCk7Ci0gIGJvb2wgb3V0Z29pbmdf ZWRnZV9yYW5nZV9wIChpcmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBuYW1lLCByYW5nZV9xdWVyeSAm cSk7Ci0gIGJvb2wgY29uZGV4cHJfYWRqdXN0IChpcmFuZ2UgJnIxLCBpcmFuZ2UgJnIyLCBnaW1w bGUgKnMsIHRyZWUgY29uZCwgdHJlZSBvcDEsCisgIGJvb2wgb3V0Z29pbmdfZWRnZV9yYW5nZV9w ICh2cmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBuYW1lLCByYW5nZV9xdWVyeSAmcSk7CisgIGJvb2wg Y29uZGV4cHJfYWRqdXN0ICh2cmFuZ2UgJnIxLCB2cmFuZ2UgJnIyLCBnaW1wbGUgKnMsIHRyZWUg Y29uZCwgdHJlZSBvcDEsCiAJCQl0cmVlIG9wMiwgZnVyX3NvdXJjZSAmc3JjKTsKICAgYm9vbCBo YXNfZWRnZV9yYW5nZV9wICh0cmVlIG5hbWUsIGJhc2ljX2Jsb2NrIGJiID0gTlVMTCk7CiAgIGJv b2wgaGFzX2VkZ2VfcmFuZ2VfcCAodHJlZSBuYW1lLCBlZGdlIGUpOwpAQCAtMTY2LDI0ICsxNjYs MjQgQEAgcHVibGljOgogcHJpdmF0ZToKICAgYm9vbCBtYXlfcmVjb21wdXRlX3AgKHRyZWUgbmFt ZSwgZWRnZSBlKTsKICAgYm9vbCBtYXlfcmVjb21wdXRlX3AgKHRyZWUgbmFtZSwgYmFzaWNfYmxv Y2sgYmIgPSBOVUxMKTsKLSAgYm9vbCBjb21wdXRlX29wZXJhbmRfcmFuZ2UgKGlyYW5nZSAmciwg Z2ltcGxlICpzdG10LCBjb25zdCBpcmFuZ2UgJmxocywKKyAgYm9vbCBjb21wdXRlX29wZXJhbmRf cmFuZ2UgKHZyYW5nZSAmciwgZ2ltcGxlICpzdG10LCBjb25zdCB2cmFuZ2UgJmxocywKIAkJCSAg ICAgIHRyZWUgbmFtZSwgY2xhc3MgZnVyX3NvdXJjZSAmc3JjKTsKLSAgYm9vbCBjb21wdXRlX29w ZXJhbmRfcmFuZ2Vfc3dpdGNoIChpcmFuZ2UgJnIsIGdzd2l0Y2ggKnMsIGNvbnN0IGlyYW5nZSAm bGhzLAorICBib29sIGNvbXB1dGVfb3BlcmFuZF9yYW5nZV9zd2l0Y2ggKHZyYW5nZSAmciwgZ3N3 aXRjaCAqcywgY29uc3QgdnJhbmdlICZsaHMsCiAJCQkJICAgICB0cmVlIG5hbWUsIGZ1cl9zb3Vy Y2UgJnNyYyk7Ci0gIGJvb2wgY29tcHV0ZV9vcGVyYW5kMV9yYW5nZSAoaXJhbmdlICZyLCBnaW1w bGUgKnN0bXQsIGNvbnN0IGlyYW5nZSAmbGhzLAorICBib29sIGNvbXB1dGVfb3BlcmFuZDFfcmFu Z2UgKHZyYW5nZSAmciwgZ2ltcGxlICpzdG10LCBjb25zdCB2cmFuZ2UgJmxocywKIAkJCSAgICAg ICB0cmVlIG5hbWUsIGZ1cl9zb3VyY2UgJnNyYyk7Ci0gIGJvb2wgY29tcHV0ZV9vcGVyYW5kMl9y YW5nZSAoaXJhbmdlICZyLCBnaW1wbGUgKnN0bXQsIGNvbnN0IGlyYW5nZSAmbGhzLAorICBib29s IGNvbXB1dGVfb3BlcmFuZDJfcmFuZ2UgKHZyYW5nZSAmciwgZ2ltcGxlICpzdG10LCBjb25zdCB2 cmFuZ2UgJmxocywKIAkJCSAgICAgICB0cmVlIG5hbWUsIGZ1cl9zb3VyY2UgJnNyYyk7Ci0gIGJv b2wgY29tcHV0ZV9vcGVyYW5kMV9hbmRfb3BlcmFuZDJfcmFuZ2UgKGlyYW5nZSAmciwgZ2ltcGxl ICpzdG10LAotCQkJCQkgICAgY29uc3QgaXJhbmdlICZsaHMsIHRyZWUgbmFtZSwKKyAgYm9vbCBj b21wdXRlX29wZXJhbmQxX2FuZF9vcGVyYW5kMl9yYW5nZSAodnJhbmdlICZyLCBnaW1wbGUgKnN0 bXQsCisJCQkJCSAgICBjb25zdCB2cmFuZ2UgJmxocywgdHJlZSBuYW1lLAogCQkJCQkgICAgZnVy X3NvdXJjZSAmc3JjKTsKLSAgdm9pZCBjb21wdXRlX2xvZ2ljYWxfb3BlcmFuZHMgKGlyYW5nZSAm dHJ1ZV9yYW5nZSwgaXJhbmdlICZmYWxzZV9yYW5nZSwKKyAgdm9pZCBjb21wdXRlX2xvZ2ljYWxf b3BlcmFuZHMgKHZyYW5nZSAmdHJ1ZV9yYW5nZSwgdnJhbmdlICZmYWxzZV9yYW5nZSwKIAkJCQkg Z2ltcGxlICpzdG10LCBjb25zdCBpcmFuZ2UgJmxocywKIAkJCQkgdHJlZSBuYW1lLCBmdXJfc291 cmNlICZzcmMsIHRyZWUgb3AsCiAJCQkJIGJvb2wgb3BfaW5fY2hhaW4pOwotICBib29sIGxvZ2lj YWxfY29tYmluZSAoaXJhbmdlICZyLCBlbnVtIHRyZWVfY29kZSBjb2RlLCBjb25zdCBpcmFuZ2Ug JmxocywKLQkJCWNvbnN0IGlyYW5nZSAmb3AxX3RydWUsIGNvbnN0IGlyYW5nZSAmb3AxX2ZhbHNl LAotCQkJY29uc3QgaXJhbmdlICZvcDJfdHJ1ZSwgY29uc3QgaXJhbmdlICZvcDJfZmFsc2UpOwor ICBib29sIGxvZ2ljYWxfY29tYmluZSAodnJhbmdlICZyLCBlbnVtIHRyZWVfY29kZSBjb2RlLCBj b25zdCBpcmFuZ2UgJmxocywKKwkJCWNvbnN0IHZyYW5nZSAmb3AxX3RydWUsIGNvbnN0IHZyYW5n ZSAmb3AxX2ZhbHNlLAorCQkJY29uc3QgdnJhbmdlICZvcDJfdHJ1ZSwgY29uc3QgdnJhbmdlICZv cDJfZmFsc2UpOwogICBpbnRfcmFuZ2U8Mj4gbV9ib29sX3plcm87CS8vIEJvb2xlYW4gZmFsc2Ug Y2FjaGVkLgogICBpbnRfcmFuZ2U8Mj4gbV9ib29sX29uZTsJLy8gQm9vbGVhbiB0cnVlIGNhY2hl ZC4KIApAQCAtMTkzLDE0ICsxOTMsMTQgQEAgcHJpdmF0ZToKIH07CiAKIC8vIFRoZXNlIHJvdXRp bmVzIHByb3ZpZGUgYSBHSU1QTEUgaW50ZXJmYWNlIHRvIHRoZSByYW5nZS1vcHMgY29kZS4KLWV4 dGVybiBib29sIGdpbXBsZV9yYW5nZV9jYWxjX29wMSAoaXJhbmdlICZyLCBjb25zdCBnaW1wbGUg KnMsCi0JCQkJICAgY29uc3QgaXJhbmdlICZsaHNfcmFuZ2UpOwotZXh0ZXJuIGJvb2wgZ2ltcGxl X3JhbmdlX2NhbGNfb3AxIChpcmFuZ2UgJnIsIGNvbnN0IGdpbXBsZSAqcywKLQkJCQkgICBjb25z dCBpcmFuZ2UgJmxoc19yYW5nZSwKLQkJCQkgICBjb25zdCBpcmFuZ2UgJm9wMl9yYW5nZSk7Ci1l eHRlcm4gYm9vbCBnaW1wbGVfcmFuZ2VfY2FsY19vcDIgKGlyYW5nZSAmciwgY29uc3QgZ2ltcGxl ICpzLAotCQkJCSAgIGNvbnN0IGlyYW5nZSAmbGhzX3JhbmdlLAotCQkJCSAgIGNvbnN0IGlyYW5n ZSAmb3AxX3JhbmdlKTsKK2V4dGVybiBib29sIGdpbXBsZV9yYW5nZV9jYWxjX29wMSAodnJhbmdl ICZyLCBjb25zdCBnaW1wbGUgKnMsCisJCQkJICAgY29uc3QgdnJhbmdlICZsaHNfcmFuZ2UpOwor ZXh0ZXJuIGJvb2wgZ2ltcGxlX3JhbmdlX2NhbGNfb3AxICh2cmFuZ2UgJnIsIGNvbnN0IGdpbXBs ZSAqcywKKwkJCQkgICBjb25zdCB2cmFuZ2UgJmxoc19yYW5nZSwKKwkJCQkgICBjb25zdCB2cmFu Z2UgJm9wMl9yYW5nZSk7CitleHRlcm4gYm9vbCBnaW1wbGVfcmFuZ2VfY2FsY19vcDIgKHZyYW5n ZSAmciwgY29uc3QgZ2ltcGxlICpzLAorCQkJCSAgIGNvbnN0IHZyYW5nZSAmbGhzX3JhbmdlLAor CQkJCSAgIGNvbnN0IHZyYW5nZSAmb3AxX3JhbmdlKTsKIAogLy8gRm9yIGVhY2ggbmFtZSB0aGF0 IGlzIGFuIGltcG9ydCBpbnRvIEJCJ3MgZXhwb3J0cy4uCiAjZGVmaW5lIEZPUl9FQUNIX0dPUklf SU1QT1JUX05BTUUoZ29yaSwgYmIsIG5hbWUpCQkJXApkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1y YW5nZS1pbmZlci5jYyBiL2djYy9naW1wbGUtcmFuZ2UtaW5mZXIuY2MKaW5kZXggMTRkZGZiODAz ZDguLmVlZTE0OTEwNGI0IDEwMDY0NAotLS0gYS9nY2MvZ2ltcGxlLXJhbmdlLWluZmVyLmNjCisr KyBiL2djYy9naW1wbGUtcmFuZ2UtaW5mZXIuY2MKQEAgLTU4LDcgKzU4LDcgQEAgbm9uX251bGxf bG9hZHN0b3JlIChnaW1wbGUgKiwgdHJlZSBvcCwgdHJlZSwgdm9pZCAqZGF0YSkKIC8vIEFkZCBO QU1FIGFuZCBSQU5HRSB0byB0aGUgdGhlIHJhbmdlIGluZmVyZW5jZSBzdW1tYXJ5LgogCiB2b2lk Ci1naW1wbGVfaW5mZXJfcmFuZ2U6OmFkZF9yYW5nZSAodHJlZSBuYW1lLCBpcmFuZ2UgJnJhbmdl KQorZ2ltcGxlX2luZmVyX3JhbmdlOjphZGRfcmFuZ2UgKHRyZWUgbmFtZSwgdnJhbmdlICZyYW5n ZSkKIHsKICAgbV9uYW1lc1tudW1fYXJnc10gPSBuYW1lOwogICBtX3Jhbmdlc1tudW1fYXJnc10g PSByYW5nZTsKQEAgLTEyNiw3ICsxMjYsNyBAQCBjbGFzcyBleGl0X3JhbmdlCiB7CiBwdWJsaWM6 CiAgIHRyZWUgbmFtZTsKLSAgaXJhbmdlICpyYW5nZTsKKyAgdnJhbmdlICpyYW5nZTsKICAgZXhp dF9yYW5nZSAqbmV4dDsKIH07CiAKQEAgLTE4MSw3ICsxODEsNyBAQCBpbmZlcl9yYW5nZV9tYW5h Z2VyOjp+aW5mZXJfcmFuZ2VfbWFuYWdlciAoKQogLy8gUmV0dXJuIGEgbm9uLXplcm8gcmFuZ2Ug dmFsdWUgb2YgdGhlIGFwcHJvcHJpYXRlIHR5cGUgZm9yIE5BTUUgZnJvbQogLy8gdGhlIGNhY2hl LCBjcmVhdGluZyBpdCBpZiBuZWNlc3NhcnkuCiAKLWNvbnN0IGlyYW5nZSYKK2NvbnN0IHZyYW5n ZSYKIGluZmVyX3JhbmdlX21hbmFnZXI6OmdldF9ub256ZXJvICh0cmVlIG5hbWUpCiB7CiAgIHVu c2lnbmVkIHYgPSBTU0FfTkFNRV9WRVJTSU9OIChuYW1lKTsKQEAgLTE4OSwxMCArMTg5LDggQEAg aW5mZXJfcmFuZ2VfbWFuYWdlcjo6Z2V0X25vbnplcm8gKHRyZWUgbmFtZSkKICAgICBtX25vbnpl cm8uc2FmZV9ncm93X2NsZWFyZWQgKG51bV9zc2FfbmFtZXMgKyAyMCk7CiAgIGlmICghbV9ub256 ZXJvW3ZdKQogICAgIHsKLSAgICAgIHRyZWUgdHlwZSA9IFRSRUVfVFlQRSAobmFtZSk7Ci0gICAg ICBtX25vbnplcm9bdl0KLQk9IHN0YXRpY19jYXN0IDxpcmFuZ2UgKj4gKG1fcmFuZ2VfYWxsb2Nh dG9yLmFsbG9jX3ZyYW5nZSAodHlwZSkpOwotICAgICAgbV9ub256ZXJvW3ZdLT5zZXRfbm9uemVy byAodHlwZSk7CisgICAgICBtX25vbnplcm9bdl0gPSBtX3JhbmdlX2FsbG9jYXRvci5hbGxvY192 cmFuZ2UgKFRSRUVfVFlQRSAobmFtZSkpOworICAgICAgbV9ub256ZXJvW3ZdLT5zZXRfbm9uemVy byAoVFJFRV9UWVBFIChuYW1lKSk7CiAgICAgfQogICByZXR1cm4gKihtX25vbnplcm9bdl0pOwog fQpAQCAtMjE5LDcgKzIxNyw3IEBAIGluZmVyX3JhbmdlX21hbmFnZXI6Omhhc19yYW5nZV9wICh0 cmVlIG5hbWUsIGJhc2ljX2Jsb2NrIGJiKQogLy8gdG8gaW5jbHVkZSBpdC4KIAogYm9vbAotaW5m ZXJfcmFuZ2VfbWFuYWdlcjo6bWF5YmVfYWRqdXN0X3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgbmFt ZSwgYmFzaWNfYmxvY2sgYmIpCitpbmZlcl9yYW5nZV9tYW5hZ2VyOjptYXliZV9hZGp1c3RfcmFu Z2UgKHZyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYikKIHsKICAgaWYgKCFoYXNf cmFuZ2VfcCAobmFtZSwgYmIpKQogICAgIHJldHVybiBmYWxzZTsKQEAgLTIzMiw3ICsyMzAsNyBA QCBpbmZlcl9yYW5nZV9tYW5hZ2VyOjptYXliZV9hZGp1c3RfcmFuZ2UgKGlyYW5nZSAmciwgdHJl ZSBuYW1lLCBiYXNpY19ibG9jayBiYikKIC8vIEFkZCByYW5nZSBSIGFzIGFuIGluZmVycmVkIHJh bmdlIGZvciBOQU1FIGluIGJsb2NrIEJCLgogCiB2b2lkCi1pbmZlcl9yYW5nZV9tYW5hZ2VyOjph ZGRfcmFuZ2UgKHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sgYmIsIGNvbnN0IGlyYW5nZSAmcikKK2lu ZmVyX3JhbmdlX21hbmFnZXI6OmFkZF9yYW5nZSAodHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYiwg Y29uc3QgdnJhbmdlICZyKQogewogICBpZiAoYmItPmluZGV4ID49IChpbnQpbV9vbl9leGl0Lmxl bmd0aCAoKSkKICAgICBtX29uX2V4aXQuc2FmZV9ncm93X2NsZWFyZWQgKGxhc3RfYmFzaWNfYmxv Y2tfZm9yX2ZuIChjZnVuKSArIDEpOwpAQCAtMjU0LDcgKzI1Miw3IEBAIGluZmVyX3JhbmdlX21h bmFnZXI6OmFkZF9yYW5nZSAodHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYiwgY29uc3QgaXJhbmdl ICZyKQogICBleGl0X3JhbmdlICpwdHIgPSBtX29uX2V4aXRbYmItPmluZGV4XS5maW5kX3B0ciAo bmFtZSk7CiAgIGlmIChwdHIpCiAgICAgewotICAgICAgaW50X3JhbmdlX21heCBjdXIgPSByOwor ICAgICAgVmFsdWVfUmFuZ2UgY3VyIChyKTsKICAgICAgIC8vIElmIG5vIG5ldyBpbmZvIGlzIGFk ZGVkLCBqdXN0IHJldHVybi4KICAgICAgIGlmICghY3VyLmludGVyc2VjdCAoKihwdHItPnJhbmdl KSkpCiAJcmV0dXJuOwpAQCAtMjYzLDcgKzI2MSw3IEBAIGluZmVyX3JhbmdlX21hbmFnZXI6OmFk ZF9yYW5nZSAodHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYiwgY29uc3QgaXJhbmdlICZyKQogICAg ICAgZWxzZQogCXsKIAkgIHZyYW5nZSAmdiA9IGN1cjsKLQkgIHB0ci0+cmFuZ2UgPSBzdGF0aWNf Y2FzdCA8aXJhbmdlICo+IChtX3JhbmdlX2FsbG9jYXRvci5jbG9uZSAodikpOworCSAgcHRyLT5y YW5nZSA9IG1fcmFuZ2VfYWxsb2NhdG9yLmNsb25lICh2KTsKIAl9CiAgICAgICByZXR1cm47CiAg ICAgfQpkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1yYW5nZS1pbmZlci5oIGIvZ2NjL2dpbXBsZS1y YW5nZS1pbmZlci5oCmluZGV4IDY1ZjZlODM4MDlkLi5hYWZhOGJiNzRmMCAxMDA2NDQKLS0tIGEv Z2NjL2dpbXBsZS1yYW5nZS1pbmZlci5oCisrKyBiL2djYy9naW1wbGUtcmFuZ2UtaW5mZXIuaApA QCAtMzUsMTUgKzM1LDE1IEBAIHB1YmxpYzoKICAgaW5saW5lIHVuc2lnbmVkIG51bSAoKSBjb25z dCB7IHJldHVybiBudW1fYXJnczsgfQogICBpbmxpbmUgdHJlZSBuYW1lICh1bnNpZ25lZCBpbmRl eCkgY29uc3QKICAgICB7IGdjY19jaGVja2luZ19hc3NlcnQgKGluZGV4IDwgbnVtX2FyZ3MpOyBy ZXR1cm4gbV9uYW1lc1tpbmRleF07IH0KLSAgaW5saW5lIGNvbnN0IGlyYW5nZSYgcmFuZ2UgKHVu c2lnbmVkIGluZGV4KSBjb25zdAorICBpbmxpbmUgY29uc3QgdnJhbmdlJiByYW5nZSAodW5zaWdu ZWQgaW5kZXgpIGNvbnN0CiAgICAgeyBnY2NfY2hlY2tpbmdfYXNzZXJ0IChpbmRleCA8IG51bV9h cmdzKTsgcmV0dXJuIG1fcmFuZ2VzW2luZGV4XTsgfQotICB2b2lkIGFkZF9yYW5nZSAodHJlZSBu YW1lLCBpcmFuZ2UgJnJhbmdlKTsKKyAgdm9pZCBhZGRfcmFuZ2UgKHRyZWUgbmFtZSwgdnJhbmdl ICZyYW5nZSk7CiAgIHZvaWQgYWRkX25vbnplcm8gKHRyZWUgbmFtZSk7CiBwcml2YXRlOgogICB1 bnNpZ25lZCBudW1fYXJnczsKICAgc3RhdGljIGNvbnN0IGludCBzaXplX2xpbWl0ID0gMTA7CiAg IHRyZWUgbV9uYW1lc1tzaXplX2xpbWl0XTsKLSAgaW50X3JhbmdlPDM+IG1fcmFuZ2VzW3NpemVf bGltaXRdOworICBWYWx1ZV9SYW5nZSBtX3Jhbmdlc1tzaXplX2xpbWl0XTsKICAgaW5saW5lIHZv aWQgYnVtcF9pbmRleCAoKSB7IGlmIChudW1fYXJncyA8IHNpemVfbGltaXQgLSAxKSBudW1fYXJn cysrOyB9CiB9OwogCkBAIC01OCwxMCArNTgsMTAgQEAgY2xhc3MgaW5mZXJfcmFuZ2VfbWFuYWdl cgogcHVibGljOgogICBpbmZlcl9yYW5nZV9tYW5hZ2VyIChib29sIGRvX3NlYXJjaCk7CiAgIH5p bmZlcl9yYW5nZV9tYW5hZ2VyICgpOwotICB2b2lkIGFkZF9yYW5nZSAodHJlZSBuYW1lLCBiYXNp Y19ibG9jayBiYiwgY29uc3QgaXJhbmdlICZyKTsKKyAgdm9pZCBhZGRfcmFuZ2UgKHRyZWUgbmFt ZSwgYmFzaWNfYmxvY2sgYmIsIGNvbnN0IHZyYW5nZSAmcik7CiAgIHZvaWQgYWRkX25vbnplcm8g KHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sgYmIpOwogICBib29sIGhhc19yYW5nZV9wICh0cmVlIG5h bWUsIGJhc2ljX2Jsb2NrIGJiKTsKLSAgYm9vbCBtYXliZV9hZGp1c3RfcmFuZ2UgKGlyYW5nZSAm ciwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYik7CisgIGJvb2wgbWF5YmVfYWRqdXN0X3Jhbmdl ICh2cmFuZ2UgJnIsIHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sgYmIpOwogcHJpdmF0ZToKICAgY2xh c3MgZXhpdF9yYW5nZV9oZWFkCiAgIHsKQEAgLTczLDggKzczLDggQEAgcHJpdmF0ZToKICAgfTsK ICAgdm9pZCByZWdpc3Rlcl9hbGxfdXNlcyAodHJlZSBuYW1lKTsKICAgdmVjIDxleGl0X3Jhbmdl X2hlYWQ+IG1fb25fZXhpdDsKLSAgY29uc3QgaXJhbmdlICZnZXRfbm9uemVybyAodHJlZSBuYW1l KTsKLSAgdmVjIDxpcmFuZ2UgKj4gbV9ub256ZXJvOworICBjb25zdCB2cmFuZ2UgJmdldF9ub256 ZXJvICh0cmVlIG5hbWUpOworICB2ZWMgPHZyYW5nZSAqPiBtX25vbnplcm87CiAgIGJpdG1hcCBt X3NlZW47CiAgIGJpdG1hcF9vYnN0YWNrIG1fYml0bWFwczsKICAgc3RydWN0IG9ic3RhY2sgbV9s aXN0X29ic3RhY2s7CmRpZmYgLS1naXQgYS9nY2MvZ2ltcGxlLXJhbmdlLXBhdGguY2MgYi9nY2Mv Z2ltcGxlLXJhbmdlLXBhdGguY2MKaW5kZXggNjZmNDMzZGQxZDUuLmY4YWU2ZmI5ZmZiIDEwMDY0 NAotLS0gYS9nY2MvZ2ltcGxlLXJhbmdlLXBhdGguY2MKKysrIGIvZ2NjL2dpbXBsZS1yYW5nZS1w YXRoLmNjCkBAIC04Myw3ICs4Myw3IEBAIHBhdGhfcmFuZ2VfcXVlcnk6OmNsZWFyX2NhY2hlICh0 cmVlIG5hbWUpCiAvLyBJZiBOQU1FIGhhcyBhIGNhY2hlIGVudHJ5LCByZXR1cm4gaXQgaW4gUiwg YW5kIHJldHVybiBUUlVFLgogCiBpbmxpbmUgYm9vbAotcGF0aF9yYW5nZV9xdWVyeTo6Z2V0X2Nh Y2hlIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSkKK3BhdGhfcmFuZ2VfcXVlcnk6OmdldF9jYWNoZSAo dnJhbmdlICZyLCB0cmVlIG5hbWUpCiB7CiAgIGlmICghZ2ltcGxlX3JhbmdlX3NzYV9wIChuYW1l KSkKICAgICByZXR1cm4gZ2V0X2dsb2JhbF9yYW5nZV9xdWVyeSAoKS0+cmFuZ2Vfb2ZfZXhwciAo ciwgbmFtZSk7CkBAIC05OCw3ICs5OCw3IEBAIHBhdGhfcmFuZ2VfcXVlcnk6OmdldF9jYWNoZSAo aXJhbmdlICZyLCB0cmVlIG5hbWUpCiAvLyBTZXQgdGhlIGNhY2hlIGVudHJ5IGZvciBOQU1FIHRv IFIuCiAKIHZvaWQKLXBhdGhfcmFuZ2VfcXVlcnk6OnNldF9jYWNoZSAoY29uc3QgaXJhbmdlICZy LCB0cmVlIG5hbWUpCitwYXRoX3JhbmdlX3F1ZXJ5OjpzZXRfY2FjaGUgKGNvbnN0IHZyYW5nZSAm ciwgdHJlZSBuYW1lKQogewogICB1bnNpZ25lZCB2ID0gU1NBX05BTUVfVkVSU0lPTiAobmFtZSk7 CiAgIGJpdG1hcF9zZXRfYml0IChtX2hhc19jYWNoZV9lbnRyeSwgdik7CkBAIC0xNDksNyArMTQ5 LDcgQEAgcGF0aF9yYW5nZV9xdWVyeTo6ZGVmaW5lZF9vdXRzaWRlX3BhdGggKHRyZWUgbmFtZSkK IC8vIFJldHVybiB0aGUgcmFuZ2Ugb2YgTkFNRSBvbiBlbnRyeSB0byB0aGUgcGF0aC4KIAogdm9p ZAotcGF0aF9yYW5nZV9xdWVyeTo6cmFuZ2Vfb25fcGF0aF9lbnRyeSAoaXJhbmdlICZyLCB0cmVl IG5hbWUpCitwYXRoX3JhbmdlX3F1ZXJ5OjpyYW5nZV9vbl9wYXRoX2VudHJ5ICh2cmFuZ2UgJnIs IHRyZWUgbmFtZSkKIHsKICAgZ2NjX2NoZWNraW5nX2Fzc2VydCAoZGVmaW5lZF9vdXRzaWRlX3Bh dGggKG5hbWUpKTsKICAgYmFzaWNfYmxvY2sgZW50cnkgPSBlbnRyeV9iYiAoKTsKQEAgLTE2OCw3 ICsxNjgsNyBAQCBwYXRoX3JhbmdlX3F1ZXJ5OjpyYW5nZV9vbl9wYXRoX2VudHJ5IChpcmFuZ2Ug JnIsIHRyZWUgbmFtZSkKICAgLy8gYmxvY2suICBUaGlzIGNhbiBoYXBwZW4gd2hlbiB3ZSdyZSBx dWVyeWluZyBhIGJsb2NrIHdpdGggb25seSBhbgogICAvLyBvdXRnb2luZyBlZGdlIChubyBzdGF0 ZW1lbnQgYnV0IHRoZSBmYWxsIHRocm91Z2ggZWRnZSksIGJ1dCBmb3IKICAgLy8gd2hpY2ggd2Ug Y2FuIGRldGVybWluZSBhIHJhbmdlIG9uIGVudHJ5IHRvIHRoZSBibG9jay4KLSAgaW50X3Jhbmdl X21heCB0bXA7CisgIFZhbHVlX1JhbmdlIHRtcCAoVFJFRV9UWVBFIChuYW1lKSk7CiAgIGJvb2wg Y2hhbmdlZCA9IGZhbHNlOwogICByLnNldF91bmRlZmluZWQgKCk7CiAgIGZvciAodW5zaWduZWQg aSA9IDA7IGkgPCBFREdFX0NPVU5UIChlbnRyeS0+cHJlZHMpOyArK2kpCkBAIC0xOTAsOSArMTkw LDkgQEAgcGF0aF9yYW5nZV9xdWVyeTo6cmFuZ2Vfb25fcGF0aF9lbnRyeSAoaXJhbmdlICZyLCB0 cmVlIG5hbWUpCiAvLyBSZXR1cm4gdGhlIHJhbmdlIG9mIE5BTUUgYXQgdGhlIGVuZCBvZiB0aGUg cGF0aCBiZWluZyBhbmFseXplZC4KIAogYm9vbAotcGF0aF9yYW5nZV9xdWVyeTo6aW50ZXJuYWxf cmFuZ2Vfb2ZfZXhwciAoaXJhbmdlICZyLCB0cmVlIG5hbWUsIGdpbXBsZSAqc3RtdCkKK3BhdGhf cmFuZ2VfcXVlcnk6OmludGVybmFsX3JhbmdlX29mX2V4cHIgKHZyYW5nZSAmciwgdHJlZSBuYW1l LCBnaW1wbGUgKnN0bXQpCiB7Ci0gIGlmICghaXJhbmdlOjpzdXBwb3J0c190eXBlX3AgKFRSRUVf VFlQRSAobmFtZSkpKQorICBpZiAoIXZyYW5nZTo6c3VwcG9ydHNfdHlwZV9wIChUUkVFX1RZUEUg KG5hbWUpKSkKICAgICByZXR1cm4gZmFsc2U7CiAKICAgaWYgKGdldF9jYWNoZSAociwgbmFtZSkp CkBAIC0yMDksMTggKzIwOSwyMiBAQCBwYXRoX3JhbmdlX3F1ZXJ5OjppbnRlcm5hbF9yYW5nZV9v Zl9leHByIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSwgZ2ltcGxlICpzdG10KQogICAgICAgJiYgcmFu Z2VfZGVmaW5lZF9pbl9ibG9jayAociwgbmFtZSwgZ2ltcGxlX2JiIChzdG10KSkpCiAgICAgewog ICAgICAgaWYgKFRSRUVfQ09ERSAobmFtZSkgPT0gU1NBX05BTUUpCi0Jci5pbnRlcnNlY3QgKGdp bXBsZV9yYW5nZV9nbG9iYWwgKG5hbWUpKTsKKwl7CisJICBWYWx1ZV9SYW5nZSBnbG9iIChUUkVF X1RZUEUgKG5hbWUpKTsKKwkgIGdpbXBsZV9yYW5nZV9nbG9iYWwgKGdsb2IsIG5hbWUpOworCSAg ci5pbnRlcnNlY3QgKGdsb2IpOworCX0KIAogICAgICAgc2V0X2NhY2hlIChyLCBuYW1lKTsKICAg ICAgIHJldHVybiB0cnVlOwogICAgIH0KIAotICByID0gZ2ltcGxlX3JhbmdlX2dsb2JhbCAobmFt ZSk7CisgIGdpbXBsZV9yYW5nZV9nbG9iYWwgKHIsIG5hbWUpOwogICByZXR1cm4gdHJ1ZTsKIH0K IAogYm9vbAotcGF0aF9yYW5nZV9xdWVyeTo6cmFuZ2Vfb2ZfZXhwciAoaXJhbmdlICZyLCB0cmVl IG5hbWUsIGdpbXBsZSAqc3RtdCkKK3BhdGhfcmFuZ2VfcXVlcnk6OnJhbmdlX29mX2V4cHIgKHZy YW5nZSAmciwgdHJlZSBuYW1lLCBnaW1wbGUgKnN0bXQpCiB7CiAgIGlmIChpbnRlcm5hbF9yYW5n ZV9vZl9leHByIChyLCBuYW1lLCBzdG10KSkKICAgICB7CkBAIC0yNjksNyArMjczLDcgQEAgcGF0 aF9yYW5nZV9xdWVyeTo6c3NhX2RlZmluZWRfaW5fYmIgKHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sg YmIpCiAvLyBjYWxjdWxhdGluZyB0aGUgUEhJJ3MgcmFuZ2UgbXVzdCBub3QgdHJpZ2dlciBhZGRp dGlvbmFsIGxvb2t1cHMuCiAKIHZvaWQKLXBhdGhfcmFuZ2VfcXVlcnk6OnNzYV9yYW5nZV9pbl9w aGkgKGlyYW5nZSAmciwgZ3BoaSAqcGhpKQorcGF0aF9yYW5nZV9xdWVyeTo6c3NhX3JhbmdlX2lu X3BoaSAodnJhbmdlICZyLCBncGhpICpwaGkpCiB7CiAgIHRyZWUgbmFtZSA9IGdpbXBsZV9waGlf cmVzdWx0IChwaGkpOwogICBiYXNpY19ibG9jayBiYiA9IGdpbXBsZV9iYiAocGhpKTsKQEAgLTI4 Myw3ICsyODcsNyBAQCBwYXRoX3JhbmdlX3F1ZXJ5Ojpzc2FfcmFuZ2VfaW5fcGhpIChpcmFuZ2Ug JnIsIGdwaGkgKnBoaSkKICAgICAgIC8vIFRyeSB0byBmb2xkIHRoZSBwaGkgZXhjbHVzaXZlbHkg d2l0aCBnbG9iYWwgb3IgY2FjaGVkIHZhbHVlcy4KICAgICAgIC8vIFRoaXMgd2lsbCBnZXQgdGhp bmdzIGxpa2UgUEhJIDw1KDk5KSwgNig4OCk+LiAgV2UgZG8gdGhpcyBieQogICAgICAgLy8gY2Fs bGluZyByYW5nZV9vZl9leHByIHdpdGggbm8gY29udGV4dC4KLSAgICAgIGludF9yYW5nZV9tYXgg YXJnX3JhbmdlOworICAgICAgVmFsdWVfUmFuZ2UgYXJnX3JhbmdlIChUUkVFX1RZUEUgKG5hbWUp KTsKICAgICAgIHIuc2V0X3VuZGVmaW5lZCAoKTsKICAgICAgIGZvciAoc2l6ZV90IGkgPSAwOyBp IDwgbmFyZ3M7ICsraSkKIAl7CkBAIC0zMTIsNyArMzE2LDcgQEAgcGF0aF9yYW5nZV9xdWVyeTo6 c3NhX3JhbmdlX2luX3BoaSAoaXJhbmdlICZyLCBncGhpICpwaGkpCiAJICB7CiAJICAgIGlmICht X3Jlc29sdmUpCiAJICAgICAgewotCQlpbnRfcmFuZ2VfbWF4IHRtcDsKKwkJVmFsdWVfUmFuZ2Ug dG1wIChUUkVFX1RZUEUgKG5hbWUpKTsKIAkJLy8gVXNpbmcgYm90aCB0aGUgcmFuZ2Ugb24gZW50 cnkgdG8gdGhlIHBhdGgsIGFuZCB0aGUKIAkJLy8gcmFuZ2Ugb24gdGhpcyBlZGdlIHlpZWxkcyBz aWduaWZpY2FudGx5IGJldHRlcgogCQkvLyByZXN1bHRzLgpAQCAtMzM1LDcgKzMzOSw3IEBAIHBh dGhfcmFuZ2VfcXVlcnk6OnNzYV9yYW5nZV9pbl9waGkgKGlyYW5nZSAmciwgZ3BoaSAqcGhpKQog Ly8gVFJVRS4gIE90aGVyd2lzZSwgcmV0dXJuIEZBTFNFLgogCiBib29sCi1wYXRoX3JhbmdlX3F1 ZXJ5OjpyYW5nZV9kZWZpbmVkX2luX2Jsb2NrIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSwgYmFzaWNf YmxvY2sgYmIpCitwYXRoX3JhbmdlX3F1ZXJ5OjpyYW5nZV9kZWZpbmVkX2luX2Jsb2NrICh2cmFu Z2UgJnIsIHRyZWUgbmFtZSwgYmFzaWNfYmxvY2sgYmIpCiB7CiAgIGdpbXBsZSAqZGVmX3N0bXQg PSBTU0FfTkFNRV9ERUZfU1RNVCAobmFtZSk7CiAgIGJhc2ljX2Jsb2NrIGRlZl9iYiA9IGdpbXBs ZV9iYiAoZGVmX3N0bXQpOwpAQCAtMzc3LDcgKzM4MSw2IEBAIHBhdGhfcmFuZ2VfcXVlcnk6OnJh bmdlX2RlZmluZWRfaW5fYmxvY2sgKGlyYW5nZSAmciwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBi YikKIHZvaWQKIHBhdGhfcmFuZ2VfcXVlcnk6OmNvbXB1dGVfcmFuZ2VzX2luX3BoaXMgKGJhc2lj X2Jsb2NrIGJiKQogewotICBpbnRfcmFuZ2VfbWF4IHI7CiAgIGF1dG9fYml0bWFwIHBoaV9zZXQ7 CiAKICAgLy8gUEhJcyBtdXN0IGJlIHJlc29sdmVkIHNpbXVsdGFuZW91c2x5IG9uIGVudHJ5IHRv IHRoZSBibG9jawpAQCAtMzkwLDcgKzM5MywxMSBAQCBwYXRoX3JhbmdlX3F1ZXJ5Ojpjb21wdXRl X3Jhbmdlc19pbl9waGlzIChiYXNpY19ibG9jayBiYikKICAgICAgIGdwaGkgKnBoaSA9IGl0ZXIu cGhpICgpOwogICAgICAgdHJlZSBuYW1lID0gZ2ltcGxlX3BoaV9yZXN1bHQgKHBoaSk7CiAKLSAg ICAgIGlmIChpbXBvcnRfcCAobmFtZSkgJiYgcmFuZ2VfZGVmaW5lZF9pbl9ibG9jayAociwgbmFt ZSwgYmIpKQorICAgICAgaWYgKCFpbXBvcnRfcCAobmFtZSkpCisJY29udGludWU7CisKKyAgICAg IFZhbHVlX1JhbmdlIHIgKFRSRUVfVFlQRSAobmFtZSkpOworICAgICAgaWYgKHJhbmdlX2RlZmlu ZWRfaW5fYmxvY2sgKHIsIG5hbWUsIGJiKSkKIAl7CiAJICB1bnNpZ25lZCB2ID0gU1NBX05BTUVf VkVSU0lPTiAobmFtZSk7CiAJICBzZXRfY2FjaGUgKHIsIG5hbWUpOwpAQCAtNDIzLDcgKzQzMCw2 IEBAIHZvaWQKIHBhdGhfcmFuZ2VfcXVlcnk6OmNvbXB1dGVfcmFuZ2VzX2luX2Jsb2NrIChiYXNp Y19ibG9jayBiYikKIHsKICAgYml0bWFwX2l0ZXJhdG9yIGJpOwotICBpbnRfcmFuZ2VfbWF4IHIs IGNhY2hlZF9yYW5nZTsKICAgdW5zaWduZWQgaTsKIAogICBpZiAobV9yZXNvbHZlICYmICFhdF9l bnRyeSAoKSkKQEAgLTQ0NCw2ICs0NTAsNyBAQCBwYXRoX3JhbmdlX3F1ZXJ5Ojpjb21wdXRlX3Jh bmdlc19pbl9ibG9jayAoYmFzaWNfYmxvY2sgYmIpCiAgIEVYRUNVVEVfSUZfU0VUX0lOX0JJVE1B UCAobV9pbXBvcnRzLCAwLCBpLCBiaSkKICAgICB7CiAgICAgICB0cmVlIG5hbWUgPSBzc2FfbmFt ZSAoaSk7CisgICAgICBWYWx1ZV9SYW5nZSByIChUUkVFX1RZUEUgKG5hbWUpKTsKIAogICAgICAg aWYgKGdpbXBsZV9jb2RlIChTU0FfTkFNRV9ERUZfU1RNVCAobmFtZSkpICE9IEdJTVBMRV9QSEkK IAkgICYmIHJhbmdlX2RlZmluZWRfaW5fYmxvY2sgKHIsIG5hbWUsIGJiKSkKQEAgLTQ4MCw4ICs0 ODcsMTAgQEAgcGF0aF9yYW5nZV9xdWVyeTo6Y29tcHV0ZV9yYW5nZXNfaW5fYmxvY2sgKGJhc2lj X2Jsb2NrIGJiKQogCiAgICAgICBpZiAoYml0bWFwX2JpdF9wIChleHBvcnRzLCBpKSkKIAl7CisJ ICBWYWx1ZV9SYW5nZSByIChUUkVFX1RZUEUgKG5hbWUpKTsKIAkgIGlmIChnLm91dGdvaW5nX2Vk Z2VfcmFuZ2VfcCAociwgZSwgbmFtZSwgKnRoaXMpKQogCSAgICB7CisJICAgICAgVmFsdWVfUmFu Z2UgY2FjaGVkX3JhbmdlIChUUkVFX1RZUEUgKG5hbWUpKTsKIAkgICAgICBpZiAoZ2V0X2NhY2hl IChjYWNoZWRfcmFuZ2UsIG5hbWUpKQogCQlyLmludGVyc2VjdCAoY2FjaGVkX3JhbmdlKTsKIApA QCAtNTM5LDcgKzU0OCw3IEBAIGJvb2wKIHBhdGhfcmFuZ2VfcXVlcnk6OmFkZF90b19pbXBvcnRz ICh0cmVlIG5hbWUsIGJpdG1hcCBpbXBvcnRzKQogewogICBpZiAoVFJFRV9DT0RFIChuYW1lKSA9 PSBTU0FfTkFNRQotICAgICAgJiYgaXJhbmdlOjpzdXBwb3J0c190eXBlX3AgKFRSRUVfVFlQRSAo bmFtZSkpKQorICAgICAgJiYgdnJhbmdlOjpzdXBwb3J0c190eXBlX3AgKFRSRUVfVFlQRSAobmFt ZSkpKQogICAgIHJldHVybiBiaXRtYXBfc2V0X2JpdCAoaW1wb3J0cywgU1NBX05BTUVfVkVSU0lP TiAobmFtZSkpOwogICByZXR1cm4gZmFsc2U7CiB9CkBAIC03NTEsMTEgKzc2MCwxMSBAQCBqdF9m dXJfc291cmNlOjpxdWVyeV9yZWxhdGlvbiAodHJlZSBvcDEsIHRyZWUgb3AyKQogLy8gUmV0dXJu IHRoZSByYW5nZSBvZiBTVE1UIGF0IHRoZSBlbmQgb2YgdGhlIHBhdGggYmVpbmcgYW5hbHl6ZWQu CiAKIGJvb2wKLXBhdGhfcmFuZ2VfcXVlcnk6OnJhbmdlX29mX3N0bXQgKGlyYW5nZSAmciwgZ2lt cGxlICpzdG10LCB0cmVlKQorcGF0aF9yYW5nZV9xdWVyeTo6cmFuZ2Vfb2Zfc3RtdCAodnJhbmdl ICZyLCBnaW1wbGUgKnN0bXQsIHRyZWUpCiB7CiAgIHRyZWUgdHlwZSA9IGdpbXBsZV9yYW5nZV90 eXBlIChzdG10KTsKIAotICBpZiAoIXR5cGUgfHwgIWlyYW5nZTo6c3VwcG9ydHNfdHlwZV9wICh0 eXBlKSkKKyAgaWYgKCF0eXBlIHx8ICF2cmFuZ2U6OnN1cHBvcnRzX3R5cGVfcCAodHlwZSkpCiAg ICAgcmV0dXJuIGZhbHNlOwogCiAgIC8vIElmIHJlc29sdmluZyB1bmtub3ducywgZm9sZCB0aGUg c3RhdGVtZW50IG1ha2luZyB1c2Ugb2YgYW55CmRpZmYgLS1naXQgYS9nY2MvZ2ltcGxlLXJhbmdl LXBhdGguaCBiL2djYy9naW1wbGUtcmFuZ2UtcGF0aC5oCmluZGV4IDkxNDk4M2JiMGFhLi4yYzQ2 MjRlNGNlZiAxMDA2NDQKLS0tIGEvZ2NjL2dpbXBsZS1yYW5nZS1wYXRoLmgKKysrIGIvZ2NjL2dp bXBsZS1yYW5nZS1wYXRoLmgKQEAgLTM4LDI5ICszOCwyOSBAQCBwdWJsaWM6CiAJCSAgICAgICBj b25zdCBiaXRtYXBfaGVhZCAqaW1wb3J0cyA9IE5VTEwpOwogICB2b2lkIGNvbXB1dGVfcmFuZ2Vz IChlZGdlIGUpOwogICB2b2lkIGNvbXB1dGVfaW1wb3J0cyAoYml0bWFwIGltcG9ydHMsIGJhc2lj X2Jsb2NrIGV4aXQpOwotICBib29sIHJhbmdlX29mX2V4cHIgKGlyYW5nZSAmciwgdHJlZSBuYW1l LCBnaW1wbGUgKiA9IE5VTEwpIG92ZXJyaWRlOwotICBib29sIHJhbmdlX29mX3N0bXQgKGlyYW5n ZSAmciwgZ2ltcGxlICosIHRyZWUgbmFtZSA9IE5VTEwpIG92ZXJyaWRlOworICBib29sIHJhbmdl X29mX2V4cHIgKHZyYW5nZSAmciwgdHJlZSBuYW1lLCBnaW1wbGUgKiA9IE5VTEwpIG92ZXJyaWRl OworICBib29sIHJhbmdlX29mX3N0bXQgKHZyYW5nZSAmciwgZ2ltcGxlICosIHRyZWUgbmFtZSA9 IE5VTEwpIG92ZXJyaWRlOwogICBib29sIHVucmVhY2hhYmxlX3BhdGhfcCAoKTsKICAgdm9pZCBk dW1wIChGSUxFICopIG92ZXJyaWRlOwogICB2b2lkIGRlYnVnICgpOwogCiBwcml2YXRlOgotICBi b29sIGludGVybmFsX3JhbmdlX29mX2V4cHIgKGlyYW5nZSAmciwgdHJlZSBuYW1lLCBnaW1wbGUg Kik7CisgIGJvb2wgaW50ZXJuYWxfcmFuZ2Vfb2ZfZXhwciAodnJhbmdlICZyLCB0cmVlIG5hbWUs IGdpbXBsZSAqKTsKICAgYm9vbCBkZWZpbmVkX291dHNpZGVfcGF0aCAodHJlZSBuYW1lKTsKLSAg dm9pZCByYW5nZV9vbl9wYXRoX2VudHJ5IChpcmFuZ2UgJnIsIHRyZWUgbmFtZSk7CisgIHZvaWQg cmFuZ2Vfb25fcGF0aF9lbnRyeSAodnJhbmdlICZyLCB0cmVlIG5hbWUpOwogICBwYXRoX29yYWNs ZSAqZ2V0X3BhdGhfb3JhY2xlICgpIHsgcmV0dXJuIChwYXRoX29yYWNsZSAqKW1fb3JhY2xlOyB9 CiAKICAgLy8gQ2FjaGUgbWFuaXB1bGF0aW9uLgotICB2b2lkIHNldF9jYWNoZSAoY29uc3QgaXJh bmdlICZyLCB0cmVlIG5hbWUpOwotICBib29sIGdldF9jYWNoZSAoaXJhbmdlICZyLCB0cmVlIG5h bWUpOworICB2b2lkIHNldF9jYWNoZSAoY29uc3QgdnJhbmdlICZyLCB0cmVlIG5hbWUpOworICBi b29sIGdldF9jYWNoZSAodnJhbmdlICZyLCB0cmVlIG5hbWUpOwogICB2b2lkIGNsZWFyX2NhY2hl ICh0cmVlIG5hbWUpOwogCiAgIC8vIE1ldGhvZHMgdG8gY29tcHV0ZSByYW5nZXMgZm9yIHRoZSBn aXZlbiBwYXRoLgotICBib29sIHJhbmdlX2RlZmluZWRfaW5fYmxvY2sgKGlyYW5nZSAmLCB0cmVl IG5hbWUsIGJhc2ljX2Jsb2NrIGJiKTsKKyAgYm9vbCByYW5nZV9kZWZpbmVkX2luX2Jsb2NrICh2 cmFuZ2UgJiwgdHJlZSBuYW1lLCBiYXNpY19ibG9jayBiYik7CiAgIHZvaWQgY29tcHV0ZV9yYW5n ZXNfaW5fYmxvY2sgKGJhc2ljX2Jsb2NrIGJiKTsKICAgdm9pZCBjb21wdXRlX3Jhbmdlc19pbl9w aGlzIChiYXNpY19ibG9jayBiYik7CiAgIHZvaWQgYWRqdXN0X2Zvcl9ub25fbnVsbF91c2VzIChi YXNpY19ibG9jayBiYik7Ci0gIHZvaWQgc3NhX3JhbmdlX2luX3BoaSAoaXJhbmdlICZyLCBncGhp ICpwaGkpOworICB2b2lkIHNzYV9yYW5nZV9pbl9waGkgKHZyYW5nZSAmciwgZ3BoaSAqcGhpKTsK ICAgdm9pZCBjb21wdXRlX291dGdvaW5nX3JlbGF0aW9ucyAoYmFzaWNfYmxvY2sgYmIsIGJhc2lj X2Jsb2NrIG5leHQpOwogICB2b2lkIGNvbXB1dGVfcGhpX3JlbGF0aW9ucyAoYmFzaWNfYmxvY2sg YmIsIGJhc2ljX2Jsb2NrIHByZXYpOwogICB2b2lkIG1heWJlX3JlZ2lzdGVyX3BoaV9yZWxhdGlv biAoZ3BoaSAqLCBlZGdlIGUpOwpkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1yYW5nZS10ZXN0cy5j YyBiL2djYy9naW1wbGUtcmFuZ2UtdGVzdHMuY2MKaW5kZXggNTcyYWNkMzNkN2YuLjg0ZWNjNDg2 ODg5IDEwMDY0NAotLS0gYS9nY2MvZ2ltcGxlLXJhbmdlLXRlc3RzLmNjCisrKyBiL2djYy9naW1w bGUtcmFuZ2UtdGVzdHMuY2MKQEAgLTQyLDggKzQyLDkgQEAgcHVibGljOgogICAgIEFTU0VSVF9U UlVFIChyID09IGV4cGVjdCk7CiAgIH0KIAotICB2aXJ0dWFsIGJvb2wgcmFuZ2Vfb2ZfZXhwciAo aXJhbmdlICZyLCB0cmVlIGV4cHIsIGdpbXBsZSAqID0gTlVMTCkgb3ZlcnJpZGUKKyAgdmlydHVh bCBib29sIHJhbmdlX29mX2V4cHIgKHZyYW5nZSAmdiwgdHJlZSBleHByLCBnaW1wbGUgKiA9IE5V TEwpIG92ZXJyaWRlCiAgIHsKKyAgICBpcmFuZ2UgJnIgPSBhc19hIDxpcmFuZ2U+ICh2KTsKICAg ICBpZiAoZXhwciA9PSBvcDApCiAgICAgICB7CiAJci5zZXQgKGJ1aWxkX2ludF9jc3QgKHR5cGUs IDUpLCBidWlsZF9pbnRfY3N0ICh0eXBlLCAxMCkpOwpkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1y YW5nZS10cmFjZS5jYyBiL2djYy9naW1wbGUtcmFuZ2UtdHJhY2UuY2MKaW5kZXggMzk5NzEwOTNl NmQuLjQ2ODI3ZjljNTgwIDEwMDY0NAotLS0gYS9nY2MvZ2ltcGxlLXJhbmdlLXRyYWNlLmNjCisr KyBiL2djYy9naW1wbGUtcmFuZ2UtdHJhY2UuY2MKQEAgLTEwMiw3ICsxMDIsNyBAQCByYW5nZV90 cmFjZXI6OnByaW50ICh1bnNpZ25lZCBjb3VudGVyLCBjb25zdCBjaGFyICpzdHIpCiAKIHZvaWQK IHJhbmdlX3RyYWNlcjo6dHJhaWxlciAodW5zaWduZWQgY291bnRlciwgY29uc3QgY2hhciAqY2Fs bGVyLCBib29sIHJlc3VsdCwKLQkJICAgICAgdHJlZSBuYW1lLCBjb25zdCBpcmFuZ2UgJnIpCisJ CSAgICAgIHRyZWUgbmFtZSwgY29uc3QgdnJhbmdlICZyKQogewogICBnY2NfY2hlY2tpbmdfYXNz ZXJ0ICh0cmFjaW5nICYmIGNvdW50ZXIgIT0gMCk7CiAKQEAgLTE0MSw3ICsxNDEsNiBAQCBkZWJ1 Z19zZWVkX3JhbmdlciAoZ2ltcGxlX3JhbmdlciAmcmFuZ2VyKQogICAgIH0KIAogICBiYXNpY19i bG9jayBiYjsKLSAgaW50X3JhbmdlX21heCByOwogICBnaW1wbGVfc3RtdF9pdGVyYXRvciBnc2k7 CiAgIEZPUl9FQUNIX0JCX0ZOIChiYiwgY2Z1bikKICAgICBmb3IgKGdzaSA9IGdzaV9zdGFydF9i YiAoYmIpOyAhZ3NpX2VuZF9wIChnc2kpOyBnc2lfbmV4dCAoJmdzaSkpCkBAIC0xNTEsNyArMTUw LDExIEBAIGRlYnVnX3NlZWRfcmFuZ2VyIChnaW1wbGVfcmFuZ2VyICZyYW5nZXIpCiAJaWYgKGlz X2dpbXBsZV9kZWJ1ZyAoc3RtdCkpCiAJICBjb250aW51ZTsKIAotCXJhbmdlci5yYW5nZV9vZl9z dG10IChyLCBzdG10KTsKKwlpZiAodHJlZSB0eXBlID0gZ2ltcGxlX3JhbmdlX3R5cGUgKHN0bXQp KQorCSAgeworCSAgICBWYWx1ZV9SYW5nZSByICh0eXBlKTsKKwkgICAgcmFuZ2VyLnJhbmdlX29m X3N0bXQgKHIsIHN0bXQpOworCSAgfQogICAgICAgfQogfQogCmRpZmYgLS1naXQgYS9nY2MvZ2lt cGxlLXJhbmdlLXRyYWNlLmggYi9nY2MvZ2ltcGxlLXJhbmdlLXRyYWNlLmgKaW5kZXggMzAyYWZk YTMxMDQuLjNmOTJlNTE4MDNiIDEwMDY0NAotLS0gYS9nY2MvZ2ltcGxlLXJhbmdlLXRyYWNlLmgK KysrIGIvZ2NjL2dpbXBsZS1yYW5nZS10cmFjZS5oCkBAIC0zMiw3ICszMiw3IEBAIHB1YmxpYzoK ICAgcmFuZ2VfdHJhY2VyIChjb25zdCBjaGFyICpuYW1lID0gIiIpOwogICB1bnNpZ25lZCBoZWFk ZXIgKGNvbnN0IGNoYXIgKnN0cik7CiAgIHZvaWQgdHJhaWxlciAodW5zaWduZWQgY291bnRlciwg Y29uc3QgY2hhciAqY2FsbGVyLCBib29sIHJlc3VsdCwgdHJlZSBuYW1lLAotCQljb25zdCBpcmFu Z2UgJnIpOworCQljb25zdCB2cmFuZ2UgJnIpOwogICB2b2lkIHByaW50ICh1bnNpZ25lZCBjb3Vu dGVyLCBjb25zdCBjaGFyICpzdHIpOwogICBpbmxpbmUgdm9pZCBlbmFibGVfdHJhY2UgKCkgeyB0 cmFjaW5nID0gdHJ1ZTsgfQogICBpbmxpbmUgdm9pZCBkaXNhYmxlX3RyYWNlICgpIHsgdHJhY2lu ZyA9IGZhbHNlOyB9CmRpZmYgLS1naXQgYS9nY2MvZ2ltcGxlLXJhbmdlLmNjIGIvZ2NjL2dpbXBs ZS1yYW5nZS5jYwppbmRleCAwYTk5Nzg3ZmM3NS4uMTJkYTE2ODQxYzIgMTAwNjQ0Ci0tLSBhL2dj Yy9naW1wbGUtcmFuZ2UuY2MKKysrIGIvZ2NjL2dpbXBsZS1yYW5nZS5jYwpAQCAtNzEsNyArNzEs NyBAQCBnaW1wbGVfcmFuZ2VyOjp+Z2ltcGxlX3JhbmdlciAoKQogfQogCiBib29sCi1naW1wbGVf cmFuZ2VyOjpyYW5nZV9vZl9leHByIChpcmFuZ2UgJnIsIHRyZWUgZXhwciwgZ2ltcGxlICpzdG10 KQorZ2ltcGxlX3Jhbmdlcjo6cmFuZ2Vfb2ZfZXhwciAodnJhbmdlICZyLCB0cmVlIGV4cHIsIGdp bXBsZSAqc3RtdCkKIHsKICAgdW5zaWduZWQgaWR4OwogICBpZiAoIWdpbXBsZV9yYW5nZV9zc2Ff cCAoZXhwcikpCkBAIC05Myw3ICs5Myw3IEBAIGdpbXBsZV9yYW5nZXI6OnJhbmdlX29mX2V4cHIg KGlyYW5nZSAmciwgdHJlZSBleHByLCBnaW1wbGUgKnN0bXQpCiAgIC8vIElmIHRoZXJlIGlzIG5v IHN0YXRlbWVudCwganVzdCBnZXQgdGhlIGdsb2JhbCB2YWx1ZS4KICAgaWYgKCFzdG10KQogICAg IHsKLSAgICAgIGludF9yYW5nZV9tYXggdG1wOworICAgICAgVmFsdWVfUmFuZ2UgdG1wIChUUkVF X1RZUEUgKGV4cHIpKTsKICAgICAgIG1fY2FjaGUuZ2V0X2dsb2JhbF9yYW5nZSAociwgZXhwcik7 CiAgICAgICAvLyBQaWNrIHVwIGltcGxpZWQgY29udGV4dCBpbmZvcm1hdGlvbiBmcm9tIHRoZSBv bi1lbnRyeSBjYWNoZQogICAgICAgLy8gaWYgY3VycmVudF9iYiBpcyBzZXQuICBEbyBub3QgYXR0 ZW1wdCBhbnkgbmV3IGNhbGN1bGF0aW9ucy4KQEAgLTEzNyw5ICsxMzcsOSBAQCBnaW1wbGVfcmFu Z2VyOjpyYW5nZV9vZl9leHByIChpcmFuZ2UgJnIsIHRyZWUgZXhwciwgZ2ltcGxlICpzdG10KQog Ly8gUmV0dXJuIHRoZSByYW5nZSBvZiBOQU1FIG9uIGVudHJ5IHRvIGJsb2NrIEJCIGluIFIuCiAK IHZvaWQKLWdpbXBsZV9yYW5nZXI6OnJhbmdlX29uX2VudHJ5IChpcmFuZ2UgJnIsIGJhc2ljX2Js b2NrIGJiLCB0cmVlIG5hbWUpCitnaW1wbGVfcmFuZ2VyOjpyYW5nZV9vbl9lbnRyeSAodnJhbmdl ICZyLCBiYXNpY19ibG9jayBiYiwgdHJlZSBuYW1lKQogewotICBpbnRfcmFuZ2VfbWF4IGVudHJ5 X3JhbmdlOworICBWYWx1ZV9SYW5nZSBlbnRyeV9yYW5nZSAoVFJFRV9UWVBFIChuYW1lKSk7CiAg IGdjY19jaGVja2luZ19hc3NlcnQgKGdpbXBsZV9yYW5nZV9zc2FfcCAobmFtZSkpOwogCiAgIHVu c2lnbmVkIGlkeDsKQEAgLTE2NCw3ICsxNjQsNyBAQCBnaW1wbGVfcmFuZ2VyOjpyYW5nZV9vbl9l bnRyeSAoaXJhbmdlICZyLCBiYXNpY19ibG9jayBiYiwgdHJlZSBuYW1lKQogLy8gUmV0dXJuIGZh bHNlIGlmIG5vIHJhbmdlIGNhbiBiZSBjYWxjdWxhdGVkLgogCiB2b2lkCi1naW1wbGVfcmFuZ2Vy OjpyYW5nZV9vbl9leGl0IChpcmFuZ2UgJnIsIGJhc2ljX2Jsb2NrIGJiLCB0cmVlIG5hbWUpCitn aW1wbGVfcmFuZ2VyOjpyYW5nZV9vbl9leGl0ICh2cmFuZ2UgJnIsIGJhc2ljX2Jsb2NrIGJiLCB0 cmVlIG5hbWUpCiB7CiAgIC8vIG9uLWV4aXQgZnJvbSB0aGUgZXhpdCBibG9jaz8KICAgZ2NjX2No ZWNraW5nX2Fzc2VydCAoYmIgIT0gRVhJVF9CTE9DS19QVFJfRk9SX0ZOIChjZnVuKSk7CkBAIC0x OTgsMTAgKzE5OCwxMCBAQCBnaW1wbGVfcmFuZ2VyOjpyYW5nZV9vbl9leGl0IChpcmFuZ2UgJnIs IGJhc2ljX2Jsb2NrIGJiLCB0cmVlIG5hbWUpCiAvLyBDYWxjdWxhdGUgYSByYW5nZSBmb3IgTkFN RSBvbiBlZGdlIEUgYW5kIHJldHVybiBpdCBpbiBSLgogCiBib29sCi1naW1wbGVfcmFuZ2VyOjpy YW5nZV9vbl9lZGdlIChpcmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBuYW1lKQorZ2ltcGxlX3Jhbmdl cjo6cmFuZ2Vfb25fZWRnZSAodnJhbmdlICZyLCBlZGdlIGUsIHRyZWUgbmFtZSkKIHsKLSAgaW50 X3JhbmdlX21heCBlZGdlX3JhbmdlOwotICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChpcmFuZ2U6OnN1 cHBvcnRzX3R5cGVfcCAoVFJFRV9UWVBFIChuYW1lKSkpOworICBWYWx1ZV9SYW5nZSBlZGdlX3Jh bmdlIChUUkVFX1RZUEUgKG5hbWUpKTsKKyAgZ2NjX2NoZWNraW5nX2Fzc2VydCAodnJhbmdlOjpz dXBwb3J0c190eXBlX3AgKFRSRUVfVFlQRSAobmFtZSkpKTsKIAogICAvLyBEbyBub3QgcHJvY2Vz cyB2YWx1ZXMgYWxvbmcgYWJub3JtYWwgZWRnZXMuCiAgIGlmIChlLT5mbGFncyAmIEVER0VfQUJO T1JNQUwpCkBAIC0yNDksNyArMjQ5LDcgQEAgZ2ltcGxlX3Jhbmdlcjo6cmFuZ2Vfb25fZWRnZSAo aXJhbmdlICZyLCBlZGdlIGUsIHRyZWUgbmFtZSkKIC8vIGZvbGRfcmFuZ2Ugd3JhcHBlciBmb3Ig cmFuZ2Vfb2Zfc3RtdCB0byB1c2UgYXMgYW4gaW50ZXJuYWwgY2xpZW50LgogCiBib29sCi1naW1w bGVfcmFuZ2VyOjpmb2xkX3JhbmdlX2ludGVybmFsIChpcmFuZ2UgJnIsIGdpbXBsZSAqcywgdHJl ZSBuYW1lKQorZ2ltcGxlX3Jhbmdlcjo6Zm9sZF9yYW5nZV9pbnRlcm5hbCAodnJhbmdlICZyLCBn aW1wbGUgKnMsIHRyZWUgbmFtZSkKIHsKICAgZm9sZF91c2luZ19yYW5nZSBmOwogICBmdXJfZGVw ZW5kIHNyYyAocywgJihnb3JpICgpKSwgdGhpcyk7CkBAIC0yNjMsNyArMjYzLDcgQEAgZ2ltcGxl X3Jhbmdlcjo6Zm9sZF9yYW5nZV9pbnRlcm5hbCAoaXJhbmdlICZyLCBnaW1wbGUgKnMsIHRyZWUg bmFtZSkKIC8vIGF2b2lkZWQuICBJZiBhIHJhbmdlIGNhbm5vdCBiZSBjYWxjdWxhdGVkLCByZXR1 cm4gZmFsc2UgYW5kIFVOREVGSU5FRC4KIAogYm9vbAotZ2ltcGxlX3Jhbmdlcjo6cmFuZ2Vfb2Zf c3RtdCAoaXJhbmdlICZyLCBnaW1wbGUgKnMsIHRyZWUgbmFtZSkKK2dpbXBsZV9yYW5nZXI6OnJh bmdlX29mX3N0bXQgKHZyYW5nZSAmciwgZ2ltcGxlICpzLCB0cmVlIG5hbWUpCiB7CiAgIGJvb2wg cmVzOwogICByLnNldF91bmRlZmluZWQgKCk7CkBAIC0zMTMsNyArMzEzLDcgQEAgZ2ltcGxlX3Jh bmdlcjo6cmFuZ2Vfb2Zfc3RtdCAoaXJhbmdlICZyLCBnaW1wbGUgKnMsIHRyZWUgbmFtZSkKIAlw cmVmaWxsX3N0bXRfZGVwZW5kZW5jaWVzIChuYW1lKTsKIAogICAgICAgLy8gQ2FsY3VsYXRlIGEg bmV3IHZhbHVlLgotICAgICAgaW50X3JhbmdlX21heCB0bXA7CisgICAgICBWYWx1ZV9SYW5nZSB0 bXAgKFRSRUVfVFlQRSAobmFtZSkpOwogICAgICAgZm9sZF9yYW5nZV9pbnRlcm5hbCAodG1wLCBz LCBuYW1lKTsKIAogICAgICAgLy8gQ29tYmluZSB0aGUgbmV3IHZhbHVlIHdpdGggdGhlIG9sZCB2 YWx1ZS4gIFRoaXMgaXMgcmVxdWlyZWQgYmVjYXVzZQpAQCAtMzM0LDcgKzMzNCw3IEBAIGdpbXBs ZV9yYW5nZXI6OnJhbmdlX29mX3N0bXQgKGlyYW5nZSAmciwgZ2ltcGxlICpzLCB0cmVlIG5hbWUp CiAvLyBzdGFjayBpZiBzby4gIFIgaXMgYSBzY3JhdGNoIHJhbmdlLgogCiBpbmxpbmUgdm9pZAot Z2ltcGxlX3Jhbmdlcjo6cHJlZmlsbF9uYW1lIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSkKK2dpbXBs ZV9yYW5nZXI6OnByZWZpbGxfbmFtZSAodnJhbmdlICZyLCB0cmVlIG5hbWUpCiB7CiAgIGlmICgh Z2ltcGxlX3JhbmdlX3NzYV9wIChuYW1lKSkKICAgICByZXR1cm47CkBAIC0zNTcsNyArMzU3LDYg QEAgZ2ltcGxlX3Jhbmdlcjo6cHJlZmlsbF9zdG10X2RlcGVuZGVuY2llcyAodHJlZSBzc2EpCiAg IGlmIChTU0FfTkFNRV9JU19ERUZBVUxUX0RFRiAoc3NhKSkKICAgICByZXR1cm47CiAKLSAgaW50 X3JhbmdlX21heCByOwogICB1bnNpZ25lZCBpZHg7CiAgIGdpbXBsZSAqc3RtdCA9IFNTQV9OQU1F X0RFRl9TVE1UIChzc2EpOwogICBnY2NfY2hlY2tpbmdfYXNzZXJ0IChzdG10ICYmIGdpbXBsZV9i YiAoc3RtdCkpOwpAQCAtMzg4LDkgKzM4NywxMCBAQCBnaW1wbGVfcmFuZ2VyOjpwcmVmaWxsX3N0 bXRfZGVwZW5kZW5jaWVzICh0cmVlIHNzYSkKIAkgICAgewogCSAgICAgIC8vIEZvbGQgYW5kIHNh dmUgdGhlIHZhbHVlIGZvciBOQU1FLgogCSAgICAgIHN0bXQgPSBTU0FfTkFNRV9ERUZfU1RNVCAo bmFtZSk7CisJICAgICAgVmFsdWVfUmFuZ2UgciAoVFJFRV9UWVBFIChuYW1lKSk7CiAJICAgICAg Zm9sZF9yYW5nZV9pbnRlcm5hbCAociwgc3RtdCwgbmFtZSk7CiAJICAgICAgLy8gTWFrZSBzdXJl IHdlIGRvbid0IGxvc2UgYW55IGN1cnJlbnQgZ2xvYmFsIGluZm8uCi0JICAgICAgaW50X3Jhbmdl X21heCB0bXA7CisJICAgICAgVmFsdWVfUmFuZ2UgdG1wIChUUkVFX1RZUEUgKG5hbWUpKTsKIAkg ICAgICBtX2NhY2hlLmdldF9nbG9iYWxfcmFuZ2UgKHRtcCwgbmFtZSk7CiAJICAgICAgci5pbnRl cnNlY3QgKHRtcCk7CiAJICAgICAgbV9jYWNoZS5zZXRfZ2xvYmFsX3JhbmdlIChuYW1lLCByKTsK QEAgLTQxNCw2ICs0MTQsNyBAQCBnaW1wbGVfcmFuZ2VyOjpwcmVmaWxsX3N0bXRfZGVwZW5kZW5j aWVzICh0cmVlIHNzYSkKICAgICAgIGdwaGkgKnBoaSA9IGR5bl9jYXN0IDxncGhpICo+IChzdG10 KTsKICAgICAgIGlmIChwaGkpCiAJeworCSAgVmFsdWVfUmFuZ2UgciAoVFJFRV9UWVBFIChnaW1w bGVfcGhpX3Jlc3VsdCAocGhpKSkpOwogCSAgZm9yICh1bnNpZ25lZCB4ID0gMDsgeCA8IGdpbXBs ZV9waGlfbnVtX2FyZ3MgKHBoaSk7IHgrKykKIAkgICAgcHJlZmlsbF9uYW1lIChyLCBnaW1wbGVf cGhpX2FyZ19kZWYgKHBoaSwgeCkpOwogCX0KQEAgLTQyMSw2ICs0MjIsNyBAQCBnaW1wbGVfcmFu Z2VyOjpwcmVmaWxsX3N0bXRfZGVwZW5kZW5jaWVzICh0cmVlIHNzYSkKIAl7CiAJICBnY2NfY2hl Y2tpbmdfYXNzZXJ0IChyYW5nZV9vcF9oYW5kbGVyIChzdG10KSk7CiAJICB0cmVlIG9wID0gZ2lt cGxlX3JhbmdlX29wZXJhbmQyIChzdG10KTsKKwkgIFZhbHVlX1JhbmdlIHIgKFRSRUVfVFlQRSAo bmFtZSkpOwogCSAgaWYgKG9wKQogCSAgICBwcmVmaWxsX25hbWUgKHIsIG9wKTsKIAkgIG9wID0g Z2ltcGxlX3JhbmdlX29wZXJhbmQxIChzdG10KTsKQEAgLTQyOSw3ICs0MzEsMTAgQEAgZ2ltcGxl X3Jhbmdlcjo6cHJlZmlsbF9zdG10X2RlcGVuZGVuY2llcyAodHJlZSBzc2EpCiAJfQogICAgIH0K ICAgaWYgKGlkeCkKLSAgICB0cmFjZXIudHJhaWxlciAoaWR4LCAiUk9TICIsIGZhbHNlLCBzc2Es IHIpOworICAgIHsKKyAgICAgIHVuc3VwcG9ydGVkX3JhbmdlIHI7CisgICAgICB0cmFjZXIudHJh aWxlciAoaWR4LCAiUk9TICIsIGZhbHNlLCBzc2EsIHIpOworICAgIH0KIH0KIAogCkBAIC00ODcs OCArNDkyLDEwIEBAIGdpbXBsZV9yYW5nZXI6OmV4cG9ydF9nbG9iYWxfcmFuZ2VzICgpCiAgIGJv b2wgcHJpbnRfaGVhZGVyID0gdHJ1ZTsKICAgZm9yICh1bnNpZ25lZCB4ID0gMTsgeCA8IG51bV9z c2FfbmFtZXM7IHgrKykKICAgICB7Ci0gICAgICBpbnRfcmFuZ2VfbWF4IHI7CiAgICAgICB0cmVl IG5hbWUgPSBzc2FfbmFtZSAoeCk7CisgICAgICBpZiAoIW5hbWUpCisJY29udGludWU7CisgICAg ICBWYWx1ZV9SYW5nZSByIChUUkVFX1RZUEUgKG5hbWUpKTsKICAgICAgIGlmIChuYW1lICYmICFT U0FfTkFNRV9JTl9GUkVFX0xJU1QgKG5hbWUpCiAJICAmJiBnaW1wbGVfcmFuZ2Vfc3NhX3AgKG5h bWUpCiAJICAmJiBtX2NhY2hlLmdldF9nbG9iYWxfcmFuZ2UgKHIsIG5hbWUpCkBAIC01MDcsMTMg KzUxNCwxNyBAQCBnaW1wbGVfcmFuZ2VyOjpleHBvcnRfZ2xvYmFsX3JhbmdlcyAoKQogCSAgICAg IHByaW50X2hlYWRlciA9IGZhbHNlOwogCSAgICB9CiAKLQkgIHZhbHVlX3JhbmdlIHZyID0gcjsK KwkgIGlmICghaXJhbmdlOjpzdXBwb3J0c190eXBlX3AgKFRSRUVfVFlQRSAobmFtZSkpKQorCSAg ICBjb250aW51ZTsKKworCSAgdnJhbmdlICZ2ID0gcjsKKwkgIHZhbHVlX3JhbmdlIHZyID0gYXNf YSA8aXJhbmdlPiAodik7CiAJICBwcmludF9nZW5lcmljX2V4cHIgKGR1bXBfZmlsZSwgbmFtZSAs IFRERl9TTElNKTsKIAkgIGZwcmludGYgKGR1bXBfZmlsZSwgIiAgOiAiKTsKIAkgIHZyLmR1bXAg KGR1bXBfZmlsZSk7CiAJICBmcHJpbnRmIChkdW1wX2ZpbGUsICJcbiIpOwogCSAgaW50X3Jhbmdl X21heCBzYW1lID0gdnI7Ci0JICBpZiAoc2FtZSAhPSByKQorCSAgaWYgKHNhbWUgIT0gYXNfYSA8 aXJhbmdlPiAodikpCiAJICAgIHsKIAkgICAgICBmcHJpbnRmIChkdW1wX2ZpbGUsICIgICAgICAg ICBpcmFuZ2UgOiAiKTsKIAkgICAgICByLmR1bXAgKGR1bXBfZmlsZSk7CkBAIC01MzEsNyArNTQy LDYgQEAgZ2ltcGxlX3Jhbmdlcjo6ZHVtcF9iYiAoRklMRSAqZiwgYmFzaWNfYmxvY2sgYmIpCiAg IHVuc2lnbmVkIHg7CiAgIGVkZ2VfaXRlcmF0b3IgZWk7CiAgIGVkZ2UgZTsKLSAgaW50X3Jhbmdl X21heCByYW5nZSwgdG1wX3JhbmdlOwogICBmcHJpbnRmIChmLCAiXG49PT09PT09PT09PSBCQiAl ZCA9PT09PT09PT09PT1cbiIsIGJiLT5pbmRleCk7CiAgIG1fY2FjaGUuZHVtcF9iYiAoZiwgYmIp OwogCkBAIC01NDEsOSArNTUxLDExIEBAIGdpbXBsZV9yYW5nZXI6OmR1bXBfYmIgKEZJTEUgKmYs IGJhc2ljX2Jsb2NrIGJiKQogICBmb3IgKHggPSAxOyB4IDwgbnVtX3NzYV9uYW1lczsgeCsrKQog ICAgIHsKICAgICAgIHRyZWUgbmFtZSA9IHNzYV9uYW1lICh4KTsKLSAgICAgIGlmIChnaW1wbGVf cmFuZ2Vfc3NhX3AgKG5hbWUpICYmIFNTQV9OQU1FX0RFRl9TVE1UIChuYW1lKSAmJgotCSAgZ2lt cGxlX2JiIChTU0FfTkFNRV9ERUZfU1RNVCAobmFtZSkpID09IGJiICYmCi0JICBtX2NhY2hlLmdl dF9nbG9iYWxfcmFuZ2UgKHJhbmdlLCBuYW1lKSkKKyAgICAgIGlmICghZ2ltcGxlX3JhbmdlX3Nz YV9wIChuYW1lKSB8fCAhU1NBX05BTUVfREVGX1NUTVQgKG5hbWUpKQorCWNvbnRpbnVlOworICAg ICAgVmFsdWVfUmFuZ2UgcmFuZ2UgKFRSRUVfVFlQRSAobmFtZSkpOworICAgICAgaWYgKGdpbXBs ZV9iYiAoU1NBX05BTUVfREVGX1NUTVQgKG5hbWUpKSA9PSBiYgorCSAgJiYgbV9jYWNoZS5nZXRf Z2xvYmFsX3JhbmdlIChyYW5nZSwgbmFtZSkpCiAJewogCSAgaWYgKCFyYW5nZS52YXJ5aW5nX3Ag KCkpCiAJICAgIHsKQEAgLTU2MiwxMCArNTc0LDE0IEBAIGdpbXBsZV9yYW5nZXI6OmR1bXBfYmIg KEZJTEUgKmYsIGJhc2ljX2Jsb2NrIGJiKQogICAgICAgZm9yICh4ID0gMTsgeCA8IG51bV9zc2Ff bmFtZXM7IHgrKykKIAl7CiAJICB0cmVlIG5hbWUgPSBnaW1wbGVfcmFuZ2Vfc3NhX3AgKHNzYV9u YW1lICh4KSk7Ci0JICBpZiAobmFtZSAmJiBnb3JpICgpLmhhc19lZGdlX3JhbmdlX3AgKG5hbWUs IGUpCi0JICAgICAgJiYgbV9jYWNoZS5yYW5nZV9vbl9lZGdlIChyYW5nZSwgZSwgbmFtZSkpCisJ ICBpZiAoIW5hbWUgfHwgIWdvcmkgKCkuaGFzX2VkZ2VfcmFuZ2VfcCAobmFtZSwgZSkpCisJICAg IGNvbnRpbnVlOworCisJICBWYWx1ZV9SYW5nZSByYW5nZSAoVFJFRV9UWVBFIChuYW1lKSk7CisJ ICBpZiAobV9jYWNoZS5yYW5nZV9vbl9lZGdlIChyYW5nZSwgZSwgbmFtZSkpCiAJICAgIHsKIAkg ICAgICBnaW1wbGUgKnMgPSBTU0FfTkFNRV9ERUZfU1RNVCAobmFtZSk7CisJICAgICAgVmFsdWVf UmFuZ2UgdG1wX3JhbmdlIChUUkVFX1RZUEUgKG5hbWUpKTsKIAkgICAgICAvLyBPbmx5IHByaW50 IHRoZSByYW5nZSBpZiB0aGlzIGlzIHRoZSBkZWYgYmxvY2ssIG9yCiAJICAgICAgLy8gdGhlIG9u IGVudHJ5IGNhY2hlIGZvciBlaXRoZXIgZW5kIG9mIHRoZSBlZGdlIGlzCiAJICAgICAgLy8gc2V0 LgpkaWZmIC0tZ2l0IGEvZ2NjL2dpbXBsZS1yYW5nZS5oIGIvZ2NjL2dpbXBsZS1yYW5nZS5oCmlu ZGV4IGM2NzI4MGRjMWQyLi4zNGY2MTAyNWFjMyAxMDA2NDQKLS0tIGEvZ2NjL2dpbXBsZS1yYW5n ZS5oCisrKyBiL2djYy9naW1wbGUtcmFuZ2UuaApAQCAtNDgsMTEgKzQ4LDExIEBAIGNsYXNzIGdp bXBsZV9yYW5nZXIgOiBwdWJsaWMgcmFuZ2VfcXVlcnkKIHB1YmxpYzoKICAgZ2ltcGxlX3Jhbmdl ciAoYm9vbCB1c2VfaW1tX3VzZXMgPSB0cnVlKTsKICAgfmdpbXBsZV9yYW5nZXIgKCk7Ci0gIHZp cnR1YWwgYm9vbCByYW5nZV9vZl9zdG10IChpcmFuZ2UgJnIsIGdpbXBsZSAqLCB0cmVlIG5hbWUg PSBOVUxMKSBvdmVycmlkZTsKLSAgdmlydHVhbCBib29sIHJhbmdlX29mX2V4cHIgKGlyYW5nZSAm ciwgdHJlZSBuYW1lLCBnaW1wbGUgKiA9IE5VTEwpIG92ZXJyaWRlOwotICB2aXJ0dWFsIGJvb2wg cmFuZ2Vfb25fZWRnZSAoaXJhbmdlICZyLCBlZGdlIGUsIHRyZWUgbmFtZSkgb3ZlcnJpZGU7Ci0g IHZvaWQgcmFuZ2Vfb25fZW50cnkgKGlyYW5nZSAmciwgYmFzaWNfYmxvY2sgYmIsIHRyZWUgbmFt ZSk7Ci0gIHZvaWQgcmFuZ2Vfb25fZXhpdCAoaXJhbmdlICZyLCBiYXNpY19ibG9jayBiYiwgdHJl ZSBuYW1lKTsKKyAgdmlydHVhbCBib29sIHJhbmdlX29mX3N0bXQgKHZyYW5nZSAmciwgZ2ltcGxl ICosIHRyZWUgbmFtZSA9IE5VTEwpIG92ZXJyaWRlOworICB2aXJ0dWFsIGJvb2wgcmFuZ2Vfb2Zf ZXhwciAodnJhbmdlICZyLCB0cmVlIG5hbWUsIGdpbXBsZSAqID0gTlVMTCkgb3ZlcnJpZGU7Cisg IHZpcnR1YWwgYm9vbCByYW5nZV9vbl9lZGdlICh2cmFuZ2UgJnIsIGVkZ2UgZSwgdHJlZSBuYW1l KSBvdmVycmlkZTsKKyAgdm9pZCByYW5nZV9vbl9lbnRyeSAodnJhbmdlICZyLCBiYXNpY19ibG9j ayBiYiwgdHJlZSBuYW1lKTsKKyAgdm9pZCByYW5nZV9vbl9leGl0ICh2cmFuZ2UgJnIsIGJhc2lj X2Jsb2NrIGJiLCB0cmVlIG5hbWUpOwogICB2b2lkIGV4cG9ydF9nbG9iYWxfcmFuZ2VzICgpOwog ICBpbmxpbmUgZ29yaV9jb21wdXRlICZnb3JpICgpICB7IHJldHVybiBtX2NhY2hlLm1fZ29yaTsg fQogICB2aXJ0dWFsIHZvaWQgZHVtcCAoRklMRSAqZikgb3ZlcnJpZGU7CkBAIC02Miw4ICs2Miw4 IEBAIHB1YmxpYzoKICAgYm9vbCBmb2xkX3N0bXQgKGdpbXBsZV9zdG10X2l0ZXJhdG9yICpnc2ks IHRyZWUgKCopICh0cmVlKSk7CiAgIHZvaWQgcmVnaXN0ZXJfaW5mZXJyZWRfcmFuZ2VzIChnaW1w bGUgKnMpOwogcHJvdGVjdGVkOgotICBib29sIGZvbGRfcmFuZ2VfaW50ZXJuYWwgKGlyYW5nZSAm ciwgZ2ltcGxlICpzLCB0cmVlIG5hbWUpOwotICB2b2lkIHByZWZpbGxfbmFtZSAoaXJhbmdlICZy LCB0cmVlIG5hbWUpOworICBib29sIGZvbGRfcmFuZ2VfaW50ZXJuYWwgKHZyYW5nZSAmciwgZ2lt cGxlICpzLCB0cmVlIG5hbWUpOworICB2b2lkIHByZWZpbGxfbmFtZSAodnJhbmdlICZyLCB0cmVl IG5hbWUpOwogICB2b2lkIHByZWZpbGxfc3RtdF9kZXBlbmRlbmNpZXMgKHRyZWUgc3NhKTsKICAg cmFuZ2VyX2NhY2hlIG1fY2FjaGU7CiAgIHJhbmdlX3RyYWNlciB0cmFjZXI7CmRpZmYgLS1naXQg YS9nY2MvZ2ltcGxlLXNzYS13YXJuLWFjY2Vzcy5jYyBiL2djYy9naW1wbGUtc3NhLXdhcm4tYWNj ZXNzLmNjCmluZGV4IDkzNTdhNGU1NzZhLi4wMGY2NTg1OGIwYyAxMDA2NDQKLS0tIGEvZ2NjL2dp bXBsZS1zc2Etd2Fybi1hY2Nlc3MuY2MKKysrIGIvZ2NjL2dpbXBsZS1zc2Etd2Fybi1hY2Nlc3Mu Y2MKQEAgLTMyOCwxMSArMzI4LDExIEBAIGNoZWNrX251bF90ZXJtaW5hdGVkX2FycmF5IChHaW1w bGVPclRyZWUgZXhwciwgdHJlZSBzcmMsIHRyZWUgYm91bmQpCiAgIHdpZGVfaW50IGJuZHJuZ1sy XTsKICAgaWYgKGJvdW5kKQogICAgIHsKLSAgICAgIHZhbHVlX3JhbmdlIHI7CisgICAgICBWYWx1 ZV9SYW5nZSByIChUUkVFX1RZUEUgKGJvdW5kKSk7CiAKICAgICAgIGdldF9nbG9iYWxfcmFuZ2Vf cXVlcnkgKCktPnJhbmdlX29mX2V4cHIgKHIsIGJvdW5kKTsKIAotICAgICAgaWYgKHIua2luZCAo KSAhPSBWUl9SQU5HRSkKKyAgICAgIGlmIChyLnVuZGVmaW5lZF9wICgpIHx8IHIudmFyeWluZ19w ICgpKQogCXJldHVybiB0cnVlOwogCiAgICAgICBibmRybmdbMF0gPSByLmxvd2VyX2JvdW5kICgp OwpAQCAtMjc5MCw5ICsyNzkwLDggQEAgbWVtbW9kZWxfdG9fdWh3aSAodHJlZSBvcmQsIGdpbXBs ZSAqc3RtdCwgdW5zaWduZWQgSE9TVF9XSURFX0lOVCAqY3N0dmFsKQogICAgIHsKICAgICAgIC8q IFVzZSB0aGUgcmFuZ2UgcXVlcnkgdG8gZGV0ZXJtaW5lIGNvbnN0YW50IHZhbHVlcyBpbiB0aGUg YWJzZW5jZQogCSBvZiBjb25zdGFudCBwcm9wYWdhdGlvbiAoc3VjaCBhcyBhdCAtTzApLiAgKi8K LSAgICAgIHZhbHVlX3JhbmdlIHJuZzsKKyAgICAgIFZhbHVlX1JhbmdlIHJuZyAoVFJFRV9UWVBF IChvcmQpKTsKICAgICAgIGlmICghZ2V0X3JhbmdlX3F1ZXJ5IChjZnVuKS0+cmFuZ2Vfb2ZfZXhw ciAocm5nLCBvcmQsIHN0bXQpCi0JICB8fCAhcm5nLmNvbnN0YW50X3AgKCkKIAkgIHx8ICFybmcu c2luZ2xldG9uX3AgKCZvcmQpKQogCXJldHVybiBmYWxzZTsKIApkaWZmIC0tZ2l0IGEvZ2NjL3Ry ZWUtc3NhLWxvb3Atbml0ZXIuY2MgYi9nY2MvdHJlZS1zc2EtbG9vcC1uaXRlci5jYwppbmRleCBh ZmE1MTA2NDk1My4uMWUwZjYwOWQ4YjYgMTAwNjQ0Ci0tLSBhL2djYy90cmVlLXNzYS1sb29wLW5p dGVyLmNjCisrKyBiL2djYy90cmVlLXNzYS1sb29wLW5pdGVyLmNjCkBAIC0yMjEsNyArMjIxLDcg QEAgcmVmaW5lX3ZhbHVlX3JhbmdlX3VzaW5nX2d1YXJkICh0cmVlIHR5cGUsIHRyZWUgdmFyLAog ICBnZXRfdHlwZV9zdGF0aWNfYm91bmRzICh0eXBlLCBtaW50LCBtYXh0KTsKICAgbXB6X2luaXQg KG1pbmMxKTsKICAgbXB6X2luaXQgKG1heGMxKTsKLSAgdmFsdWVfcmFuZ2UgcjsKKyAgVmFsdWVf UmFuZ2UgciAoVFJFRV9UWVBFICh2YXJjMSkpOwogICAvKiBTZXR1cCByYW5nZSBpbmZvcm1hdGlv biBmb3IgdmFyYzEuICAqLwogICBpZiAoaW50ZWdlcl96ZXJvcCAodmFyYzEpKQogICAgIHsKQEAg LTM3NCw3ICszNzQsNyBAQCBkZXRlcm1pbmVfdmFsdWVfcmFuZ2UgKGNsYXNzIGxvb3AgKmxvb3As IHRyZWUgdHlwZSwgdHJlZSB2YXIsIG1wel90IG9mZiwKICAgICAgIGdwaGlfaXRlcmF0b3IgZ3Np OwogCiAgICAgICAvKiBFaXRoZXIgZm9yIFZBUiBpdHNlbGYuLi4gICovCi0gICAgICB2YWx1ZV9y YW5nZSB2YXJfcmFuZ2U7CisgICAgICBWYWx1ZV9SYW5nZSB2YXJfcmFuZ2UgKFRSRUVfVFlQRSAo dmFyKSk7CiAgICAgICBnZXRfcmFuZ2VfcXVlcnkgKGNmdW4pLT5yYW5nZV9vZl9leHByICh2YXJf cmFuZ2UsIHZhcik7CiAgICAgICBydHlwZSA9IHZhcl9yYW5nZS5raW5kICgpOwogICAgICAgaWYg KCF2YXJfcmFuZ2UudW5kZWZpbmVkX3AgKCkpCkBAIC0zODUsMTAgKzM4NSwxMCBAQCBkZXRlcm1p bmVfdmFsdWVfcmFuZ2UgKGNsYXNzIGxvb3AgKmxvb3AsIHRyZWUgdHlwZSwgdHJlZSB2YXIsIG1w el90IG9mZiwKIAogICAgICAgLyogT3IgZm9yIFBISSByZXN1bHRzIGluIGxvb3AtPmhlYWRlciB3 aGVyZSBWQVIgaXMgdXNlZCBhcwogCSBQSEkgYXJndW1lbnQgZnJvbSB0aGUgbG9vcCBwcmVoZWFk ZXIgZWRnZS4gICovCisgICAgICBWYWx1ZV9SYW5nZSBwaGlfcmFuZ2UgKFRSRUVfVFlQRSAodmFy KSk7CiAgICAgICBmb3IgKGdzaSA9IGdzaV9zdGFydF9waGlzIChsb29wLT5oZWFkZXIpOyAhZ3Np X2VuZF9wIChnc2kpOyBnc2lfbmV4dCAoJmdzaSkpCiAJewogCSAgZ3BoaSAqcGhpID0gZ3NpLnBo aSAoKTsKLQkgIHZhbHVlX3JhbmdlIHBoaV9yYW5nZTsKIAkgIGlmIChQSElfQVJHX0RFRl9GUk9N X0VER0UgKHBoaSwgZSkgPT0gdmFyCiAJICAgICAgJiYgZ2V0X3JhbmdlX3F1ZXJ5IChjZnVuKS0+ cmFuZ2Vfb2ZfZXhwciAocGhpX3JhbmdlLAogCQkJCQkJICAgIGdpbXBsZV9waGlfcmVzdWx0IChw aGkpKQpAQCAtNDEwLDcgKzQxMCw3IEBAIGRldGVybWluZV92YWx1ZV9yYW5nZSAoY2xhc3MgbG9v cCAqbG9vcCwgdHJlZSB0eXBlLCB0cmVlIHZhciwgbXB6X3Qgb2ZmLAogCQkgICAgIGludm9sdmVk LiAgKi8KIAkJICBpZiAod2k6Omd0X3AgKG1pbnYsIG1heHYsIHNnbikpCiAJCSAgICB7Ci0JCSAg ICAgIHZhbHVlX3JhbmdlIHZyOworCQkgICAgICBWYWx1ZV9SYW5nZSB2ciAoVFJFRV9UWVBFICh2 YXIpKTsKIAkJICAgICAgZ2V0X3JhbmdlX3F1ZXJ5IChjZnVuKS0+cmFuZ2Vfb2ZfZXhwciAodnIs IHZhcik7CiAJCSAgICAgIHJ0eXBlID0gdnIua2luZCAoKTsKIAkJICAgICAgaWYgKCF2ci51bmRl ZmluZWRfcCAoKSkKQEAgLTM2NTAsNyArMzY1MCw3IEBAIHJlY29yZF9ub253cmFwcGluZ19pdiAo Y2xhc3MgbG9vcCAqbG9vcCwgdHJlZSBiYXNlLCB0cmVlIHN0ZXAsIGdpbXBsZSAqc3RtdCwKICAg aWYgKHRyZWVfaW50X2NzdF9zaWduX2JpdCAoc3RlcCkpCiAgICAgewogICAgICAgd2lkZV9pbnQg bWF4OwotICAgICAgdmFsdWVfcmFuZ2UgYmFzZV9yYW5nZTsKKyAgICAgIFZhbHVlX1JhbmdlIGJh c2VfcmFuZ2UgKFRSRUVfVFlQRSAob3JpZ19iYXNlKSk7CiAgICAgICBpZiAoZ2V0X3JhbmdlX3F1 ZXJ5IChjZnVuKS0+cmFuZ2Vfb2ZfZXhwciAoYmFzZV9yYW5nZSwgb3JpZ19iYXNlKQogCSAgJiYg IWJhc2VfcmFuZ2UudW5kZWZpbmVkX3AgKCkpCiAJbWF4ID0gYmFzZV9yYW5nZS51cHBlcl9ib3Vu ZCAoKTsKQEAgLTM2NzIsNyArMzY3Miw3IEBAIHJlY29yZF9ub253cmFwcGluZ19pdiAoY2xhc3Mg bG9vcCAqbG9vcCwgdHJlZSBiYXNlLCB0cmVlIHN0ZXAsIGdpbXBsZSAqc3RtdCwKICAgZWxzZQog ICAgIHsKICAgICAgIHdpZGVfaW50IG1pbjsKLSAgICAgIHZhbHVlX3JhbmdlIGJhc2VfcmFuZ2U7 CisgICAgICBWYWx1ZV9SYW5nZSBiYXNlX3JhbmdlIChUUkVFX1RZUEUgKG9yaWdfYmFzZSkpOwog ICAgICAgaWYgKGdldF9yYW5nZV9xdWVyeSAoY2Z1biktPnJhbmdlX29mX2V4cHIgKGJhc2VfcmFu Z2UsIG9yaWdfYmFzZSkKIAkgICYmICFiYXNlX3JhbmdlLnVuZGVmaW5lZF9wICgpKQogCW1pbiA9 IGJhc2VfcmFuZ2UubG93ZXJfYm91bmQgKCk7CkBAIC0zOTQ3LDcgKzM5NDcsNyBAQCBpbmZlcl9s b29wX2JvdW5kc19mcm9tX3NpZ25lZG5lc3MgKGNsYXNzIGxvb3AgKmxvb3AsIGdpbXBsZSAqc3Rt dCkKIAogICBsb3cgPSBsb3dlcl9ib3VuZF9pbl90eXBlICh0eXBlLCB0eXBlKTsKICAgaGlnaCA9 IHVwcGVyX2JvdW5kX2luX3R5cGUgKHR5cGUsIHR5cGUpOwotICB2YWx1ZV9yYW5nZSByOworICBW YWx1ZV9SYW5nZSByIChUUkVFX1RZUEUgKGRlZikpOwogICBnZXRfcmFuZ2VfcXVlcnkgKGNmdW4p LT5yYW5nZV9vZl9leHByIChyLCBkZWYpOwogICBpZiAoci5raW5kICgpID09IFZSX1JBTkdFKQog ICAgIHsKQEAgLTQ5OTcsNyArNDk5Nyw3IEBAIHNjZXZfdmFyX3JhbmdlX2NhbnRfb3ZlcmZsb3cg KHRyZWUgdmFyLCB0cmVlIHN0ZXAsIGNsYXNzIGxvb3AgKmxvb3ApCiAgIGlmICghZGVmX2JiIHx8 ICFkb21pbmF0ZWRfYnlfcCAoQ0RJX0RPTUlOQVRPUlMsIGxvb3AtPmxhdGNoLCBkZWZfYmIpKQog ICAgIHJldHVybiBmYWxzZTsKIAotICB2YWx1ZV9yYW5nZSByOworICBWYWx1ZV9SYW5nZSByIChU UkVFX1RZUEUgKHZhcikpOwogICBnZXRfcmFuZ2VfcXVlcnkgKGNmdW4pLT5yYW5nZV9vZl9leHBy IChyLCB2YXIpOwogICBpZiAoci5raW5kICgpICE9IFZSX1JBTkdFKQogICAgIHJldHVybiBmYWxz ZTsKZGlmZiAtLWdpdCBhL2djYy90cmVlLXNzYS1sb29wLXVuc3dpdGNoLmNjIGIvZ2NjL3RyZWUt c3NhLWxvb3AtdW5zd2l0Y2guY2MKaW5kZXggYTU1OTA1YzJjNjguLmFkMWQwNWNjZGZmIDEwMDY0 NAotLS0gYS9nY2MvdHJlZS1zc2EtbG9vcC11bnN3aXRjaC5jYworKysgYi9nY2MvdHJlZS1zc2Et bG9vcC11bnN3aXRjaC5jYwpAQCAtMTQwLDEzICsxNDAsMTMgQEAgc3RydWN0IHVuc3dpdGNoX3By ZWRpY2F0ZQogCWludF9yYW5nZTwyPiByaHNfcmFuZ2UgKFRSRUVfVFlQRSAocmhzKSk7CiAJaWYg KENPTlNUQU5UX0NMQVNTX1AgKHJocykpCiAJICByaHNfcmFuZ2Uuc2V0IChyaHMpOwotCWlmICgh cmFuZ2Vfb3AtPm9wMV9yYW5nZSAodHJ1ZV9yYW5nZSwgVFJFRV9UWVBFIChsaHMpLAotCQkJCSAg aW50X3JhbmdlPDI+IChib29sZWFuX3RydWVfbm9kZSwKLQkJCQkJCWJvb2xlYW5fdHJ1ZV9ub2Rl KSwgcmhzX3JhbmdlKQotCSAgICB8fCAhcmFuZ2Vfb3AtPm9wMV9yYW5nZSAoZmFsc2VfcmFuZ2Us IFRSRUVfVFlQRSAobGhzKSwKLQkJCQkgICAgIGludF9yYW5nZTwyPiAoYm9vbGVhbl9mYWxzZV9u b2RlLAotCQkJCQkJICAgYm9vbGVhbl9mYWxzZV9ub2RlKSwKLQkJCQkgICAgIHJoc19yYW5nZSkp CisJaWYgKCFyYW5nZV9vcC5vcDFfcmFuZ2UgKHRydWVfcmFuZ2UsIFRSRUVfVFlQRSAobGhzKSwK KwkJCQkgaW50X3JhbmdlPDI+IChib29sZWFuX3RydWVfbm9kZSwKKwkJCQkJICAgICAgIGJvb2xl YW5fdHJ1ZV9ub2RlKSwgcmhzX3JhbmdlKQorCSAgICB8fCAhcmFuZ2Vfb3Aub3AxX3JhbmdlIChm YWxzZV9yYW5nZSwgVFJFRV9UWVBFIChsaHMpLAorCQkJCSAgICBpbnRfcmFuZ2U8Mj4gKGJvb2xl YW5fZmFsc2Vfbm9kZSwKKwkJCQkJCSAgYm9vbGVhbl9mYWxzZV9ub2RlKSwKKwkJCQkgICAgcmhz X3JhbmdlKSkKIAkgIHsKIAkgICAgdHJ1ZV9yYW5nZS5zZXRfdmFyeWluZyAoVFJFRV9UWVBFIChs aHMpKTsKIAkgICAgZmFsc2VfcmFuZ2Uuc2V0X3ZhcnlpbmcgKFRSRUVfVFlQRSAobGhzKSk7CmRp ZmYgLS1naXQgYS9nY2MvdHJlZS1zc2EtdGhyZWFkZWRnZS5jYyBiL2djYy90cmVlLXNzYS10aHJl YWRlZGdlLmNjCmluZGV4IDRlYjY1Y2E3Y2FjLi45MzFhYTc0NzliYiAxMDA2NDQKLS0tIGEvZ2Nj L3RyZWUtc3NhLXRocmVhZGVkZ2UuY2MKKysrIGIvZ2NjL3RyZWUtc3NhLXRocmVhZGVkZ2UuY2MK QEAgLTE0MDksMTkgKzE0MDksMTkgQEAgdHJlZQogaHlicmlkX2p0X3NpbXBsaWZpZXI6OnNpbXBs aWZ5IChnaW1wbGUgKnN0bXQsIGdpbXBsZSAqLCBiYXNpY19ibG9jaywKIAkJCQlqdF9zdGF0ZSAq c3RhdGUpCiB7Ci0gIGludF9yYW5nZV9tYXggcjsKLQogICBjb21wdXRlX3Jhbmdlc19mcm9tX3N0 YXRlIChzdG10LCBzdGF0ZSk7CiAKICAgaWYgKGdpbXBsZV9jb2RlIChzdG10KSA9PSBHSU1QTEVf Q09ORAogICAgICAgfHwgZ2ltcGxlX2NvZGUgKHN0bXQpID09IEdJTVBMRV9BU1NJR04pCiAgICAg eworICAgICAgVmFsdWVfUmFuZ2UgciAoZ2ltcGxlX3JhbmdlX3R5cGUgKHN0bXQpKTsKICAgICAg IHRyZWUgcmV0OwogICAgICAgaWYgKG1fcXVlcnktPnJhbmdlX29mX3N0bXQgKHIsIHN0bXQpICYm IHIuc2luZ2xldG9uX3AgKCZyZXQpKQogCXJldHVybiByZXQ7CiAgICAgfQogICBlbHNlIGlmIChn aW1wbGVfY29kZSAoc3RtdCkgPT0gR0lNUExFX1NXSVRDSCkKICAgICB7CisgICAgICBpbnRfcmFu Z2VfbWF4IHI7CiAgICAgICBnc3dpdGNoICpzd2l0Y2hfc3RtdCA9IGR5bl9jYXN0IDxnc3dpdGNo ICo+IChzdG10KTsKICAgICAgIHRyZWUgaW5kZXggPSBnaW1wbGVfc3dpdGNoX2luZGV4IChzd2l0 Y2hfc3RtdCk7CiAgICAgICBpZiAobV9xdWVyeS0+cmFuZ2Vfb2ZfZXhwciAociwgaW5kZXgsIHN0 bXQpKQpkaWZmIC0tZ2l0IGEvZ2NjL3ZhbHVlLXF1ZXJ5LmNjIGIvZ2NjL3ZhbHVlLXF1ZXJ5LmNj CmluZGV4IDMxZTU2ZWVhZTUzLi5lNDBlMzU4ZWJkNCAxMDA2NDQKLS0tIGEvZ2NjL3ZhbHVlLXF1 ZXJ5LmNjCisrKyBiL2djYy92YWx1ZS1xdWVyeS5jYwpAQCAtNTcsMTMgKzU3LDEzIEBAIHZhbHVl X3F1ZXJ5Ojp2YWx1ZV9vZl9zdG10IChnaW1wbGUgKnN0bXQsIHRyZWUgbmFtZSkKIC8vIHJhbmdl X3F1ZXJ5IGRlZmF1bHQgbWV0aG9kcy4KIAogYm9vbAotcmFuZ2VfcXVlcnk6OnJhbmdlX29uX2Vk Z2UgKGlyYW5nZSAmciwgZWRnZSwgdHJlZSBleHByKQorcmFuZ2VfcXVlcnk6OnJhbmdlX29uX2Vk Z2UgKHZyYW5nZSAmciwgZWRnZSwgdHJlZSBleHByKQogewogICByZXR1cm4gcmFuZ2Vfb2ZfZXhw ciAociwgZXhwcik7CiB9CiAKIGJvb2wKLXJhbmdlX3F1ZXJ5OjpyYW5nZV9vZl9zdG10IChpcmFu Z2UgJnIsIGdpbXBsZSAqc3RtdCwgdHJlZSBuYW1lKQorcmFuZ2VfcXVlcnk6OnJhbmdlX29mX3N0 bXQgKHZyYW5nZSAmciwgZ2ltcGxlICpzdG10LCB0cmVlIG5hbWUpCiB7CiAgIGlmICghbmFtZSkK ICAgICBuYW1lID0gZ2ltcGxlX2dldF9saHMgKHN0bXQpOwpAQCAtNzksMTEgKzc5LDEyIEBAIHRy ZWUKIHJhbmdlX3F1ZXJ5Ojp2YWx1ZV9vZl9leHByICh0cmVlIGV4cHIsIGdpbXBsZSAqc3RtdCkK IHsKICAgdHJlZSB0OwotICBpbnRfcmFuZ2VfbWF4IHI7CiAKLSAgaWYgKCFpcmFuZ2U6OnN1cHBv cnRzX3R5cGVfcCAoVFJFRV9UWVBFIChleHByKSkpCisgIGlmICghdnJhbmdlOjpzdXBwb3J0c190 eXBlX3AgKFRSRUVfVFlQRSAoZXhwcikpKQogICAgIHJldHVybiBOVUxMX1RSRUU7CiAKKyAgVmFs dWVfUmFuZ2UgciAoVFJFRV9UWVBFIChleHByKSk7CisKICAgaWYgKHJhbmdlX29mX2V4cHIgKHIs IGV4cHIsIHN0bXQpKQogICAgIHsKICAgICAgIC8vIEEgY29uc3RhbnQgdXNlZCBpbiBhbiB1bnJl YWNoYWJsZSBibG9jayBvZnRlbnMgcmV0dXJucyBhcyBVTkRFRklORUQuCkBAIC0xMDAsMTAgKzEw MSwxMCBAQCB0cmVlCiByYW5nZV9xdWVyeTo6dmFsdWVfb25fZWRnZSAoZWRnZSBlLCB0cmVlIGV4 cHIpCiB7CiAgIHRyZWUgdDsKLSAgaW50X3JhbmdlX21heCByOwogCi0gIGlmICghaXJhbmdlOjpz dXBwb3J0c190eXBlX3AgKFRSRUVfVFlQRSAoZXhwcikpKQorICBpZiAoIXZyYW5nZTo6c3VwcG9y dHNfdHlwZV9wIChUUkVFX1RZUEUgKGV4cHIpKSkKICAgICByZXR1cm4gTlVMTF9UUkVFOworICBW YWx1ZV9SYW5nZSByIChUUkVFX1RZUEUgKGV4cHIpKTsKICAgaWYgKHJhbmdlX29uX2VkZ2UgKHIs IGUsIGV4cHIpKQogICAgIHsKICAgICAgIC8vIEEgY29uc3RhbnQgdXNlZCBpbiBhbiB1bnJlYWNo YWJsZSBibG9jayBvZnRlbnMgcmV0dXJucyBhcyBVTkRFRklORUQuCkBAIC0xMjEsMTUgKzEyMiwx NSBAQCB0cmVlCiByYW5nZV9xdWVyeTo6dmFsdWVfb2Zfc3RtdCAoZ2ltcGxlICpzdG10LCB0cmVl IG5hbWUpCiB7CiAgIHRyZWUgdDsKLSAgaW50X3JhbmdlX21heCByOwogCiAgIGlmICghbmFtZSkK ICAgICBuYW1lID0gZ2ltcGxlX2dldF9saHMgKHN0bXQpOwogCiAgIGdjY19jaGVja2luZ19hc3Nl cnQgKCFuYW1lIHx8IG5hbWUgPT0gZ2ltcGxlX2dldF9saHMgKHN0bXQpKTsKIAotICBpZiAoIW5h bWUgfHwgIWlyYW5nZTo6c3VwcG9ydHNfdHlwZV9wIChUUkVFX1RZUEUgKG5hbWUpKSkKKyAgaWYg KCFuYW1lIHx8ICF2cmFuZ2U6OnN1cHBvcnRzX3R5cGVfcCAoVFJFRV9UWVBFIChuYW1lKSkpCiAg ICAgcmV0dXJuIE5VTExfVFJFRTsKKyAgVmFsdWVfUmFuZ2UgciAoVFJFRV9UWVBFIChuYW1lKSk7 CiAgIGlmIChyYW5nZV9vZl9zdG10IChyLCBzdG10LCBuYW1lKSAmJiByLnNpbmdsZXRvbl9wICgm dCkpCiAgICAgcmV0dXJuIHQ7CiAgIHJldHVybiBOVUxMX1RSRUU7CkBAIC0xODcsNyArMTg4LDcg QEAgcmFuZ2VfcXVlcnk6On5yYW5nZV9xdWVyeSAoKQogLy8gcmVwcmVzZW50YWJsZSwgYW5kIFVO REVGSU5FRC9mYWxzZSBpZiBub3QuCiAKIGJvb2wKLXJhbmdlX3F1ZXJ5OjpnZXRfdHJlZV9yYW5n ZSAoaXJhbmdlICZyLCB0cmVlIGV4cHIsIGdpbXBsZSAqc3RtdCkKK3JhbmdlX3F1ZXJ5OjpnZXRf dHJlZV9yYW5nZSAodnJhbmdlICZyLCB0cmVlIGV4cHIsIGdpbXBsZSAqc3RtdCkKIHsKICAgdHJl ZSB0eXBlOwogICBpZiAoVFlQRV9QIChleHByKSkKQEAgLTE5NSw3ICsxOTYsNyBAQCByYW5nZV9x dWVyeTo6Z2V0X3RyZWVfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSBleHByLCBnaW1wbGUgKnN0bXQp CiAgIGVsc2UKICAgICB0eXBlID0gVFJFRV9UWVBFIChleHByKTsKIAotICBpZiAoIWlyYW5nZTo6 c3VwcG9ydHNfdHlwZV9wICh0eXBlKSkKKyAgaWYgKCF2cmFuZ2U6OnN1cHBvcnRzX3R5cGVfcCAo dHlwZSkpCiAgICAgewogICAgICAgci5zZXRfdW5kZWZpbmVkICgpOwogICAgICAgcmV0dXJuIGZh bHNlOwpAQCAtMjE0LDcgKzIxNSw3IEBAIHJhbmdlX3F1ZXJ5OjpnZXRfdHJlZV9yYW5nZSAoaXJh bmdlICZyLCB0cmVlIGV4cHIsIGdpbXBsZSAqc3RtdCkKICAgICAgIHJldHVybiB0cnVlOwogCiAg ICAgY2FzZSBTU0FfTkFNRToKLSAgICAgIHIgPSBnaW1wbGVfcmFuZ2VfZ2xvYmFsIChleHByKTsK KyAgICAgIGdpbXBsZV9yYW5nZV9nbG9iYWwgKHIsIGV4cHIpOwogICAgICAgcmV0dXJuIHRydWU7 CiAKICAgICBjYXNlIEFERFJfRVhQUjoKQEAgLTIyMyw3ICsyMjQsNyBAQCByYW5nZV9xdWVyeTo6 Z2V0X3RyZWVfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSBleHByLCBnaW1wbGUgKnN0bXQpCiAJYm9v bCBvdjsKIAlpZiAodHJlZV9zaW5nbGVfbm9uemVyb193YXJudl9wIChleHByLCAmb3YpKQogCSAg ewotCSAgICByID0gcmFuZ2Vfbm9uemVybyAodHlwZSk7CisJICAgIHIuc2V0X25vbnplcm8gKHR5 cGUpOwogCSAgICByZXR1cm4gdHJ1ZTsKIAkgIH0KIAlicmVhazsKQEAgLTIzNyw3ICsyMzgsOCBA QCByYW5nZV9xdWVyeTo6Z2V0X3RyZWVfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSBleHByLCBnaW1w bGUgKnN0bXQpCiAgICAgICByYW5nZV9vcF9oYW5kbGVyIG9wIChUUkVFX0NPREUgKGV4cHIpLCB0 eXBlKTsKICAgICAgIGlmIChvcCkKIAl7Ci0JICBpbnRfcmFuZ2VfbWF4IHIwLCByMTsKKwkgIFZh bHVlX1JhbmdlIHIwIChUUkVFX1RZUEUgKFRSRUVfT1BFUkFORCAoZXhwciwgMCkpKTsKKwkgIFZh bHVlX1JhbmdlIHIxIChUUkVFX1RZUEUgKFRSRUVfT1BFUkFORCAoZXhwciwgMSkpKTsKIAkgIHJh bmdlX29mX2V4cHIgKHIwLCBUUkVFX09QRVJBTkQgKGV4cHIsIDApLCBzdG10KTsKIAkgIHJhbmdl X29mX2V4cHIgKHIxLCBUUkVFX09QRVJBTkQgKGV4cHIsIDEpLCBzdG10KTsKIAkgIG9wLmZvbGRf cmFuZ2UgKHIsIHR5cGUsIHIwLCByMSk7CkBAIC0yNTAsMTEgKzI1MiwxMyBAQCByYW5nZV9xdWVy eTo6Z2V0X3RyZWVfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSBleHByLCBnaW1wbGUgKnN0bXQpCiAg ICAgewogICAgICAgcmFuZ2Vfb3BfaGFuZGxlciBvcCAoVFJFRV9DT0RFIChleHByKSwgdHlwZSk7 CiAgICAgICB0cmVlIG9wMF90eXBlID0gVFJFRV9UWVBFIChUUkVFX09QRVJBTkQgKGV4cHIsIDAp KTsKLSAgICAgIGlmIChvcCAmJiBpcmFuZ2U6OnN1cHBvcnRzX3R5cGVfcCAob3AwX3R5cGUpKQor ICAgICAgaWYgKG9wICYmIHZyYW5nZTo6c3VwcG9ydHNfdHlwZV9wIChvcDBfdHlwZSkpCiAJewot CSAgaW50X3JhbmdlX21heCByMDsKKwkgIFZhbHVlX1JhbmdlIHIwIChUUkVFX1RZUEUgKFRSRUVf T1BFUkFORCAoZXhwciwgMCkpKTsKKwkgIFZhbHVlX1JhbmdlIHIxICh0eXBlKTsKKwkgIHIxLnNl dF92YXJ5aW5nICh0eXBlKTsKIAkgIHJhbmdlX29mX2V4cHIgKHIwLCBUUkVFX09QRVJBTkQgKGV4 cHIsIDApLCBzdG10KTsKLQkgIG9wLmZvbGRfcmFuZ2UgKHIsIHR5cGUsIHIwLCBpbnRfcmFuZ2U8 MT4gKHR5cGUpKTsKKwkgIG9wLmZvbGRfcmFuZ2UgKHIsIHR5cGUsIHIwLCByMSk7CiAJfQogICAg ICAgZWxzZQogCXIuc2V0X3ZhcnlpbmcgKHR5cGUpOwpAQCAtMzExLDcgKzMxNSw3IEBAIGdldF9z c2FfbmFtZV9wdHJfaW5mb19ub25udWxsIChjb25zdF90cmVlIG5hbWUpCiAvLyB1cGRhdGVkLgog CiBib29sCi11cGRhdGVfZ2xvYmFsX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSkKK3VwZGF0 ZV9nbG9iYWxfcmFuZ2UgKHZyYW5nZSAmciwgdHJlZSBuYW1lKQogewogICB0cmVlIHR5cGUgPSBU UkVFX1RZUEUgKG5hbWUpOwogCkBAIC0zMzAsOCArMzM0LDcgQEAgdXBkYXRlX2dsb2JhbF9yYW5n ZSAoaXJhbmdlICZyLCB0cmVlIG5hbWUpCiAgICAgICBpZiAoci51bmRlZmluZWRfcCAoKSkKIAly ZXR1cm4gZmFsc2U7CiAKLSAgICAgIHZhbHVlX3JhbmdlIHZyID0gcjsKLSAgICAgIHNldF9yYW5n ZV9pbmZvIChuYW1lLCB2cik7CisgICAgICBzZXRfcmFuZ2VfaW5mbyAobmFtZSwgYXNfYSA8aXJh bmdlPiAocikpOwogICAgICAgcmV0dXJuIHRydWU7CiAgICAgfQogICBlbHNlIGlmIChQT0lOVEVS X1RZUEVfUCAodHlwZSkpCkBAIC0zNDksNyArMzUyLDcgQEAgdXBkYXRlX2dsb2JhbF9yYW5nZSAo aXJhbmdlICZyLCB0cmVlIG5hbWUpCiAvLyByZXR1cm4gVkFSWUlORy4KIAogc3RhdGljIHZvaWQK LWdldF9yYW5nZV9nbG9iYWwgKGlyYW5nZSAmciwgdHJlZSBuYW1lKQorZ2V0X3JhbmdlX2dsb2Jh bCAodnJhbmdlICZyLCB0cmVlIG5hbWUpCiB7CiAgIHRyZWUgdHlwZSA9IFRSRUVfVFlQRSAobmFt ZSk7CiAKQEAgLTM2OSw3ICszNzIsNyBAQCBnZXRfcmFuZ2VfZ2xvYmFsIChpcmFuZ2UgJnIsIHRy ZWUgbmFtZSkKIAkgICAgci5zZXRfbm9uemVybyAodHlwZSk7CiAJICBlbHNlIGlmIChJTlRFR1JB TF9UWVBFX1AgKHR5cGUpKQogCSAgICB7Ci0JICAgICAgZ2V0X3NzYV9uYW1lX3JhbmdlX2luZm8g KHIsIG5hbWUpOworCSAgICAgIGdldF9zc2FfbmFtZV9yYW5nZV9pbmZvIChhc19hIDxpcmFuZ2U+ IChyKSwgbmFtZSk7CiAJICAgICAgaWYgKHIudW5kZWZpbmVkX3AgKCkpCiAJCXIuc2V0X3Zhcnlp bmcgKHR5cGUpOwogCSAgICB9CkBAIC0zODQsNyArMzg3LDggQEAgZ2V0X3JhbmdlX2dsb2JhbCAo aXJhbmdlICZyLCB0cmVlIG5hbWUpCiAgICB9CiAgIGVsc2UgaWYgKCFQT0lOVEVSX1RZUEVfUCAo dHlwZSkgJiYgU1NBX05BTUVfUkFOR0VfSU5GTyAobmFtZSkpCiAgICAgewotICAgICAgZ2V0X3Nz YV9uYW1lX3JhbmdlX2luZm8gKHIsIG5hbWUpOworICAgICAgZ2NjX2NoZWNraW5nX2Fzc2VydCAo aXJhbmdlOjpzdXBwb3J0c190eXBlX3AgKFRSRUVfVFlQRSAobmFtZSkpKTsKKyAgICAgIGdldF9z c2FfbmFtZV9yYW5nZV9pbmZvIChhc19hIDxpcmFuZ2U+IChyKSwgbmFtZSk7CiAgICAgICBpZiAo ci51bmRlZmluZWRfcCAoKSkKIAlyLnNldF92YXJ5aW5nICh0eXBlKTsKICAgICB9CkBAIC00MTQs MjEgKzQxOCwxOSBAQCBnZXRfcmFuZ2VfZ2xvYmFsIChpcmFuZ2UgJnIsIHRyZWUgbmFtZSkKIC8v IFNlZSBkaXNjdXNzaW9uIGhlcmU6CiAvLyBodHRwczovL2djYy5nbnUub3JnL3BpcGVybWFpbC9n Y2MtcGF0Y2hlcy8yMDIxLUp1bmUvNTcxNzA5Lmh0bWwKIAotdmFsdWVfcmFuZ2UKLWdpbXBsZV9y YW5nZV9nbG9iYWwgKHRyZWUgbmFtZSkKK3ZvaWQKK2dpbXBsZV9yYW5nZV9nbG9iYWwgKHZyYW5n ZSAmciwgdHJlZSBuYW1lKQogewogICB0cmVlIHR5cGUgPSBUUkVFX1RZUEUgKG5hbWUpOwotICBn Y2NfY2hlY2tpbmdfYXNzZXJ0IChUUkVFX0NPREUgKG5hbWUpID09IFNTQV9OQU1FCi0JCSAgICAg ICAmJiBpcmFuZ2U6OnN1cHBvcnRzX3R5cGVfcCAodHlwZSkpOworICBnY2NfY2hlY2tpbmdfYXNz ZXJ0IChUUkVFX0NPREUgKG5hbWUpID09IFNTQV9OQU1FKTsKIAogICBpZiAoU1NBX05BTUVfSVNf REVGQVVMVF9ERUYgKG5hbWUpIHx8IChjZnVuICYmIGNmdW4tPmFmdGVyX2lubGluaW5nKQogICAg ICAgfHwgaXNfYTxncGhpICo+IChTU0FfTkFNRV9ERUZfU1RNVCAobmFtZSkpKQogICAgIHsKLSAg ICAgIHZhbHVlX3JhbmdlIHZyOwotICAgICAgZ2V0X3JhbmdlX2dsb2JhbCAodnIsIG5hbWUpOwot ICAgICAgcmV0dXJuIHZyOworICAgICAgZ2V0X3JhbmdlX2dsb2JhbCAociwgbmFtZSk7CisgICAg ICByZXR1cm47CiAgICAgfQotICByZXR1cm4gdmFsdWVfcmFuZ2UgKHR5cGUpOworICByLnNldF92 YXJ5aW5nICh0eXBlKTsKIH0KIAogLy8gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQpAQCAtNDM3LDcgKzQzOSw3IEBAIGdpbXBsZV9yYW5nZV9nbG9iYWwgKHRy ZWUgbmFtZSkKIGdsb2JhbF9yYW5nZV9xdWVyeSBnbG9iYWxfcmFuZ2VzOwogCiBib29sCi1nbG9i YWxfcmFuZ2VfcXVlcnk6OnJhbmdlX29mX2V4cHIgKGlyYW5nZSAmciwgdHJlZSBleHByLCBnaW1w bGUgKnN0bXQpCitnbG9iYWxfcmFuZ2VfcXVlcnk6OnJhbmdlX29mX2V4cHIgKHZyYW5nZSAmciwg dHJlZSBleHByLCBnaW1wbGUgKnN0bXQpCiB7CiAgIHRyZWUgdHlwZSA9IFRSRUVfVFlQRSAoZXhw cik7CiAKQEAgLTQ1NiwxNSArNDU4LDE2IEBAIGdsb2JhbF9yYW5nZV9xdWVyeTo6cmFuZ2Vfb2Zf ZXhwciAoaXJhbmdlICZyLCB0cmVlIGV4cHIsIGdpbXBsZSAqc3RtdCkKIHJlbGF0aW9uX2tpbmQK IHJhbmdlX3F1ZXJ5OjpxdWVyeV9yZWxhdGlvbiAoZ2ltcGxlICpzLCB0cmVlIHNzYTEsIHRyZWUg c3NhMiwgYm9vbCBnZXRfcmFuZ2UpCiB7Ci0gIGludF9yYW5nZV9tYXggdG1wOwogICBpZiAoIW1f b3JhY2xlIHx8IFRSRUVfQ09ERSAoc3NhMSkgIT0gU1NBX05BTUUgfHwgVFJFRV9DT0RFIChzc2Ey KSAhPSBTU0FfTkFNRSkKICAgICByZXR1cm4gVlJFTF9WQVJZSU5HOwogCiAgIC8vIEVuc3VyZSBz c2ExIGFuZCBzc2EyIGhhdmUgYm90aCBiZWVuIGV2YWx1YXRlZC4KICAgaWYgKGdldF9yYW5nZSkK ICAgICB7Ci0gICAgICByYW5nZV9vZl9leHByICh0bXAsIHNzYTEsIHMpOwotICAgICAgcmFuZ2Vf b2ZfZXhwciAodG1wLCBzc2EyLCBzKTsKKyAgICAgIFZhbHVlX1JhbmdlIHRtcDEgKFRSRUVfVFlQ RSAoc3NhMSkpOworICAgICAgVmFsdWVfUmFuZ2UgdG1wMiAoVFJFRV9UWVBFIChzc2EyKSk7Cisg ICAgICByYW5nZV9vZl9leHByICh0bXAxLCBzc2ExLCBzKTsKKyAgICAgIHJhbmdlX29mX2V4cHIg KHRtcDIsIHNzYTIsIHMpOwogICAgIH0KICAgcmV0dXJuIG1fb3JhY2xlLT5xdWVyeV9yZWxhdGlv biAoZ2ltcGxlX2JiIChzKSwgc3NhMSwgc3NhMik7CiB9CkBAIC00NzcsNyArNDgwLDYgQEAgcmVs YXRpb25fa2luZAogcmFuZ2VfcXVlcnk6OnF1ZXJ5X3JlbGF0aW9uIChlZGdlIGUsIHRyZWUgc3Nh MSwgdHJlZSBzc2EyLCBib29sIGdldF9yYW5nZSkKIHsKICAgYmFzaWNfYmxvY2sgYmI7Ci0gIGlu dF9yYW5nZV9tYXggdG1wOwogICBpZiAoIW1fb3JhY2xlIHx8IFRSRUVfQ09ERSAoc3NhMSkgIT0g U1NBX05BTUUgfHwgVFJFRV9DT0RFIChzc2EyKSAhPSBTU0FfTkFNRSkKICAgICByZXR1cm4gVlJF TF9WQVJZSU5HOwogCkBAIC00OTIsNiArNDk0LDcgQEAgcmFuZ2VfcXVlcnk6OnF1ZXJ5X3JlbGF0 aW9uIChlZGdlIGUsIHRyZWUgc3NhMSwgdHJlZSBzc2EyLCBib29sIGdldF9yYW5nZSkKICAgLy8g RW5zdXJlIHNzYTEgYW5kIHNzYTIgaGF2ZSBib3RoIGJlZW4gZXZhbHVhdGVkLgogICBpZiAoZ2V0 X3JhbmdlKQogICAgIHsKKyAgICAgIFZhbHVlX1JhbmdlIHRtcCAoVFJFRV9UWVBFIChzc2ExKSk7 CiAgICAgICByYW5nZV9vbl9lZGdlICh0bXAsIGUsIHNzYTEpOwogICAgICAgcmFuZ2Vfb25fZWRn ZSAodG1wLCBlLCBzc2EyKTsKICAgICB9CmRpZmYgLS1naXQgYS9nY2MvdmFsdWUtcXVlcnkuaCBi L2djYy92YWx1ZS1xdWVyeS5oCmluZGV4IGNmMWExZDc0ZGUzLi4yODBlNDdlM2Y2YiAxMDA2NDQK LS0tIGEvZ2NjL3ZhbHVlLXF1ZXJ5LmgKKysrIGIvZ2NjL3ZhbHVlLXF1ZXJ5LmgKQEAgLTg5LDkg Kzg5LDkgQEAgcHVibGljOgogICAvLwogICAvLyBOb3RlIHRoYXQgcmFuZ2Vfb2ZfZXhwciBtdXN0 IGFsd2F5cyByZXR1cm4gVFJVRSB1bmxlc3MgcmFuZ2VzIGFyZQogICAvLyB1bnN1cHBvcnRlZCBm b3IgRVhQUidzIHR5cGUgKHN1cHBvcnRzX3R5cGVfcCBpcyBmYWxzZSkuCi0gIHZpcnR1YWwgYm9v bCByYW5nZV9vZl9leHByIChpcmFuZ2UgJnIsIHRyZWUgZXhwciwgZ2ltcGxlICogPSBOVUxMKSA9 IDA7Ci0gIHZpcnR1YWwgYm9vbCByYW5nZV9vbl9lZGdlIChpcmFuZ2UgJnIsIGVkZ2UsIHRyZWUg ZXhwcik7Ci0gIHZpcnR1YWwgYm9vbCByYW5nZV9vZl9zdG10IChpcmFuZ2UgJnIsIGdpbXBsZSAq LCB0cmVlIG5hbWUgPSBOVUxMKTsKKyAgdmlydHVhbCBib29sIHJhbmdlX29mX2V4cHIgKHZyYW5n ZSAmciwgdHJlZSBleHByLCBnaW1wbGUgKiA9IE5VTEwpID0gMDsKKyAgdmlydHVhbCBib29sIHJh bmdlX29uX2VkZ2UgKHZyYW5nZSAmciwgZWRnZSwgdHJlZSBleHByKTsKKyAgdmlydHVhbCBib29s IHJhbmdlX29mX3N0bXQgKHZyYW5nZSAmciwgZ2ltcGxlICosIHRyZWUgbmFtZSA9IE5VTEwpOwog CiAgIC8vIFF1ZXJ5IGlmIHRoZXJlIGlzIGFueSByZWxhdGlvbiBiZXR3ZWVuIFNTQTEgYW5kIFNT QTIuCiAgIHJlbGF0aW9uX2tpbmQgcXVlcnlfcmVsYXRpb24gKGdpbXBsZSAqcywgdHJlZSBzc2Ex LCB0cmVlIHNzYTIsCkBAIC0xMTAsOCArMTEwLDggQEAgcHVibGljOgogcHJvdGVjdGVkOgogICBj bGFzcyB2YWx1ZV9yYW5nZV9lcXVpdiAqYWxsb2NhdGVfdmFsdWVfcmFuZ2VfZXF1aXYgKCk7CiAg IHZvaWQgZnJlZV92YWx1ZV9yYW5nZV9lcXVpdiAoY2xhc3MgdmFsdWVfcmFuZ2VfZXF1aXYgKik7 Ci0gIGJvb2wgZ2V0X3RyZWVfcmFuZ2UgKGlyYW5nZSAmciwgdHJlZSBleHByLCBnaW1wbGUgKnN0 bXQpOwotICBib29sIGdldF9hcml0aF9leHByX3JhbmdlIChpcmFuZ2UgJnIsIHRyZWUgZXhwciwg Z2ltcGxlICpzdG10KTsKKyAgYm9vbCBnZXRfdHJlZV9yYW5nZSAodnJhbmdlICZ2LCB0cmVlIGV4 cHIsIGdpbXBsZSAqc3RtdCk7CisgIGJvb2wgZ2V0X2FyaXRoX2V4cHJfcmFuZ2UgKHZyYW5nZSAm ciwgdHJlZSBleHByLCBnaW1wbGUgKnN0bXQpOwogICByZWxhdGlvbl9vcmFjbGUgKm1fb3JhY2xl OwogCiBwcml2YXRlOgpAQCAtMTIzLDcgKzEyMyw3IEBAIHByaXZhdGU6CiBjbGFzcyBnbG9iYWxf cmFuZ2VfcXVlcnkgOiBwdWJsaWMgcmFuZ2VfcXVlcnkKIHsKIHB1YmxpYzoKLSAgYm9vbCByYW5n ZV9vZl9leHByIChpcmFuZ2UgJnIsIHRyZWUgZXhwciwgZ2ltcGxlICogPSBOVUxMKSBvdmVycmlk ZTsKKyAgYm9vbCByYW5nZV9vZl9leHByICh2cmFuZ2UgJnIsIHRyZWUgZXhwciwgZ2ltcGxlICog PSBOVUxMKSBvdmVycmlkZTsKIH07CiAKIGV4dGVybiBnbG9iYWxfcmFuZ2VfcXVlcnkgZ2xvYmFs X3JhbmdlczsKQEAgLTE0Myw3ICsxNDMsNyBAQCBnZXRfcmFuZ2VfcXVlcnkgKGNvbnN0IHN0cnVj dCBmdW5jdGlvbiAqZnVuKQogICByZXR1cm4gZnVuLT54X3JhbmdlX3F1ZXJ5ID8gZnVuLT54X3Jh bmdlX3F1ZXJ5IDogJmdsb2JhbF9yYW5nZXM7CiB9CiAKLWV4dGVybiB2YWx1ZV9yYW5nZSBnaW1w bGVfcmFuZ2VfZ2xvYmFsICh0cmVlIG5hbWUpOwotZXh0ZXJuIGJvb2wgdXBkYXRlX2dsb2JhbF9y YW5nZSAoaXJhbmdlICZyLCB0cmVlIG5hbWUpOworZXh0ZXJuIHZvaWQgZ2ltcGxlX3JhbmdlX2ds b2JhbCAodnJhbmdlICZ2LCB0cmVlIG5hbWUpOworZXh0ZXJuIGJvb2wgdXBkYXRlX2dsb2JhbF9y YW5nZSAodnJhbmdlICZ2LCB0cmVlIG5hbWUpOwogCiAjZW5kaWYgLy8gR0NDX1FVRVJZX0gKZGlm ZiAtLWdpdCBhL2djYy92ci12YWx1ZXMuY2MgYi9nY2MvdnItdmFsdWVzLmNjCmluZGV4IDZmODU4 M2M4ZDAxLi4zOGYyMDRlMmY1ZCAxMDA2NDQKLS0tIGEvZ2NjL3ZyLXZhbHVlcy5jYworKysgYi9n Y2MvdnItdmFsdWVzLmNjCkBAIC0xNzcsNyArMTc3LDcgQEAgdnJfdmFsdWVzOjpnZXRfdmFsdWVf cmFuZ2UgKGNvbnN0X3RyZWUgdmFyLAogfQogCiBib29sCi12cl92YWx1ZXM6OnJhbmdlX29mX2V4 cHIgKGlyYW5nZSAmciwgdHJlZSBleHByLCBnaW1wbGUgKnN0bXQpCit2cl92YWx1ZXM6OnJhbmdl X29mX2V4cHIgKHZyYW5nZSAmciwgdHJlZSBleHByLCBnaW1wbGUgKnN0bXQpCiB7CiAgIGlmICgh Z2ltcGxlX3JhbmdlX3NzYV9wIChleHByKSkKICAgICByZXR1cm4gZ2V0X3RyZWVfcmFuZ2UgKHIs IGV4cHIsIHN0bXQpOwpAQCAtMTYzMCw2ICsxNjMwLDIwIEBAIGNvbXBhcmVfcmFuZ2Vfd2l0aF92 YWx1ZSAoZW51bSB0cmVlX2NvZGUgY29tcCwgY29uc3QgdmFsdWVfcmFuZ2UgKnZyLAogICBnY2Nf dW5yZWFjaGFibGUgKCk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgdm9pZAorZml4X292ZXJmbG93ICh0 cmVlICptaW4sIHRyZWUgKm1heCkKK3sKKyAgLyogRXZlbiBmb3IgdmFsaWQgcmFuZ2UgaW5mbywg c29tZXRpbWVzIG92ZXJmbG93IGZsYWcgd2lsbCBsZWFrIGluLgorICAgICBBcyBHSU1QTEUgSUwg c2hvdWxkIGhhdmUgbm8gY29uc3RhbnRzIHdpdGggVFJFRV9PVkVSRkxPVyBzZXQsIHdlCisgICAg IGRyb3AgdGhlbS4gICovCisgIGlmIChUUkVFX09WRVJGTE9XX1AgKCptaW4pKQorICAgICptaW4g PSBkcm9wX3RyZWVfb3ZlcmZsb3cgKCptaW4pOworICBpZiAoVFJFRV9PVkVSRkxPV19QICgqbWF4 KSkKKyAgICAqbWF4ID0gZHJvcF90cmVlX292ZXJmbG93ICgqbWF4KTsKKworICBnY2NfY2hlY2tp bmdfYXNzZXJ0IChjb21wYXJlX3ZhbHVlcyAoKm1pbiwgKm1heCkgIT0gMSk7Cit9CisKIC8qIEdp dmVuIGEgVkFSIGluIFNUTVQgd2l0aGluIExPT1AsIGRldGVybWluZSB0aGUgYm91bmRzIG9mIHRo ZQogICAgdmFyaWFibGUgYW5kIHN0b3JlIGl0IGluIE1JTi9NQVggYW5kIHJldHVybiBUUlVFLiAg SWYgbm8gYm91bmRzCiAgICBjb3VsZCBiZSBkZXRlcm1pbmVkLCByZXR1cm4gRkFMU0UuICAqLwpA QCAtMTY0MCw2ICsxNjU0LDcgQEAgYm91bmRzX29mX3Zhcl9pbl9sb29wICh0cmVlICptaW4sIHRy ZWUgKm1heCwgcmFuZ2VfcXVlcnkgKnF1ZXJ5LAogewogICB0cmVlIGluaXQsIHN0ZXAsIGNocmVj LCB0bWluLCB0bWF4LCB0eXBlID0gVFJFRV9UWVBFICh2YXIpOwogICBlbnVtIGV2X2RpcmVjdGlv biBkaXI7CisgIGludF9yYW5nZTwyPiByOwogCiAgIGNocmVjID0gaW5zdGFudGlhdGVfcGFyYW1l dGVycyAobG9vcCwgYW5hbHl6ZV9zY2FsYXJfZXZvbHV0aW9uIChsb29wLCB2YXIpKTsKIApAQCAt MTY0Nyw3ICsxNjYyLDggQEAgYm91bmRzX29mX3Zhcl9pbl9sb29wICh0cmVlICptaW4sIHRyZWUg Km1heCwgcmFuZ2VfcXVlcnkgKnF1ZXJ5LAogICBpZiAoaXNfZ2ltcGxlX21pbl9pbnZhcmlhbnQg KGNocmVjKSkKICAgICB7CiAgICAgICAqbWluID0gKm1heCA9IGNocmVjOwotICAgICAgZ290byBm aXhfb3ZlcmZsb3c7CisgICAgICBmaXhfb3ZlcmZsb3cgKG1pbiwgbWF4KTsKKyAgICAgIHJldHVy biB0cnVlOwogICAgIH0KIAogICBpZiAoVFJFRV9DT0RFIChjaHJlYykgIT0gUE9MWU5PTUlBTF9D SFJFQykKQEAgLTE2NTksMTMgKzE2NzUsMTcgQEAgYm91bmRzX29mX3Zhcl9pbl9sb29wICh0cmVl ICptaW4sIHRyZWUgKm1heCwgcmFuZ2VfcXVlcnkgKnF1ZXJ5LAogICBpZiAoIWluaXQgfHwgIXN0 ZXApCiAgICAgcmV0dXJuIGZhbHNlOwogCisgIFZhbHVlX1JhbmdlIHJpbml0IChUUkVFX1RZUEUg KGluaXQpKTsKKyAgVmFsdWVfUmFuZ2UgcnN0ZXAgKFRSRUVfVFlQRSAoc3RlcCkpOwogICAvKiBJ ZiBJTklUIGlzIGFuIFNTQSB3aXRoIGEgc2luZ2xldG9uIHJhbmdlLCBzZXQgSU5JVCB0byBzYWlk CiAgICAgIHNpbmdsZXRvbiwgb3RoZXJ3aXNlIGxlYXZlIElOSVQgYWxvbmUuICAqLwotICBpZiAo VFJFRV9DT0RFIChpbml0KSA9PSBTU0FfTkFNRSkKLSAgICBxdWVyeS0+Z2V0X3ZhbHVlX3Jhbmdl IChpbml0LCBzdG10KS0+c2luZ2xldG9uX3AgKCZpbml0KTsKKyAgaWYgKFRSRUVfQ09ERSAoaW5p dCkgPT0gU1NBX05BTUUKKyAgICAgICYmIHF1ZXJ5LT5yYW5nZV9vZl9leHByIChyaW5pdCwgaW5p dCwgc3RtdCkpCisgICAgcmluaXQuc2luZ2xldG9uX3AgKCZpbml0KTsKICAgLyogTGlrZXdpc2Ug Zm9yIHN0ZXAuICAqLwotICBpZiAoVFJFRV9DT0RFIChzdGVwKSA9PSBTU0FfTkFNRSkKLSAgICBx dWVyeS0+Z2V0X3ZhbHVlX3JhbmdlIChzdGVwLCBzdG10KS0+c2luZ2xldG9uX3AgKCZzdGVwKTsK KyAgaWYgKFRSRUVfQ09ERSAoc3RlcCkgPT0gU1NBX05BTUUKKyAgICAgICYmIHF1ZXJ5LT5yYW5n ZV9vZl9leHByIChyc3RlcCwgc3RlcCwgc3RtdCkpCisgICAgcnN0ZXAuc2luZ2xldG9uX3AgKCZz dGVwKTsKIAogICAvKiBJZiBTVEVQIGlzIHN5bWJvbGljLCB3ZSBjYW4ndCBrbm93IHdoZXRoZXIg SU5JVCB3aWxsIGJlIHRoZQogICAgICBtaW5pbXVtIG9yIG1heGltdW0gdmFsdWUgaW4gdGhlIHJh bmdlLiAgQWxzbywgdW5sZXNzIElOSVQgaXMKQEAgLTE2OTksNyArMTcxOSw4IEBAIGJvdW5kc19v Zl92YXJfaW5fbG9vcCAodHJlZSAqbWluLCB0cmVlICptYXgsIHJhbmdlX3F1ZXJ5ICpxdWVyeSwK ICAgaWYgKFRSRUVfQ09ERSAoc3RlcCkgPT0gSU5URUdFUl9DU1QKICAgICAgICYmIGlzX2dpbXBs ZV92YWwgKGluaXQpCiAgICAgICAmJiAoVFJFRV9DT0RFIChpbml0KSAhPSBTU0FfTkFNRQotCSAg fHwgcXVlcnktPmdldF92YWx1ZV9yYW5nZSAoaW5pdCwgc3RtdCktPmtpbmQgKCkgPT0gVlJfUkFO R0UpKQorCSAgfHwgKHF1ZXJ5LT5yYW5nZV9vZl9leHByIChyLCBpbml0LCBzdG10KQorCSAgICAg ICYmIHIua2luZCAoKSA9PSBWUl9SQU5HRSkpKQogICAgIHsKICAgICAgIHdpZGVzdF9pbnQgbml0 OwogCkBAIC0xNzI0LDcgKzE3NDUsNyBAQCBib3VuZHNfb2ZfdmFyX2luX2xvb3AgKHRyZWUgKm1p biwgdHJlZSAqbWF4LCByYW5nZV9xdWVyeSAqcXVlcnksCiAJICAgIHsKIAkgICAgICB2YWx1ZV9y YW5nZSBtYXh2ciwgdnIwLCB2cjE7CiAJICAgICAgaWYgKFRSRUVfQ09ERSAoaW5pdCkgPT0gU1NB X05BTUUpCi0JCXZyMCA9ICoocXVlcnktPmdldF92YWx1ZV9yYW5nZSAoaW5pdCwgc3RtdCkpOwor CQlxdWVyeS0+cmFuZ2Vfb2ZfZXhwciAodnIwLCBpbml0LCBzdG10KTsKIAkgICAgICBlbHNlIGlm IChpc19naW1wbGVfbWluX2ludmFyaWFudCAoaW5pdCkpCiAJCXZyMC5zZXQgKGluaXQpOwogCSAg ICAgIGVsc2UKQEAgLTE3MzcsMTAgKzE3NTgsMTAgQEAgYm91bmRzX29mX3Zhcl9pbl9sb29wICh0 cmVlICptaW4sIHRyZWUgKm1heCwgcmFuZ2VfcXVlcnkgKnF1ZXJ5LAogCSAgICAgIC8qIExpa2V3 aXNlIGlmIHRoZSBhZGRpdGlvbiBkaWQuICAqLwogCSAgICAgIGlmIChtYXh2ci5raW5kICgpID09 IFZSX1JBTkdFKQogCQl7Ci0JCSAgdmFsdWVfcmFuZ2UgaW5pdHZyOworCQkgIGludF9yYW5nZTwy PiBpbml0dnI7CiAKIAkJICBpZiAoVFJFRV9DT0RFIChpbml0KSA9PSBTU0FfTkFNRSkKLQkJICAg IGluaXR2ciA9ICoocXVlcnktPmdldF92YWx1ZV9yYW5nZSAoaW5pdCwgc3RtdCkpOworCQkgICAg cXVlcnktPnJhbmdlX29mX2V4cHIgKGluaXR2ciwgaW5pdCwgc3RtdCk7CiAJCSAgZWxzZSBpZiAo aXNfZ2ltcGxlX21pbl9pbnZhcmlhbnQgKGluaXQpKQogCQkgICAgaW5pdHZyLnNldCAoaW5pdCk7 CiAJCSAgZWxzZQpAQCAtMTc3MCwxNiArMTc5MSw3IEBAIGJvdW5kc19vZl92YXJfaW5fbG9vcCAo dHJlZSAqbWluLCB0cmVlICptYXgsIHJhbmdlX3F1ZXJ5ICpxdWVyeSwKICAgZWxzZQogICAgICpt aW4gPSBpbml0OwogCi0gZml4X292ZXJmbG93OgotICAvKiBFdmVuIGZvciB2YWxpZCByYW5nZSBp bmZvLCBzb21ldGltZXMgb3ZlcmZsb3cgZmxhZyB3aWxsIGxlYWsgaW4uCi0gICAgIEFzIEdJTVBM RSBJTCBzaG91bGQgaGF2ZSBubyBjb25zdGFudHMgd2l0aCBUUkVFX09WRVJGTE9XIHNldCwgd2UK LSAgICAgZHJvcCB0aGVtLiAgKi8KLSAgaWYgKFRSRUVfT1ZFUkZMT1dfUCAoKm1pbikpCi0gICAg Km1pbiA9IGRyb3BfdHJlZV9vdmVyZmxvdyAoKm1pbik7Ci0gIGlmIChUUkVFX09WRVJGTE9XX1Ag KCptYXgpKQotICAgICptYXggPSBkcm9wX3RyZWVfb3ZlcmZsb3cgKCptYXgpOwotCi0gIGdjY19j aGVja2luZ19hc3NlcnQgKGNvbXBhcmVfdmFsdWVzICgqbWluLCAqbWF4KSAhPSAxKTsKKyAgZml4 X292ZXJmbG93IChtaW4sIG1heCk7CiAgIHJldHVybiB0cnVlOwogfQogCkBAIC0yNDQ2LDcgKzI0 NTgsOSBAQCBzaW1wbGlmeV91c2luZ19yYW5nZXM6OnZycF92aXNpdF9jb25kX3N0bXQgKGdjb25k ICpzdG10LCBlZGdlICp0YWtlbl9lZGdlX3ApCiAJICBmcHJpbnRmIChkdW1wX2ZpbGUsICJcdCIp OwogCSAgcHJpbnRfZ2VuZXJpY19leHByIChkdW1wX2ZpbGUsIHVzZSk7CiAJICBmcHJpbnRmIChk dW1wX2ZpbGUsICI6ICIpOwotCSAgZHVtcF92YWx1ZV9yYW5nZSAoZHVtcF9maWxlLCBxdWVyeS0+ Z2V0X3ZhbHVlX3JhbmdlICh1c2UsIHN0bXQpKTsKKwkgIFZhbHVlX1JhbmdlIHIgKFRSRUVfVFlQ RSAodXNlKSk7CisJICBxdWVyeS0+cmFuZ2Vfb2ZfZXhwciAociwgdXNlLCBzdG10KTsKKwkgIHIu ZHVtcCAoZHVtcF9maWxlKTsKIAl9CiAKICAgICAgIGZwcmludGYgKGR1bXBfZmlsZSwgIlxuIik7 CmRpZmYgLS1naXQgYS9nY2MvdnItdmFsdWVzLmggYi9nY2MvdnItdmFsdWVzLmgKaW5kZXggN2Ez NzdjZWJkMDEuLmYwMThkMGRmYzRiIDEwMDY0NAotLS0gYS9nY2MvdnItdmFsdWVzLmgKKysrIGIv Z2NjL3ZyLXZhbHVlcy5oCkBAIC0xMDksNyArMTA5LDcgQEAgY2xhc3MgdnJfdmFsdWVzIDogcHVi bGljIHJhbmdlX3F1ZXJ5CiAgIHZyX3ZhbHVlcyAodm9pZCk7CiAgIH52cl92YWx1ZXMgKHZvaWQp OwogCi0gIHZpcnR1YWwgYm9vbCByYW5nZV9vZl9leHByIChpcmFuZ2UgJnIsIHRyZWUgZXhwciwg Z2ltcGxlICpzdG10KSBvdmVycmlkZTsKKyAgdmlydHVhbCBib29sIHJhbmdlX29mX2V4cHIgKHZy YW5nZSAmciwgdHJlZSBleHByLCBnaW1wbGUgKnN0bXQpIG92ZXJyaWRlOwogICB2aXJ0dWFsIHRy ZWUgdmFsdWVfb2ZfZXhwciAodHJlZSwgZ2ltcGxlICogPSBOVUxMKSBvdmVycmlkZTsKICAgdmly dHVhbCB0cmVlIHZhbHVlX29uX2VkZ2UgKGVkZ2UsIHRyZWUpIG92ZXJyaWRlOwogICB2aXJ0dWFs IHRyZWUgdmFsdWVfb2Zfc3RtdCAoZ2ltcGxlICosIHRyZWUgPSBOVUxMX1RSRUUpIG92ZXJyaWRl OwotLSAKMi4zNi4xCgo= --0000000000005e8d0d05e05f2f4b--