From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 23810 invoked by alias); 29 Sep 2014 14:20:08 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 23797 invoked by uid 89); 29 Sep 2014 14:20:07 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-3.3 required=5.0 tests=AWL,BAYES_00,RCVD_IN_DNSWL_LOW,RP_MATCHES_RCVD,SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-qg0-f52.google.com Received: from mail-qg0-f52.google.com (HELO mail-qg0-f52.google.com) (209.85.192.52) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Mon, 29 Sep 2014 14:20:00 +0000 Received: by mail-qg0-f52.google.com with SMTP id z60so2213356qgd.25 for ; Mon, 29 Sep 2014 07:19:57 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:in-reply-to:references:date :message-id:subject:from:to:cc:content-type; bh=xS9UA5nKuDz43ic+WAV/qv6+mwaryLfTVOsn2kUPVVs=; b=k3MzObDuHTlt98Ahu+YhKk4DhXKA5ta5Inl/jF+gAjMkF5uC/pDa1j7BapD+VKM14e 5ZYvC3RxmLYrdRjywPZbf+ROONEpnWSuQ6VgLul/rjbtwQ19On8bv+5kB+pWSJveKzNk BfRhRZiXJsW6VCmz+EyQxV0k4wRGamQCKAfOIMRrGefCkXOlDpH78L/iyfFxlrrl8//O FARiO6Qps+82UZ3ZJdjn0SYhsGUIK+ox+mfvhpHRz6mKENvlrPwIM2c9PIw25r5tt2vt t49ATHwqoR8WTsUm8dMs0KqB78qgJWPAZUwlGU3t3KRjRBEtaSB+HZcKza6CQLbcq/c/ JKIA== X-Gm-Message-State: ALoCoQkBtnhe+iOw0PQ+Op/PIFOQ2kImbx5IHZDWxHuaSvG4mtFDKloXhAJ0YckK0KHA5pxkNYKh MIME-Version: 1.0 X-Received: by 10.229.131.5 with SMTP id v5mr666559qcs.21.1412000396014; Mon, 29 Sep 2014 07:19:56 -0700 (PDT) Received: by 10.229.148.1 with HTTP; Mon, 29 Sep 2014 07:19:55 -0700 (PDT) In-Reply-To: References: <53CF1DFD.7080805@redhat.com> Date: Mon, 29 Sep 2014 14:20:00 -0000 Message-ID: Subject: Re: [PATCH] Redesign jump threading profile updates From: Teresa Johnson To: Jeff Law Cc: "gcc-patches@gcc.gnu.org" , Jan Hubicka , David Li Content-Type: multipart/mixed; boundary=001a1132e2b607a7a8050434f62e X-IsSubscribed: yes X-SW-Source: 2014-09/txt/msg02525.txt.bz2 --001a1132e2b607a7a8050434f62e Content-Type: text/plain; charset=UTF-8 Content-length: 45969 On Fri, Aug 1, 2014 at 10:10 PM, Teresa Johnson wrote: > On Wed, Jul 23, 2014 at 2:08 PM, Teresa Johnson wrote: >> On Tue, Jul 22, 2014 at 7:29 PM, Jeff Law wrote: >>> On 03/26/14 17:44, Teresa Johnson wrote: >>>> >>>> Recently I discovered that the profile updates being performed by jump >>>> threading were incorrect in many cases, particularly in the case where >>>> the threading path contains a joiner. Some of the duplicated >>>> blocks/edges were not getting any counts, leading to incorrect >>>> function splitting and other downstream optimizations, and there were >>>> other insanities as well. After making a few attempts to fix the >>>> handling I ended up completely redesigning the profile update code, >>>> removing a few places throughout the code where it was attempting to >>>> do some updates. >>>> >>>> The biggest complication (see the large comment and example above the >>>> new routine compute_path_counts) is that we duplicate a conditional >>>> jump in the joiner case, possibly multiple times for multiple jump >>>> thread paths through that joiner, and it isn't trivial to figure out >>>> what probability to assign each of the duplicated successor edges (and >>>> the original after threading). Each jump thread path may need to have >>>> a different probability of staying on path through the joiner in order >>>> to keep the counts going out of the threading path sane. >>>> >>>> The patch below was bootstrapped and tested on >>>> x86_64-unknown-linux-gnu, and also tested with a profiledbootstrap. I >>>> additionally tested with cpu2006, confirming that the amount of >>>> resulting cycle samples in the split cold sections reduced, and >>>> through manual inspection that many different cases were now correct. >>>> I also measured performance with cpu2006, running each benchmark >>>> multiple times on a Westmere and see some speedups (453.povray 1-2%, >>>> 403.gcc 1-1.5%, and noisy but positive speedups in 471.omnetpp and >>>> 483.xalancbmk). >>>> >>>> Looks like my mailer is corrupting the spacing, which makes it harder >>>> to look at the CFG examples in the big header comment block I added. >>>> So I have also included the patch as an attachment. >>>> >>>> Ok for stage 1? >>>> >>>> Thanks, >>>> Teresa >>>> >>>> 2014-03-26 Teresa Johnson >>>> >>>> * tree-ssa-threadupdate.c (struct ssa_local_info_t): New >>>> duplicate_blocks bitmap. >>>> (remove_ctrl_stmt_and_useless_edges): Ditto. >>>> (create_block_for_threading): Ditto. >>>> (compute_path_counts): New function. >>>> (update_profile): Ditto. >>>> (deduce_freq): Ditto. >>>> (recompute_probabilities): Ditto. >>>> (update_joiner_offpath_counts): Ditto. >>>> (ssa_fix_duplicate_block_edges): Update profile info. >>>> (ssa_create_duplicates): Pass new parameter. >>>> (ssa_redirect_edges): Remove old profile update. >>>> (thread_block_1): New duplicate_blocks bitmap, >>>> remove old profile update. >>>> (thread_single_edge): Pass new parameter. >>> >>> First off, sorry this took so long to get reviewed. >>> >>> Most of what's going on in here is similar to something I sketched out, but >>> never coded up a while back -- with the significant difference that you're >>> handling joiner blocks as well. >>> >>> Everything looks to be well thought through and documented in the code at a >>> level I wish existed throughout GCC. >>> >>> The only thing I see missing is regression tests. I don't think you need to >>> do anything huge here, but it ought to be possible to set up relatively >>> simple cases which show the probabilities/counts being updated properly. >>> >>> Otherwise it looks excellent. It's pre-approved once you've added some kind >>> of testing and fixed the nits noted below. >> >> Thanks! I will fix the issues you note below and create some test >> cases before I commit. > > Just an update - I found some good test cases by compiling the > c-torture tests with profile feedback with and without my patch. But > in the cases I pulled out I saw that there were still a couple profile > or probability insanities introduced by jump threading (albeit far > less than before), so I wanted to investigate before I commit. I ran > out of time this week and will not get to this until I get back from > vacation the week after next. Hi Jeff, I finally had a chance to get back to this and look at the remaining insanities in the new test cases I created. It turns out that there were still a few issues in the case where there were guessed frequencies and no profile counts. The two test cases I created do use FDO, and the insanities in the routines with profile counts went away with my patch. But the outlined copies of routines that were also inlined into the main routine still had estimated frequencies, and these still had a few issues. The problem is that the profile updates are done incrementally as we walk and update the paths in ssa_fix_duplicate_block_edges, including the block and edge counts, the block frequencies and the probabilities. This is very difficult to do when only operating on frequencies since the edge frequencies are derived from the source block frequency and the probability. Therefore, once the source block frequency is updated, the edge frequency is also affected, and it is really difficult to figure out what the update to the edge frequency (essentially the probability) is using the same incremental update approach. I was attempting to handle this with the routine deduce_freq, for example, but this turned out to have issues for certain types of paths. I tried a few other approaches, but they start looking really ugly and I didn't want to add a parallel but different algorithm in the case of no profile counts. So by far the simplest approach was simply to take a snapshot of the existing block and edge frequencies along the path before we start the updates in ssa_fix_duplicate_block_edges, by copying them into the profile count fields of those blocks and edges. Then the existing algorithm operates the same as when we do have counts, and can essentially operate incrementally on the edge frequencies since they live in the count field of the edge and are no longer affected anytime the source block is updated. Since the algorithm does update block frequencies and probabilities as well (based on the count updates performed), we can simply clear out these fake count fields at the end of ssa_fix_duplicate_block_edges. This takes care of the remaining insanities introduced by jump threading from these test cases. During testing I also added in some checking to ensure that the count fields for the whole routine were cleared properly to make sure the new clear_counts_path was not missing anything (checking is a little too heavyweight to add in normally). New patch below (also attached since my mailer sometimes eats spaces). The differences between the old patch and the new one: - removed deduce_freq (which was my least favorite part of the patch anyway!), and its call from recompute_probabilities, since it is no longer necessary. - two new routines freqs_to_counts_path and clear_counts_path, invoked from ssa_fix_duplicate_block_edges. - two new tests Bootstrapped and tested on x86_64-unknown-linux-gnu, ok for trunk? Thanks, Teresa gcc: 2014-09-29 Teresa Johnson * tree-ssa-threadupdate.c (struct ssa_local_info_t): New duplicate_blocks bitmap. (remove_ctrl_stmt_and_useless_edges): Ditto. (create_block_for_threading): Ditto. (compute_path_counts): New function. (update_profile): Ditto. (recompute_probabilities): Ditto. (update_joiner_offpath_counts): Ditto. (freqs_to_counts_path): Ditto. (clear_counts_path): Ditto. (ssa_fix_duplicate_block_edges): Update profile info. (ssa_create_duplicates): Pass new parameter. (ssa_redirect_edges): Remove old profile update. (thread_block_1): New duplicate_blocks bitmap, remove old profile update. (thread_single_edge): Pass new parameter. gcc/testsuite: 2014-09-29 Teresa Johnson * testsuite/gcc.dg/tree-prof/20050826-2.c: New test. * testsuite/gcc.dg/tree-prof/cmpsf-1.c: Ditto. Index: tree-ssa-threadupdate.c =================================================================== --- tree-ssa-threadupdate.c (revision 215645) +++ tree-ssa-threadupdate.c (working copy) @@ -229,6 +229,9 @@ struct ssa_local_info_t /* TRUE if we thread one or more jumps, FALSE otherwise. */ bool jumps_threaded; + + /* Blocks duplicated for the thread. */ + bitmap duplicate_blocks; }; /* Passes which use the jump threading code register jump threading @@ -292,7 +295,8 @@ remove_ctrl_stmt_and_useless_edges (basic_block bb static void create_block_for_threading (basic_block bb, struct redirection_data *rd, - unsigned int count) + unsigned int count, + bitmap *duplicate_blocks) { edge_iterator ei; edge e; @@ -307,6 +311,8 @@ create_block_for_threading (basic_block bb, /* Zero out the profile, since the block is unreachable for now. */ rd->dup_blocks[count]->frequency = 0; rd->dup_blocks[count]->count = 0; + if (duplicate_blocks) + bitmap_set_bit (*duplicate_blocks, rd->dup_blocks[count]->index); } /* Main data structure to hold information for duplicates of BB. */ @@ -555,8 +561,475 @@ any_remaining_duplicated_blocks (vec J -> Son -> D (path 1) + C -> J -> Son -> E (path 2) + + Note that the control flow could be more complicated: + - Each jump threading path may have more than one incoming edge. I.e. A and + Ea could represent multiple incoming blocks/edges that are included in + path 1. + - There could be EDGE_NO_COPY_SRC_BLOCK edges after the joiner (either + before or after the "normal" copy block). These are not duplicated onto + the jump threading path, as they are single-successor. + - Any of the blocks along the path may have other incoming edges that + are not part of any jump threading path, but add profile counts along + the path. + + In the aboe example, after all jump threading is complete, we will + end up with the following control flow: + + A B C + | | | + Ea| |Eb |Ec + | | | + v v v + Ja J Jc + / \ / \Eon' / \ + Eona/ \ ---/---\-------- \Eonc + / \ / / \ \ + v v v v v + Sona Soff Son Sonc + \ /\ / + \___________ / \ _____/ + \ / \/ + vv v + D E + + The main issue to notice here is that when we are processing path 1 + (A->J->Son->D) we need to figure out the outgoing edge weights to + the duplicated edges Ja->Sona and Ja->Soff, while ensuring that the + sum of the incoming weights to D remain Ed. The problem with simply + assuming that Ja (and Jc when processing path 2) has the same outgoing + probabilities to its successors as the original block J, is that after + all paths are processed and other edges/counts removed (e.g. none + of Ec will reach D after processing path 2), we may end up with not + enough count flowing along duplicated edge Sona->D. + + Therefore, in the case of a joiner, we keep track of all counts + coming in along the current path, as well as from predecessors not + on any jump threading path (Eb in the above example). While we + first assume that the duplicated Eona for Ja->Sona has the same + probability as the original, we later compensate for other jump + threading paths that may eliminate edges. We do that by keep track + of all counts coming into the original path that are not in a jump + thread (Eb in the above example, but as noted earlier, there could + be other predecessors incoming to the path at various points, such + as at Son). Call this cumulative non-path count coming into the path + before D as Enonpath. We then ensure that the count from Sona->D is as at + least as big as (Ed - Enonpath), but no bigger than the minimum + weight along the jump threading path. The probabilities of both the + original and duplicated joiner block J and Ja will be adjusted + accordingly after the updates. */ + +static bool +compute_path_counts (struct redirection_data *rd, + ssa_local_info_t *local_info, + gcov_type *path_in_count_ptr, + gcov_type *path_out_count_ptr, + int *path_in_freq_ptr) +{ + edge e = rd->incoming_edges->e; + vec *path = THREAD_PATH (e); + edge elast = path->last ()->e; + gcov_type nonpath_count = 0; + bool has_joiner = false; + gcov_type path_in_count = 0; + int path_in_freq = 0; + + /* Start by accumulating incoming edge counts to the path's first bb + into a couple buckets: + path_in_count: total count of incoming edges that flow into the + current path. + nonpath_count: total count of incoming edges that are not + flowing along *any* path. These are the counts + that will still flow along the original path after + all path duplication is done by potentially multiple + calls to this routine. + (any other incoming edge counts are for a different jump threading + path that will be handled by a later call to this routine.) + To make this easier, start by recording all incoming edges that flow into + the current path in a bitmap. We could add up the path's incoming edge + counts here, but we still need to walk all the first bb's incoming edges + below to add up the counts of the other edges not included in this jump + threading path. */ + struct el *next, *el; + bitmap in_edge_srcs = BITMAP_ALLOC (NULL); + for (el = rd->incoming_edges; el; el = next) + { + next = el->next; + bitmap_set_bit (in_edge_srcs, el->e->src->index); + } + edge ein; + edge_iterator ei; + FOR_EACH_EDGE (ein, ei, e->dest->preds) + { + vec *ein_path = THREAD_PATH (ein); + /* Simply check the incoming edge src against the set captured above. */ + if (ein_path + && bitmap_bit_p (in_edge_srcs, (*ein_path)[0]->e->src->index)) + { + /* It is necessary but not sufficient that the last path edges + are identical. There may be different paths that share the + same last path edge in the case where the last edge has a nocopy + source block. */ + gcc_assert (ein_path->last ()->e == elast); + path_in_count += ein->count; + path_in_freq += EDGE_FREQUENCY (ein); + } + else if (!ein_path) + { + /* Keep track of the incoming edges that are not on any jump-threading + path. These counts will still flow out of original path after all + jump threading is complete. */ + nonpath_count += ein->count; + } + } + BITMAP_FREE (in_edge_srcs); + + /* Now compute the fraction of the total count coming into the first + path bb that is from the current threading path. */ + gcov_type total_count = e->dest->count; + /* Handle incoming profile insanities. */ + if (total_count < path_in_count) + path_in_count = total_count; + int onpath_scale = GCOV_COMPUTE_SCALE (path_in_count, total_count); + + /* Walk the entire path to do some more computation in order to estimate + how much of the path_in_count will flow out of the duplicated threading + path. In the non-joiner case this is straightforward (it should be + the same as path_in_count, although we will handle incoming profile + insanities by setting it equal to the minimum count along the path). + + In the joiner case, we need to estimate how much of the path_in_count + will stay on the threading path after the joiner's conditional branch. + We don't really know for sure how much of the counts + associated with this path go to each successor of the joiner, but we'll + estimate based on the fraction of the total count coming into the path + bb was from the threading paths (computed above in onpath_scale). + Afterwards, we will need to do some fixup to account for other threading + paths and possible profile insanities. + + In order to estimate the joiner case's counts we also need to update + nonpath_count with any additional counts coming into the path. Other + blocks along the path may have additional predecessors from outside + the path. */ + gcov_type path_out_count = path_in_count; + gcov_type min_path_count = path_in_count; + for (unsigned int i = 1; i < path->length (); i++) + { + edge epath = (*path)[i]->e; + gcov_type cur_count = epath->count; + if ((*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK) + { + has_joiner = true; + cur_count = apply_probability (cur_count, onpath_scale); + } + /* In the joiner case we need to update nonpath_count for any edges + coming into the path that will contribute to the count flowing + into the path successor. */ + if (has_joiner && epath != elast) + { + /* Look for other incoming edges after joiner. */ + FOR_EACH_EDGE (ein, ei, epath->dest->preds) + { + if (ein != epath + /* Ignore in edges from blocks we have duplicated for a + threading path, which have duplicated edge counts until + they are redirected by an invocation of this routine. */ + && !bitmap_bit_p (local_info->duplicate_blocks, + ein->src->index)) + nonpath_count += ein->count; + } + } + if (cur_count < path_out_count) + path_out_count = cur_count; + if (epath->count < min_path_count) + min_path_count = epath->count; + } + + /* We computed path_out_count above assuming that this path targeted + the joiner's on-path successor with the same likelihood as it + reached the joiner. However, other thread paths through the joiner + may take a different path through the normal copy source block + (i.e. they have a different elast), meaning that they do not + contribute any counts to this path's elast. As a result, it may + turn out that this path must have more count flowing to the on-path + successor of the joiner. Essentially, all of this path's elast + count must be contributed by this path and any nonpath counts + (since any path through the joiner with a different elast will not + include a copy of this elast in its duplicated path). + So ensure that this path's path_out_count is at least the + difference between elast->count and nonpath_count. Otherwise the edge + counts after threading will not be sane. */ + if (has_joiner && path_out_count < elast->count - nonpath_count) + { + path_out_count = elast->count - nonpath_count; + /* But neither can we go above the minimum count along the path + we are duplicating. This can be an issue due to profile + insanities coming in to this pass. */ + if (path_out_count > min_path_count) + path_out_count = min_path_count; + } + + *path_in_count_ptr = path_in_count; + *path_out_count_ptr = path_out_count; + *path_in_freq_ptr = path_in_freq; + return has_joiner; +} + + +/* Update the counts and frequencies for both an original path + edge EPATH and its duplicate EDUP. The duplicate source block + will get a count/frequency of PATH_IN_COUNT and PATH_IN_FREQ, + and the duplicate edge EDUP will have a count of PATH_OUT_COUNT. */ +static void +update_profile (edge epath, edge edup, gcov_type path_in_count, + gcov_type path_out_count, int path_in_freq) +{ + + /* First update the duplicated block's count / frequency. */ + if (edup) + { + basic_block dup_block = edup->src; + gcc_assert (dup_block->count == 0); + gcc_assert (dup_block->frequency == 0); + dup_block->count = path_in_count; + dup_block->frequency = path_in_freq; + } + + /* Now update the original block's count and frequency in the + opposite manner - remove the counts/freq that will flow + into the duplicated block. Handle underflow due to precision/ + rounding issues. */ + epath->src->count -= path_in_count; + if (epath->src->count < 0) + epath->src->count = 0; + epath->src->frequency -= path_in_freq; + if (epath->src->frequency < 0) + epath->src->frequency = 0; + + /* Next update this path edge's original and duplicated counts. We know + that the duplicated path will have path_out_count flowing + out of it (in the joiner case this is the count along the duplicated path + out of the duplicated joiner). This count can then be removed from the + original path edge. */ + if (edup) + edup->count = path_out_count; + epath->count -= path_out_count; + gcc_assert (epath->count >= 0); +} + + +/* The duplicate and original joiner blocks may end up with different + probabilities (different from both the original and from each other). + Recompute the probabilities here once we have updated the edge + counts and frequencies. */ + +static void +recompute_probabilities (basic_block bb) +{ + edge esucc; + edge_iterator ei; + FOR_EACH_EDGE (esucc, ei, bb->succs) + { + if (bb->count) + esucc->probability = GCOV_COMPUTE_SCALE (esucc->count, + bb->count); + if (esucc->probability > REG_BR_PROB_BASE) + { + /* Can happen with missing/guessed probabilities, since we + may determine that more is flowing along duplicated + path than joiner succ probabilities allowed. + Counts and freqs will be insane after jump threading, + at least make sure probability is sane or we will + get a flow verification error. + Not much we can do to make counts/freqs sane without + redoing the profile estimation. */ + esucc->probability = REG_BR_PROB_BASE; + } + } +} + + +/* Update the counts of the original and duplicated edges from a joiner + that go off path, given that we have already determined that the + duplicate joiner DUP_BB has incoming count PATH_IN_COUNT and + outgoing count along the path PATH_OUT_COUNT. The original (on-)path + edge from joiner is EPATH. */ + +static void +update_joiner_offpath_counts (edge epath, basic_block dup_bb, + gcov_type path_in_count, + gcov_type path_out_count) +{ + /* Compute the count that currently flows off path from the joiner. + In other words, the total count of joiner's out edges other than + epath. Compute this by walking the successors instead of + subtracting epath's count from the joiner bb count, since there + are sometimes slight insanities where the total out edge count is + larger than the bb count (possibly due to rounding/truncation + errors). */ + gcov_type total_orig_off_path_count = 0; + edge enonpath; + edge_iterator ei; + FOR_EACH_EDGE (enonpath, ei, epath->src->succs) + { + if (enonpath == epath) + continue; + total_orig_off_path_count += enonpath->count; + } + + /* For the path that we are duplicating, the amount that will flow + off path from the duplicated joiner is the delta between the + path's cumulative in count and the portion of that count we + estimated above as flowing from the joiner along the duplicated + path. */ + gcov_type total_dup_off_path_count = path_in_count - path_out_count; + + /* Now do the actual updates of the off-path edges. */ + FOR_EACH_EDGE (enonpath, ei, epath->src->succs) + { + /* Look for edges going off of the threading path. */ + if (enonpath == epath) + continue; + + /* Find the corresponding edge out of the duplicated joiner. */ + edge enonpathdup = find_edge (dup_bb, enonpath->dest); + gcc_assert (enonpathdup); + + /* We can't use the original probability of the joiner's out + edges, since the probabilities of the original branch + and the duplicated branches may vary after all threading is + complete. But apportion the duplicated joiner's off-path + total edge count computed earlier (total_dup_off_path_count) + among the duplicated off-path edges based on their original + ratio to the full off-path count (total_orig_off_path_count). + */ + int scale = GCOV_COMPUTE_SCALE (enonpath->count, + total_orig_off_path_count); + /* Give the duplicated offpath edge a portion of the duplicated + total. */ + enonpathdup->count = apply_scale (scale, + total_dup_off_path_count); + /* Now update the original offpath edge count, handling underflow + due to rounding errors. */ + enonpath->count -= enonpathdup->count; + if (enonpath->count < 0) + enonpath->count = 0; + } +} + + +/* Invoked for routines that have guessed frequencies and no profile + counts to record the block and edge frequencies for paths through RD + in the profile count fields of those blocks and edges. This is because + ssa_fix_duplicate_block_edges incrementally updates the block and + edge counts as edges are redirected, and it is difficult to do that + for edge frequencies which are computed on the fly from the source + block frequency and probability. When a block frequency is updated + its outgoing edge frequencies are affected and become difficult to + adjust. */ + +static void +freqs_to_counts_path (struct redirection_data *rd) +{ + edge e = rd->incoming_edges->e; + vec *path = THREAD_PATH (e); + edge ein; + edge_iterator ei; + FOR_EACH_EDGE (ein, ei, e->dest->preds) + { + gcc_assert (!ein->count); + ein->count = EDGE_FREQUENCY (ein); + } + + for (unsigned int i = 1; i < path->length (); i++) + { + edge epath = (*path)[i]->e; + gcc_assert (!epath->count); + edge esucc; + FOR_EACH_EDGE (esucc, ei, epath->src->succs) + { + esucc->count = EDGE_FREQUENCY (esucc); + } + epath->src->count = epath->src->frequency; + } +} + +static void +clear_counts_path (struct redirection_data *rd) +{ + edge e = rd->incoming_edges->e; + vec *path = THREAD_PATH (e); + edge ein, esucc; + edge_iterator ei; + FOR_EACH_EDGE (ein, ei, e->dest->preds) + ein->count = 0; + + for (unsigned int i = 1; i < path->length (); i++) + { + edge epath = (*path)[i]->e; + FOR_EACH_EDGE (esucc, ei, epath->src->succs) + { + esucc->count = 0; + } + epath->src->count = 0; + } + for (unsigned int i = 0; i < 2; i++) + { + basic_block dup = rd->dup_blocks[i]; + if (!dup) + continue; + FOR_EACH_EDGE (esucc, ei, dup->succs) + { + esucc->count = 0; + } + dup->count = 0; + } +} + /* Wire up the outgoing edges from the duplicate blocks and - update any PHIs as needed. */ + update any PHIs as needed. Also update the profile counts + on the original and duplicate blocks and edges. */ void ssa_fix_duplicate_block_edges (struct redirection_data *rd, ssa_local_info_t *local_info) @@ -564,9 +1037,31 @@ ssa_fix_duplicate_block_edges (struct redirection_ bool multi_incomings = (rd->incoming_edges->next != NULL); edge e = rd->incoming_edges->e; vec *path = THREAD_PATH (e); + edge elast = path->last ()->e; + gcov_type path_in_count = 0; + gcov_type path_out_count = 0; + int path_in_freq = 0; + bool do_freqs_to_counts = (profile_status_for_fn (cfun) != PROFILE_READ + || !ENTRY_BLOCK_PTR_FOR_FN (cfun)->count); + if (do_freqs_to_counts) + freqs_to_counts_path (rd); + + /* First determine how much profile count to move from original + path to the duplicate path. This is tricky in the presence of + a joiner (see comments for compute_path_counts), where some portion + of the path's counts will flow off-path from the joiner. In the + non-joiner case the path_in_count and path_out_count should be the + same. */ + bool has_joiner = compute_path_counts (rd, local_info, + &path_in_count, &path_out_count, + &path_in_freq); + + int cur_path_freq = path_in_freq; for (unsigned int count = 0, i = 1; i < path->length (); i++) { + edge epath = (*path)[i]->e; + /* If we were threading through an joiner block, then we want to keep its control statement and redirect an outgoing edge. Else we want to remove the control statement & edges, then create @@ -576,6 +1071,8 @@ ssa_fix_duplicate_block_edges (struct redirection_ edge victim; edge e2; + gcc_assert (has_joiner); + /* This updates the PHIs at the destination of the duplicate block. Pass 0 instead of i if we are threading a path which has multiple incoming edges. */ @@ -591,14 +1088,13 @@ ssa_fix_duplicate_block_edges (struct redirection_ threading path. */ if (!any_remaining_duplicated_blocks (path, i)) { - e2 = redirect_edge_and_branch (victim, path->last ()->e->dest); - e2->count = path->last ()->e->count; + e2 = redirect_edge_and_branch (victim, elast->dest); /* If we redirected the edge, then we need to copy PHI arguments at the target. If the edge already existed (e2 != victim case), then the PHIs in the target already have the correct arguments. */ if (e2 == victim) - copy_phi_args (e2->dest, path->last ()->e, e2, + copy_phi_args (e2->dest, elast, e2, path, multi_incomings ? 0 : i); } else @@ -626,7 +1122,31 @@ ssa_fix_duplicate_block_edges (struct redirection_ } } } - count++; + + /* Update the counts and frequency of both the original block + and path edge, and the duplicates. The path duplicate's + incoming count and frequency are the totals for all edges + incoming to this jump threading path computed earlier. + And we know that the duplicated path will have path_out_count + flowing out of it (i.e. along the duplicated path out of the + duplicated joiner). */ + update_profile (epath, e2, path_in_count, path_out_count, + path_in_freq); + + /* Next we need to update the counts of the original and duplicated + edges from the joiner that go off path. */ + update_joiner_offpath_counts (epath, e2->src, path_in_count, + path_out_count); + + /* Finally, we need to set the probabilities on the duplicated + edges out of the duplicated joiner (e2->src). The probabilities + along the original path will all be updated below after we finish + processing the whole path. */ + recompute_probabilities (e2->src); + + /* Record the frequency flowing to the downstream duplicated + path blocks. */ + cur_path_freq = EDGE_FREQUENCY (e2); } else if ((*path)[i]->type == EDGE_COPY_SRC_BLOCK) { @@ -635,9 +1155,58 @@ ssa_fix_duplicate_block_edges (struct redirection_ multi_incomings ? 0 : i); if (count == 1) single_succ_edge (rd->dup_blocks[1])->aux = NULL; + + /* Update the counts and frequency of both the original block + and path edge, and the duplicates. Since we are now after + any joiner that may have existed on the path, the count + flowing along the duplicated threaded path is path_out_count. + If we didn't have a joiner, then cur_path_freq was the sum + of the total frequencies along all incoming edges to the + thread path (path_in_freq). If we had a joiner, it would have + been updated at the end of that handling to the edge frequency + along the duplicated joiner path edge. */ + update_profile (epath, EDGE_SUCC (rd->dup_blocks[count], 0), + path_out_count, path_out_count, + cur_path_freq); + } + else + { + /* No copy case. In this case we don't have an equivalent block + on the duplicated thread path to update, but we do need + to remove the portion of the counts/freqs that were moved + to the duplicated path from the counts/freqs flowing through + this block on the original path. Since all the no-copy edges + are after any joiner, the removed count is the same as + path_out_count. + + If we didn't have a joiner, then cur_path_freq was the sum + of the total frequencies along all incoming edges to the + thread path (path_in_freq). If we had a joiner, it would have + been updated at the end of that handling to the edge frequency + along the duplicated joiner path edge. */ + update_profile (epath, NULL, path_out_count, path_out_count, + cur_path_freq); + } + + /* Increment the index into the duplicated path when we processed + a duplicated block. */ + if ((*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK + || (*path)[i]->type == EDGE_COPY_SRC_BLOCK) + { count++; - } + } } + + /* Now walk orig blocks and update their probabilities, since the + counts and freqs should be updated properly by above loop. */ + for (unsigned int i = 1; i < path->length (); i++) + { + edge epath = (*path)[i]->e; + recompute_probabilities (epath->src); + } + + if (do_freqs_to_counts) + clear_counts_path (rd); } /* Hash table traversal callback routine to create duplicate blocks. */ @@ -663,7 +1232,8 @@ ssa_create_duplicates (struct redirection_data **s if ((*path)[i]->type == EDGE_COPY_SRC_BLOCK || (*path)[i]->type == EDGE_COPY_SRC_JOINER_BLOCK) { - create_block_for_threading ((*path)[i]->e->src, rd, 1); + create_block_for_threading ((*path)[i]->e->src, rd, 1, + &local_info->duplicate_blocks); break; } } @@ -672,7 +1242,8 @@ ssa_create_duplicates (struct redirection_data **s use the template to create a new block. */ if (local_info->template_block == NULL) { - create_block_for_threading ((*path)[1]->e->src, rd, 0); + create_block_for_threading ((*path)[1]->e->src, rd, 0, + &local_info->duplicate_blocks); local_info->template_block = rd->dup_blocks[0]; /* We do not create any outgoing edges for the template. We will @@ -681,7 +1252,8 @@ ssa_create_duplicates (struct redirection_data **s } else { - create_block_for_threading (local_info->template_block, rd, 0); + create_block_for_threading (local_info->template_block, rd, 0, + &local_info->duplicate_blocks); /* Go ahead and wire up outgoing edges and update PHIs for the duplicate block. */ @@ -751,19 +1323,6 @@ ssa_redirect_edges (struct redirection_data **slot fprintf (dump_file, " Threaded jump %d --> %d to %d\n", e->src->index, e->dest->index, rd->dup_blocks[0]->index); - rd->dup_blocks[0]->count += e->count; - - /* Excessive jump threading may make frequencies large enough so - the computation overflows. */ - if (rd->dup_blocks[0]->frequency < BB_FREQ_MAX * 2) - rd->dup_blocks[0]->frequency += EDGE_FREQUENCY (e); - - /* In the case of threading through a joiner block, the outgoing - edges from the duplicate block were updated when they were - redirected during ssa_fix_duplicate_block_edges. */ - if ((*path)[1]->type != EDGE_COPY_SRC_JOINER_BLOCK) - EDGE_SUCC (rd->dup_blocks[0], 0)->count += e->count; - /* If we redirect a loop latch edge cancel its loop. */ if (e->src == e->src->loop_father->latch) mark_loop_for_removal (e->src->loop_father); @@ -849,6 +1408,8 @@ thread_block_1 (basic_block bb, bool noloop_only, edge_iterator ei; ssa_local_info_t local_info; + local_info.duplicate_blocks = BITMAP_ALLOC (NULL); + /* To avoid scanning a linear array for the element we need we instead use a hash table. For normal code there should be no noticeable difference. However, if we have a block with a large number of @@ -908,10 +1469,6 @@ thread_block_1 (basic_block bb, bool noloop_only, continue; } - if (e->dest == e2->src) - update_bb_profile_for_threading (e->dest, EDGE_FREQUENCY (e), - e->count, (*THREAD_PATH (e))[1]->e); - /* Insert the outgoing edge into the hash table if it is not already in the hash table. */ lookup_redirection_data (e, INSERT); @@ -965,6 +1522,9 @@ thread_block_1 (basic_block bb, bool noloop_only, && bb == bb->loop_father->header) set_loop_copy (bb->loop_father, NULL); + BITMAP_FREE (local_info.duplicate_blocks); + local_info.duplicate_blocks = NULL; + /* Indicate to our caller whether or not any jumps were threaded. */ return local_info.jumps_threaded; } @@ -1031,7 +1591,7 @@ thread_single_edge (edge e) npath->safe_push (x); rd.path = npath; - create_block_for_threading (bb, &rd, 0); + create_block_for_threading (bb, &rd, 0, NULL); remove_ctrl_stmt_and_useless_edges (rd.dup_blocks[0], NULL); create_edge_and_update_destination_phis (&rd, rd.dup_blocks[0], 0); Index: testsuite/gcc.dg/tree-prof/20050826-2.c =================================================================== --- testsuite/gcc.dg/tree-prof/20050826-2.c (revision 0) +++ testsuite/gcc.dg/tree-prof/20050826-2.c (revision 0) @@ -0,0 +1,75 @@ +/* Testcase derived from gcc.c-torture/execute 20050826-2.c + which showed jump threading profile insanities. */ +/* { dg-options "-Ofast -fdump-tree-dom1-all" } */ + +struct rtattr +{ + unsigned short rta_len; + unsigned short rta_type; +}; + +__attribute__ ((noinline)) +int inet_check_attr (void *r, struct rtattr **rta) +{ + int i; + + for (i = 1; i <= 14; i++) + { + struct rtattr *attr = rta[i - 1]; + if (attr) + { + if (attr->rta_len - sizeof (struct rtattr) < 4) + return -22; + if (i != 9 && i != 8) + rta[i - 1] = attr + 1; + } + } + return 0; +} + +extern void abort (void); + +int +test (void) +{ + struct rtattr rt[2]; + struct rtattr *rta[14]; + int i; + + rt[0].rta_len = sizeof (struct rtattr) + 8; + rt[0].rta_type = 0; + rt[1] = rt[0]; + for (i = 0; i < 14; i++) + rta[i] = &rt[0]; + if (inet_check_attr (0, rta) != 0) + abort (); + for (i = 0; i < 14; i++) + if (rta[i] != &rt[i != 7 && i != 8]) + abort (); + for (i = 0; i < 14; i++) + rta[i] = &rt[0]; + rta[1] = 0; + rt[1].rta_len -= 8; + rta[5] = &rt[1]; + if (inet_check_attr (0, rta) != -22) + abort (); + for (i = 0; i < 14; i++) + if (i == 1 && rta[i] != 0) + abort (); + else if (i != 1 && i <= 5 && rta[i] != &rt[1]) + abort (); + else if (i > 5 && rta[i] != &rt[0]) + abort (); + return 0; +} + +int +main (void) +{ + int i; + for (i=0; i<100; i++) + test (); + return 0; +} + +/* { dg-final-use { scan-tree-dump-not "Invalid sum" "dom1"} } */ Index: testsuite/gcc.dg/tree-prof/cmpsf-1.c =================================================================== --- testsuite/gcc.dg/tree-prof/cmpsf-1.c (revision 0) +++ testsuite/gcc.dg/tree-prof/cmpsf-1.c (revision 0) @@ -0,0 +1,178 @@ +/* Testcase derived from gcc.c-torture/execute cmpsf-1.c + which showed jump threading profile insanities. */ +/* { dg-options "-Ofast -fdump-tree-dom1-all" } */ + +#include + +void abort(); +extern void exit (int); + +#define F 140 +#define T 13 + +feq (float x, float y) +{ + if (x == y) + return T; + else + return F; +} + +fne (float x, float y) +{ + if (x != y) + return T; + else + return F; +} + +flt (float x, float y) +{ + if (x < y) + return T; + else + return F; +} + +fge (float x, float y) +{ + if (x >= y) + return T; + else + return F; +} + +fgt (float x, float y) +{ + if (x > y) + return T; + else + return F; +} + +fle (float x, float y) +{ + if (x <= y) + return T; + else + return F; +} + +float args[] = +{ + 0.0F, + 1.0F, + -1.0F, + __FLT_MAX__, + __FLT_MIN__, + 0.0000000000001F, + 123456789.0F, + -987654321.0F +}; + +int correct_results[] = +{ + T, F, F, T, F, T, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, F, T, T, F, + T, F, F, T, F, T, + F, T, F, T, T, F, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, T, F, F, T, + F, T, T, F, F, T, + T, F, F, T, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, F, T, T, F, + T, F, F, T, F, T, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, T, F, F, T, + T, F, F, T, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, T, F, F, T, + F, T, F, T, T, F, + T, F, F, T, F, T, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, F, T, T, F, + F, T, T, F, F, T, + F, T, F, T, T, F, + F, T, F, T, T, F, + T, F, F, T, F, T, + F, T, F, T, T, F, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + F, T, T, F, F, T, + T, F, F, T, F, T, +}; + +void +test (void) +{ + int i, j, *res = correct_results; + + for (i = 0; i < 8; i++) + { + float arg0 = args[i]; + for (j = 0; j < 8; j++) + { + float arg1 = args[j]; + + if (feq (arg0, arg1) != *res++) + abort (); + if (fne (arg0, arg1) != *res++) + abort (); + if (flt (arg0, arg1) != *res++) + abort (); + if (fge (arg0, arg1) != *res++) + abort (); + if (fgt (arg0, arg1) != *res++) + abort (); + if (fle (arg0, arg1) != *res++) + abort (); + } + } +} + +int +main (void) +{ + int i; + for (i=0; i<100; i++) + test (); + exit (0); +} + +/* { dg-final-use { scan-tree-dump-not "Invalid sum" "dom1"} } */ -- Teresa Johnson | Software Engineer | tejohnson@google.com | 408-460-2413 --001a1132e2b607a7a8050434f62e Content-Type: text/plain; charset=US-ASCII; name="patch.diff" Content-Disposition: attachment; filename="patch.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_i0nwkqz80 Content-length: 51907 Z2NjOgoKMjAxNC0wOS0yOSAgVGVyZXNhIEpvaG5zb24gIDx0ZWpvaG5zb25A Z29vZ2xlLmNvbT4KCgkqIHRyZWUtc3NhLXRocmVhZHVwZGF0ZS5jIChzdHJ1 Y3Qgc3NhX2xvY2FsX2luZm9fdCk6IE5ldwoJZHVwbGljYXRlX2Jsb2NrcyBi aXRtYXAuCgkocmVtb3ZlX2N0cmxfc3RtdF9hbmRfdXNlbGVzc19lZGdlcyk6 IERpdHRvLgoJKGNyZWF0ZV9ibG9ja19mb3JfdGhyZWFkaW5nKTogRGl0dG8u CgkoY29tcHV0ZV9wYXRoX2NvdW50cyk6IE5ldyBmdW5jdGlvbi4KCSh1cGRh dGVfcHJvZmlsZSk6IERpdHRvLgoJKHJlY29tcHV0ZV9wcm9iYWJpbGl0aWVz KTogRGl0dG8uCgkodXBkYXRlX2pvaW5lcl9vZmZwYXRoX2NvdW50cyk6IERp dHRvLgoJKGZyZXFzX3RvX2NvdW50c19wYXRoKTogRGl0dG8uCgkoY2xlYXJf Y291bnRzX3BhdGgpOiBEaXR0by4KCShzc2FfZml4X2R1cGxpY2F0ZV9ibG9j a19lZGdlcyk6IFVwZGF0ZSBwcm9maWxlIGluZm8uCgkoc3NhX2NyZWF0ZV9k dXBsaWNhdGVzKTogUGFzcyBuZXcgcGFyYW1ldGVyLgoJKHNzYV9yZWRpcmVj dF9lZGdlcyk6IFJlbW92ZSBvbGQgcHJvZmlsZSB1cGRhdGUuCgkodGhyZWFk X2Jsb2NrXzEpOiBOZXcgZHVwbGljYXRlX2Jsb2NrcyBiaXRtYXAsCglyZW1v dmUgb2xkIHByb2ZpbGUgdXBkYXRlLgoJKHRocmVhZF9zaW5nbGVfZWRnZSk6 IFBhc3MgbmV3IHBhcmFtZXRlci4KCmdjYy90ZXN0c3VpdGU6CgoyMDE0LTA5 LTI5ICBUZXJlc2EgSm9obnNvbiAgPHRlam9obnNvbkBnb29nbGUuY29tPgoK CSogdGVzdHN1aXRlL2djYy5kZy90cmVlLXByb2YvMjAwNTA4MjYtMi5jOiBO ZXcgdGVzdC4KCSogdGVzdHN1aXRlL2djYy5kZy90cmVlLXByb2YvY21wc2Yt MS5jOiBEaXR0by4KCkluZGV4OiB0cmVlLXNzYS10aHJlYWR1cGRhdGUuYwo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSB0cmVlLXNzYS10aHJlYWR1cGRh dGUuYwkocmV2aXNpb24gMjE1NjQ1KQorKysgdHJlZS1zc2EtdGhyZWFkdXBk YXRlLmMJKHdvcmtpbmcgY29weSkKQEAgLTIyOSw2ICsyMjksOSBAQCBzdHJ1 Y3Qgc3NhX2xvY2FsX2luZm9fdAogCiAgIC8qIFRSVUUgaWYgd2UgdGhyZWFk IG9uZSBvciBtb3JlIGp1bXBzLCBGQUxTRSBvdGhlcndpc2UuICAqLwogICBi b29sIGp1bXBzX3RocmVhZGVkOworCisgIC8qIEJsb2NrcyBkdXBsaWNhdGVk IGZvciB0aGUgdGhyZWFkLiAgKi8KKyAgYml0bWFwIGR1cGxpY2F0ZV9ibG9j a3M7CiB9OwogCiAvKiBQYXNzZXMgd2hpY2ggdXNlIHRoZSBqdW1wIHRocmVh ZGluZyBjb2RlIHJlZ2lzdGVyIGp1bXAgdGhyZWFkaW5nCkBAIC0yOTIsNyAr Mjk1LDggQEAgcmVtb3ZlX2N0cmxfc3RtdF9hbmRfdXNlbGVzc19lZGdlcyAo YmFzaWNfYmxvY2sgYmIKIHN0YXRpYyB2b2lkCiBjcmVhdGVfYmxvY2tfZm9y X3RocmVhZGluZyAoYmFzaWNfYmxvY2sgYmIsCiAJCQkgICAgc3RydWN0IHJl ZGlyZWN0aW9uX2RhdGEgKnJkLAotCQkJICAgIHVuc2lnbmVkIGludCBjb3Vu dCkKKwkJCSAgICB1bnNpZ25lZCBpbnQgY291bnQsCisJCQkgICAgYml0bWFw ICpkdXBsaWNhdGVfYmxvY2tzKQogewogICBlZGdlX2l0ZXJhdG9yIGVpOwog ICBlZGdlIGU7CkBAIC0zMDcsNiArMzExLDggQEAgY3JlYXRlX2Jsb2NrX2Zv cl90aHJlYWRpbmcgKGJhc2ljX2Jsb2NrIGJiLAogICAvKiBaZXJvIG91dCB0 aGUgcHJvZmlsZSwgc2luY2UgdGhlIGJsb2NrIGlzIHVucmVhY2hhYmxlIGZv ciBub3cuICAqLwogICByZC0+ZHVwX2Jsb2Nrc1tjb3VudF0tPmZyZXF1ZW5j eSA9IDA7CiAgIHJkLT5kdXBfYmxvY2tzW2NvdW50XS0+Y291bnQgPSAwOwor ICBpZiAoZHVwbGljYXRlX2Jsb2NrcykKKyAgICBiaXRtYXBfc2V0X2JpdCAo KmR1cGxpY2F0ZV9ibG9ja3MsIHJkLT5kdXBfYmxvY2tzW2NvdW50XS0+aW5k ZXgpOwogfQogCiAvKiBNYWluIGRhdGEgc3RydWN0dXJlIHRvIGhvbGQgaW5m b3JtYXRpb24gZm9yIGR1cGxpY2F0ZXMgb2YgQkIuICAqLwpAQCAtNTU1LDgg KzU2MSw0NzUgQEAgYW55X3JlbWFpbmluZ19kdXBsaWNhdGVkX2Jsb2NrcyAo dmVjPGp1bXBfdGhyZWFkX2UKICAgcmV0dXJuIGZhbHNlOwogfQogCisKKy8q IENvbXB1dGUgdGhlIGFtb3VudCBvZiBwcm9maWxlIGNvdW50L2ZyZXF1ZW5j eSBjb21pbmcgaW50byB0aGUganVtcCB0aHJlYWRpbmcKKyAgIHBhdGggc3Rv cmVkIGluIFJEIHRoYXQgd2UgYXJlIGR1cGxpY2F0aW5nLCByZXR1cm5lZCBp biBQQVRIX0lOX0NPVU5UX1BUUiBhbmQKKyAgIFBBVEhfSU5fRlJFUV9QVFIs IGFzIHdlbGwgYXMgdGhlIGFtb3VudCBvZiBjb3VudHMgZmxvd2luZyBvdXQg b2YgdGhlCisgICBkdXBsaWNhdGVkIHBhdGgsIHJldHVybmVkIGluIFBBVEhf T1VUX0NPVU5UX1BUUi4gIExPQ0FMX0lORk8gaXMgdXNlZCB0bworICAgaWRl bnRpZnkgYmxvY2tzIGR1cGxpY2F0ZWQgZm9yIGp1bXAgdGhyZWFkaW5nLCB3 aGljaCBoYXZlIGR1cGxpY2F0ZWQKKyAgIGVkZ2VzIHRoYXQgbmVlZCB0byBi ZSBpZ25vcmVkIGluIHRoZSBhbmFseXNpcy4gIFJldHVybiB0cnVlIGlmIHBh dGggY29udGFpbnMKKyAgIGEgam9pbmVyLCBmYWxzZSBvdGhlcndpc2UuCisK KyAgIEluIHRoZSBub24tam9pbmVyIGNhc2UsIHRoaXMgaXMgc3RyYWlnaHRm b3J3YXJkIC0gYWxsIHRoZSBjb3VudHMvZnJlcXVlbmN5CisgICBmbG93aW5n IGludG8gdGhlIGp1bXAgdGhyZWFkaW5nIHBhdGggc2hvdWxkIGZsb3cgdGhy b3VnaCB0aGUgZHVwbGljYXRlZAorICAgYmxvY2sgYW5kIG91dCBvZiB0aGUg ZHVwbGljYXRlZCBwYXRoLgorCisgICBJbiB0aGUgam9pbmVyIGNhc2UsIGl0 IGlzIHZlcnkgdHJpY2t5LiAgU29tZSBvZiB0aGUgY291bnRzIGZsb3dpbmcg aW50bworICAgdGhlIG9yaWdpbmFsIHBhdGggZ28gb2ZmcGF0aCBhdCB0aGUg am9pbmVyLiAgVGhlIHByb2JsZW0gaXMgdGhhdCB3aGlsZQorICAgd2Uga25v dyBob3cgbXVjaCB0b3RhbCBjb3VudCBnb2VzIG9mZi1wYXRoIGluIHRoZSBv cmlnaW5hbCBjb250cm9sIGZsb3csCisgICB3ZSBkb24ndCBrbm93IGhvdyBt YW55IG9mIHRoZSBjb3VudHMgY29ycmVzcG9uZGluZyB0byBqdXN0IHRoZSBq dW1wCisgICB0aHJlYWRpbmcgcGF0aCBnbyBvZmZwYXRoIGF0IHRoZSBqb2lu ZXIuCisKKyAgIEZvciBleGFtcGxlLCBhc3N1bWUgd2UgaGF2ZSB0aGUgZm9s bG93aW5nIGNvbnRyb2wgZmxvdyBhbmQgaWRlbnRpZmllZAorICAganVtcCB0 aHJlYWRpbmcgcGF0aHM6CisKKyAgICAgICAgICAgICAgICBBICAgICBCICAg ICBDCisgICAgICAgICAgICAgICAgIFwgICAgfCAgICAvCisgICAgICAgICAg ICAgICBFYSBcICAgfEViIC8gRWMKKyAgICAgICAgICAgICAgICAgICBcICB8 ICAvCisgICAgICAgICAgICAgICAgICAgIHYgdiB2CisgICAgICAgICAgICAg ICAgICAgICAgSiAgICAgICA8LS0gSm9pbmVyCisgICAgICAgICAgICAgICAg ICAgICAvIFwKKyAgICAgICAgICAgICAgICBFb2ZmLyAgIFxFb24KKyAgICAg ICAgICAgICAgICAgICAvICAgICBcCisgICAgICAgICAgICAgICAgICB2ICAg ICAgIHYKKyAgICAgICAgICAgICAgICBTb2ZmICAgICBTb24gIDwtLS0gTm9y bWFsCisgICAgICAgICAgICAgICAgICAgICAgICAgL1wKKyAgICAgICAgICAg ICAgICAgICAgICBFZC8gIFwgRWUKKyAgICAgICAgICAgICAgICAgICAgICAg LyAgICBcCisgICAgICAgICAgICAgICAgICAgICAgdiAgICAgdgorICAgICAg ICAgICAgICAgICAgICAgIEQgICAgICBFCisKKyAgICAgICAgICAgIEp1bXAg dGhyZWFkaW5nIHBhdGhzOiBBIC0+IEogLT4gU29uIC0+IEQgKHBhdGggMSkK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDIC0+IEogLT4g U29uIC0+IEUgKHBhdGggMikKKworICAgTm90ZSB0aGF0IHRoZSBjb250cm9s IGZsb3cgY291bGQgYmUgbW9yZSBjb21wbGljYXRlZDoKKyAgIC0gRWFjaCBq dW1wIHRocmVhZGluZyBwYXRoIG1heSBoYXZlIG1vcmUgdGhhbiBvbmUgaW5j b21pbmcgZWRnZS4gIEkuZS4gQSBhbmQKKyAgIEVhIGNvdWxkIHJlcHJlc2Vu dCBtdWx0aXBsZSBpbmNvbWluZyBibG9ja3MvZWRnZXMgdGhhdCBhcmUgaW5j bHVkZWQgaW4KKyAgIHBhdGggMS4KKyAgIC0gVGhlcmUgY291bGQgYmUgRURH RV9OT19DT1BZX1NSQ19CTE9DSyBlZGdlcyBhZnRlciB0aGUgam9pbmVyIChl aXRoZXIKKyAgIGJlZm9yZSBvciBhZnRlciB0aGUgIm5vcm1hbCIgY29weSBi bG9jaykuICBUaGVzZSBhcmUgbm90IGR1cGxpY2F0ZWQgb250bworICAgdGhl IGp1bXAgdGhyZWFkaW5nIHBhdGgsIGFzIHRoZXkgYXJlIHNpbmdsZS1zdWNj ZXNzb3IuCisgICAtIEFueSBvZiB0aGUgYmxvY2tzIGFsb25nIHRoZSBwYXRo IG1heSBoYXZlIG90aGVyIGluY29taW5nIGVkZ2VzIHRoYXQKKyAgIGFyZSBu b3QgcGFydCBvZiBhbnkganVtcCB0aHJlYWRpbmcgcGF0aCwgYnV0IGFkZCBw cm9maWxlIGNvdW50cyBhbG9uZworICAgdGhlIHBhdGguCisKKyAgIEluIHRo ZSBhYm9lIGV4YW1wbGUsIGFmdGVyIGFsbCBqdW1wIHRocmVhZGluZyBpcyBj b21wbGV0ZSwgd2Ugd2lsbAorICAgZW5kIHVwIHdpdGggdGhlIGZvbGxvd2lu ZyBjb250cm9sIGZsb3c6CisKKyAgICAgICAgICAgICAgICBBICAgICAgICAg IEIgICAgICAgICAgICBDCisgICAgICAgICAgICAgICAgfCAgICAgICAgICB8 ICAgICAgICAgICAgfAorICAgICAgICAgICAgICBFYXwgICAgICAgICAgfEVi ICAgICAgICAgIHxFYworICAgICAgICAgICAgICAgIHwgICAgICAgICAgfCAg ICAgICAgICAgIHwKKyAgICAgICAgICAgICAgICB2ICAgICAgICAgIHYgICAg ICAgICAgICB2CisgICAgICAgICAgICAgICBKYSAgICAgICAgICBKICAgICAg ICAgICBKYworICAgICAgICAgICAgICAgLyBcICAgICAgICAvIFxFb24nICAg ICAvIFwKKyAgICAgICAgICBFb25hLyAgIFwgICAtLS0vLS0tXC0tLS0tLS0t ICAgXEVvbmMKKyAgICAgICAgICAgICAvICAgICBcIC8gIC8gICAgIFwgICAg ICAgICAgIFwKKyAgICAgICAgICAgIHYgICAgICAgdiAgdiAgICAgICB2ICAg ICAgICAgIHYKKyAgICAgICAgICAgU29uYSAgICAgU29mZiAgICAgIFNvbiAg ICAgICAgU29uYworICAgICAgICAgICAgIFwgICAgICAgICAgICAgICAgIC9c ICAgICAgICAgLworICAgICAgICAgICAgICBcX19fX19fX19fX18gICAgLyAg XCAgX19fX18vCisgICAgICAgICAgICAgICAgICAgICAgICAgIFwgIC8gICAg XC8KKyAgICAgICAgICAgICAgICAgICAgICAgICAgIHZ2ICAgICAgdgorICAg ICAgICAgICAgICAgICAgICAgICAgICAgIEQgICAgICBFCisKKyAgIFRoZSBt YWluIGlzc3VlIHRvIG5vdGljZSBoZXJlIGlzIHRoYXQgd2hlbiB3ZSBhcmUg cHJvY2Vzc2luZyBwYXRoIDEKKyAgIChBLT5KLT5Tb24tPkQpIHdlIG5lZWQg dG8gZmlndXJlIG91dCB0aGUgb3V0Z29pbmcgZWRnZSB3ZWlnaHRzIHRvCisg ICB0aGUgZHVwbGljYXRlZCBlZGdlcyBKYS0+U29uYSBhbmQgSmEtPlNvZmYs IHdoaWxlIGVuc3VyaW5nIHRoYXQgdGhlCisgICBzdW0gb2YgdGhlIGluY29t aW5nIHdlaWdodHMgdG8gRCByZW1haW4gRWQuICBUaGUgcHJvYmxlbSB3aXRo IHNpbXBseQorICAgYXNzdW1pbmcgdGhhdCBKYSAoYW5kIEpjIHdoZW4gcHJv Y2Vzc2luZyBwYXRoIDIpIGhhcyB0aGUgc2FtZSBvdXRnb2luZworICAgcHJv YmFiaWxpdGllcyB0byBpdHMgc3VjY2Vzc29ycyBhcyB0aGUgb3JpZ2luYWwg YmxvY2sgSiwgaXMgdGhhdCBhZnRlcgorICAgYWxsIHBhdGhzIGFyZSBwcm9j ZXNzZWQgYW5kIG90aGVyIGVkZ2VzL2NvdW50cyByZW1vdmVkIChlLmcuIG5v bmUKKyAgIG9mIEVjIHdpbGwgcmVhY2ggRCBhZnRlciBwcm9jZXNzaW5nIHBh dGggMiksIHdlIG1heSBlbmQgdXAgd2l0aCBub3QKKyAgIGVub3VnaCBjb3Vu dCBmbG93aW5nIGFsb25nIGR1cGxpY2F0ZWQgZWRnZSBTb25hLT5ELgorCisg ICBUaGVyZWZvcmUsIGluIHRoZSBjYXNlIG9mIGEgam9pbmVyLCB3ZSBrZWVw IHRyYWNrIG9mIGFsbCBjb3VudHMKKyAgIGNvbWluZyBpbiBhbG9uZyB0aGUg Y3VycmVudCBwYXRoLCBhcyB3ZWxsIGFzIGZyb20gcHJlZGVjZXNzb3JzIG5v dAorICAgb24gYW55IGp1bXAgdGhyZWFkaW5nIHBhdGggKEViIGluIHRoZSBh Ym92ZSBleGFtcGxlKS4gIFdoaWxlIHdlCisgICBmaXJzdCBhc3N1bWUgdGhh dCB0aGUgZHVwbGljYXRlZCBFb25hIGZvciBKYS0+U29uYSBoYXMgdGhlIHNh bWUKKyAgIHByb2JhYmlsaXR5IGFzIHRoZSBvcmlnaW5hbCwgd2UgbGF0ZXIg Y29tcGVuc2F0ZSBmb3Igb3RoZXIganVtcAorICAgdGhyZWFkaW5nIHBhdGhz IHRoYXQgbWF5IGVsaW1pbmF0ZSBlZGdlcy4gIFdlIGRvIHRoYXQgYnkga2Vl cCB0cmFjaworICAgb2YgYWxsIGNvdW50cyBjb21pbmcgaW50byB0aGUgb3Jp Z2luYWwgcGF0aCB0aGF0IGFyZSBub3QgaW4gYSBqdW1wCisgICB0aHJlYWQg KEViIGluIHRoZSBhYm92ZSBleGFtcGxlLCBidXQgYXMgbm90ZWQgZWFybGll ciwgdGhlcmUgY291bGQKKyAgIGJlIG90aGVyIHByZWRlY2Vzc29ycyBpbmNv bWluZyB0byB0aGUgcGF0aCBhdCB2YXJpb3VzIHBvaW50cywgc3VjaAorICAg YXMgYXQgU29uKS4gIENhbGwgdGhpcyBjdW11bGF0aXZlIG5vbi1wYXRoIGNv dW50IGNvbWluZyBpbnRvIHRoZSBwYXRoCisgICBiZWZvcmUgRCBhcyBFbm9u cGF0aC4gIFdlIHRoZW4gZW5zdXJlIHRoYXQgdGhlIGNvdW50IGZyb20gU29u YS0+RCBpcyBhcyBhdAorICAgbGVhc3QgYXMgYmlnIGFzIChFZCAtIEVub25w YXRoKSwgYnV0IG5vIGJpZ2dlciB0aGFuIHRoZSBtaW5pbXVtCisgICB3ZWln aHQgYWxvbmcgdGhlIGp1bXAgdGhyZWFkaW5nIHBhdGguICBUaGUgcHJvYmFi aWxpdGllcyBvZiBib3RoIHRoZQorICAgb3JpZ2luYWwgYW5kIGR1cGxpY2F0 ZWQgam9pbmVyIGJsb2NrIEogYW5kIEphIHdpbGwgYmUgYWRqdXN0ZWQKKyAg IGFjY29yZGluZ2x5IGFmdGVyIHRoZSB1cGRhdGVzLiAgKi8KKworc3RhdGlj IGJvb2wKK2NvbXB1dGVfcGF0aF9jb3VudHMgKHN0cnVjdCByZWRpcmVjdGlv bl9kYXRhICpyZCwKKyAgICAgICAgICAgICAgICAgICAgIHNzYV9sb2NhbF9p bmZvX3QgKmxvY2FsX2luZm8sCisgICAgICAgICAgICAgICAgICAgICBnY292 X3R5cGUgKnBhdGhfaW5fY291bnRfcHRyLAorICAgICAgICAgICAgICAgICAg ICAgZ2Nvdl90eXBlICpwYXRoX291dF9jb3VudF9wdHIsCisgICAgICAgICAg ICAgICAgICAgICBpbnQgKnBhdGhfaW5fZnJlcV9wdHIpCit7CisgIGVkZ2Ug ZSA9IHJkLT5pbmNvbWluZ19lZGdlcy0+ZTsKKyAgdmVjPGp1bXBfdGhyZWFk X2VkZ2UgKj4gKnBhdGggPSBUSFJFQURfUEFUSCAoZSk7CisgIGVkZ2UgZWxh c3QgPSBwYXRoLT5sYXN0ICgpLT5lOworICBnY292X3R5cGUgbm9ucGF0aF9j b3VudCA9IDA7CisgIGJvb2wgaGFzX2pvaW5lciA9IGZhbHNlOworICBnY292 X3R5cGUgcGF0aF9pbl9jb3VudCA9IDA7CisgIGludCBwYXRoX2luX2ZyZXEg PSAwOworCisgIC8qIFN0YXJ0IGJ5IGFjY3VtdWxhdGluZyBpbmNvbWluZyBl ZGdlIGNvdW50cyB0byB0aGUgcGF0aCdzIGZpcnN0IGJiCisgICAgIGludG8g YSBjb3VwbGUgYnVja2V0czoKKyAgICAgICAgcGF0aF9pbl9jb3VudDogdG90 YWwgY291bnQgb2YgaW5jb21pbmcgZWRnZXMgdGhhdCBmbG93IGludG8gdGhl CisgICAgICAgICAgICAgICAgICBjdXJyZW50IHBhdGguCisgICAgICAgIG5v bnBhdGhfY291bnQ6IHRvdGFsIGNvdW50IG9mIGluY29taW5nIGVkZ2VzIHRo YXQgYXJlIG5vdAorICAgICAgICAgICAgICAgICAgZmxvd2luZyBhbG9uZyAq YW55KiBwYXRoLiAgVGhlc2UgYXJlIHRoZSBjb3VudHMKKyAgICAgICAgICAg ICAgICAgIHRoYXQgd2lsbCBzdGlsbCBmbG93IGFsb25nIHRoZSBvcmlnaW5h bCBwYXRoIGFmdGVyCisgICAgICAgICAgICAgICAgICBhbGwgcGF0aCBkdXBs aWNhdGlvbiBpcyBkb25lIGJ5IHBvdGVudGlhbGx5IG11bHRpcGxlCisgICAg ICAgICAgICAgICAgICBjYWxscyB0byB0aGlzIHJvdXRpbmUuCisgICAgIChh bnkgb3RoZXIgaW5jb21pbmcgZWRnZSBjb3VudHMgYXJlIGZvciBhIGRpZmZl cmVudCBqdW1wIHRocmVhZGluZworICAgICBwYXRoIHRoYXQgd2lsbCBiZSBo YW5kbGVkIGJ5IGEgbGF0ZXIgY2FsbCB0byB0aGlzIHJvdXRpbmUuKQorICAg ICBUbyBtYWtlIHRoaXMgZWFzaWVyLCBzdGFydCBieSByZWNvcmRpbmcgYWxs IGluY29taW5nIGVkZ2VzIHRoYXQgZmxvdyBpbnRvCisgICAgIHRoZSBjdXJy ZW50IHBhdGggaW4gYSBiaXRtYXAuICBXZSBjb3VsZCBhZGQgdXAgdGhlIHBh dGgncyBpbmNvbWluZyBlZGdlCisgICAgIGNvdW50cyBoZXJlLCBidXQgd2Ug c3RpbGwgbmVlZCB0byB3YWxrIGFsbCB0aGUgZmlyc3QgYmIncyBpbmNvbWlu ZyBlZGdlcworICAgICBiZWxvdyB0byBhZGQgdXAgdGhlIGNvdW50cyBvZiB0 aGUgb3RoZXIgZWRnZXMgbm90IGluY2x1ZGVkIGluIHRoaXMganVtcAorICAg ICB0aHJlYWRpbmcgcGF0aC4gICovCisgIHN0cnVjdCBlbCAqbmV4dCwgKmVs OworICBiaXRtYXAgaW5fZWRnZV9zcmNzID0gQklUTUFQX0FMTE9DIChOVUxM KTsKKyAgZm9yIChlbCA9IHJkLT5pbmNvbWluZ19lZGdlczsgZWw7IGVsID0g bmV4dCkKKyAgICB7CisgICAgICBuZXh0ID0gZWwtPm5leHQ7CisgICAgICBi aXRtYXBfc2V0X2JpdCAoaW5fZWRnZV9zcmNzLCBlbC0+ZS0+c3JjLT5pbmRl eCk7CisgICAgfQorICBlZGdlIGVpbjsKKyAgZWRnZV9pdGVyYXRvciBlaTsK KyAgRk9SX0VBQ0hfRURHRSAoZWluLCBlaSwgZS0+ZGVzdC0+cHJlZHMpCisg ICAgeworICAgICAgdmVjPGp1bXBfdGhyZWFkX2VkZ2UgKj4gKmVpbl9wYXRo ID0gVEhSRUFEX1BBVEggKGVpbik7CisgICAgICAvKiBTaW1wbHkgY2hlY2sg dGhlIGluY29taW5nIGVkZ2Ugc3JjIGFnYWluc3QgdGhlIHNldCBjYXB0dXJl ZCBhYm92ZS4gICovCisgICAgICBpZiAoZWluX3BhdGgKKyAgICAgICAgICAm JiBiaXRtYXBfYml0X3AgKGluX2VkZ2Vfc3JjcywgKCplaW5fcGF0aClbMF0t PmUtPnNyYy0+aW5kZXgpKQorICAgICAgICB7CisgICAgICAgICAgLyogSXQg aXMgbmVjZXNzYXJ5IGJ1dCBub3Qgc3VmZmljaWVudCB0aGF0IHRoZSBsYXN0 IHBhdGggZWRnZXMKKyAgICAgICAgICAgICBhcmUgaWRlbnRpY2FsLiAgVGhl cmUgbWF5IGJlIGRpZmZlcmVudCBwYXRocyB0aGF0IHNoYXJlIHRoZQorICAg ICAgICAgICAgIHNhbWUgbGFzdCBwYXRoIGVkZ2UgaW4gdGhlIGNhc2Ugd2hl cmUgdGhlIGxhc3QgZWRnZSBoYXMgYSBub2NvcHkKKyAgICAgICAgICAgICBz b3VyY2UgYmxvY2suICAqLworICAgICAgICAgIGdjY19hc3NlcnQgKGVpbl9w YXRoLT5sYXN0ICgpLT5lID09IGVsYXN0KTsKKyAgICAgICAgICBwYXRoX2lu X2NvdW50ICs9IGVpbi0+Y291bnQ7CisgICAgICAgICAgcGF0aF9pbl9mcmVx ICs9IEVER0VfRlJFUVVFTkNZIChlaW4pOworICAgICAgICB9CisgICAgICBl bHNlIGlmICghZWluX3BhdGgpCisgICAgICAgIHsKKyAgICAgICAgICAvKiBL ZWVwIHRyYWNrIG9mIHRoZSBpbmNvbWluZyBlZGdlcyB0aGF0IGFyZSBub3Qg b24gYW55IGp1bXAtdGhyZWFkaW5nCisgICAgICAgICAgICAgcGF0aC4gIFRo ZXNlIGNvdW50cyB3aWxsIHN0aWxsIGZsb3cgb3V0IG9mIG9yaWdpbmFsIHBh dGggYWZ0ZXIgYWxsCisgICAgICAgICAgICAganVtcCB0aHJlYWRpbmcgaXMg Y29tcGxldGUuICAqLworICAgICAgICAgICAgbm9ucGF0aF9jb3VudCArPSBl aW4tPmNvdW50OworICAgICAgICB9CisgICAgfQorICBCSVRNQVBfRlJFRSAo aW5fZWRnZV9zcmNzKTsKKworICAvKiBOb3cgY29tcHV0ZSB0aGUgZnJhY3Rp b24gb2YgdGhlIHRvdGFsIGNvdW50IGNvbWluZyBpbnRvIHRoZSBmaXJzdAor ICAgICBwYXRoIGJiIHRoYXQgaXMgZnJvbSB0aGUgY3VycmVudCB0aHJlYWRp bmcgcGF0aC4gICovCisgIGdjb3ZfdHlwZSB0b3RhbF9jb3VudCA9IGUtPmRl c3QtPmNvdW50OworICAvKiBIYW5kbGUgaW5jb21pbmcgcHJvZmlsZSBpbnNh bml0aWVzLiAgKi8KKyAgaWYgKHRvdGFsX2NvdW50IDwgcGF0aF9pbl9jb3Vu dCkKKyAgICBwYXRoX2luX2NvdW50ID0gdG90YWxfY291bnQ7CisgIGludCBv bnBhdGhfc2NhbGUgPSBHQ09WX0NPTVBVVEVfU0NBTEUgKHBhdGhfaW5fY291 bnQsIHRvdGFsX2NvdW50KTsKKworICAvKiBXYWxrIHRoZSBlbnRpcmUgcGF0 aCB0byBkbyBzb21lIG1vcmUgY29tcHV0YXRpb24gaW4gb3JkZXIgdG8gZXN0 aW1hdGUKKyAgICAgaG93IG11Y2ggb2YgdGhlIHBhdGhfaW5fY291bnQgd2ls bCBmbG93IG91dCBvZiB0aGUgZHVwbGljYXRlZCB0aHJlYWRpbmcKKyAgICAg cGF0aC4gIEluIHRoZSBub24tam9pbmVyIGNhc2UgdGhpcyBpcyBzdHJhaWdo dGZvcndhcmQgKGl0IHNob3VsZCBiZQorICAgICB0aGUgc2FtZSBhcyBwYXRo X2luX2NvdW50LCBhbHRob3VnaCB3ZSB3aWxsIGhhbmRsZSBpbmNvbWluZyBw cm9maWxlCisgICAgIGluc2FuaXRpZXMgYnkgc2V0dGluZyBpdCBlcXVhbCB0 byB0aGUgbWluaW11bSBjb3VudCBhbG9uZyB0aGUgcGF0aCkuCisKKyAgICAg SW4gdGhlIGpvaW5lciBjYXNlLCB3ZSBuZWVkIHRvIGVzdGltYXRlIGhvdyBt dWNoIG9mIHRoZSBwYXRoX2luX2NvdW50CisgICAgIHdpbGwgc3RheSBvbiB0 aGUgdGhyZWFkaW5nIHBhdGggYWZ0ZXIgdGhlIGpvaW5lcidzIGNvbmRpdGlv bmFsIGJyYW5jaC4KKyAgICAgV2UgZG9uJ3QgcmVhbGx5IGtub3cgZm9yIHN1 cmUgaG93IG11Y2ggb2YgdGhlIGNvdW50cworICAgICBhc3NvY2lhdGVkIHdp dGggdGhpcyBwYXRoIGdvIHRvIGVhY2ggc3VjY2Vzc29yIG9mIHRoZSBqb2lu ZXIsIGJ1dCB3ZSdsbAorICAgICBlc3RpbWF0ZSBiYXNlZCBvbiB0aGUgZnJh Y3Rpb24gb2YgdGhlIHRvdGFsIGNvdW50IGNvbWluZyBpbnRvIHRoZSBwYXRo CisgICAgIGJiIHdhcyBmcm9tIHRoZSB0aHJlYWRpbmcgcGF0aHMgKGNvbXB1 dGVkIGFib3ZlIGluIG9ucGF0aF9zY2FsZSkuCisgICAgIEFmdGVyd2FyZHMs IHdlIHdpbGwgbmVlZCB0byBkbyBzb21lIGZpeHVwIHRvIGFjY291bnQgZm9y IG90aGVyIHRocmVhZGluZworICAgICBwYXRocyBhbmQgcG9zc2libGUgcHJv ZmlsZSBpbnNhbml0aWVzLgorCisgICAgIEluIG9yZGVyIHRvIGVzdGltYXRl IHRoZSBqb2luZXIgY2FzZSdzIGNvdW50cyB3ZSBhbHNvIG5lZWQgdG8gdXBk YXRlCisgICAgIG5vbnBhdGhfY291bnQgd2l0aCBhbnkgYWRkaXRpb25hbCBj b3VudHMgY29taW5nIGludG8gdGhlIHBhdGguICBPdGhlcgorICAgICBibG9j a3MgYWxvbmcgdGhlIHBhdGggbWF5IGhhdmUgYWRkaXRpb25hbCBwcmVkZWNl c3NvcnMgZnJvbSBvdXRzaWRlCisgICAgIHRoZSBwYXRoLiAgKi8KKyAgZ2Nv dl90eXBlIHBhdGhfb3V0X2NvdW50ID0gcGF0aF9pbl9jb3VudDsKKyAgZ2Nv dl90eXBlIG1pbl9wYXRoX2NvdW50ID0gcGF0aF9pbl9jb3VudDsKKyAgZm9y ICh1bnNpZ25lZCBpbnQgaSA9IDE7IGkgPCBwYXRoLT5sZW5ndGggKCk7IGkr KykKKyAgICB7CisgICAgICBlZGdlIGVwYXRoID0gKCpwYXRoKVtpXS0+ZTsK KyAgICAgIGdjb3ZfdHlwZSBjdXJfY291bnQgPSBlcGF0aC0+Y291bnQ7Cisg ICAgICBpZiAoKCpwYXRoKVtpXS0+dHlwZSA9PSBFREdFX0NPUFlfU1JDX0pP SU5FUl9CTE9DSykKKyAgICAgICAgeworICAgICAgICAgIGhhc19qb2luZXIg PSB0cnVlOworICAgICAgICAgIGN1cl9jb3VudCA9IGFwcGx5X3Byb2JhYmls aXR5IChjdXJfY291bnQsIG9ucGF0aF9zY2FsZSk7CisgICAgICAgIH0KKyAg ICAgIC8qIEluIHRoZSBqb2luZXIgY2FzZSB3ZSBuZWVkIHRvIHVwZGF0ZSBu b25wYXRoX2NvdW50IGZvciBhbnkgZWRnZXMKKyAgICAgICAgIGNvbWluZyBp bnRvIHRoZSBwYXRoIHRoYXQgd2lsbCBjb250cmlidXRlIHRvIHRoZSBjb3Vu dCBmbG93aW5nCisgICAgICAgICBpbnRvIHRoZSBwYXRoIHN1Y2Nlc3Nvci4g ICovCisgICAgICBpZiAoaGFzX2pvaW5lciAmJiBlcGF0aCAhPSBlbGFzdCkK KyAgICAgIHsKKyAgICAgICAgLyogTG9vayBmb3Igb3RoZXIgaW5jb21pbmcg ZWRnZXMgYWZ0ZXIgam9pbmVyLiAgKi8KKyAgICAgICAgRk9SX0VBQ0hfRURH RSAoZWluLCBlaSwgZXBhdGgtPmRlc3QtPnByZWRzKQorICAgICAgICAgIHsK KyAgICAgICAgICAgIGlmIChlaW4gIT0gZXBhdGgKKyAgICAgICAgICAgICAg ICAvKiBJZ25vcmUgaW4gZWRnZXMgZnJvbSBibG9ja3Mgd2UgaGF2ZSBkdXBs aWNhdGVkIGZvciBhCisgICAgICAgICAgICAgICAgICAgdGhyZWFkaW5nIHBh dGgsIHdoaWNoIGhhdmUgZHVwbGljYXRlZCBlZGdlIGNvdW50cyB1bnRpbAor ICAgICAgICAgICAgICAgICAgIHRoZXkgYXJlIHJlZGlyZWN0ZWQgYnkgYW4g aW52b2NhdGlvbiBvZiB0aGlzIHJvdXRpbmUuICAqLworICAgICAgICAgICAg ICAgICYmICFiaXRtYXBfYml0X3AgKGxvY2FsX2luZm8tPmR1cGxpY2F0ZV9i bG9ja3MsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZWlu LT5zcmMtPmluZGV4KSkKKyAgICAgICAgICAgICAgbm9ucGF0aF9jb3VudCAr PSBlaW4tPmNvdW50OworICAgICAgICAgIH0KKyAgICAgIH0KKyAgICAgIGlm IChjdXJfY291bnQgPCBwYXRoX291dF9jb3VudCkKKyAgICAgICAgcGF0aF9v dXRfY291bnQgPSBjdXJfY291bnQ7CisgICAgICBpZiAoZXBhdGgtPmNvdW50 IDwgbWluX3BhdGhfY291bnQpCisgICAgICAgIG1pbl9wYXRoX2NvdW50ID0g ZXBhdGgtPmNvdW50OworICAgIH0KKworICAvKiBXZSBjb21wdXRlZCBwYXRo X291dF9jb3VudCBhYm92ZSBhc3N1bWluZyB0aGF0IHRoaXMgcGF0aCB0YXJn ZXRlZAorICAgICB0aGUgam9pbmVyJ3Mgb24tcGF0aCBzdWNjZXNzb3Igd2l0 aCB0aGUgc2FtZSBsaWtlbGlob29kIGFzIGl0CisgICAgIHJlYWNoZWQgdGhl IGpvaW5lci4gIEhvd2V2ZXIsIG90aGVyIHRocmVhZCBwYXRocyB0aHJvdWdo IHRoZSBqb2luZXIKKyAgICAgbWF5IHRha2UgYSBkaWZmZXJlbnQgcGF0aCB0 aHJvdWdoIHRoZSBub3JtYWwgY29weSBzb3VyY2UgYmxvY2sKKyAgICAgKGku ZS4gdGhleSBoYXZlIGEgZGlmZmVyZW50IGVsYXN0KSwgbWVhbmluZyB0aGF0 IHRoZXkgZG8gbm90CisgICAgIGNvbnRyaWJ1dGUgYW55IGNvdW50cyB0byB0 aGlzIHBhdGgncyBlbGFzdC4gIEFzIGEgcmVzdWx0LCBpdCBtYXkKKyAgICAg dHVybiBvdXQgdGhhdCB0aGlzIHBhdGggbXVzdCBoYXZlIG1vcmUgY291bnQg Zmxvd2luZyB0byB0aGUgb24tcGF0aAorICAgICBzdWNjZXNzb3Igb2YgdGhl IGpvaW5lci4gIEVzc2VudGlhbGx5LCBhbGwgb2YgdGhpcyBwYXRoJ3MgZWxh c3QKKyAgICAgY291bnQgbXVzdCBiZSBjb250cmlidXRlZCBieSB0aGlzIHBh dGggYW5kIGFueSBub25wYXRoIGNvdW50cworICAgICAoc2luY2UgYW55IHBh dGggdGhyb3VnaCB0aGUgam9pbmVyIHdpdGggYSBkaWZmZXJlbnQgZWxhc3Qg d2lsbCBub3QKKyAgICAgaW5jbHVkZSBhIGNvcHkgb2YgdGhpcyBlbGFzdCBp biBpdHMgZHVwbGljYXRlZCBwYXRoKS4KKyAgICAgU28gZW5zdXJlIHRoYXQg dGhpcyBwYXRoJ3MgcGF0aF9vdXRfY291bnQgaXMgYXQgbGVhc3QgdGhlCisg ICAgIGRpZmZlcmVuY2UgYmV0d2VlbiBlbGFzdC0+Y291bnQgYW5kIG5vbnBh dGhfY291bnQuICBPdGhlcndpc2UgdGhlIGVkZ2UKKyAgICAgY291bnRzIGFm dGVyIHRocmVhZGluZyB3aWxsIG5vdCBiZSBzYW5lLiAgKi8KKyAgaWYgKGhh c19qb2luZXIgJiYgcGF0aF9vdXRfY291bnQgPCBlbGFzdC0+Y291bnQgLSBu b25wYXRoX2NvdW50KQorICB7CisgICAgcGF0aF9vdXRfY291bnQgPSBlbGFz dC0+Y291bnQgLSBub25wYXRoX2NvdW50OworICAgIC8qIEJ1dCBuZWl0aGVy IGNhbiB3ZSBnbyBhYm92ZSB0aGUgbWluaW11bSBjb3VudCBhbG9uZyB0aGUg cGF0aAorICAgICAgIHdlIGFyZSBkdXBsaWNhdGluZy4gIFRoaXMgY2FuIGJl IGFuIGlzc3VlIGR1ZSB0byBwcm9maWxlCisgICAgICAgaW5zYW5pdGllcyBj b21pbmcgaW4gdG8gdGhpcyBwYXNzLiAgKi8KKyAgICBpZiAocGF0aF9vdXRf Y291bnQgPiBtaW5fcGF0aF9jb3VudCkKKyAgICAgIHBhdGhfb3V0X2NvdW50 ID0gbWluX3BhdGhfY291bnQ7CisgIH0KKworICAqcGF0aF9pbl9jb3VudF9w dHIgPSBwYXRoX2luX2NvdW50OworICAqcGF0aF9vdXRfY291bnRfcHRyID0g cGF0aF9vdXRfY291bnQ7CisgICpwYXRoX2luX2ZyZXFfcHRyID0gcGF0aF9p bl9mcmVxOworICByZXR1cm4gaGFzX2pvaW5lcjsKK30KKworCisvKiBVcGRh dGUgdGhlIGNvdW50cyBhbmQgZnJlcXVlbmNpZXMgZm9yIGJvdGggYW4gb3Jp Z2luYWwgcGF0aAorICAgZWRnZSBFUEFUSCBhbmQgaXRzIGR1cGxpY2F0ZSBF RFVQLiAgVGhlIGR1cGxpY2F0ZSBzb3VyY2UgYmxvY2sKKyAgIHdpbGwgZ2V0 IGEgY291bnQvZnJlcXVlbmN5IG9mIFBBVEhfSU5fQ09VTlQgYW5kIFBBVEhf SU5fRlJFUSwKKyAgIGFuZCB0aGUgZHVwbGljYXRlIGVkZ2UgRURVUCB3aWxs IGhhdmUgYSBjb3VudCBvZiBQQVRIX09VVF9DT1VOVC4gICovCitzdGF0aWMg dm9pZAordXBkYXRlX3Byb2ZpbGUgKGVkZ2UgZXBhdGgsIGVkZ2UgZWR1cCwg Z2Nvdl90eXBlIHBhdGhfaW5fY291bnQsCisgICAgICAgICAgICAgICAgZ2Nv dl90eXBlIHBhdGhfb3V0X2NvdW50LCBpbnQgcGF0aF9pbl9mcmVxKQorewor CisgIC8qIEZpcnN0IHVwZGF0ZSB0aGUgZHVwbGljYXRlZCBibG9jaydzIGNv dW50IC8gZnJlcXVlbmN5LiAgKi8KKyAgaWYgKGVkdXApCisgICAgeworICAg ICAgYmFzaWNfYmxvY2sgZHVwX2Jsb2NrID0gZWR1cC0+c3JjOworICAgICAg Z2NjX2Fzc2VydCAoZHVwX2Jsb2NrLT5jb3VudCA9PSAwKTsKKyAgICAgIGdj Y19hc3NlcnQgKGR1cF9ibG9jay0+ZnJlcXVlbmN5ID09IDApOworICAgICAg ZHVwX2Jsb2NrLT5jb3VudCA9IHBhdGhfaW5fY291bnQ7CisgICAgICBkdXBf YmxvY2stPmZyZXF1ZW5jeSA9IHBhdGhfaW5fZnJlcTsKKyAgICB9CisKKyAg LyogTm93IHVwZGF0ZSB0aGUgb3JpZ2luYWwgYmxvY2sncyBjb3VudCBhbmQg ZnJlcXVlbmN5IGluIHRoZQorICAgICBvcHBvc2l0ZSBtYW5uZXIgLSByZW1v dmUgdGhlIGNvdW50cy9mcmVxIHRoYXQgd2lsbCBmbG93CisgICAgIGludG8g dGhlIGR1cGxpY2F0ZWQgYmxvY2suICBIYW5kbGUgdW5kZXJmbG93IGR1ZSB0 byBwcmVjaXNpb24vCisgICAgIHJvdW5kaW5nIGlzc3Vlcy4gICovCisgIGVw YXRoLT5zcmMtPmNvdW50IC09IHBhdGhfaW5fY291bnQ7CisgIGlmIChlcGF0 aC0+c3JjLT5jb3VudCA8IDApCisgICAgZXBhdGgtPnNyYy0+Y291bnQgPSAw OworICBlcGF0aC0+c3JjLT5mcmVxdWVuY3kgLT0gcGF0aF9pbl9mcmVxOwor ICBpZiAoZXBhdGgtPnNyYy0+ZnJlcXVlbmN5IDwgMCkKKyAgICBlcGF0aC0+ c3JjLT5mcmVxdWVuY3kgPSAwOworCisgIC8qIE5leHQgdXBkYXRlIHRoaXMg cGF0aCBlZGdlJ3Mgb3JpZ2luYWwgYW5kIGR1cGxpY2F0ZWQgY291bnRzLiAg V2Uga25vdworICAgICB0aGF0IHRoZSBkdXBsaWNhdGVkIHBhdGggd2lsbCBo YXZlIHBhdGhfb3V0X2NvdW50IGZsb3dpbmcKKyAgICAgb3V0IG9mIGl0IChp biB0aGUgam9pbmVyIGNhc2UgdGhpcyBpcyB0aGUgY291bnQgYWxvbmcgdGhl IGR1cGxpY2F0ZWQgcGF0aAorICAgICBvdXQgb2YgdGhlIGR1cGxpY2F0ZWQg am9pbmVyKS4gIFRoaXMgY291bnQgY2FuIHRoZW4gYmUgcmVtb3ZlZCBmcm9t IHRoZQorICAgICBvcmlnaW5hbCBwYXRoIGVkZ2UuICAqLworICBpZiAoZWR1 cCkKKyAgICBlZHVwLT5jb3VudCA9IHBhdGhfb3V0X2NvdW50OworICBlcGF0 aC0+Y291bnQgLT0gcGF0aF9vdXRfY291bnQ7CisgIGdjY19hc3NlcnQgKGVw YXRoLT5jb3VudCA+PSAwKTsKK30KKworCisvKiBUaGUgZHVwbGljYXRlIGFu ZCBvcmlnaW5hbCBqb2luZXIgYmxvY2tzIG1heSBlbmQgdXAgd2l0aCBkaWZm ZXJlbnQKKyAgIHByb2JhYmlsaXRpZXMgKGRpZmZlcmVudCBmcm9tIGJvdGgg dGhlIG9yaWdpbmFsIGFuZCBmcm9tIGVhY2ggb3RoZXIpLgorICAgUmVjb21w dXRlIHRoZSBwcm9iYWJpbGl0aWVzIGhlcmUgb25jZSB3ZSBoYXZlIHVwZGF0 ZWQgdGhlIGVkZ2UKKyAgIGNvdW50cyBhbmQgZnJlcXVlbmNpZXMuICAqLwor CitzdGF0aWMgdm9pZAorcmVjb21wdXRlX3Byb2JhYmlsaXRpZXMgKGJhc2lj X2Jsb2NrIGJiKQoreworICBlZGdlIGVzdWNjOworICBlZGdlX2l0ZXJhdG9y IGVpOworICBGT1JfRUFDSF9FREdFIChlc3VjYywgZWksIGJiLT5zdWNjcykK KyAgICB7CisgICAgICBpZiAoYmItPmNvdW50KQorICAgICAgICBlc3VjYy0+ cHJvYmFiaWxpdHkgPSBHQ09WX0NPTVBVVEVfU0NBTEUgKGVzdWNjLT5jb3Vu dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBiYi0+Y291bnQpOworICAgICAgaWYgKGVzdWNjLT5wcm9iYWJp bGl0eSA+IFJFR19CUl9QUk9CX0JBU0UpCisgICAgICAgIHsKKwkgIC8qIENh biBoYXBwZW4gd2l0aCBtaXNzaW5nL2d1ZXNzZWQgcHJvYmFiaWxpdGllcywg c2luY2Ugd2UKKwkgICAgIG1heSBkZXRlcm1pbmUgdGhhdCBtb3JlIGlzIGZs b3dpbmcgYWxvbmcgZHVwbGljYXRlZAorCSAgICAgcGF0aCB0aGFuIGpvaW5l ciBzdWNjIHByb2JhYmlsaXRpZXMgYWxsb3dlZC4KKwkgICAgIENvdW50cyBh bmQgZnJlcXMgd2lsbCBiZSBpbnNhbmUgYWZ0ZXIganVtcCB0aHJlYWRpbmcs CisJICAgICBhdCBsZWFzdCBtYWtlIHN1cmUgcHJvYmFiaWxpdHkgaXMgc2Fu ZSBvciB3ZSB3aWxsCisJICAgICBnZXQgYSBmbG93IHZlcmlmaWNhdGlvbiBl cnJvci4KKwkgICAgIE5vdCBtdWNoIHdlIGNhbiBkbyB0byBtYWtlIGNvdW50 cy9mcmVxcyBzYW5lIHdpdGhvdXQKKwkgICAgIHJlZG9pbmcgdGhlIHByb2Zp bGUgZXN0aW1hdGlvbi4gICovCisJICBlc3VjYy0+cHJvYmFiaWxpdHkgPSBS RUdfQlJfUFJPQl9CQVNFOworCX0KKyAgICB9Cit9CisKKworLyogVXBkYXRl IHRoZSBjb3VudHMgb2YgdGhlIG9yaWdpbmFsIGFuZCBkdXBsaWNhdGVkIGVk Z2VzIGZyb20gYSBqb2luZXIKKyAgIHRoYXQgZ28gb2ZmIHBhdGgsIGdpdmVu IHRoYXQgd2UgaGF2ZSBhbHJlYWR5IGRldGVybWluZWQgdGhhdCB0aGUKKyAg IGR1cGxpY2F0ZSBqb2luZXIgRFVQX0JCIGhhcyBpbmNvbWluZyBjb3VudCBQ QVRIX0lOX0NPVU5UIGFuZAorICAgb3V0Z29pbmcgY291bnQgYWxvbmcgdGhl IHBhdGggUEFUSF9PVVRfQ09VTlQuICBUaGUgb3JpZ2luYWwgKG9uLSlwYXRo CisgICBlZGdlIGZyb20gam9pbmVyIGlzIEVQQVRILiAgKi8KKworc3RhdGlj IHZvaWQKK3VwZGF0ZV9qb2luZXJfb2ZmcGF0aF9jb3VudHMgKGVkZ2UgZXBh dGgsIGJhc2ljX2Jsb2NrIGR1cF9iYiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGdjb3ZfdHlwZSBwYXRoX2luX2NvdW50LAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZ2Nvdl90eXBlIHBhdGhfb3V0X2NvdW50 KQoreworICAvKiBDb21wdXRlIHRoZSBjb3VudCB0aGF0IGN1cnJlbnRseSBm bG93cyBvZmYgcGF0aCBmcm9tIHRoZSBqb2luZXIuCisgICAgIEluIG90aGVy IHdvcmRzLCB0aGUgdG90YWwgY291bnQgb2Ygam9pbmVyJ3Mgb3V0IGVkZ2Vz IG90aGVyIHRoYW4KKyAgICAgZXBhdGguICBDb21wdXRlIHRoaXMgYnkgd2Fs a2luZyB0aGUgc3VjY2Vzc29ycyBpbnN0ZWFkIG9mCisgICAgIHN1YnRyYWN0 aW5nIGVwYXRoJ3MgY291bnQgZnJvbSB0aGUgam9pbmVyIGJiIGNvdW50LCBz aW5jZSB0aGVyZQorICAgICBhcmUgc29tZXRpbWVzIHNsaWdodCBpbnNhbml0 aWVzIHdoZXJlIHRoZSB0b3RhbCBvdXQgZWRnZSBjb3VudCBpcworICAgICBs YXJnZXIgdGhhbiB0aGUgYmIgY291bnQgKHBvc3NpYmx5IGR1ZSB0byByb3Vu ZGluZy90cnVuY2F0aW9uCisgICAgIGVycm9ycykuICAqLworICBnY292X3R5 cGUgdG90YWxfb3JpZ19vZmZfcGF0aF9jb3VudCA9IDA7CisgIGVkZ2UgZW5v bnBhdGg7CisgIGVkZ2VfaXRlcmF0b3IgZWk7CisgIEZPUl9FQUNIX0VER0Ug KGVub25wYXRoLCBlaSwgZXBhdGgtPnNyYy0+c3VjY3MpCisgICAgeworICAg ICAgaWYgKGVub25wYXRoID09IGVwYXRoKQorICAgICAgICBjb250aW51ZTsK KyAgICAgIHRvdGFsX29yaWdfb2ZmX3BhdGhfY291bnQgKz0gZW5vbnBhdGgt PmNvdW50OworICAgIH0KKworICAvKiBGb3IgdGhlIHBhdGggdGhhdCB3ZSBh cmUgZHVwbGljYXRpbmcsIHRoZSBhbW91bnQgdGhhdCB3aWxsIGZsb3cKKyAg ICAgb2ZmIHBhdGggZnJvbSB0aGUgZHVwbGljYXRlZCBqb2luZXIgaXMgdGhl IGRlbHRhIGJldHdlZW4gdGhlCisgICAgIHBhdGgncyBjdW11bGF0aXZlIGlu IGNvdW50IGFuZCB0aGUgcG9ydGlvbiBvZiB0aGF0IGNvdW50IHdlCisgICAg IGVzdGltYXRlZCBhYm92ZSBhcyBmbG93aW5nIGZyb20gdGhlIGpvaW5lciBh bG9uZyB0aGUgZHVwbGljYXRlZAorICAgICBwYXRoLiAgKi8KKyAgZ2Nvdl90 eXBlIHRvdGFsX2R1cF9vZmZfcGF0aF9jb3VudCA9IHBhdGhfaW5fY291bnQg LSBwYXRoX291dF9jb3VudDsKKworICAvKiBOb3cgZG8gdGhlIGFjdHVhbCB1 cGRhdGVzIG9mIHRoZSBvZmYtcGF0aCBlZGdlcy4gICovCisgIEZPUl9FQUNI X0VER0UgKGVub25wYXRoLCBlaSwgZXBhdGgtPnNyYy0+c3VjY3MpCisgICAg eworICAgICAgLyogTG9vayBmb3IgZWRnZXMgZ29pbmcgb2ZmIG9mIHRoZSB0 aHJlYWRpbmcgcGF0aC4gICovCisgICAgICBpZiAoZW5vbnBhdGggPT0gZXBh dGgpCisgICAgICAgIGNvbnRpbnVlOworCisgICAgICAvKiBGaW5kIHRoZSBj b3JyZXNwb25kaW5nIGVkZ2Ugb3V0IG9mIHRoZSBkdXBsaWNhdGVkIGpvaW5l ci4gICovCisgICAgICBlZGdlIGVub25wYXRoZHVwID0gZmluZF9lZGdlIChk dXBfYmIsIGVub25wYXRoLT5kZXN0KTsKKyAgICAgIGdjY19hc3NlcnQgKGVu b25wYXRoZHVwKTsKKworICAgICAgLyogV2UgY2FuJ3QgdXNlIHRoZSBvcmln aW5hbCBwcm9iYWJpbGl0eSBvZiB0aGUgam9pbmVyJ3Mgb3V0CisgICAgICAg ICBlZGdlcywgc2luY2UgdGhlIHByb2JhYmlsaXRpZXMgb2YgdGhlIG9yaWdp bmFsIGJyYW5jaAorICAgICAgICAgYW5kIHRoZSBkdXBsaWNhdGVkIGJyYW5j aGVzIG1heSB2YXJ5IGFmdGVyIGFsbCB0aHJlYWRpbmcgaXMKKyAgICAgICAg IGNvbXBsZXRlLiAgQnV0IGFwcG9ydGlvbiB0aGUgZHVwbGljYXRlZCBqb2lu ZXIncyBvZmYtcGF0aAorICAgICAgICAgdG90YWwgZWRnZSBjb3VudCBjb21w dXRlZCBlYXJsaWVyICh0b3RhbF9kdXBfb2ZmX3BhdGhfY291bnQpCisgICAg ICAgICBhbW9uZyB0aGUgZHVwbGljYXRlZCBvZmYtcGF0aCBlZGdlcyBiYXNl ZCBvbiB0aGVpciBvcmlnaW5hbAorICAgICAgICAgcmF0aW8gdG8gdGhlIGZ1 bGwgb2ZmLXBhdGggY291bnQgKHRvdGFsX29yaWdfb2ZmX3BhdGhfY291bnQp LgorICAgICAgICAgKi8KKyAgICAgIGludCBzY2FsZSA9IEdDT1ZfQ09NUFVU RV9TQ0FMRSAoZW5vbnBhdGgtPmNvdW50LAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB0b3RhbF9vcmlnX29mZl9wYXRoX2NvdW50 KTsKKyAgICAgIC8qIEdpdmUgdGhlIGR1cGxpY2F0ZWQgb2ZmcGF0aCBlZGdl IGEgcG9ydGlvbiBvZiB0aGUgZHVwbGljYXRlZAorICAgICAgICAgdG90YWwu ICAqLworICAgICAgZW5vbnBhdGhkdXAtPmNvdW50ID0gYXBwbHlfc2NhbGUg KHNjYWxlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHRvdGFsX2R1cF9vZmZfcGF0aF9jb3VudCk7CisgICAgICAvKiBOb3cg dXBkYXRlIHRoZSBvcmlnaW5hbCBvZmZwYXRoIGVkZ2UgY291bnQsIGhhbmRs aW5nIHVuZGVyZmxvdworICAgICAgICAgZHVlIHRvIHJvdW5kaW5nIGVycm9y cy4gICovCisgICAgICBlbm9ucGF0aC0+Y291bnQgLT0gZW5vbnBhdGhkdXAt PmNvdW50OworICAgICAgaWYgKGVub25wYXRoLT5jb3VudCA8IDApCisgICAg ICAgIGVub25wYXRoLT5jb3VudCA9IDA7CisgICAgfQorfQorCisKKy8qIElu dm9rZWQgZm9yIHJvdXRpbmVzIHRoYXQgaGF2ZSBndWVzc2VkIGZyZXF1ZW5j aWVzIGFuZCBubyBwcm9maWxlCisgICBjb3VudHMgdG8gcmVjb3JkIHRoZSBi bG9jayBhbmQgZWRnZSBmcmVxdWVuY2llcyBmb3IgcGF0aHMgdGhyb3VnaCBS RAorICAgaW4gdGhlIHByb2ZpbGUgY291bnQgZmllbGRzIG9mIHRob3NlIGJs b2NrcyBhbmQgZWRnZXMuICBUaGlzIGlzIGJlY2F1c2UKKyAgIHNzYV9maXhf ZHVwbGljYXRlX2Jsb2NrX2VkZ2VzIGluY3JlbWVudGFsbHkgdXBkYXRlcyB0 aGUgYmxvY2sgYW5kCisgICBlZGdlIGNvdW50cyBhcyBlZGdlcyBhcmUgcmVk aXJlY3RlZCwgYW5kIGl0IGlzIGRpZmZpY3VsdCB0byBkbyB0aGF0CisgICBm b3IgZWRnZSBmcmVxdWVuY2llcyB3aGljaCBhcmUgY29tcHV0ZWQgb24gdGhl IGZseSBmcm9tIHRoZSBzb3VyY2UKKyAgIGJsb2NrIGZyZXF1ZW5jeSBhbmQg cHJvYmFiaWxpdHkuICBXaGVuIGEgYmxvY2sgZnJlcXVlbmN5IGlzIHVwZGF0 ZWQKKyAgIGl0cyBvdXRnb2luZyBlZGdlIGZyZXF1ZW5jaWVzIGFyZSBhZmZl Y3RlZCBhbmQgYmVjb21lIGRpZmZpY3VsdCB0bworICAgYWRqdXN0LiAgKi8K Kworc3RhdGljIHZvaWQKK2ZyZXFzX3RvX2NvdW50c19wYXRoIChzdHJ1Y3Qg cmVkaXJlY3Rpb25fZGF0YSAqcmQpCit7CisgIGVkZ2UgZSA9IHJkLT5pbmNv bWluZ19lZGdlcy0+ZTsKKyAgdmVjPGp1bXBfdGhyZWFkX2VkZ2UgKj4gKnBh dGggPSBUSFJFQURfUEFUSCAoZSk7CisgIGVkZ2UgZWluOworICBlZGdlX2l0 ZXJhdG9yIGVpOworICBGT1JfRUFDSF9FREdFIChlaW4sIGVpLCBlLT5kZXN0 LT5wcmVkcykKKyAgICB7CisgICAgICBnY2NfYXNzZXJ0ICghZWluLT5jb3Vu dCk7CisgICAgICBlaW4tPmNvdW50ID0gRURHRV9GUkVRVUVOQ1kgKGVpbik7 CisgICAgfQorCisgIGZvciAodW5zaWduZWQgaW50IGkgPSAxOyBpIDwgcGF0 aC0+bGVuZ3RoICgpOyBpKyspCisgICAgeworICAgICAgZWRnZSBlcGF0aCA9 ICgqcGF0aClbaV0tPmU7CisgICAgICBnY2NfYXNzZXJ0ICghZXBhdGgtPmNv dW50KTsKKyAgICAgIGVkZ2UgZXN1Y2M7CisgICAgICBGT1JfRUFDSF9FREdF IChlc3VjYywgZWksIGVwYXRoLT5zcmMtPnN1Y2NzKQorICAgICAgICB7Cisg ICAgICAgICAgZXN1Y2MtPmNvdW50ID0gRURHRV9GUkVRVUVOQ1kgKGVzdWNj KTsKKyAgICAgICAgfQorICAgICAgZXBhdGgtPnNyYy0+Y291bnQgPSBlcGF0 aC0+c3JjLT5mcmVxdWVuY3k7CisgICAgfQorfQorCitzdGF0aWMgdm9pZAor Y2xlYXJfY291bnRzX3BhdGggKHN0cnVjdCByZWRpcmVjdGlvbl9kYXRhICpy ZCkKK3sKKyAgZWRnZSBlID0gcmQtPmluY29taW5nX2VkZ2VzLT5lOworICB2 ZWM8anVtcF90aHJlYWRfZWRnZSAqPiAqcGF0aCA9IFRIUkVBRF9QQVRIIChl KTsKKyAgZWRnZSBlaW4sIGVzdWNjOworICBlZGdlX2l0ZXJhdG9yIGVpOwor ICBGT1JfRUFDSF9FREdFIChlaW4sIGVpLCBlLT5kZXN0LT5wcmVkcykKKyAg ICBlaW4tPmNvdW50ID0gMDsKKworICBmb3IgKHVuc2lnbmVkIGludCBpID0g MTsgaSA8IHBhdGgtPmxlbmd0aCAoKTsgaSsrKQorICAgIHsKKyAgICAgIGVk Z2UgZXBhdGggPSAoKnBhdGgpW2ldLT5lOworICAgICAgRk9SX0VBQ0hfRURH RSAoZXN1Y2MsIGVpLCBlcGF0aC0+c3JjLT5zdWNjcykKKyAgICAgIHsKKyAg ICAgICAgZXN1Y2MtPmNvdW50ID0gMDsKKyAgICAgIH0KKyAgICAgIGVwYXRo LT5zcmMtPmNvdW50ID0gMDsKKyAgICB9CisgIGZvciAodW5zaWduZWQgaW50 IGkgPSAwOyBpIDwgMjsgaSsrKQorICAgIHsKKyAgICAgIGJhc2ljX2Jsb2Nr IGR1cCA9IHJkLT5kdXBfYmxvY2tzW2ldOworICAgICAgaWYgKCFkdXApCisg ICAgICAgIGNvbnRpbnVlOworICAgICAgRk9SX0VBQ0hfRURHRSAoZXN1Y2Ms IGVpLCBkdXAtPnN1Y2NzKQorICAgICAgeworICAgICAgICBlc3VjYy0+Y291 bnQgPSAwOworICAgICAgfQorICAgICAgZHVwLT5jb3VudCA9IDA7CisgICAg fQorfQorCiAvKiBXaXJlIHVwIHRoZSBvdXRnb2luZyBlZGdlcyBmcm9tIHRo ZSBkdXBsaWNhdGUgYmxvY2tzIGFuZAotICAgdXBkYXRlIGFueSBQSElzIGFz IG5lZWRlZC4gICovCisgICB1cGRhdGUgYW55IFBISXMgYXMgbmVlZGVkLiAg QWxzbyB1cGRhdGUgdGhlIHByb2ZpbGUgY291bnRzCisgICBvbiB0aGUgb3Jp Z2luYWwgYW5kIGR1cGxpY2F0ZSBibG9ja3MgYW5kIGVkZ2VzLiAgKi8KIHZv aWQKIHNzYV9maXhfZHVwbGljYXRlX2Jsb2NrX2VkZ2VzIChzdHJ1Y3QgcmVk aXJlY3Rpb25fZGF0YSAqcmQsCiAJCQkgICAgICAgc3NhX2xvY2FsX2luZm9f dCAqbG9jYWxfaW5mbykKQEAgLTU2NCw5ICsxMDM3LDMxIEBAIHNzYV9maXhf ZHVwbGljYXRlX2Jsb2NrX2VkZ2VzIChzdHJ1Y3QgcmVkaXJlY3Rpb25fCiAg IGJvb2wgbXVsdGlfaW5jb21pbmdzID0gKHJkLT5pbmNvbWluZ19lZGdlcy0+ bmV4dCAhPSBOVUxMKTsKICAgZWRnZSBlID0gcmQtPmluY29taW5nX2VkZ2Vz LT5lOwogICB2ZWM8anVtcF90aHJlYWRfZWRnZSAqPiAqcGF0aCA9IFRIUkVB RF9QQVRIIChlKTsKKyAgZWRnZSBlbGFzdCA9IHBhdGgtPmxhc3QgKCktPmU7 CisgIGdjb3ZfdHlwZSBwYXRoX2luX2NvdW50ID0gMDsKKyAgZ2Nvdl90eXBl IHBhdGhfb3V0X2NvdW50ID0gMDsKKyAgaW50IHBhdGhfaW5fZnJlcSA9IDA7 CiAKKyAgYm9vbCBkb19mcmVxc190b19jb3VudHMgPSAocHJvZmlsZV9zdGF0 dXNfZm9yX2ZuIChjZnVuKSAhPSBQUk9GSUxFX1JFQUQKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgfHwgIUVOVFJZX0JMT0NLX1BUUl9GT1JfRk4g KGNmdW4pLT5jb3VudCk7CisgIGlmIChkb19mcmVxc190b19jb3VudHMpCisg ICAgZnJlcXNfdG9fY291bnRzX3BhdGggKHJkKTsKKworICAvKiBGaXJzdCBk ZXRlcm1pbmUgaG93IG11Y2ggcHJvZmlsZSBjb3VudCB0byBtb3ZlIGZyb20g b3JpZ2luYWwKKyAgICAgcGF0aCB0byB0aGUgZHVwbGljYXRlIHBhdGguICBU aGlzIGlzIHRyaWNreSBpbiB0aGUgcHJlc2VuY2Ugb2YKKyAgICAgYSBqb2lu ZXIgKHNlZSBjb21tZW50cyBmb3IgY29tcHV0ZV9wYXRoX2NvdW50cyksIHdo ZXJlIHNvbWUgcG9ydGlvbgorICAgICBvZiB0aGUgcGF0aCdzIGNvdW50cyB3 aWxsIGZsb3cgb2ZmLXBhdGggZnJvbSB0aGUgam9pbmVyLiAgSW4gdGhlCisg ICAgIG5vbi1qb2luZXIgY2FzZSB0aGUgcGF0aF9pbl9jb3VudCBhbmQgcGF0 aF9vdXRfY291bnQgc2hvdWxkIGJlIHRoZQorICAgICBzYW1lLiAgKi8KKyAg Ym9vbCBoYXNfam9pbmVyID0gY29tcHV0ZV9wYXRoX2NvdW50cyAocmQsIGxv Y2FsX2luZm8sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICZwYXRoX2luX2NvdW50LCAmcGF0aF9vdXRfY291bnQsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZwYXRoX2lu X2ZyZXEpOworCisgIGludCBjdXJfcGF0aF9mcmVxID0gcGF0aF9pbl9mcmVx OwogICBmb3IgKHVuc2lnbmVkIGludCBjb3VudCA9IDAsIGkgPSAxOyBpIDwg cGF0aC0+bGVuZ3RoICgpOyBpKyspCiAgICAgeworICAgICAgZWRnZSBlcGF0 aCA9ICgqcGF0aClbaV0tPmU7CisKICAgICAgIC8qIElmIHdlIHdlcmUgdGhy ZWFkaW5nIHRocm91Z2ggYW4gam9pbmVyIGJsb2NrLCB0aGVuIHdlIHdhbnQK IAkgdG8ga2VlcCBpdHMgY29udHJvbCBzdGF0ZW1lbnQgYW5kIHJlZGlyZWN0 IGFuIG91dGdvaW5nIGVkZ2UuCiAJIEVsc2Ugd2Ugd2FudCB0byByZW1vdmUg dGhlIGNvbnRyb2wgc3RhdGVtZW50ICYgZWRnZXMsIHRoZW4gY3JlYXRlCkBA IC01NzYsNiArMTA3MSw4IEBAIHNzYV9maXhfZHVwbGljYXRlX2Jsb2NrX2Vk Z2VzIChzdHJ1Y3QgcmVkaXJlY3Rpb25fCiAJICBlZGdlIHZpY3RpbTsKIAkg IGVkZ2UgZTI7CiAKKyAgICAgICAgICBnY2NfYXNzZXJ0IChoYXNfam9pbmVy KTsKKwogCSAgLyogVGhpcyB1cGRhdGVzIHRoZSBQSElzIGF0IHRoZSBkZXN0 aW5hdGlvbiBvZiB0aGUgZHVwbGljYXRlCiAJICAgICBibG9jay4gIFBhc3Mg MCBpbnN0ZWFkIG9mIGkgaWYgd2UgYXJlIHRocmVhZGluZyBhIHBhdGggd2hp Y2gKIAkgICAgIGhhcyBtdWx0aXBsZSBpbmNvbWluZyBlZGdlcy4gICovCkBA IC01OTEsMTQgKzEwODgsMTMgQEAgc3NhX2ZpeF9kdXBsaWNhdGVfYmxvY2tf ZWRnZXMgKHN0cnVjdCByZWRpcmVjdGlvbl8KIAkgICAgIHRocmVhZGluZyBw YXRoLiAgKi8KIAkgIGlmICghYW55X3JlbWFpbmluZ19kdXBsaWNhdGVkX2Js b2NrcyAocGF0aCwgaSkpCiAJICAgIHsKLQkgICAgICBlMiA9IHJlZGlyZWN0 X2VkZ2VfYW5kX2JyYW5jaCAodmljdGltLCBwYXRoLT5sYXN0ICgpLT5lLT5k ZXN0KTsKLQkgICAgICBlMi0+Y291bnQgPSBwYXRoLT5sYXN0ICgpLT5lLT5j b3VudDsKKwkgICAgICBlMiA9IHJlZGlyZWN0X2VkZ2VfYW5kX2JyYW5jaCAo dmljdGltLCBlbGFzdC0+ZGVzdCk7CiAJICAgICAgLyogSWYgd2UgcmVkaXJl Y3RlZCB0aGUgZWRnZSwgdGhlbiB3ZSBuZWVkIHRvIGNvcHkgUEhJIGFyZ3Vt ZW50cwogCQkgYXQgdGhlIHRhcmdldC4gIElmIHRoZSBlZGdlIGFscmVhZHkg ZXhpc3RlZCAoZTIgIT0gdmljdGltCiAJCSBjYXNlKSwgdGhlbiB0aGUgUEhJ cyBpbiB0aGUgdGFyZ2V0IGFscmVhZHkgaGF2ZSB0aGUgY29ycmVjdAogCQkg YXJndW1lbnRzLiAgKi8KIAkgICAgICBpZiAoZTIgPT0gdmljdGltKQotCQlj b3B5X3BoaV9hcmdzIChlMi0+ZGVzdCwgcGF0aC0+bGFzdCAoKS0+ZSwgZTIs CisJCWNvcHlfcGhpX2FyZ3MgKGUyLT5kZXN0LCBlbGFzdCwgZTIsCiAJCQkg ICAgICAgcGF0aCwgbXVsdGlfaW5jb21pbmdzID8gMCA6IGkpOwogCSAgICB9 CiAJICBlbHNlCkBAIC02MjYsNyArMTEyMiwzMSBAQCBzc2FfZml4X2R1cGxp Y2F0ZV9ibG9ja19lZGdlcyAoc3RydWN0IHJlZGlyZWN0aW9uXwogCQkgICAg fQogCQl9CiAJICAgIH0KLQkgIGNvdW50Kys7CisKKwkgIC8qIFVwZGF0ZSB0 aGUgY291bnRzIGFuZCBmcmVxdWVuY3kgb2YgYm90aCB0aGUgb3JpZ2luYWwg YmxvY2sKKwkgICAgIGFuZCBwYXRoIGVkZ2UsIGFuZCB0aGUgZHVwbGljYXRl cy4gIFRoZSBwYXRoIGR1cGxpY2F0ZSdzCisJICAgICBpbmNvbWluZyBjb3Vu dCBhbmQgZnJlcXVlbmN5IGFyZSB0aGUgdG90YWxzIGZvciBhbGwgZWRnZXMK KwkgICAgIGluY29taW5nIHRvIHRoaXMganVtcCB0aHJlYWRpbmcgcGF0aCBj b21wdXRlZCBlYXJsaWVyLgorCSAgICAgQW5kIHdlIGtub3cgdGhhdCB0aGUg ZHVwbGljYXRlZCBwYXRoIHdpbGwgaGF2ZSBwYXRoX291dF9jb3VudAorCSAg ICAgZmxvd2luZyBvdXQgb2YgaXQgKGkuZS4gYWxvbmcgdGhlIGR1cGxpY2F0 ZWQgcGF0aCBvdXQgb2YgdGhlCisJICAgICBkdXBsaWNhdGVkIGpvaW5lciku ICAqLworCSAgdXBkYXRlX3Byb2ZpbGUgKGVwYXRoLCBlMiwgcGF0aF9pbl9j b3VudCwgcGF0aF9vdXRfY291bnQsCisJCQkgIHBhdGhfaW5fZnJlcSk7CisK KwkgIC8qIE5leHQgd2UgbmVlZCB0byB1cGRhdGUgdGhlIGNvdW50cyBvZiB0 aGUgb3JpZ2luYWwgYW5kIGR1cGxpY2F0ZWQKKwkgICAgIGVkZ2VzIGZyb20g dGhlIGpvaW5lciB0aGF0IGdvIG9mZiBwYXRoLiAgKi8KKwkgIHVwZGF0ZV9q b2luZXJfb2ZmcGF0aF9jb3VudHMgKGVwYXRoLCBlMi0+c3JjLCBwYXRoX2lu X2NvdW50LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHBhdGhfb3V0X2NvdW50KTsKKworCSAgLyogRmluYWxseSwgd2UgbmVl ZCB0byBzZXQgdGhlIHByb2JhYmlsaXRpZXMgb24gdGhlIGR1cGxpY2F0ZWQK KwkgICAgIGVkZ2VzIG91dCBvZiB0aGUgZHVwbGljYXRlZCBqb2luZXIgKGUy LT5zcmMpLiAgVGhlIHByb2JhYmlsaXRpZXMKKwkgICAgIGFsb25nIHRoZSBv cmlnaW5hbCBwYXRoIHdpbGwgYWxsIGJlIHVwZGF0ZWQgYmVsb3cgYWZ0ZXIg d2UgZmluaXNoCisJICAgICBwcm9jZXNzaW5nIHRoZSB3aG9sZSBwYXRoLiAg Ki8KKwkgIHJlY29tcHV0ZV9wcm9iYWJpbGl0aWVzIChlMi0+c3JjKTsKKwor CSAgLyogUmVjb3JkIHRoZSBmcmVxdWVuY3kgZmxvd2luZyB0byB0aGUgZG93 bnN0cmVhbSBkdXBsaWNhdGVkCisJICAgICBwYXRoIGJsb2Nrcy4gICovCisJ ICBjdXJfcGF0aF9mcmVxID0gRURHRV9GUkVRVUVOQ1kgKGUyKTsKIAl9CiAg ICAgICBlbHNlIGlmICgoKnBhdGgpW2ldLT50eXBlID09IEVER0VfQ09QWV9T UkNfQkxPQ0spCiAJewpAQCAtNjM1LDkgKzExNTUsNTggQEAgc3NhX2ZpeF9k dXBsaWNhdGVfYmxvY2tfZWRnZXMgKHN0cnVjdCByZWRpcmVjdGlvbl8KIAkJ CQkJCSAgIG11bHRpX2luY29taW5ncyA/IDAgOiBpKTsKIAkgIGlmIChjb3Vu dCA9PSAxKQogCSAgICBzaW5nbGVfc3VjY19lZGdlIChyZC0+ZHVwX2Jsb2Nr c1sxXSktPmF1eCA9IE5VTEw7CisKKwkgIC8qIFVwZGF0ZSB0aGUgY291bnRz IGFuZCBmcmVxdWVuY3kgb2YgYm90aCB0aGUgb3JpZ2luYWwgYmxvY2sKKwkg ICAgIGFuZCBwYXRoIGVkZ2UsIGFuZCB0aGUgZHVwbGljYXRlcy4gIFNpbmNl IHdlIGFyZSBub3cgYWZ0ZXIKKwkgICAgIGFueSBqb2luZXIgdGhhdCBtYXkg aGF2ZSBleGlzdGVkIG9uIHRoZSBwYXRoLCB0aGUgY291bnQKKwkgICAgIGZs b3dpbmcgYWxvbmcgdGhlIGR1cGxpY2F0ZWQgdGhyZWFkZWQgcGF0aCBpcyBw YXRoX291dF9jb3VudC4KKwkgICAgIElmIHdlIGRpZG4ndCBoYXZlIGEgam9p bmVyLCB0aGVuIGN1cl9wYXRoX2ZyZXEgd2FzIHRoZSBzdW0KKwkgICAgIG9m IHRoZSB0b3RhbCBmcmVxdWVuY2llcyBhbG9uZyBhbGwgaW5jb21pbmcgZWRn ZXMgdG8gdGhlCisJICAgICB0aHJlYWQgcGF0aCAocGF0aF9pbl9mcmVxKS4g IElmIHdlIGhhZCBhIGpvaW5lciwgaXQgd291bGQgaGF2ZQorCSAgICAgYmVl biB1cGRhdGVkIGF0IHRoZSBlbmQgb2YgdGhhdCBoYW5kbGluZyB0byB0aGUg ZWRnZSBmcmVxdWVuY3kKKwkgICAgIGFsb25nIHRoZSBkdXBsaWNhdGVkIGpv aW5lciBwYXRoIGVkZ2UuICAqLworCSAgdXBkYXRlX3Byb2ZpbGUgKGVwYXRo LCBFREdFX1NVQ0MgKHJkLT5kdXBfYmxvY2tzW2NvdW50XSwgMCksCisJCQkg IHBhdGhfb3V0X2NvdW50LCBwYXRoX291dF9jb3VudCwKKwkJCSAgY3VyX3Bh dGhfZnJlcSk7CisJfQorICAgICAgZWxzZQorICAgICAgICB7CisJICAvKiBO byBjb3B5IGNhc2UuICBJbiB0aGlzIGNhc2Ugd2UgZG9uJ3QgaGF2ZSBhbiBl cXVpdmFsZW50IGJsb2NrCisJICAgICBvbiB0aGUgZHVwbGljYXRlZCB0aHJl YWQgcGF0aCB0byB1cGRhdGUsIGJ1dCB3ZSBkbyBuZWVkCisJICAgICB0byBy ZW1vdmUgdGhlIHBvcnRpb24gb2YgdGhlIGNvdW50cy9mcmVxcyB0aGF0IHdl cmUgbW92ZWQKKwkgICAgIHRvIHRoZSBkdXBsaWNhdGVkIHBhdGggZnJvbSB0 aGUgY291bnRzL2ZyZXFzIGZsb3dpbmcgdGhyb3VnaAorCSAgICAgdGhpcyBi bG9jayBvbiB0aGUgb3JpZ2luYWwgcGF0aC4gIFNpbmNlIGFsbCB0aGUgbm8t Y29weSBlZGdlcworCSAgICAgYXJlIGFmdGVyIGFueSBqb2luZXIsIHRoZSBy ZW1vdmVkIGNvdW50IGlzIHRoZSBzYW1lIGFzCisJICAgICBwYXRoX291dF9j b3VudC4KKworCSAgICAgSWYgd2UgZGlkbid0IGhhdmUgYSBqb2luZXIsIHRo ZW4gY3VyX3BhdGhfZnJlcSB3YXMgdGhlIHN1bQorCSAgICAgb2YgdGhlIHRv dGFsIGZyZXF1ZW5jaWVzIGFsb25nIGFsbCBpbmNvbWluZyBlZGdlcyB0byB0 aGUKKwkgICAgIHRocmVhZCBwYXRoIChwYXRoX2luX2ZyZXEpLiAgSWYgd2Ug aGFkIGEgam9pbmVyLCBpdCB3b3VsZCBoYXZlCisJICAgICBiZWVuIHVwZGF0 ZWQgYXQgdGhlIGVuZCBvZiB0aGF0IGhhbmRsaW5nIHRvIHRoZSBlZGdlIGZy ZXF1ZW5jeQorCSAgICAgYWxvbmcgdGhlIGR1cGxpY2F0ZWQgam9pbmVyIHBh dGggZWRnZS4gICovCisJICAgICB1cGRhdGVfcHJvZmlsZSAoZXBhdGgsIE5V TEwsIHBhdGhfb3V0X2NvdW50LCBwYXRoX291dF9jb3VudCwKKwkJCSAgICAg Y3VyX3BhdGhfZnJlcSk7CisJfQorCisgICAgICAvKiBJbmNyZW1lbnQgdGhl IGluZGV4IGludG8gdGhlIGR1cGxpY2F0ZWQgcGF0aCB3aGVuIHdlIHByb2Nl c3NlZAorICAgICAgICAgYSBkdXBsaWNhdGVkIGJsb2NrLiAgKi8KKyAgICAg IGlmICgoKnBhdGgpW2ldLT50eXBlID09IEVER0VfQ09QWV9TUkNfSk9JTkVS X0JMT0NLCisgICAgICAgICAgfHwgKCpwYXRoKVtpXS0+dHlwZSA9PSBFREdF X0NPUFlfU1JDX0JMT0NLKQorICAgICAgewogCSAgY291bnQrKzsKLQl9Cisg ICAgICB9CiAgICAgfQorCisgIC8qIE5vdyB3YWxrIG9yaWcgYmxvY2tzIGFu ZCB1cGRhdGUgdGhlaXIgcHJvYmFiaWxpdGllcywgc2luY2UgdGhlCisgICAg IGNvdW50cyBhbmQgZnJlcXMgc2hvdWxkIGJlIHVwZGF0ZWQgcHJvcGVybHkg YnkgYWJvdmUgbG9vcC4gICovCisgIGZvciAodW5zaWduZWQgaW50IGkgPSAx OyBpIDwgcGF0aC0+bGVuZ3RoICgpOyBpKyspCisgICAgeworICAgICAgZWRn ZSBlcGF0aCA9ICgqcGF0aClbaV0tPmU7CisgICAgICByZWNvbXB1dGVfcHJv YmFiaWxpdGllcyAoZXBhdGgtPnNyYyk7CisgICAgfQorCisgIGlmIChkb19m cmVxc190b19jb3VudHMpCisgICAgY2xlYXJfY291bnRzX3BhdGggKHJkKTsK IH0KIAogLyogSGFzaCB0YWJsZSB0cmF2ZXJzYWwgY2FsbGJhY2sgcm91dGlu ZSB0byBjcmVhdGUgZHVwbGljYXRlIGJsb2Nrcy4gICovCkBAIC02NjMsNyAr MTIzMiw4IEBAIHNzYV9jcmVhdGVfZHVwbGljYXRlcyAoc3RydWN0IHJlZGly ZWN0aW9uX2RhdGEgKipzCiAgICAgICBpZiAoKCpwYXRoKVtpXS0+dHlwZSA9 PSBFREdFX0NPUFlfU1JDX0JMT0NLCiAJICB8fCAoKnBhdGgpW2ldLT50eXBl ID09IEVER0VfQ09QWV9TUkNfSk9JTkVSX0JMT0NLKQogCXsKLQkgIGNyZWF0 ZV9ibG9ja19mb3JfdGhyZWFkaW5nICgoKnBhdGgpW2ldLT5lLT5zcmMsIHJk LCAxKTsKKwkgIGNyZWF0ZV9ibG9ja19mb3JfdGhyZWFkaW5nICgoKnBhdGgp W2ldLT5lLT5zcmMsIHJkLCAxLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAmbG9jYWxfaW5mby0+ZHVwbGljYXRlX2Jsb2Nrcyk7 CiAJICBicmVhazsKIAl9CiAgICAgfQpAQCAtNjcyLDcgKzEyNDIsOCBAQCBz c2FfY3JlYXRlX2R1cGxpY2F0ZXMgKHN0cnVjdCByZWRpcmVjdGlvbl9kYXRh ICoqcwogICAgICB1c2UgdGhlIHRlbXBsYXRlIHRvIGNyZWF0ZSBhIG5ldyBi bG9jay4gICovCiAgIGlmIChsb2NhbF9pbmZvLT50ZW1wbGF0ZV9ibG9jayA9 PSBOVUxMKQogICAgIHsKLSAgICAgIGNyZWF0ZV9ibG9ja19mb3JfdGhyZWFk aW5nICgoKnBhdGgpWzFdLT5lLT5zcmMsIHJkLCAwKTsKKyAgICAgIGNyZWF0 ZV9ibG9ja19mb3JfdGhyZWFkaW5nICgoKnBhdGgpWzFdLT5lLT5zcmMsIHJk LCAwLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZsb2Nh bF9pbmZvLT5kdXBsaWNhdGVfYmxvY2tzKTsKICAgICAgIGxvY2FsX2luZm8t PnRlbXBsYXRlX2Jsb2NrID0gcmQtPmR1cF9ibG9ja3NbMF07CiAKICAgICAg IC8qIFdlIGRvIG5vdCBjcmVhdGUgYW55IG91dGdvaW5nIGVkZ2VzIGZvciB0 aGUgdGVtcGxhdGUuICBXZSB3aWxsCkBAIC02ODEsNyArMTI1Miw4IEBAIHNz YV9jcmVhdGVfZHVwbGljYXRlcyAoc3RydWN0IHJlZGlyZWN0aW9uX2RhdGEg KipzCiAgICAgfQogICBlbHNlCiAgICAgewotICAgICAgY3JlYXRlX2Jsb2Nr X2Zvcl90aHJlYWRpbmcgKGxvY2FsX2luZm8tPnRlbXBsYXRlX2Jsb2NrLCBy ZCwgMCk7CisgICAgICBjcmVhdGVfYmxvY2tfZm9yX3RocmVhZGluZyAobG9j YWxfaW5mby0+dGVtcGxhdGVfYmxvY2ssIHJkLCAwLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICZsb2NhbF9pbmZvLT5kdXBsaWNhdGVf YmxvY2tzKTsKIAogICAgICAgLyogR28gYWhlYWQgYW5kIHdpcmUgdXAgb3V0 Z29pbmcgZWRnZXMgYW5kIHVwZGF0ZSBQSElzIGZvciB0aGUgZHVwbGljYXRl CiAJIGJsb2NrLiAgICovCkBAIC03NTEsMTkgKzEzMjMsNiBAQCBzc2FfcmVk aXJlY3RfZWRnZXMgKHN0cnVjdCByZWRpcmVjdGlvbl9kYXRhICoqc2xvdAog CSAgICBmcHJpbnRmIChkdW1wX2ZpbGUsICIgIFRocmVhZGVkIGp1bXAgJWQg LS0+ICVkIHRvICVkXG4iLAogCQkgICAgIGUtPnNyYy0+aW5kZXgsIGUtPmRl c3QtPmluZGV4LCByZC0+ZHVwX2Jsb2Nrc1swXS0+aW5kZXgpOwogCi0JICBy ZC0+ZHVwX2Jsb2Nrc1swXS0+Y291bnQgKz0gZS0+Y291bnQ7Ci0KLQkgIC8q IEV4Y2Vzc2l2ZSBqdW1wIHRocmVhZGluZyBtYXkgbWFrZSBmcmVxdWVuY2ll cyBsYXJnZSBlbm91Z2ggc28KLQkgICAgIHRoZSBjb21wdXRhdGlvbiBvdmVy Zmxvd3MuICAqLwotCSAgaWYgKHJkLT5kdXBfYmxvY2tzWzBdLT5mcmVxdWVu Y3kgPCBCQl9GUkVRX01BWCAqIDIpCi0JICAgIHJkLT5kdXBfYmxvY2tzWzBd LT5mcmVxdWVuY3kgKz0gRURHRV9GUkVRVUVOQ1kgKGUpOwotCi0JICAvKiBJ biB0aGUgY2FzZSBvZiB0aHJlYWRpbmcgdGhyb3VnaCBhIGpvaW5lciBibG9j aywgdGhlIG91dGdvaW5nCi0JICAgICBlZGdlcyBmcm9tIHRoZSBkdXBsaWNh dGUgYmxvY2sgd2VyZSB1cGRhdGVkIHdoZW4gdGhleSB3ZXJlCi0JICAgICBy ZWRpcmVjdGVkIGR1cmluZyBzc2FfZml4X2R1cGxpY2F0ZV9ibG9ja19lZGdl cy4gICovCi0JICBpZiAoKCpwYXRoKVsxXS0+dHlwZSAhPSBFREdFX0NPUFlf U1JDX0pPSU5FUl9CTE9DSykKLQkgICAgRURHRV9TVUNDIChyZC0+ZHVwX2Js b2Nrc1swXSwgMCktPmNvdW50ICs9IGUtPmNvdW50OwotCiAJICAvKiBJZiB3 ZSByZWRpcmVjdCBhIGxvb3AgbGF0Y2ggZWRnZSBjYW5jZWwgaXRzIGxvb3Au ICAqLwogCSAgaWYgKGUtPnNyYyA9PSBlLT5zcmMtPmxvb3BfZmF0aGVyLT5s YXRjaCkKIAkgICAgbWFya19sb29wX2Zvcl9yZW1vdmFsIChlLT5zcmMtPmxv b3BfZmF0aGVyKTsKQEAgLTg0OSw2ICsxNDA4LDggQEAgdGhyZWFkX2Jsb2Nr XzEgKGJhc2ljX2Jsb2NrIGJiLCBib29sIG5vbG9vcF9vbmx5LAogICBlZGdl X2l0ZXJhdG9yIGVpOwogICBzc2FfbG9jYWxfaW5mb190IGxvY2FsX2luZm87 CiAKKyAgbG9jYWxfaW5mby5kdXBsaWNhdGVfYmxvY2tzID0gQklUTUFQX0FM TE9DIChOVUxMKTsKKwogICAvKiBUbyBhdm9pZCBzY2FubmluZyBhIGxpbmVh ciBhcnJheSBmb3IgdGhlIGVsZW1lbnQgd2UgbmVlZCB3ZSBpbnN0ZWFkCiAg ICAgIHVzZSBhIGhhc2ggdGFibGUuICBGb3Igbm9ybWFsIGNvZGUgdGhlcmUg c2hvdWxkIGJlIG5vIG5vdGljZWFibGUKICAgICAgZGlmZmVyZW5jZS4gIEhv d2V2ZXIsIGlmIHdlIGhhdmUgYSBibG9jayB3aXRoIGEgbGFyZ2UgbnVtYmVy IG9mCkBAIC05MDgsMTAgKzE0NjksNiBAQCB0aHJlYWRfYmxvY2tfMSAoYmFz aWNfYmxvY2sgYmIsIGJvb2wgbm9sb29wX29ubHksCiAJICAgIGNvbnRpbnVl OwogCX0KIAotICAgICAgaWYgKGUtPmRlc3QgPT0gZTItPnNyYykKLQl1cGRh dGVfYmJfcHJvZmlsZV9mb3JfdGhyZWFkaW5nIChlLT5kZXN0LCBFREdFX0ZS RVFVRU5DWSAoZSksCi0JCQkJCSBlLT5jb3VudCwgKCpUSFJFQURfUEFUSCAo ZSkpWzFdLT5lKTsKLQogICAgICAgLyogSW5zZXJ0IHRoZSBvdXRnb2luZyBl ZGdlIGludG8gdGhlIGhhc2ggdGFibGUgaWYgaXQgaXMgbm90CiAJIGFscmVh ZHkgaW4gdGhlIGhhc2ggdGFibGUuICAqLwogICAgICAgbG9va3VwX3JlZGly ZWN0aW9uX2RhdGEgKGUsIElOU0VSVCk7CkBAIC05NjUsNiArMTUyMiw5IEBA IHRocmVhZF9ibG9ja18xIChiYXNpY19ibG9jayBiYiwgYm9vbCBub2xvb3Bf b25seSwKICAgICAgICYmIGJiID09IGJiLT5sb29wX2ZhdGhlci0+aGVhZGVy KQogICAgIHNldF9sb29wX2NvcHkgKGJiLT5sb29wX2ZhdGhlciwgTlVMTCk7 CiAKKyAgQklUTUFQX0ZSRUUgKGxvY2FsX2luZm8uZHVwbGljYXRlX2Jsb2Nr cyk7CisgIGxvY2FsX2luZm8uZHVwbGljYXRlX2Jsb2NrcyA9IE5VTEw7CisK ICAgLyogSW5kaWNhdGUgdG8gb3VyIGNhbGxlciB3aGV0aGVyIG9yIG5vdCBh bnkganVtcHMgd2VyZSB0aHJlYWRlZC4gICovCiAgIHJldHVybiBsb2NhbF9p bmZvLmp1bXBzX3RocmVhZGVkOwogfQpAQCAtMTAzMSw3ICsxNTkxLDcgQEAg dGhyZWFkX3NpbmdsZV9lZGdlIChlZGdlIGUpCiAgIG5wYXRoLT5zYWZlX3B1 c2ggKHgpOwogICByZC5wYXRoID0gbnBhdGg7CiAKLSAgY3JlYXRlX2Jsb2Nr X2Zvcl90aHJlYWRpbmcgKGJiLCAmcmQsIDApOworICBjcmVhdGVfYmxvY2tf Zm9yX3RocmVhZGluZyAoYmIsICZyZCwgMCwgTlVMTCk7CiAgIHJlbW92ZV9j dHJsX3N0bXRfYW5kX3VzZWxlc3NfZWRnZXMgKHJkLmR1cF9ibG9ja3NbMF0s IE5VTEwpOwogICBjcmVhdGVfZWRnZV9hbmRfdXBkYXRlX2Rlc3RpbmF0aW9u X3BoaXMgKCZyZCwgcmQuZHVwX2Jsb2Nrc1swXSwgMCk7CiAKSW5kZXg6IHRl c3RzdWl0ZS9nY2MuZGcvdHJlZS1wcm9mLzIwMDUwODI2LTIuYwo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSB0ZXN0c3VpdGUvZ2NjLmRnL3RyZWUtcHJv Zi8yMDA1MDgyNi0yLmMJKHJldmlzaW9uIDApCisrKyB0ZXN0c3VpdGUvZ2Nj LmRnL3RyZWUtcHJvZi8yMDA1MDgyNi0yLmMJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsNzUgQEAKKy8qIFRlc3RjYXNlIGRlcml2ZWQgZnJvbSBnY2MuYy10 b3J0dXJlL2V4ZWN1dGUgMjAwNTA4MjYtMi5jCisgICB3aGljaCBzaG93ZWQg anVtcCB0aHJlYWRpbmcgcHJvZmlsZSBpbnNhbml0aWVzLiAgKi8KKy8qIHsg ZGctb3B0aW9ucyAiLU9mYXN0IC1mZHVtcC10cmVlLWRvbTEtYWxsIiB9ICov CisKK3N0cnVjdCBydGF0dHIKK3sKKyAgdW5zaWduZWQgc2hvcnQgcnRhX2xl bjsKKyAgdW5zaWduZWQgc2hvcnQgcnRhX3R5cGU7Cit9OworCitfX2F0dHJp YnV0ZV9fICgobm9pbmxpbmUpKQoraW50IGluZXRfY2hlY2tfYXR0ciAodm9p ZCAqciwgc3RydWN0IHJ0YXR0ciAqKnJ0YSkKK3sKKyAgaW50IGk7CisKKyAg Zm9yIChpID0gMTsgaSA8PSAxNDsgaSsrKQorICAgIHsKKyAgICAgIHN0cnVj dCBydGF0dHIgKmF0dHIgPSBydGFbaSAtIDFdOworICAgICAgaWYgKGF0dHIp CisJeworCSAgaWYgKGF0dHItPnJ0YV9sZW4gLSBzaXplb2YgKHN0cnVjdCBy dGF0dHIpIDwgNCkKKwkgICAgcmV0dXJuIC0yMjsKKwkgIGlmIChpICE9IDkg JiYgaSAhPSA4KQorCSAgICBydGFbaSAtIDFdID0gYXR0ciArIDE7CisJfQor ICAgIH0KKyAgcmV0dXJuIDA7Cit9CisKK2V4dGVybiB2b2lkIGFib3J0ICh2 b2lkKTsKKworaW50Cit0ZXN0ICh2b2lkKQoreworICBzdHJ1Y3QgcnRhdHRy IHJ0WzJdOworICBzdHJ1Y3QgcnRhdHRyICpydGFbMTRdOworICBpbnQgaTsK KworICBydFswXS5ydGFfbGVuID0gc2l6ZW9mIChzdHJ1Y3QgcnRhdHRyKSAr IDg7CisgIHJ0WzBdLnJ0YV90eXBlID0gMDsKKyAgcnRbMV0gPSBydFswXTsK KyAgZm9yIChpID0gMDsgaSA8IDE0OyBpKyspCisgICAgcnRhW2ldID0gJnJ0 WzBdOworICBpZiAoaW5ldF9jaGVja19hdHRyICgwLCBydGEpICE9IDApCisg ICAgYWJvcnQgKCk7CisgIGZvciAoaSA9IDA7IGkgPCAxNDsgaSsrKQorICAg IGlmIChydGFbaV0gIT0gJnJ0W2kgIT0gNyAmJiBpICE9IDhdKQorICAgICAg YWJvcnQgKCk7CisgIGZvciAoaSA9IDA7IGkgPCAxNDsgaSsrKQorICAgIHJ0 YVtpXSA9ICZydFswXTsKKyAgcnRhWzFdID0gMDsKKyAgcnRbMV0ucnRhX2xl biAtPSA4OworICBydGFbNV0gPSAmcnRbMV07CisgIGlmIChpbmV0X2NoZWNr X2F0dHIgKDAsIHJ0YSkgIT0gLTIyKQorICAgIGFib3J0ICgpOworICBmb3Ig KGkgPSAwOyBpIDwgMTQ7IGkrKykKKyAgICBpZiAoaSA9PSAxICYmIHJ0YVtp XSAhPSAwKQorICAgICAgYWJvcnQgKCk7CisgICAgZWxzZSBpZiAoaSAhPSAx ICYmIGkgPD0gNSAmJiBydGFbaV0gIT0gJnJ0WzFdKQorICAgICAgYWJvcnQg KCk7CisgICAgZWxzZSBpZiAoaSA+IDUgJiYgcnRhW2ldICE9ICZydFswXSkK KyAgICAgIGFib3J0ICgpOworICByZXR1cm4gMDsKK30KKworaW50CittYWlu ICh2b2lkKQoreworICBpbnQgaTsKKyAgZm9yIChpPTA7IGk8MTAwOyBpKysp CisgICAgdGVzdCAoKTsKKyAgcmV0dXJuIDA7Cit9CisKKy8qIHsgZGctZmlu YWwtdXNlIHsgc2Nhbi10cmVlLWR1bXAtbm90ICJJbnZhbGlkIHN1bSIgImRv bTEifSB9ICovCkluZGV4OiB0ZXN0c3VpdGUvZ2NjLmRnL3RyZWUtcHJvZi9j bXBzZi0xLmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gdGVzdHN1aXRl L2djYy5kZy90cmVlLXByb2YvY21wc2YtMS5jCShyZXZpc2lvbiAwKQorKysg dGVzdHN1aXRlL2djYy5kZy90cmVlLXByb2YvY21wc2YtMS5jCShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDE3OCBAQAorLyogVGVzdGNhc2UgZGVyaXZlZCBm cm9tIGdjYy5jLXRvcnR1cmUvZXhlY3V0ZSBjbXBzZi0xLmMKKyAgIHdoaWNo IHNob3dlZCBqdW1wIHRocmVhZGluZyBwcm9maWxlIGluc2FuaXRpZXMuICAq LworLyogeyBkZy1vcHRpb25zICItT2Zhc3QgLWZkdW1wLXRyZWUtZG9tMS1h bGwiIH0gKi8KKworI2luY2x1ZGUgPGxpbWl0cy5oPgorCit2b2lkIGFib3J0 KCk7CitleHRlcm4gdm9pZCBleGl0IChpbnQpOworCisjZGVmaW5lIEYgMTQw CisjZGVmaW5lIFQgMTMKKworZmVxIChmbG9hdCB4LCBmbG9hdCB5KQorewor ICBpZiAoeCA9PSB5KQorICAgIHJldHVybiBUOworICBlbHNlCisgICAgcmV0 dXJuIEY7Cit9CisKK2ZuZSAoZmxvYXQgeCwgZmxvYXQgeSkKK3sKKyAgaWYg KHggIT0geSkKKyAgICByZXR1cm4gVDsKKyAgZWxzZQorICAgIHJldHVybiBG OworfQorCitmbHQgKGZsb2F0IHgsIGZsb2F0IHkpCit7CisgIGlmICh4IDwg eSkKKyAgICByZXR1cm4gVDsKKyAgZWxzZQorICAgIHJldHVybiBGOworfQor CitmZ2UgKGZsb2F0IHgsIGZsb2F0IHkpCit7CisgIGlmICh4ID49IHkpCisg ICAgcmV0dXJuIFQ7CisgIGVsc2UKKyAgICByZXR1cm4gRjsKK30KKworZmd0 IChmbG9hdCB4LCBmbG9hdCB5KQoreworICBpZiAoeCA+IHkpCisgICAgcmV0 dXJuIFQ7CisgIGVsc2UKKyAgICByZXR1cm4gRjsKK30KKworZmxlIChmbG9h dCB4LCBmbG9hdCB5KQoreworICBpZiAoeCA8PSB5KQorICAgIHJldHVybiBU OworICBlbHNlCisgICAgcmV0dXJuIEY7Cit9CisKK2Zsb2F0IGFyZ3NbXSA9 Cit7CisgIDAuMEYsCisgIDEuMEYsCisgIC0xLjBGLCAKKyAgX19GTFRfTUFY X18sCisgIF9fRkxUX01JTl9fLAorICAwLjAwMDAwMDAwMDAwMDFGLAorICAx MjM0NTY3ODkuMEYsCisgIC05ODc2NTQzMjEuMEYKK307CisKK2ludCBjb3Jy ZWN0X3Jlc3VsdHNbXSA9Cit7CisgVCwgRiwgRiwgVCwgRiwgVCwgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyBGLCBU LCBULCBGLCBGLCBULCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIAorIEYsIFQsIEYsIFQsIFQsIEYsICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgRiwgVCwgVCwg RiwgRiwgVCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAKKyBGLCBULCBULCBGLCBGLCBULCAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorIEYsIFQsIFQsIEYsIEYs IFQsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgCisgRiwgVCwgVCwgRiwgRiwgVCwgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAKKyBGLCBULCBGLCBULCBULCBGLCAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAor IEYsIFQsIEYsIFQsIFQsIEYsICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgCisgVCwgRiwgRiwgVCwgRiwgVCwgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyBGLCBU LCBGLCBULCBULCBGLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIAorIEYsIFQsIFQsIEYsIEYsIFQsICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgRiwgVCwgRiwg VCwgVCwgRiwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAKKyBGLCBULCBGLCBULCBULCBGLCAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorIEYsIFQsIFQsIEYsIEYs IFQsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgCisgRiwgVCwgRiwgVCwgVCwgRiwgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAKKyBGLCBULCBULCBGLCBGLCBULCAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAor IEYsIFQsIFQsIEYsIEYsIFQsICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgCisgVCwgRiwgRiwgVCwgRiwgVCwgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKKyBGLCBU LCBULCBGLCBGLCBULCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIAorIEYsIFQsIFQsIEYsIEYsIFQsICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCisgRiwgVCwgVCwg RiwgRiwgVCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAKKyBGLCBULCBULCBGLCBGLCBULCAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIAorIEYsIFQsIEYsIFQsIFQs IEYsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgCisgRiwgVCwgRiwgVCwgVCwgRiwgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAKKyBGLCBULCBGLCBULCBULCBGLAor IEYsIFQsIEYsIFQsIFQsIEYsCisgVCwgRiwgRiwgVCwgRiwgVCwKKyBGLCBU LCBGLCBULCBULCBGLAorIEYsIFQsIEYsIFQsIFQsIEYsCisgRiwgVCwgRiwg VCwgVCwgRiwKKyBGLCBULCBGLCBULCBULCBGLAorIEYsIFQsIEYsIFQsIFQs IEYsCisgRiwgVCwgVCwgRiwgRiwgVCwKKyBGLCBULCBGLCBULCBULCBGLAor IEYsIFQsIFQsIEYsIEYsIFQsCisgVCwgRiwgRiwgVCwgRiwgVCwKKyBGLCBU LCBULCBGLCBGLCBULAorIEYsIFQsIFQsIEYsIEYsIFQsCisgRiwgVCwgRiwg VCwgVCwgRiwKKyBGLCBULCBGLCBULCBULCBGLAorIEYsIFQsIFQsIEYsIEYs IFQsCisgRiwgVCwgRiwgVCwgVCwgRiwKKyBGLCBULCBULCBGLCBGLCBULAor IEYsIFQsIEYsIFQsIFQsIEYsCisgVCwgRiwgRiwgVCwgRiwgVCwKKyBGLCBU LCBULCBGLCBGLCBULAorIEYsIFQsIEYsIFQsIFQsIEYsCisgRiwgVCwgRiwg VCwgVCwgRiwKKyBGLCBULCBGLCBULCBULCBGLAorIEYsIFQsIEYsIFQsIFQs IEYsCisgRiwgVCwgVCwgRiwgRiwgVCwKKyBGLCBULCBGLCBULCBULCBGLAor IEYsIFQsIEYsIFQsIFQsIEYsCisgVCwgRiwgRiwgVCwgRiwgVCwKKyBGLCBU LCBGLCBULCBULCBGLAorIEYsIFQsIFQsIEYsIEYsIFQsCisgRiwgVCwgVCwg RiwgRiwgVCwKKyBGLCBULCBULCBGLCBGLCBULAorIEYsIFQsIFQsIEYsIEYs IFQsCisgRiwgVCwgVCwgRiwgRiwgVCwKKyBGLCBULCBULCBGLCBGLCBULAor IEYsIFQsIFQsIEYsIEYsIFQsCisgVCwgRiwgRiwgVCwgRiwgVCwKK307CisK K3ZvaWQKK3Rlc3QgKHZvaWQpCit7CisgIGludCBpLCBqLCAqcmVzID0gY29y cmVjdF9yZXN1bHRzOworCisgIGZvciAoaSA9IDA7IGkgPCA4OyBpKyspCisg ICAgeworICAgICAgZmxvYXQgYXJnMCA9IGFyZ3NbaV07CisgICAgICBmb3Ig KGogPSAwOyBqIDwgODsgaisrKQorCXsKKwkgIGZsb2F0IGFyZzEgPSBhcmdz W2pdOworCisJICBpZiAoZmVxIChhcmcwLCBhcmcxKSAhPSAqcmVzKyspCisJ ICAgIGFib3J0ICgpOworCSAgaWYgKGZuZSAoYXJnMCwgYXJnMSkgIT0gKnJl cysrKQorCSAgICBhYm9ydCAoKTsKKwkgIGlmIChmbHQgKGFyZzAsIGFyZzEp ICE9ICpyZXMrKykKKwkgICAgYWJvcnQgKCk7CisJICBpZiAoZmdlIChhcmcw LCBhcmcxKSAhPSAqcmVzKyspCisJICAgIGFib3J0ICgpOworCSAgaWYgKGZn dCAoYXJnMCwgYXJnMSkgIT0gKnJlcysrKQorCSAgICBhYm9ydCAoKTsKKwkg IGlmIChmbGUgKGFyZzAsIGFyZzEpICE9ICpyZXMrKykKKwkgICAgYWJvcnQg KCk7CisJfQorICAgIH0KK30KKworaW50CittYWluICh2b2lkKQoreworICBp bnQgaTsKKyAgZm9yIChpPTA7IGk8MTAwOyBpKyspCisgICAgdGVzdCAoKTsK KyAgZXhpdCAoMCk7Cit9CisKKy8qIHsgZGctZmluYWwtdXNlIHsgc2Nhbi10 cmVlLWR1bXAtbm90ICJJbnZhbGlkIHN1bSIgImRvbTEifSB9ICovCg== --001a1132e2b607a7a8050434f62e--