From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id EB1A1C77B6C for ; Tue, 4 Apr 2023 17:14:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235800AbjDDROj (ORCPT ); Tue, 4 Apr 2023 13:14:39 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37370 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235724AbjDDROg (ORCPT ); Tue, 4 Apr 2023 13:14:36 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 617941736; Tue, 4 Apr 2023 10:14:29 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id A97456378C; Tue, 4 Apr 2023 17:14:28 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id C11B1C433D2; Tue, 4 Apr 2023 17:14:21 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1680628468; bh=RDhAalIr7SbY9i/gonqpJqUhnY/gKX0tENUa/Gexl1c=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=hnz2sUUlVV0mBAJ7nZemrq3FX/QaQ9bz/plf8FINrTpgLYRyHbQcZZljDYYW68wZW tvMZ65XN1EjpTtuRMFaR6bB3XYR41nS9KJdbIEIz8D2fmBleQ++C6Yf1k26cLxpxuF +wWl0MTv/scHDZex8leGJwfxwIZFuPiU0q7htmH+8JAWLEaKaZtc+L8sM3Rzf/Q202 mJtkpUwWT0eKImgFrCFamFa2lOwPSXJJQj/7kcNNi7HPYMzEpuICmsCcbhfH0VyGoo 5qNTsbV2JsPEtwVFxxuY30g4a2tXMgc9Z9Z7NRW9i4XCfeRkRhJn3oqem+z957Dwi+ bps75EJMcjreQ== From: Zorro Lang To: fstests@vger.kernel.org Cc: linux-btrfs@vger.kernel.org, ceph-devel@vger.kernel.org, linux-cifs@vger.kernel.org, linux-ext4@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net, linux-fsdevel@vger.kernel.org, linux-nfs@vger.kernel.org, ocfs2-devel@oss.oracle.com, linux-unionfs@vger.kernel.org, jack@suse.com, linux-xfs@vger.kernel.org, fdmanana@suse.com, ebiggers@google.com, brauner@kernel.org, amir73il@gmail.com, djwong@kernel.org, anand.jain@oracle.com Subject: [PATCH 1/5] fstests: add MAINTAINERS and get_maintainer.pl files Date: Wed, 5 Apr 2023 01:14:07 +0800 Message-Id: <20230404171411.699655-2-zlang@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230404171411.699655-1-zlang@kernel.org> References: <20230404171411.699655-1-zlang@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: ceph-devel@vger.kernel.org As fstests covers more and more fs testing, so we always get help from fs specific mailing list, due to they learn about their features and bugs more. Besides that, some folks help to review patches (relevant with them) more often. So I'd like to bring in the similar way of linux/MAINTAINERS, records fs relevant mailing lists, reviewers or co-maintainers. To recognize the contribution from them, and help more users to know who or what mailing list can be added in CC list of a patch. The MAINTAINERS and get_maintainer.pl are copied from linux project, then made some changes for fstests specially. Signed-off-by: Zorro Lang --- MAINTAINERS | 116 ++ tools/get_maintainer.pl | 2616 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 2732 insertions(+) create mode 100644 MAINTAINERS create mode 100755 tools/get_maintainer.pl diff --git a/MAINTAINERS b/MAINTAINERS new file mode 100644 index 00000000..09b1a5a3 --- /dev/null +++ b/MAINTAINERS @@ -0,0 +1,116 @@ +List of reviewers, co-maintainers and how to submit fstests changes +==================================================== + +Please try to follow the guidelines below. This will make things +easier on the maintainers. Not all of these guidelines matter for every +trivial patch so apply some common sense. + +Tips for patch submitters +------------------------- + +1. Always *test* your changes, however small, on at least 4 or + 5 people, preferably many more. + +2. Make sure your changes compile correctly in multiple + configurations. In particular check that changes work both as a + module and built into the kernel. + +3. When you are happy with a change make it generally available for + testing and await feedback. + +4. Make a patch available to fstests@ list directly, that's the only + one mailing list which maintain the whole fstests project. + + PLEASE CC: the relevant reviewers, co-maintainers and mailing lists + that are generated by ``tools/get_maintainer.pl.`` + + PLEASE try to include any credit lines you want added with the + patch. It avoids people being missed off by mistake and makes + it easier to know who wants adding and who doesn't. + + PLEASE document known bugs. If it doesn't work for everything + or does something very odd once a month document it. + +5. Make sure you have the right to send any changes you make. If you + do changes at work you may find your employer owns the patch + not you. + +6. Happy hacking. + +Descriptions of section entries and preferred order +--------------------------------------------------- + + M: *Mail* patches to: FullName + These people might be a co-maintainer (with Supported status) or + maintainer (with Maintained status). + R: Designated *Reviewer*: FullName + These reviewers should be CCed on patches. + L: Besides fstests@ list itself, this *Mailing list* is relevant to + this area, should be CCed. + S: *Status*, one of the following (note: all things are maintained by + fstests@vger.kernel.org): + Supported: Someone is actually paid to look after this. + Maintained: Someone actually looks after it, has the privilege to + merge & push. + Odd Fixes: It has a maintainer but they don't have time to do + much other than throw the odd patch in. See below.. + Orphan: No current maintainer [but maybe you could take the + role as you write your new code]. + Obsolete: Old code. Something tagged obsolete generally means + it has been replaced by a better system and you + should be using that. + W: *Web-page* with status/info + Q: *Patchwork* web based patch tracking system site + B: URI for where to file *bugs*. A web-page with detailed bug + filing info, a direct bug tracker link, or a mailto: URI. + C: URI for *chat* protocol, server and channel where developers + usually hang out, for example irc://server/channel. + P: Subsystem Profile document for more details submitting + patches to the given subsystem. This is either an in-tree file, + or a URI. + T: *SCM* tree type and location. + Type is one of: git, hg, quilt, stgit, topgit + F: *Files* and directories wildcard patterns. + A trailing slash includes all files and subdirectory files. + F: tests/xfs/ all files in and below tests/xfs + F: tests/generic/* all files in tests/generic, but not below + F: */ext4/* all files in "any top level directory"/ext4 + One pattern per line. Multiple F: lines acceptable. + X: *Excluded* files and directories that are NOT maintained, same + rules as F:. Files exclusions are tested before file matches. + Can be useful for excluding a specific subdirectory, for instance: + F: src/ + X: src/vfs + matches all files in and below net excluding net/ipv6/ + N: Files and directories *Regex* patterns. + N: [^a-z]tegra all files whose path contains tegra + (not including files like integrator) + One pattern per line. Multiple N: lines acceptable. + tools/get_maintainer.pl has different behavior for files that + match F: pattern and matches of N: patterns. By default, + get_maintainer will not look at git log history when an F: pattern + match occurs. When an N: match occurs, git log history is used + to also notify the people that have git commit signatures. + K: *Content regex* (perl extended) pattern match in a patch or file. + For instance: + K: of_get_profile + matches patches or files that contain "of_get_profile" + K: \b(printk|pr_(info|err))\b + matches patches or files that contain one or more of the words + printk, pr_info or pr_err + One regex pattern per line. Multiple K: lines acceptable. + +Maintainers List +---------------- + +.. note:: The whole fstests are maintained by fstests@vger.kernel.org, so you + should send patch to fstests@ at least. Other relevant mailing list + or reviewer or co-maintainer can be in cc list. + +ALL +M: Zorro Lang +L: fstests@vger.kernel.org +S: Maintained +T: git git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git +F: * +F: */ diff --git a/tools/get_maintainer.pl b/tools/get_maintainer.pl new file mode 100755 index 00000000..376c7c02 --- /dev/null +++ b/tools/get_maintainer.pl @@ -0,0 +1,2616 @@ +#!/usr/bin/env perl +# SPDX-License-Identifier: GPL-2.0 +# +# This script is copied from linux/scripts/get_maintainer.pl, then +# changes for fstests specifically. +# +# Print selected MAINTAINERS information for +# the files modified in a patch or for a file +# +# usage: perl tools/get_maintainer.pl [OPTIONS] +# perl tools/get_maintainer.pl [OPTIONS] -f + +use warnings; +use strict; + +my $P = $0; +my $V = '0.26'; + +use Getopt::Long qw(:config no_auto_abbrev); +use Cwd; +use File::Find; +use File::Spec::Functions; + +my $cur_path = fastgetcwd() . '/'; +my $lk_path = "./"; +my $email = 1; +my $email_usename = 1; +my $email_maintainer = 1; +my $email_reviewer = 1; +my $email_fixes = 1; +my $email_list = 1; +my $email_moderated_list = 1; +my $email_subscriber_list = 0; +my $email_git_penguin_chiefs = 0; +my $email_git = 0; +my $email_git_all_signature_types = 0; +my $email_git_blame = 0; +my $email_git_blame_signatures = 1; +my $email_git_fallback = 1; +my $email_git_min_signatures = 1; +my $email_git_max_maintainers = 5; +my $email_git_min_percent = 5; +my $email_git_since = "1-year-ago"; +my $email_hg_since = "-365"; +my $interactive = 0; +my $email_remove_duplicates = 1; +my $email_use_mailmap = 1; +my $output_multiline = 1; +my $output_separator = ", "; +my $output_roles = 0; +my $output_rolestats = 1; +my $output_section_maxlen = 50; +my $scm = 0; +my $tree = 1; +my $web = 0; +my $subsystem = 0; +my $status = 0; +my $letters = ""; +my $keywords = 1; +my $sections = 0; +my $email_file_emails = 0; +my $from_filename = 0; +my $pattern_depth = 0; +my $self_test = undef; +my $version = 0; +my $help = 0; +my $find_maintainer_files = 0; +my $maintainer_path; +my $vcs_used = 0; + +my $exit = 0; + +my @files = (); +my @fixes = (); # If a patch description includes Fixes: lines +my @range = (); +my @keyword_tvi = (); +my @file_emails = (); + +my %commit_author_hash; +my %commit_signer_hash; + +my @penguin_chief = (); +push(@penguin_chief, "Zorro Lang:zlang\@kernel.org"); + +my @penguin_chief_names = (); +foreach my $chief (@penguin_chief) { + if ($chief =~ m/^(.*):(.*)/) { + my $chief_name = $1; + my $chief_addr = $2; + push(@penguin_chief_names, $chief_name); + } +} +my $penguin_chiefs = "\(" . join("|", @penguin_chief_names) . "\)"; + +# Signature types of people who are either +# a) responsible for the code in question, or +# b) familiar enough with it to give relevant feedback +my @signature_tags = (); +push(@signature_tags, "Signed-off-by:"); +push(@signature_tags, "Reviewed-by:"); +push(@signature_tags, "Acked-by:"); + +my $signature_pattern = "\(" . join("|", @signature_tags) . "\)"; + +# rfc822 email address - preloaded methods go here. +my $rfc822_lwsp = "(?:(?:\\r\\n)?[ \\t])"; +my $rfc822_char = '[\\000-\\377]'; + +# VCS command support: class-like functions and strings + +my %VCS_cmds; + +my %VCS_cmds_git = ( + "execute_cmd" => \&git_execute_cmd, + "available" => '(which("git") ne "") && (-e ".git")', + "find_signers_cmd" => + "git log --no-color --follow --since=\$email_git_since " . + '--numstat --no-merges ' . + '--format="GitCommit: %H%n' . + 'GitAuthor: %an <%ae>%n' . + 'GitDate: %aD%n' . + 'GitSubject: %s%n' . + '%b%n"' . + " -- \$file", + "find_commit_signers_cmd" => + "git log --no-color " . + '--numstat ' . + '--format="GitCommit: %H%n' . + 'GitAuthor: %an <%ae>%n' . + 'GitDate: %aD%n' . + 'GitSubject: %s%n' . + '%b%n"' . + " -1 \$commit", + "find_commit_author_cmd" => + "git log --no-color " . + '--numstat ' . + '--format="GitCommit: %H%n' . + 'GitAuthor: %an <%ae>%n' . + 'GitDate: %aD%n' . + 'GitSubject: %s%n"' . + " -1 \$commit", + "blame_range_cmd" => "git blame -l -L \$diff_start,+\$diff_length \$file", + "blame_file_cmd" => "git blame -l \$file", + "commit_pattern" => "^GitCommit: ([0-9a-f]{40,40})", + "blame_commit_pattern" => "^([0-9a-f]+) ", + "author_pattern" => "^GitAuthor: (.*)", + "subject_pattern" => "^GitSubject: (.*)", + "stat_pattern" => "^(\\d+)\\t(\\d+)\\t\$file\$", + "file_exists_cmd" => "git ls-files \$file", + "list_files_cmd" => "git ls-files \$file", +); + +my %VCS_cmds_hg = ( + "execute_cmd" => \&hg_execute_cmd, + "available" => '(which("hg") ne "") && (-d ".hg")', + "find_signers_cmd" => + "hg log --date=\$email_hg_since " . + "--template='HgCommit: {node}\\n" . + "HgAuthor: {author}\\n" . + "HgSubject: {desc}\\n'" . + " -- \$file", + "find_commit_signers_cmd" => + "hg log " . + "--template='HgSubject: {desc}\\n'" . + " -r \$commit", + "find_commit_author_cmd" => + "hg log " . + "--template='HgCommit: {node}\\n" . + "HgAuthor: {author}\\n" . + "HgSubject: {desc|firstline}\\n'" . + " -r \$commit", + "blame_range_cmd" => "", # not supported + "blame_file_cmd" => "hg blame -n \$file", + "commit_pattern" => "^HgCommit: ([0-9a-f]{40,40})", + "blame_commit_pattern" => "^([ 0-9a-f]+):", + "author_pattern" => "^HgAuthor: (.*)", + "subject_pattern" => "^HgSubject: (.*)", + "stat_pattern" => "^(\\d+)\t(\\d+)\t\$file\$", + "file_exists_cmd" => "hg files \$file", + "list_files_cmd" => "hg manifest -R \$file", +); + +my $conf = which_conf(".get_maintainer.conf"); +if (-f $conf) { + my @conf_args; + open(my $conffile, '<', "$conf") + or warn "$P: Can't find a readable .get_maintainer.conf file $!\n"; + + while (<$conffile>) { + my $line = $_; + + $line =~ s/\s*\n?$//g; + $line =~ s/^\s*//g; + $line =~ s/\s+/ /g; + + next if ($line =~ m/^\s*#/); + next if ($line =~ m/^\s*$/); + + my @words = split(" ", $line); + foreach my $word (@words) { + last if ($word =~ m/^#/); + push (@conf_args, $word); + } + } + close($conffile); + unshift(@ARGV, @conf_args) if @conf_args; +} + +my @ignore_emails = (); +my $ignore_file = which_conf(".get_maintainer.ignore"); +if (-f $ignore_file) { + open(my $ignore, '<', "$ignore_file") + or warn "$P: Can't find a readable .get_maintainer.ignore file $!\n"; + while (<$ignore>) { + my $line = $_; + + $line =~ s/\s*\n?$//; + $line =~ s/^\s*//; + $line =~ s/\s+$//; + $line =~ s/#.*$//; + + next if ($line =~ m/^\s*$/); + if (rfc822_valid($line)) { + push(@ignore_emails, $line); + } + } + close($ignore); +} + +if ($#ARGV > 0) { + foreach (@ARGV) { + if ($_ =~ /^-{1,2}self-test(?:=|$)/) { + die "$P: using --self-test does not allow any other option or argument\n"; + } + } +} + +if (!GetOptions( + 'email!' => \$email, + 'git!' => \$email_git, + 'git-all-signature-types!' => \$email_git_all_signature_types, + 'git-blame!' => \$email_git_blame, + 'git-blame-signatures!' => \$email_git_blame_signatures, + 'git-fallback!' => \$email_git_fallback, + 'git-chief-penguins!' => \$email_git_penguin_chiefs, + 'git-min-signatures=i' => \$email_git_min_signatures, + 'git-max-maintainers=i' => \$email_git_max_maintainers, + 'git-min-percent=i' => \$email_git_min_percent, + 'git-since=s' => \$email_git_since, + 'hg-since=s' => \$email_hg_since, + 'i|interactive!' => \$interactive, + 'remove-duplicates!' => \$email_remove_duplicates, + 'mailmap!' => \$email_use_mailmap, + 'm!' => \$email_maintainer, + 'r!' => \$email_reviewer, + 'n!' => \$email_usename, + 'l!' => \$email_list, + 'fixes!' => \$email_fixes, + 'moderated!' => \$email_moderated_list, + 's!' => \$email_subscriber_list, + 'multiline!' => \$output_multiline, + 'roles!' => \$output_roles, + 'rolestats!' => \$output_rolestats, + 'separator=s' => \$output_separator, + 'subsystem!' => \$subsystem, + 'status!' => \$status, + 'scm!' => \$scm, + 'tree!' => \$tree, + 'web!' => \$web, + 'letters=s' => \$letters, + 'pattern-depth=i' => \$pattern_depth, + 'k|keywords!' => \$keywords, + 'sections!' => \$sections, + 'fe|file-emails!' => \$email_file_emails, + 'f|file' => \$from_filename, + 'find-maintainer-files' => \$find_maintainer_files, + 'mpath|maintainer-path=s' => \$maintainer_path, + 'self-test:s' => \$self_test, + 'v|version' => \$version, + 'h|help|usage' => \$help, + )) { + die "$P: invalid argument - use --help if necessary\n"; +} + +if ($help != 0) { + usage(); + exit 0; +} + +if ($version != 0) { + print("${P} ${V}\n"); + exit 0; +} + +if (defined $self_test) { + read_all_maintainer_files(); + self_test(); + exit 0; +} + +if (-t STDIN && !@ARGV) { + # We're talking to a terminal, but have no command line arguments. + die "$P: missing patchfile or -f file - use --help if necessary\n"; +} + +$output_multiline = 0 if ($output_separator ne ", "); +$output_rolestats = 1 if ($interactive); +$output_roles = 1 if ($output_rolestats); + +if ($sections || $letters ne "") { + $sections = 1; + $email = 0; + $email_list = 0; + $scm = 0; + $status = 0; + $subsystem = 0; + $web = 0; + $keywords = 0; + $interactive = 0; +} else { + my $selections = $email + $scm + $status + $subsystem + $web; + if ($selections == 0) { + die "$P: Missing required option: email, scm, status, subsystem or web\n"; + } +} + +if ($email && + ($email_maintainer + $email_reviewer + + $email_list + $email_subscriber_list + + $email_git + $email_git_penguin_chiefs + $email_git_blame) == 0) { + die "$P: Please select at least 1 email option\n"; +} + +if ($tree && !top_of_fstests_tree($lk_path)) { + die "$P: The current directory does not appear to be " + . "a fstests source tree.\n"; +} + +## Read MAINTAINERS for type/value pairs + +my @typevalue = (); +my %keyword_hash; +my @mfiles = (); +my @self_test_info = (); + +sub read_maintainer_file { + my ($file) = @_; + + open (my $maint, '<', "$file") + or die "$P: Can't open MAINTAINERS file '$file': $!\n"; + my $i = 1; + while (<$maint>) { + my $line = $_; + chomp $line; + + if ($line =~ m/^([A-Z]):\s*(.*)/) { + my $type = $1; + my $value = $2; + + ##Filename pattern matching + if ($type eq "F" || $type eq "X") { + $value =~ s@\.@\\\.@g; ##Convert . to \. + $value =~ s/\*/\.\*/g; ##Convert * to .* + $value =~ s/\?/\./g; ##Convert ? to . + ##if pattern is a directory and it lacks a trailing slash, add one + if ((-d $value)) { + $value =~ s@([^/])$@$1/@; + } + } elsif ($type eq "K") { + $keyword_hash{@typevalue} = $value; + } + push(@typevalue, "$type:$value"); + } elsif (!(/^\s*$/ || /^\s*\#/)) { + push(@typevalue, $line); + } + if (defined $self_test) { + push(@self_test_info, {file=>$file, linenr=>$i, line=>$line}); + } + $i++; + } + close($maint); +} + +sub find_is_maintainer_file { + my ($file) = $_; + return if ($file !~ m@/MAINTAINERS$@); + $file = $File::Find::name; + return if (! -f $file); + push(@mfiles, $file); +} + +sub find_ignore_git { + return grep { $_ !~ /^\.git$/; } @_; +} + +read_all_maintainer_files(); + +sub read_all_maintainer_files { + my $path = "${lk_path}MAINTAINERS"; + if (defined $maintainer_path) { + $path = $maintainer_path; + # Perl Cookbook tilde expansion if necessary + $path =~ s@^~([^/]*)@ $1 ? (getpwnam($1))[7] : ( $ENV{HOME} || $ENV{LOGDIR} || (getpwuid($<))[7])@ex; + } + + if (-d $path) { + $path .= '/' if ($path !~ m@/$@); + if ($find_maintainer_files) { + find( { wanted => \&find_is_maintainer_file, + preprocess => \&find_ignore_git, + no_chdir => 1, + }, "$path"); + } else { + opendir(DIR, "$path") or die $!; + my @files = readdir(DIR); + closedir(DIR); + foreach my $file (@files) { + push(@mfiles, "$path$file") if ($file !~ /^\./); + } + } + } elsif (-f "$path") { + push(@mfiles, "$path"); + } else { + die "$P: MAINTAINER file not found '$path'\n"; + } + die "$P: No MAINTAINER files found in '$path'\n" if (scalar(@mfiles) == 0); + foreach my $file (@mfiles) { + read_maintainer_file("$file"); + } +} + +sub maintainers_in_file { + my ($file) = @_; + + return if ($file =~ m@\bMAINTAINERS$@); + + if (-f $file && ($email_file_emails || $file =~ /\.yaml$/)) { + open(my $f, '<', $file) + or die "$P: Can't open $file: $!\n"; + my $text = do { local($/) ; <$f> }; + close($f); + + my @poss_addr = $text =~ m$[A-Za-zÀ-ÿ\"\' \,\.\+-]*\s*[\,]*\s*[\(\<\{]{0,1}[A-Za-z0-9_\.\+-]+\@[A-Za-z0-9\.-]+\.[A-Za-z0-9]+[\)\>\}]{0,1}$g; + push(@file_emails, clean_file_emails(@poss_addr)); + } +} + +# +# Read mail address map +# + +my $mailmap; + +read_mailmap(); + +sub read_mailmap { + $mailmap = { + names => {}, + addresses => {} + }; + + return if (!$email_use_mailmap || !(-f "${lk_path}.mailmap")); + + open(my $mailmap_file, '<', "${lk_path}.mailmap") + or warn "$P: Can't open .mailmap: $!\n"; + + while (<$mailmap_file>) { + s/#.*$//; #strip comments + s/^\s+|\s+$//g; #trim + + next if (/^\s*$/); #skip empty lines + #entries have one of the following formats: + # name1 + # + # name1 + # name1 name2 + # (see man git-shortlog) + + if (/^([^<]+)<([^>]+)>$/) { + my $real_name = $1; + my $address = $2; + + $real_name =~ s/\s+$//; + ($real_name, $address) = parse_email("$real_name <$address>"); + $mailmap->{names}->{$address} = $real_name; + + } elsif (/^<([^>]+)>\s*<([^>]+)>$/) { + my $real_address = $1; + my $wrong_address = $2; + + $mailmap->{addresses}->{$wrong_address} = $real_address; + + } elsif (/^(.+)<([^>]+)>\s*<([^>]+)>$/) { + my $real_name = $1; + my $real_address = $2; + my $wrong_address = $3; + + $real_name =~ s/\s+$//; + ($real_name, $real_address) = + parse_email("$real_name <$real_address>"); + $mailmap->{names}->{$wrong_address} = $real_name; + $mailmap->{addresses}->{$wrong_address} = $real_address; + + } elsif (/^(.+)<([^>]+)>\s*(.+)\s*<([^>]+)>$/) { + my $real_name = $1; + my $real_address = $2; + my $wrong_name = $3; + my $wrong_address = $4; + + $real_name =~ s/\s+$//; + ($real_name, $real_address) = + parse_email("$real_name <$real_address>"); + + $wrong_name =~ s/\s+$//; + ($wrong_name, $wrong_address) = + parse_email("$wrong_name <$wrong_address>"); + + my $wrong_email = format_email($wrong_name, $wrong_address, 1); + $mailmap->{names}->{$wrong_email} = $real_name; + $mailmap->{addresses}->{$wrong_email} = $real_address; + } + } + close($mailmap_file); +} + +## use the filenames on the command line or find the filenames in the patchfiles + +if (!@ARGV) { + push(@ARGV, "&STDIN"); +} + +foreach my $file (@ARGV) { + if ($file ne "&STDIN") { + $file = canonpath($file); + ##if $file is a directory and it lacks a trailing slash, add one + if ((-d $file)) { + $file =~ s@([^/])$@$1/@; + } elsif (!(-f $file)) { + die "$P: file '${file}' not found\n"; + } + } + if ($from_filename && (vcs_exists() && !vcs_file_exists($file))) { + warn "$P: file '$file' not found in version control $!\n"; + } + if ($from_filename || ($file ne "&STDIN" && vcs_file_exists($file))) { + $file =~ s/^\Q${cur_path}\E//; #strip any absolute path + $file =~ s/^\Q${lk_path}\E//; #or the path to the lk tree + push(@files, $file); + if ($file ne "MAINTAINERS" && -f $file && $keywords) { + open(my $f, '<', $file) + or die "$P: Can't open $file: $!\n"; + my $text = do { local($/) ; <$f> }; + close($f); + if ($keywords) { + foreach my $line (keys %keyword_hash) { + if ($text =~ m/$keyword_hash{$line}/x) { + push(@keyword_tvi, $line); + } + } + } + } + } else { + my $file_cnt = @files; + my $lastfile; + + open(my $patch, "< $file") + or die "$P: Can't open $file: $!\n"; + + # We can check arbitrary information before the patch + # like the commit message, mail headers, etc... + # This allows us to match arbitrary keywords against any part + # of a git format-patch generated file (subject tags, etc...) + + my $patch_prefix = ""; #Parsing the intro + + while (<$patch>) { + my $patch_line = $_; + if (m/^ mode change [0-7]+ => [0-7]+ (\S+)\s*$/) { + my $filename = $1; + push(@files, $filename); + } elsif (m/^rename (?:from|to) (\S+)\s*$/) { + my $filename = $1; + push(@files, $filename); + } elsif (m/^diff --git a\/(\S+) b\/(\S+)\s*$/) { + my $filename1 = $1; + my $filename2 = $2; + push(@files, $filename1); + push(@files, $filename2); + } elsif (m/^Fixes:\s+([0-9a-fA-F]{6,40})/) { + push(@fixes, $1) if ($email_fixes); + } elsif (m/^\+\+\+\s+(\S+)/ or m/^---\s+(\S+)/) { + my $filename = $1; + $filename =~ s@^[^/]*/@@; + $filename =~ s@\n@@; + $lastfile = $filename; + push(@files, $filename); + $patch_prefix = "^[+-].*"; #Now parsing the actual patch + } elsif (m/^\@\@ -(\d+),(\d+)/) { + if ($email_git_blame) { + push(@range, "$lastfile:$1:$2"); + } + } elsif ($keywords) { + foreach my $line (keys %keyword_hash) { + if ($patch_line =~ m/${patch_prefix}$keyword_hash{$line}/x) { + push(@keyword_tvi, $line); + } + } + } + } + close($patch); + + if ($file_cnt == @files) { + warn "$P: file '${file}' doesn't appear to be a patch. " + . "Add -f to options?\n"; + } + @files = sort_and_uniq(@files); + } +} + +@file_emails = uniq(@file_emails); +@fixes = uniq(@fixes); + +my %email_hash_name; +my %email_hash_address; +my @email_to = (); +my %hash_list_to; +my @list_to = (); +my @scm = (); +my @web = (); +my @subsystem = (); +my @status = (); +my %deduplicate_name_hash = (); +my %deduplicate_address_hash = (); + +my @maintainers = get_maintainers(); +if (@maintainers) { + @maintainers = merge_email(@maintainers); + output(@maintainers); +} + +if ($scm) { + @scm = uniq(@scm); + output(@scm); +} + +if ($status) { + @status = uniq(@status); + output(@status); +} + +if ($subsystem) { + @subsystem = uniq(@subsystem); + output(@subsystem); +} + +if ($web) { + @web = uniq(@web); + output(@web); +} + +exit($exit); + +sub self_test { + my @lsfiles = (); + my @good_links = (); + my @bad_links = (); + my @section_headers = (); + my $index = 0; + + @lsfiles = vcs_list_files($lk_path); + + for my $x (@self_test_info) { + $index++; + + ## Section header duplication and missing section content + if (($self_test eq "" || $self_test =~ /\bsections\b/) && + $x->{line} =~ /^\S[^:]/ && + defined $self_test_info[$index] && + $self_test_info[$index]->{line} =~ /^([A-Z]):\s*\S/) { + my $has_S = 0; + my $has_F = 0; + my $has_ML = 0; + my $status = ""; + if (grep(m@^\Q$x->{line}\E@, @section_headers)) { + print("$x->{file}:$x->{linenr}: warning: duplicate section header\t$x->{line}\n"); + } else { + push(@section_headers, $x->{line}); + } + my $nextline = $index; + while (defined $self_test_info[$nextline] && + $self_test_info[$nextline]->{line} =~ /^([A-Z]):\s*(\S.*)/) { + my $type = $1; + my $value = $2; + if ($type eq "S") { + $has_S = 1; + $status = $value; + } elsif ($type eq "F" || $type eq "N") { + $has_F = 1; + } elsif ($type eq "M" || $type eq "R" || $type eq "L") { + $has_ML = 1; + } + $nextline++; + } + if (!$has_ML && $status !~ /orphan|obsolete/i) { + print("$x->{file}:$x->{linenr}: warning: section without email address\t$x->{line}\n"); + } + if (!$has_S) { + print("$x->{file}:$x->{linenr}: warning: section without status \t$x->{line}\n"); + } + if (!$has_F) { + print("$x->{file}:$x->{linenr}: warning: section without file pattern\t$x->{line}\n"); + } + } + + next if ($x->{line} !~ /^([A-Z]):\s*(.*)/); + + my $type = $1; + my $value = $2; + + ## Filename pattern matching + if (($type eq "F" || $type eq "X") && + ($self_test eq "" || $self_test =~ /\bpatterns\b/)) { + $value =~ s@\.@\\\.@g; ##Convert . to \. + $value =~ s/\*/\.\*/g; ##Convert * to .* + $value =~ s/\?/\./g; ##Convert ? to . + ##if pattern is a directory and it lacks a trailing slash, add one + if ((-d $value)) { + $value =~ s@([^/])$@$1/@; + } + if (!grep(m@^$value@, @lsfiles)) { + print("$x->{file}:$x->{linenr}: warning: no file matches\t$x->{line}\n"); + } + + ## Link reachability + } elsif (($type eq "W" || $type eq "Q" || $type eq "B") && + $value =~ /^https?:/ && + ($self_test eq "" || $self_test =~ /\blinks\b/)) { + next if (grep(m@^\Q$value\E$@, @good_links)); + my $isbad = 0; + if (grep(m@^\Q$value\E$@, @bad_links)) { + $isbad = 1; + } else { + my $output = `wget --spider -q --no-check-certificate --timeout 10 --tries 1 $value`; + if ($? == 0) { + push(@good_links, $value); + } else { + push(@bad_links, $value); + $isbad = 1; + } + } + if ($isbad) { + print("$x->{file}:$x->{linenr}: warning: possible bad link\t$x->{line}\n"); + } + + ## SCM reachability + } elsif ($type eq "T" && + ($self_test eq "" || $self_test =~ /\bscm\b/)) { + next if (grep(m@^\Q$value\E$@, @good_links)); + my $isbad = 0; + if (grep(m@^\Q$value\E$@, @bad_links)) { + $isbad = 1; + } elsif ($value !~ /^(?:git|quilt|hg)\s+\S/) { + print("$x->{file}:$x->{linenr}: warning: malformed entry\t$x->{line}\n"); + } elsif ($value =~ /^git\s+(\S+)(\s+([^\(]+\S+))?/) { + my $url = $1; + my $branch = ""; + $branch = $3 if $3; + my $output = `git ls-remote --exit-code -h "$url" $branch > /dev/null 2>&1`; + if ($? == 0) { + push(@good_links, $value); + } else { + push(@bad_links, $value); + $isbad = 1; + } + } elsif ($value =~ /^(?:quilt|hg)\s+(https?:\S+)/) { + my $url = $1; + my $output = `wget --spider -q --no-check-certificate --timeout 10 --tries 1 $url`; + if ($? == 0) { + push(@good_links, $value); + } else { + push(@bad_links, $value); + $isbad = 1; + } + } + if ($isbad) { + print("$x->{file}:$x->{linenr}: warning: possible bad link\t$x->{line}\n"); + } + } + } +} + +sub ignore_email_address { + my ($address) = @_; + + foreach my $ignore (@ignore_emails) { + return 1 if ($ignore eq $address); + } + + return 0; +} + +sub range_is_maintained { + my ($start, $end) = @_; + + for (my $i = $start; $i < $end; $i++) { + my $line = $typevalue[$i]; + if ($line =~ m/^([A-Z]):\s*(.*)/) { + my $type = $1; + my $value = $2; + if ($type eq 'S') { + if ($value =~ /(maintain|support)/i) { + return 1; + } + } + } + } + return 0; +} + +sub range_has_maintainer { + my ($start, $end) = @_; + + for (my $i = $start; $i < $end; $i++) { + my $line = $typevalue[$i]; + if ($line =~ m/^([A-Z]):\s*(.*)/) { + my $type = $1; + my $value = $2; + if ($type eq 'M') { + return 1; + } + } + } + return 0; +} + +sub get_maintainers { + %email_hash_name = (); + %email_hash_address = (); + %commit_author_hash = (); + %commit_signer_hash = (); + @email_to = (); + %hash_list_to = (); + @list_to = (); + @scm = (); + @web = (); + @subsystem = (); + @status = (); + %deduplicate_name_hash = (); + %deduplicate_address_hash = (); + if ($email_git_all_signature_types) { + $signature_pattern = "(.+?)[Bb][Yy]:"; + } else { + $signature_pattern = "\(" . join("|", @signature_tags) . "\)"; + } + + # Find responsible parties + + my %exact_pattern_match_hash = (); + + foreach my $file (@files) { + + my %hash; + my $tvi = find_first_section(); + while ($tvi < @typevalue) { + my $start = find_starting_index($tvi); + my $end = find_ending_index($tvi); + my $exclude = 0; + my $i; + + #Do not match excluded file patterns + + for ($i = $start; $i < $end; $i++) { + my $line = $typevalue[$i]; + if ($line =~ m/^([A-Z]):\s*(.*)/) { + my $type = $1; + my $value = $2; + if ($type eq 'X') { + if (file_match_pattern($file, $value)) { + $exclude = 1; + last; + } + } + } + } + + if (!$exclude) { + for ($i = $start; $i < $end; $i++) { + my $line = $typevalue[$i]; + if ($line =~ m/^([A-Z]):\s*(.*)/) { + my $type = $1; + my $value = $2; + if ($type eq 'F') { + if (file_match_pattern($file, $value)) { + my $value_pd = ($value =~ tr@/@@); + my $file_pd = ($file =~ tr@/@@); + $value_pd++ if (substr($value,-1,1) ne "/"); + $value_pd = -1 if ($value =~ /^\.\*/); + if ($value_pd >= $file_pd && + range_is_maintained($start, $end) && + range_has_maintainer($start, $end)) { + $exact_pattern_match_hash{$file} = 1; + } + if ($pattern_depth == 0 || + (($file_pd - $value_pd) < $pattern_depth)) { + $hash{$tvi} = $value_pd; + } + } + } elsif ($type eq 'N') { + if ($file =~ m/$value/x) { + $hash{$tvi} = 0; + } + } + } + } + } + $tvi = $end + 1; + } + + foreach my $line (sort {$hash{$b} <=> $hash{$a}} keys %hash) { + add_categories($line); + if ($sections) { + my $i; + my $start = find_starting_index($line); + my $end = find_ending_index($line); + for ($i = $start; $i < $end; $i++) { + my $line = $typevalue[$i]; + if ($line =~ /^[FX]:/) { ##Restore file patterns + $line =~ s/([^\\])\.([^\*])/$1\?$2/g; + $line =~ s/([^\\])\.$/$1\?/g; ##Convert . back to ? + $line =~ s/\\\./\./g; ##Convert \. to . + $line =~ s/\.\*/\*/g; ##Convert .* to * + } + my $count = $line =~ s/^([A-Z]):/$1:\t/g; + if ($letters eq "" || (!$count || $letters =~ /$1/i)) { + print("$line\n"); + } + } + print("\n"); + } + } + + maintainers_in_file($file); + } + + if ($keywords) { + @keyword_tvi = sort_and_uniq(@keyword_tvi); + foreach my $line (@keyword_tvi) { + add_categories($line); + } + } + + foreach my $email (@email_to, @list_to) { + $email->[0] = deduplicate_email($email->[0]); + } + + foreach my $file (@files) { + if ($email && + ($email_git || + ($email_git_fallback && + $file !~ /MAINTAINERS$/ && + !$exact_pattern_match_hash{$file}))) { + vcs_file_signoffs($file); + } + if ($email && $email_git_blame) { + vcs_file_blame($file); + } + } + + if ($email) { + foreach my $chief (@penguin_chief) { + if ($chief =~ m/^(.*):(.*)/) { + my $email_address; + + $email_address = format_email($1, $2, $email_usename); + if ($email_git_penguin_chiefs) { + push(@email_to, [$email_address, 'chief penguin']); + } else { + @email_to = grep($_->[0] !~ /${email_address}/, @email_to); + } + } + } + + foreach my $email (@file_emails) { + $email = mailmap_email($email); + my ($name, $address) = parse_email($email); + + my $tmp_email = format_email($name, $address, $email_usename); + push_email_address($tmp_email, ''); + add_role($tmp_email, 'in file'); + } + } + + foreach my $fix (@fixes) { + vcs_add_commit_signers($fix, "blamed_fixes"); + } + + my @to = (); + if ($email || $email_list) { + if ($email) { + @to = (@to, @email_to); + } + if ($email_list) { + @to = (@to, @list_to); + } + } + + if ($interactive) { + @to = interactive_get_maintainers(\@to); + } + + return @to; +} + +sub file_match_pattern { + my ($file, $pattern) = @_; + if (substr($pattern, -1) eq "/") { + if ($file =~ m@^$pattern@) { + return 1; + } + } else { + if ($file =~ m@^$pattern@) { + my $s1 = ($file =~ tr@/@@); + my $s2 = ($pattern =~ tr@/@@); + if ($s1 == $s2) { + return 1; + } + } + } + return 0; +} + +sub usage { + print < print email address(es) if any + --git => include recent git \*-by: signers + --git-all-signature-types => include signers regardless of signature type + or use only ${signature_pattern} signers (default: $email_git_all_signature_types) + --git-fallback => use git when no exact MAINTAINERS pattern (default: $email_git_fallback) + --git-chief-penguins => include ${penguin_chiefs} + --git-min-signatures => number of signatures required (default: $email_git_min_signatures) + --git-max-maintainers => maximum maintainers to add (default: $email_git_max_maintainers) + --git-min-percent => minimum percentage of commits required (default: $email_git_min_percent) + --git-blame => use git blame to find modified commits for patch or file + --git-blame-signatures => when used with --git-blame, also include all commit signers + --git-since => git history to use (default: $email_git_since) + --hg-since => hg history to use (default: $email_hg_since) + --interactive => display a menu (mostly useful if used with the --git option) + --m => include maintainer(s) if any + --r => include reviewer(s) if any + --n => include name 'Full Name ' + --l => include list(s) if any + --moderated => include moderated lists(s) if any (default: true) + --s => include subscriber only list(s) if any (default: false) + --remove-duplicates => minimize duplicate email names/addresses + --roles => show roles (status:subsystem, git-signer, list, etc...) + --rolestats => show roles and statistics (commits/total_commits, %) + --file-emails => add email addresses found in -f file (default: 0 (off)) + --fixes => for patches, add signatures of commits with 'Fixes: ' (default: 1 (on)) + --scm => print SCM tree(s) if any + --status => print status if any + --subsystem => print subsystem name if any + --web => print website(s) if any + +Output type options: + --separator [, ] => separator for multiple entries on 1 line + using --separator also sets --nomultiline if --separator is not [, ] + --multiline => print 1 entry per line + +Other options: + --pattern-depth => Number of pattern directory traversals (default: 0 (all)) + --keywords => scan patch for keywords (default: $keywords) + --sections => print all of the subsystem sections with pattern matches + --letters => print all matching 'letter' types from all matching sections + --mailmap => use .mailmap file (default: $email_use_mailmap) + --no-tree => run without a kernel tree + --self-test => show potential issues with MAINTAINERS file content + --version => show version + --help => show this help information + +Default options: + [--email --tree --nogit --git-fallback --m --r --n --l --multiline + --pattern-depth=0 --remove-duplicates --rolestats] + +Notes: + Using "-f directory" may give unexpected results: + Used with "--git", git signators for _all_ files in and below + directory are examined as git recurses directories. + Any specified X: (exclude) pattern matches are _not_ ignored. + Used with "--nogit", directory is used as a pattern match, + no individual file within the directory or subdirectory + is matched. + Used with "--git-blame", does not iterate all files in directory + Using "--git-blame" is slow and may add old committers and authors + that are no longer active maintainers to the output. + Using "--roles" or "--rolestats" with git send-email --cc-cmd or any + other automated tools that expect only ["name"] + may not work because of additional output after . + Using "--rolestats" and "--git-blame" shows the #/total=% commits, + not the percentage of the entire file authored. # of commits is + not a good measure of amount of code authored. 1 major commit may + contain a thousand lines, 5 trivial commits may modify a single line. + If git is not installed, but mercurial (hg) is installed and an .hg + repository exists, the following options apply to mercurial: + --git, + --git-min-signatures, --git-max-maintainers, --git-min-percent, and + --git-blame + Use --hg-since not --git-since to control date selection + File ".get_maintainer.conf", if it exists in the fstests source root + directory, can change whatever get_maintainer defaults are desired. + Entries in this file can be any command line argument. + This file is prepended to any additional command line arguments. + Multiple lines and # comments are allowed. + Most options have both positive and negative forms. + The negative forms for -- are --no and --no-. + +EOT +} + +sub top_of_fstests_tree { + my ($lk_path) = @_; + + if ($lk_path ne "" && substr($lk_path,length($lk_path)-1,1) ne "/") { + $lk_path .= "/"; + } + if ( (-f "${lk_path}check") + && (-f "${lk_path}local.config.example") + && (-e "${lk_path}MAINTAINERS") + && (-f "${lk_path}Makefile") + && (-f "${lk_path}README") + && (-f "${lk_path}new") + && (-d "${lk_path}LICENSES") + && (-d "${lk_path}tests") + && (-d "${lk_path}common") + && (-d "${lk_path}src") + && (-d "${lk_path}tools") + && (-d "${lk_path}include") + && (-d "${lk_path}m4") + && (-d "${lk_path}lib") + && (-d "${lk_path}doc")) { + return 1; + } + return 0; +} + +sub parse_email { + my ($formatted_email) = @_; + + my $name = ""; + my $address = ""; + + if ($formatted_email =~ /^([^<]+)<(.+\@.*)>.*$/) { + $name = $1; + $address = $2; + } elsif ($formatted_email =~ /^\s*<(.+\@\S*)>.*$/) { + $address = $1; + } elsif ($formatted_email =~ /^(.+\@\S*).*$/) { + $address = $1; + } + + $name =~ s/^\s+|\s+$//g; + $name =~ s/^\"|\"$//g; + $address =~ s/^\s+|\s+$//g; + + if ($name =~ /[^\w \-]/i) { ##has "must quote" chars + $name =~ s/(?"; + } + } else { + $formatted_email = $address; + } + + return $formatted_email; +} + +sub find_first_section { + my $index = 0; + + while ($index < @typevalue) { + my $tv = $typevalue[$index]; + if (($tv =~ m/^([A-Z]):\s*(.*)/)) { + last; + } + $index++; + } + + return $index; +} + +sub find_starting_index { + my ($index) = @_; + + while ($index > 0) { + my $tv = $typevalue[$index]; + if (!($tv =~ m/^([A-Z]):\s*(.*)/)) { + last; + } + $index--; + } + + return $index; +} + +sub find_ending_index { + my ($index) = @_; + + while ($index < @typevalue) { + my $tv = $typevalue[$index]; + if (!($tv =~ m/^([A-Z]):\s*(.*)/)) { + last; + } + $index++; + } + + return $index; +} + +sub get_subsystem_name { + my ($index) = @_; + + my $start = find_starting_index($index); + + my $subsystem = $typevalue[$start]; + if ($output_section_maxlen && length($subsystem) > $output_section_maxlen) { + $subsystem = substr($subsystem, 0, $output_section_maxlen - 3); + $subsystem =~ s/\s*$//; + $subsystem = $subsystem . "..."; + } + return $subsystem; +} + +sub get_maintainer_role { + my ($index) = @_; + + my $i; + my $start = find_starting_index($index); + my $end = find_ending_index($index); + + my $role = "unknown"; + my $subsystem = get_subsystem_name($index); + + for ($i = $start + 1; $i < $end; $i++) { + my $tv = $typevalue[$i]; + if ($tv =~ m/^([A-Z]):\s*(.*)/) { + my $ptype = $1; + my $pvalue = $2; + if ($ptype eq "S") { + $role = $pvalue; + } + } + } + + $role = lc($role); + if ($role eq "supported") { + $role = "supporter"; + } elsif ($role eq "maintained") { + $role = "maintainer"; + } elsif ($role eq "odd fixes") { + $role = "odd fixer"; + } elsif ($role eq "orphan") { + $role = "orphan minder"; + } elsif ($role eq "obsolete") { + $role = "obsolete minder"; + } elsif ($role eq "buried alive in reporters") { + $role = "chief penguin"; + } + + return $role . ":" . $subsystem; +} + +sub get_list_role { + my ($index) = @_; + + my $subsystem = get_subsystem_name($index); + + if ($subsystem eq "ALL") { + $subsystem = "Send To Me"; + } + + return $subsystem; +} + +sub add_categories { + my ($index) = @_; + + my $i; + my $start = find_starting_index($index); + my $end = find_ending_index($index); + + push(@subsystem, $typevalue[$start]); + + for ($i = $start + 1; $i < $end; $i++) { + my $tv = $typevalue[$i]; + if ($tv =~ m/^([A-Z]):\s*(.*)/) { + my $ptype = $1; + my $pvalue = $2; + if ($ptype eq "L") { + my $list_address = $pvalue; + my $list_additional = ""; + my $list_role = get_list_role($i); + + if ($list_role ne "") { + $list_role = ":" . $list_role; + } + if ($list_address =~ m/([^\s]+)\s+(.*)$/) { + $list_address = $1; + $list_additional = $2; + } + if ($list_additional =~ m/subscribers-only/) { + if ($email_subscriber_list) { + if (!$hash_list_to{lc($list_address)}) { + $hash_list_to{lc($list_address)} = 1; + push(@list_to, [$list_address, + "subscriber list${list_role}"]); + } + } + } else { + if ($email_list) { + if (!$hash_list_to{lc($list_address)}) { + if ($list_additional =~ m/moderated/) { + if ($email_moderated_list) { + $hash_list_to{lc($list_address)} = 1; + push(@list_to, [$list_address, + "moderated list${list_role}"]); + } + } else { + $hash_list_to{lc($list_address)} = 1; + push(@list_to, [$list_address, + "open list${list_role}"]); + } + } + } + } + } elsif ($ptype eq "M") { + if ($email_maintainer) { + my $role = get_maintainer_role($i); + push_email_addresses($pvalue, $role); + } + } elsif ($ptype eq "R") { + if ($email_reviewer) { + my $subsystem = get_subsystem_name($i); + push_email_addresses($pvalue, "reviewer:$subsystem"); + } + } elsif ($ptype eq "T") { + push(@scm, $pvalue); + } elsif ($ptype eq "W") { + push(@web, $pvalue); + } elsif ($ptype eq "S") { + push(@status, $pvalue); + } + } + } +} + +sub email_inuse { + my ($name, $address) = @_; + + return 1 if (($name eq "") && ($address eq "")); + return 1 if (($name ne "") && exists($email_hash_name{lc($name)})); + return 1 if (($address ne "") && exists($email_hash_address{lc($address)})); + + return 0; +} + +sub push_email_address { + my ($line, $role) = @_; + + my ($name, $address) = parse_email($line); + + if ($address eq "") { + return 0; + } + + if (!$email_remove_duplicates) { + push(@email_to, [format_email($name, $address, $email_usename), $role]); + } elsif (!email_inuse($name, $address)) { + push(@email_to, [format_email($name, $address, $email_usename), $role]); + $email_hash_name{lc($name)}++ if ($name ne ""); + $email_hash_address{lc($address)}++; + } + + return 1; +} + +sub push_email_addresses { + my ($address, $role) = @_; + + my @address_list = (); + + if (rfc822_valid($address)) { + push_email_address($address, $role); + } elsif (@address_list = rfc822_validlist($address)) { + my $array_count = shift(@address_list); + while (my $entry = shift(@address_list)) { + push_email_address($entry, $role); + } + } else { + if (!push_email_address($address, $role)) { + warn("Invalid MAINTAINERS address: '" . $address . "'\n"); + } + } +} + +sub add_role { + my ($line, $role) = @_; + + my ($name, $address) = parse_email($line); + my $email = format_email($name, $address, $email_usename); + + foreach my $entry (@email_to) { + if ($email_remove_duplicates) { + my ($entry_name, $entry_address) = parse_email($entry->[0]); + if (($name eq $entry_name || $address eq $entry_address) + && ($role eq "" || !($entry->[1] =~ m/$role/)) + ) { + if ($entry->[1] eq "") { + $entry->[1] = "$role"; + } else { + $entry->[1] = "$entry->[1],$role"; + } + } + } else { + if ($email eq $entry->[0] + && ($role eq "" || !($entry->[1] =~ m/$role/)) + ) { + if ($entry->[1] eq "") { + $entry->[1] = "$role"; + } else { + $entry->[1] = "$entry->[1],$role"; + } + } + } + } +} + +sub which { + my ($bin) = @_; + + foreach my $path (split(/:/, $ENV{PATH})) { + if (-e "$path/$bin") { + return "$path/$bin"; + } + } + + return ""; +} + +sub which_conf { + my ($conf) = @_; + + foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) { + if (-e "$path/$conf") { + return "$path/$conf"; + } + } + + return ""; +} + +sub mailmap_email { + my ($line) = @_; + + my ($name, $address) = parse_email($line); + my $email = format_email($name, $address, 1); + my $real_name = $name; + my $real_address = $address; + + if (exists $mailmap->{names}->{$email} || + exists $mailmap->{addresses}->{$email}) { + if (exists $mailmap->{names}->{$email}) { + $real_name = $mailmap->{names}->{$email}; + } + if (exists $mailmap->{addresses}->{$email}) { + $real_address = $mailmap->{addresses}->{$email}; + } + } else { + if (exists $mailmap->{names}->{$address}) { + $real_name = $mailmap->{names}->{$address}; + } + if (exists $mailmap->{addresses}->{$address}) { + $real_address = $mailmap->{addresses}->{$address}; + } + } + return format_email($real_name, $real_address, 1); +} + +sub mailmap { + my (@addresses) = @_; + + my @mapped_emails = (); + foreach my $line (@addresses) { + push(@mapped_emails, mailmap_email($line)); + } + merge_by_realname(@mapped_emails) if ($email_use_mailmap); + return @mapped_emails; +} + +sub merge_by_realname { + my %address_map; + my (@emails) = @_; + + foreach my $email (@emails) { + my ($name, $address) = parse_email($email); + if (exists $address_map{$name}) { + $address = $address_map{$name}; + $email = format_email($name, $address, 1); + } else { + $address_map{$name} = $address; + } + } +} + +sub git_execute_cmd { + my ($cmd) = @_; + my @lines = (); + + my $output = `$cmd`; + $output =~ s/^\s*//gm; + @lines = split("\n", $output); + + return @lines; +} + +sub hg_execute_cmd { + my ($cmd) = @_; + my @lines = (); + + my $output = `$cmd`; + @lines = split("\n", $output); + + return @lines; +} + +sub extract_formatted_signatures { + my (@signature_lines) = @_; + + my @type = @signature_lines; + + s/\s*(.*):.*/$1/ for (@type); + + # cut -f2- -d":" + s/\s*.*:\s*(.+)\s*/$1/ for (@signature_lines); + +## Reformat email addresses (with names) to avoid badly written signatures + + foreach my $signer (@signature_lines) { + $signer = deduplicate_email($signer); + } + + return (\@type, \@signature_lines); +} + +sub vcs_find_signers { + my ($cmd, $file) = @_; + my $commits; + my @lines = (); + my @signatures = (); + my @authors = (); + my @stats = (); + + @lines = &{$VCS_cmds{"execute_cmd"}}($cmd); + + my $pattern = $VCS_cmds{"commit_pattern"}; + my $author_pattern = $VCS_cmds{"author_pattern"}; + my $stat_pattern = $VCS_cmds{"stat_pattern"}; + + $stat_pattern =~ s/(\$\w+)/$1/eeg; #interpolate $stat_pattern + + $commits = grep(/$pattern/, @lines); # of commits + + @authors = grep(/$author_pattern/, @lines); + @signatures = grep(/^[ \t]*${signature_pattern}.*\@.*$/, @lines); + @stats = grep(/$stat_pattern/, @lines); + +# print("stats: <@stats>\n"); + + return (0, \@signatures, \@authors, \@stats) if !@signatures; + + save_commits_by_author(@lines) if ($interactive); + save_commits_by_signer(@lines) if ($interactive); + + if (!$email_git_penguin_chiefs) { + @signatures = grep(!/${penguin_chiefs}/i, @signatures); + } + + my ($author_ref, $authors_ref) = extract_formatted_signatures(@authors); + my ($types_ref, $signers_ref) = extract_formatted_signatures(@signatures); + + return ($commits, $signers_ref, $authors_ref, \@stats); +} + +sub vcs_find_author { + my ($cmd) = @_; + my @lines = (); + + @lines = &{$VCS_cmds{"execute_cmd"}}($cmd); + + if (!$email_git_penguin_chiefs) { + @lines = grep(!/${penguin_chiefs}/i, @lines); + } + + return @lines if !@lines; + + my @authors = (); + foreach my $line (@lines) { + if ($line =~ m/$VCS_cmds{"author_pattern"}/) { + my $author = $1; + my ($name, $address) = parse_email($author); + $author = format_email($name, $address, 1); + push(@authors, $author); + } + } + + save_commits_by_author(@lines) if ($interactive); + save_commits_by_signer(@lines) if ($interactive); + + return @authors; +} + +sub vcs_save_commits { + my ($cmd) = @_; + my @lines = (); + my @commits = (); + + @lines = &{$VCS_cmds{"execute_cmd"}}($cmd); + + foreach my $line (@lines) { + if ($line =~ m/$VCS_cmds{"blame_commit_pattern"}/) { + push(@commits, $1); + } + } + + return @commits; +} + +sub vcs_blame { + my ($file) = @_; + my $cmd; + my @commits = (); + + return @commits if (!(-f $file)); + + if (@range && $VCS_cmds{"blame_range_cmd"} eq "") { + my @all_commits = (); + + $cmd = $VCS_cmds{"blame_file_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd + @all_commits = vcs_save_commits($cmd); + + foreach my $file_range_diff (@range) { + next if (!($file_range_diff =~ m/(.+):(.+):(.+)/)); + my $diff_file = $1; + my $diff_start = $2; + my $diff_length = $3; + next if ("$file" ne "$diff_file"); + for (my $i = $diff_start; $i < $diff_start + $diff_length; $i++) { + push(@commits, $all_commits[$i]); + } + } + } elsif (@range) { + foreach my $file_range_diff (@range) { + next if (!($file_range_diff =~ m/(.+):(.+):(.+)/)); + my $diff_file = $1; + my $diff_start = $2; + my $diff_length = $3; + next if ("$file" ne "$diff_file"); + $cmd = $VCS_cmds{"blame_range_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd + push(@commits, vcs_save_commits($cmd)); + } + } else { + $cmd = $VCS_cmds{"blame_file_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd + @commits = vcs_save_commits($cmd); + } + + foreach my $commit (@commits) { + $commit =~ s/^\^//g; + } + + return @commits; +} + +my $printed_novcs = 0; +sub vcs_exists { + %VCS_cmds = %VCS_cmds_git; + return 1 if eval $VCS_cmds{"available"}; + %VCS_cmds = %VCS_cmds_hg; + return 2 if eval $VCS_cmds{"available"}; + %VCS_cmds = (); + if (!$printed_novcs && $email_git) { + warn("$P: No supported VCS found. Add --nogit to options?\n"); + warn("Using a git repository produces better results.\n"); + warn("Try Linus Torvalds' latest git repository using:\n"); + warn("git clone git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git\n"); + $printed_novcs = 1; + } + return 0; +} + +sub vcs_is_git { + vcs_exists(); + return $vcs_used == 1; +} + +sub vcs_is_hg { + return $vcs_used == 2; +} + +sub vcs_add_commit_signers { + return if (!vcs_exists()); + + my ($commit, $desc) = @_; + my $commit_count = 0; + my $commit_authors_ref; + my $commit_signers_ref; + my $stats_ref; + my @commit_authors = (); + my @commit_signers = (); + my $cmd; + + $cmd = $VCS_cmds{"find_commit_signers_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd + + ($commit_count, $commit_signers_ref, $commit_authors_ref, $stats_ref) = vcs_find_signers($cmd, ""); + @commit_authors = @{$commit_authors_ref} if defined $commit_authors_ref; + @commit_signers = @{$commit_signers_ref} if defined $commit_signers_ref; + + foreach my $signer (@commit_signers) { + $signer = deduplicate_email($signer); + } + + vcs_assign($desc, 1, @commit_signers); +} + +sub interactive_get_maintainers { + my ($list_ref) = @_; + my @list = @$list_ref; + + vcs_exists(); + + my %selected; + my %authored; + my %signed; + my $count = 0; + my $maintained = 0; + foreach my $entry (@list) { + $maintained = 1 if ($entry->[1] =~ /^(maintainer|supporter)/i); + $selected{$count} = 1; + $authored{$count} = 0; + $signed{$count} = 0; + $count++; + } + + #menu loop + my $done = 0; + my $print_options = 0; + my $redraw = 1; + while (!$done) { + $count = 0; + if ($redraw) { + printf STDERR "\n%1s %2s %-65s", + "*", "#", "email/list and role:stats"; + if ($email_git || + ($email_git_fallback && !$maintained) || + $email_git_blame) { + print STDERR "auth sign"; + } + print STDERR "\n"; + foreach my $entry (@list) { + my $email = $entry->[0]; + my $role = $entry->[1]; + my $sel = ""; + $sel = "*" if ($selected{$count}); + my $commit_author = $commit_author_hash{$email}; + my $commit_signer = $commit_signer_hash{$email}; + my $authored = 0; + my $signed = 0; + $authored++ for (@{$commit_author}); + $signed++ for (@{$commit_signer}); + printf STDERR "%1s %2d %-65s", $sel, $count + 1, $email; + printf STDERR "%4d %4d", $authored, $signed + if ($authored > 0 || $signed > 0); + printf STDERR "\n %s\n", $role; + if ($authored{$count}) { + my $commit_author = $commit_author_hash{$email}; + foreach my $ref (@{$commit_author}) { + print STDERR " Author: @{$ref}[1]\n"; + } + } + if ($signed{$count}) { + my $commit_signer = $commit_signer_hash{$email}; + foreach my $ref (@{$commit_signer}) { + print STDERR " @{$ref}[2]: @{$ref}[1]\n"; + } + } + + $count++; + } + } + my $date_ref = \$email_git_since; + $date_ref = \$email_hg_since if (vcs_is_hg()); + if ($print_options) { + $print_options = 0; + if (vcs_exists()) { + print STDERR <; + chomp($input); + + $redraw = 1; + my $rerun = 0; + my @wish = split(/[, ]+/, $input); + foreach my $nr (@wish) { + $nr = lc($nr); + my $sel = substr($nr, 0, 1); + my $str = substr($nr, 1); + my $val = 0; + $val = $1 if $str =~ /^(\d+)$/; + + if ($sel eq "y") { + $interactive = 0; + $done = 1; + $output_rolestats = 0; + $output_roles = 0; + last; + } elsif ($nr =~ /^\d+$/ && $nr > 0 && $nr <= $count) { + $selected{$nr - 1} = !$selected{$nr - 1}; + } elsif ($sel eq "*" || $sel eq '^') { + my $toggle = 0; + $toggle = 1 if ($sel eq '*'); + for (my $i = 0; $i < $count; $i++) { + $selected{$i} = $toggle; + } + } elsif ($sel eq "0") { + for (my $i = 0; $i < $count; $i++) { + $selected{$i} = !$selected{$i}; + } + } elsif ($sel eq "t") { + if (lc($str) eq "m") { + for (my $i = 0; $i < $count; $i++) { + $selected{$i} = !$selected{$i} + if ($list[$i]->[1] =~ /^(maintainer|supporter)/i); + } + } elsif (lc($str) eq "g") { + for (my $i = 0; $i < $count; $i++) { + $selected{$i} = !$selected{$i} + if ($list[$i]->[1] =~ /^(author|commit|signer)/i); + } + } elsif (lc($str) eq "l") { + for (my $i = 0; $i < $count; $i++) { + $selected{$i} = !$selected{$i} + if ($list[$i]->[1] =~ /^(open list)/i); + } + } elsif (lc($str) eq "s") { + for (my $i = 0; $i < $count; $i++) { + $selected{$i} = !$selected{$i} + if ($list[$i]->[1] =~ /^(subscriber list)/i); + } + } + } elsif ($sel eq "a") { + if ($val > 0 && $val <= $count) { + $authored{$val - 1} = !$authored{$val - 1}; + } elsif ($str eq '*' || $str eq '^') { + my $toggle = 0; + $toggle = 1 if ($str eq '*'); + for (my $i = 0; $i < $count; $i++) { + $authored{$i} = $toggle; + } + } + } elsif ($sel eq "s") { + if ($val > 0 && $val <= $count) { + $signed{$val - 1} = !$signed{$val - 1}; + } elsif ($str eq '*' || $str eq '^') { + my $toggle = 0; + $toggle = 1 if ($str eq '*'); + for (my $i = 0; $i < $count; $i++) { + $signed{$i} = $toggle; + } + } + } elsif ($sel eq "o") { + $print_options = 1; + $redraw = 1; + } elsif ($sel eq "g") { + if ($str eq "f") { + bool_invert(\$email_git_fallback); + } else { + bool_invert(\$email_git); + } + $rerun = 1; + } elsif ($sel eq "b") { + if ($str eq "s") { + bool_invert(\$email_git_blame_signatures); + } else { + bool_invert(\$email_git_blame); + } + $rerun = 1; + } elsif ($sel eq "c") { + if ($val > 0) { + $email_git_min_signatures = $val; + $rerun = 1; + } + } elsif ($sel eq "x") { + if ($val > 0) { + $email_git_max_maintainers = $val; + $rerun = 1; + } + } elsif ($sel eq "%") { + if ($str ne "" && $val >= 0) { + $email_git_min_percent = $val; + $rerun = 1; + } + } elsif ($sel eq "d") { + if (vcs_is_git()) { + $email_git_since = $str; + } elsif (vcs_is_hg()) { + $email_hg_since = $str; + } + $rerun = 1; + } elsif ($sel eq "t") { + bool_invert(\$email_git_all_signature_types); + $rerun = 1; + } elsif ($sel eq "f") { + bool_invert(\$email_file_emails); + $rerun = 1; + } elsif ($sel eq "r") { + bool_invert(\$email_remove_duplicates); + $rerun = 1; + } elsif ($sel eq "m") { + bool_invert(\$email_use_mailmap); + read_mailmap(); + $rerun = 1; + } elsif ($sel eq "k") { + bool_invert(\$keywords); + $rerun = 1; + } elsif ($sel eq "p") { + if ($str ne "" && $val >= 0) { + $pattern_depth = $val; + $rerun = 1; + } + } elsif ($sel eq "h" || $sel eq "?") { + print STDERR <[0]; + $address = $deduplicate_name_hash{lc($name)}->[1]; + $matched = 1; + } elsif ($deduplicate_address_hash{lc($address)}) { + $name = $deduplicate_address_hash{lc($address)}->[0]; + $address = $deduplicate_address_hash{lc($address)}->[1]; + $matched = 1; + } + if (!$matched) { + $deduplicate_name_hash{lc($name)} = [ $name, $address ]; + $deduplicate_address_hash{lc($address)} = [ $name, $address ]; + } + $email = format_email($name, $address, 1); + $email = mailmap_email($email); + return $email; +} + +sub save_commits_by_author { + my (@lines) = @_; + + my @authors = (); + my @commits = (); + my @subjects = (); + + foreach my $line (@lines) { + if ($line =~ m/$VCS_cmds{"author_pattern"}/) { + my $author = $1; + $author = deduplicate_email($author); + push(@authors, $author); + } + push(@commits, $1) if ($line =~ m/$VCS_cmds{"commit_pattern"}/); + push(@subjects, $1) if ($line =~ m/$VCS_cmds{"subject_pattern"}/); + } + + for (my $i = 0; $i < @authors; $i++) { + my $exists = 0; + foreach my $ref(@{$commit_author_hash{$authors[$i]}}) { + if (@{$ref}[0] eq $commits[$i] && + @{$ref}[1] eq $subjects[$i]) { + $exists = 1; + last; + } + } + if (!$exists) { + push(@{$commit_author_hash{$authors[$i]}}, + [ ($commits[$i], $subjects[$i]) ]); + } + } +} + +sub save_commits_by_signer { + my (@lines) = @_; + + my $commit = ""; + my $subject = ""; + + foreach my $line (@lines) { + $commit = $1 if ($line =~ m/$VCS_cmds{"commit_pattern"}/); + $subject = $1 if ($line =~ m/$VCS_cmds{"subject_pattern"}/); + if ($line =~ /^[ \t]*${signature_pattern}.*\@.*$/) { + my @signatures = ($line); + my ($types_ref, $signers_ref) = extract_formatted_signatures(@signatures); + my @types = @$types_ref; + my @signers = @$signers_ref; + + my $type = $types[0]; + my $signer = $signers[0]; + + $signer = deduplicate_email($signer); + + my $exists = 0; + foreach my $ref(@{$commit_signer_hash{$signer}}) { + if (@{$ref}[0] eq $commit && + @{$ref}[1] eq $subject && + @{$ref}[2] eq $type) { + $exists = 1; + last; + } + } + if (!$exists) { + push(@{$commit_signer_hash{$signer}}, + [ ($commit, $subject, $type) ]); + } + } + } +} + +sub vcs_assign { + my ($role, $divisor, @lines) = @_; + + my %hash; + my $count = 0; + + return if (@lines <= 0); + + if ($divisor <= 0) { + warn("Bad divisor in " . (caller(0))[3] . ": $divisor\n"); + $divisor = 1; + } + + @lines = mailmap(@lines); + + return if (@lines <= 0); + + @lines = sort(@lines); + + # uniq -c + $hash{$_}++ for @lines; + + # sort -rn + foreach my $line (sort {$hash{$b} <=> $hash{$a}} keys %hash) { + my $sign_offs = $hash{$line}; + my $percent = $sign_offs * 100 / $divisor; + + $percent = 100 if ($percent > 100); + next if (ignore_email_address($line)); + $count++; + last if ($sign_offs < $email_git_min_signatures || + $count > $email_git_max_maintainers || + $percent < $email_git_min_percent); + push_email_address($line, ''); + if ($output_rolestats) { + my $fmt_percent = sprintf("%.0f", $percent); + add_role($line, "$role:$sign_offs/$divisor=$fmt_percent%"); + } else { + add_role($line, $role); + } + } +} + +sub vcs_file_signoffs { + my ($file) = @_; + + my $authors_ref; + my $signers_ref; + my $stats_ref; + my @authors = (); + my @signers = (); + my @stats = (); + my $commits; + + $vcs_used = vcs_exists(); + return if (!$vcs_used); + + my $cmd = $VCS_cmds{"find_signers_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; # interpolate $cmd + + ($commits, $signers_ref, $authors_ref, $stats_ref) = vcs_find_signers($cmd, $file); + + @signers = @{$signers_ref} if defined $signers_ref; + @authors = @{$authors_ref} if defined $authors_ref; + @stats = @{$stats_ref} if defined $stats_ref; + +# print("commits: <$commits>\nsigners:<@signers>\nauthors: <@authors>\nstats: <@stats>\n"); + + foreach my $signer (@signers) { + $signer = deduplicate_email($signer); + } + + vcs_assign("commit_signer", $commits, @signers); + vcs_assign("authored", $commits, @authors); + if ($#authors == $#stats) { + my $stat_pattern = $VCS_cmds{"stat_pattern"}; + $stat_pattern =~ s/(\$\w+)/$1/eeg; #interpolate $stat_pattern + + my $added = 0; + my $deleted = 0; + for (my $i = 0; $i <= $#stats; $i++) { + if ($stats[$i] =~ /$stat_pattern/) { + $added += $1; + $deleted += $2; + } + } + my @tmp_authors = uniq(@authors); + foreach my $author (@tmp_authors) { + $author = deduplicate_email($author); + } + @tmp_authors = uniq(@tmp_authors); + my @list_added = (); + my @list_deleted = (); + foreach my $author (@tmp_authors) { + my $auth_added = 0; + my $auth_deleted = 0; + for (my $i = 0; $i <= $#stats; $i++) { + if ($author eq deduplicate_email($authors[$i]) && + $stats[$i] =~ /$stat_pattern/) { + $auth_added += $1; + $auth_deleted += $2; + } + } + for (my $i = 0; $i < $auth_added; $i++) { + push(@list_added, $author); + } + for (my $i = 0; $i < $auth_deleted; $i++) { + push(@list_deleted, $author); + } + } + vcs_assign("added_lines", $added, @list_added); + vcs_assign("removed_lines", $deleted, @list_deleted); + } +} + +sub vcs_file_blame { + my ($file) = @_; + + my @signers = (); + my @all_commits = (); + my @commits = (); + my $total_commits; + my $total_lines; + + $vcs_used = vcs_exists(); + return if (!$vcs_used); + + @all_commits = vcs_blame($file); + @commits = uniq(@all_commits); + $total_commits = @commits; + $total_lines = @all_commits; + + if ($email_git_blame_signatures) { + if (vcs_is_hg()) { + my $commit_count; + my $commit_authors_ref; + my $commit_signers_ref; + my $stats_ref; + my @commit_authors = (); + my @commit_signers = (); + my $commit = join(" -r ", @commits); + my $cmd; + + $cmd = $VCS_cmds{"find_commit_signers_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd + + ($commit_count, $commit_signers_ref, $commit_authors_ref, $stats_ref) = vcs_find_signers($cmd, $file); + @commit_authors = @{$commit_authors_ref} if defined $commit_authors_ref; + @commit_signers = @{$commit_signers_ref} if defined $commit_signers_ref; + + push(@signers, @commit_signers); + } else { + foreach my $commit (@commits) { + my $commit_count; + my $commit_authors_ref; + my $commit_signers_ref; + my $stats_ref; + my @commit_authors = (); + my @commit_signers = (); + my $cmd; + + $cmd = $VCS_cmds{"find_commit_signers_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd + + ($commit_count, $commit_signers_ref, $commit_authors_ref, $stats_ref) = vcs_find_signers($cmd, $file); + @commit_authors = @{$commit_authors_ref} if defined $commit_authors_ref; + @commit_signers = @{$commit_signers_ref} if defined $commit_signers_ref; + + push(@signers, @commit_signers); + } + } + } + + if ($from_filename) { + if ($output_rolestats) { + my @blame_signers; + if (vcs_is_hg()) {{ # Double brace for last exit + my $commit_count; + my @commit_signers = (); + @commits = uniq(@commits); + @commits = sort(@commits); + my $commit = join(" -r ", @commits); + my $cmd; + + $cmd = $VCS_cmds{"find_commit_author_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd + + my @lines = (); + + @lines = &{$VCS_cmds{"execute_cmd"}}($cmd); + + if (!$email_git_penguin_chiefs) { + @lines = grep(!/${penguin_chiefs}/i, @lines); + } + + last if !@lines; + + my @authors = (); + foreach my $line (@lines) { + if ($line =~ m/$VCS_cmds{"author_pattern"}/) { + my $author = $1; + $author = deduplicate_email($author); + push(@authors, $author); + } + } + + save_commits_by_author(@lines) if ($interactive); + save_commits_by_signer(@lines) if ($interactive); + + push(@signers, @authors); + }} + else { + foreach my $commit (@commits) { + my $i; + my $cmd = $VCS_cmds{"find_commit_author_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd + my @author = vcs_find_author($cmd); + next if !@author; + + my $formatted_author = deduplicate_email($author[0]); + + my $count = grep(/$commit/, @all_commits); + for ($i = 0; $i < $count ; $i++) { + push(@blame_signers, $formatted_author); + } + } + } + if (@blame_signers) { + vcs_assign("authored lines", $total_lines, @blame_signers); + } + } + foreach my $signer (@signers) { + $signer = deduplicate_email($signer); + } + vcs_assign("commits", $total_commits, @signers); + } else { + foreach my $signer (@signers) { + $signer = deduplicate_email($signer); + } + vcs_assign("modified commits", $total_commits, @signers); + } +} + +sub vcs_file_exists { + my ($file) = @_; + + my $exists; + + my $vcs_used = vcs_exists(); + return 0 if (!$vcs_used); + + my $cmd = $VCS_cmds{"file_exists_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; # interpolate $cmd + $cmd .= " 2>&1"; + $exists = &{$VCS_cmds{"execute_cmd"}}($cmd); + + return 0 if ($? != 0); + + return $exists; +} + +sub vcs_list_files { + my ($file) = @_; + + my @lsfiles = (); + + my $vcs_used = vcs_exists(); + return 0 if (!$vcs_used); + + my $cmd = $VCS_cmds{"list_files_cmd"}; + $cmd =~ s/(\$\w+)/$1/eeg; # interpolate $cmd + @lsfiles = &{$VCS_cmds{"execute_cmd"}}($cmd); + + return () if ($? != 0); + + return @lsfiles; +} + +sub uniq { + my (@parms) = @_; + + my %saw; + @parms = grep(!$saw{$_}++, @parms); + return @parms; +} + +sub sort_and_uniq { + my (@parms) = @_; + + my %saw; + @parms = sort @parms; + @parms = grep(!$saw{$_}++, @parms); + return @parms; +} + +sub clean_file_emails { + my (@file_emails) = @_; + my @fmt_emails = (); + + foreach my $email (@file_emails) { + $email =~ s/[\(\<\{]{0,1}([A-Za-z0-9_\.\+-]+\@[A-Za-z0-9\.-]+)[\)\>\}]{0,1}/\<$1\>/g; + my ($name, $address) = parse_email($email); + if ($name eq '"[,\.]"') { + $name = ""; + } + + my @nw = split(/[^A-Za-zÀ-ÿ\'\,\.\+-]/, $name); + if (@nw > 2) { + my $first = $nw[@nw - 3]; + my $middle = $nw[@nw - 2]; + my $last = $nw[@nw - 1]; + + if (((length($first) == 1 && $first =~ m/[A-Za-z]/) || + (length($first) == 2 && substr($first, -1) eq ".")) || + (length($middle) == 1 || + (length($middle) == 2 && substr($middle, -1) eq "."))) { + $name = "$first $middle $last"; + } else { + $name = "$middle $last"; + } + } + + if (substr($name, -1) =~ /[,\.]/) { + $name = substr($name, 0, length($name) - 1); + } elsif (substr($name, -2) =~ /[,\.]"/) { + $name = substr($name, 0, length($name) - 2) . '"'; + } + + if (substr($name, 0, 1) =~ /[,\.]/) { + $name = substr($name, 1, length($name) - 1); + } elsif (substr($name, 0, 2) =~ /"[,\.]/) { + $name = '"' . substr($name, 2, length($name) - 2); + } + + my $fmt_email = format_email($name, $address, $email_usename); + push(@fmt_emails, $fmt_email); + } + return @fmt_emails; +} + +sub merge_email { + my @lines; + my %saw; + + for (@_) { + my ($address, $role) = @$_; + if (!$saw{$address}) { + if ($output_roles) { + push(@lines, "$address ($role)"); + } else { + push(@lines, $address); + } + $saw{$address} = 1; + } + } + + return @lines; +} + +sub output { + my (@parms) = @_; + + if ($output_multiline) { + foreach my $line (@parms) { + print("${line}\n"); + } + } else { + print(join($output_separator, @parms)); + print("\n"); + } +} + +my $rfc822re; + +sub make_rfc822re { +# Basic lexical tokens are specials, domain_literal, quoted_string, atom, and +# comment. We must allow for rfc822_lwsp (or comments) after each of these. +# This regexp will only work on addresses which have had comments stripped +# and replaced with rfc822_lwsp. + + my $specials = '()<>@,;:\\\\".\\[\\]'; + my $controls = '\\000-\\037\\177'; + + my $dtext = "[^\\[\\]\\r\\\\]"; + my $domain_literal = "\\[(?:$dtext|\\\\.)*\\]$rfc822_lwsp*"; + + my $quoted_string = "\"(?:[^\\\"\\r\\\\]|\\\\.|$rfc822_lwsp)*\"$rfc822_lwsp*"; + +# Use zero-width assertion to spot the limit of an atom. A simple +# $rfc822_lwsp* causes the regexp engine to hang occasionally. + my $atom = "[^$specials $controls]+(?:$rfc822_lwsp+|\\Z|(?=[\\[\"$specials]))"; + my $word = "(?:$atom|$quoted_string)"; + my $localpart = "$word(?:\\.$rfc822_lwsp*$word)*"; + + my $sub_domain = "(?:$atom|$domain_literal)"; + my $domain = "$sub_domain(?:\\.$rfc822_lwsp*$sub_domain)*"; + + my $addr_spec = "$localpart\@$rfc822_lwsp*$domain"; + + my $phrase = "$word*"; + my $route = "(?:\@$domain(?:,\@$rfc822_lwsp*$domain)*:$rfc822_lwsp*)"; + my $route_addr = "\\<$rfc822_lwsp*$route?$addr_spec\\>$rfc822_lwsp*"; + my $mailbox = "(?:$addr_spec|$phrase$route_addr)"; + + my $group = "$phrase:$rfc822_lwsp*(?:$mailbox(?:,\\s*$mailbox)*)?;\\s*"; + my $address = "(?:$mailbox|$group)"; + + return "$rfc822_lwsp*$address"; +} + +sub rfc822_strip_comments { + my $s = shift; +# Recursively remove comments, and replace with a single space. The simpler +# regexps in the Email Addressing FAQ are imperfect - they will miss escaped +# chars in atoms, for example. + + while ($s =~ s/^((?:[^"\\]|\\.)* + (?:"(?:[^"\\]|\\.)*"(?:[^"\\]|\\.)*)*) + \((?:[^()\\]|\\.)*\)/$1 /osx) {} + return $s; +} + +# valid: returns true if the parameter is an RFC822 valid address +# +sub rfc822_valid { + my $s = rfc822_strip_comments(shift); + + if (!$rfc822re) { + $rfc822re = make_rfc822re(); + } + + return $s =~ m/^$rfc822re$/so && $s =~ m/^$rfc822_char*$/; +} + +# validlist: In scalar context, returns true if the parameter is an RFC822 +# valid list of addresses. +# +# In list context, returns an empty list on failure (an invalid +# address was found); otherwise a list whose first element is the +# number of addresses found and whose remaining elements are the +# addresses. This is needed to disambiguate failure (invalid) +# from success with no addresses found, because an empty string is +# a valid list. + +sub rfc822_validlist { + my $s = rfc822_strip_comments(shift); + + if (!$rfc822re) { + $rfc822re = make_rfc822re(); + } + # * null list items are valid according to the RFC + # * the '1' business is to aid in distinguishing failure from no results + + my @r; + if ($s =~ m/^(?:$rfc822re)?(?:,(?:$rfc822re)?)*$/so && + $s =~ m/^$rfc822_char*$/) { + while ($s =~ m/(?:^|,$rfc822_lwsp*)($rfc822re)/gos) { + push(@r, $1); + } + return wantarray ? (scalar(@r), @r) : 1; + } + return wantarray ? () : 0; +} -- 2.39.2 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from lists.sourceforge.net (lists.sourceforge.net [216.105.38.7]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id CF891C77B73 for ; Tue, 4 Apr 2023 17:14:43 +0000 (UTC) Received: from [127.0.0.1] (helo=sfs-ml-1.v29.lw.sourceforge.com) by sfs-ml-1.v29.lw.sourceforge.com with esmtp (Exim 4.95) (envelope-from ) id 1pjkF1-0000Cl-U9; Tue, 04 Apr 2023 17:14:43 +0000 Received: from [172.30.20.202] (helo=mx.sourceforge.net) by sfs-ml-1.v29.lw.sourceforge.com with esmtps (TLS1.2) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.95) (envelope-from ) id 1pjkEz-0000Cc-4L for linux-f2fs-devel@lists.sourceforge.net; Tue, 04 Apr 2023 17:14:40 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sourceforge.net; s=x; h=Content-Transfer-Encoding:Content-Type:MIME-Version :References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=3CgFjY4Q+YZeUtT9C4AwApscctqoidLpFYxE87Ke21M=; b=LoZ0EdDzifHvWZJBa82nxJ07mr NRA1rbVBbTcDyeWzu/iTTZOt0PBuAqRz5nZZjjU4v8QtQ/J6m+p50YvtZdmldunJt73lnx07UAb8Z utNa5kWvITBEDL38sroADWfauqqB3l8t4tN2RpfVJuJBGMWaOUtDmCBs8jSPfLp9hdm4=; DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sf.net; s=x ; h=Content-Transfer-Encoding:Content-Type:MIME-Version:References: In-Reply-To:Message-Id:Date:Subject:Cc:To:From:Sender:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=3CgFjY4Q+YZeUtT9C4AwApscctqoidLpFYxE87Ke21M=; b=KlIP209kT7BRxIZUkLWX77Uawx 5GJgHDcp7ciXPOIm7mxEM9147vXKmrR9gZhazOrTcWPt9jJvgHIC8m+r6U0bSaAvW1JoQfho2lZF7 zCH32mYhB/vnKSyp0QeEIFYiXOKExr2e7j1MAiTZ/T7B67E8FNFH/vczz3qB7nsmSof8=; Received: from dfw.source.kernel.org ([139.178.84.217]) by sfi-mx-2.v28.lw.sourceforge.com with esmtps (TLS1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.95) id 1pjkEv-0001ZF-GR for linux-f2fs-devel@lists.sourceforge.net; Tue, 04 Apr 2023 17:14:40 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id A8F7B63785; Tue, 4 Apr 2023 17:14:28 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id C11B1C433D2; Tue, 4 Apr 2023 17:14:21 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1680628468; bh=RDhAalIr7SbY9i/gonqpJqUhnY/gKX0tENUa/Gexl1c=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=hnz2sUUlVV0mBAJ7nZemrq3FX/QaQ9bz/plf8FINrTpgLYRyHbQcZZljDYYW68wZW tvMZ65XN1EjpTtuRMFaR6bB3XYR41nS9KJdbIEIz8D2fmBleQ++C6Yf1k26cLxpxuF +wWl0MTv/scHDZex8leGJwfxwIZFuPiU0q7htmH+8JAWLEaKaZtc+L8sM3Rzf/Q202 mJtkpUwWT0eKImgFrCFamFa2lOwPSXJJQj/7kcNNi7HPYMzEpuICmsCcbhfH0VyGoo 5qNTsbV2JsPEtwVFxxuY30g4a2tXMgc9Z9Z7NRW9i4XCfeRkRhJn3oqem+z957Dwi+ bps75EJMcjreQ== From: Zorro Lang To: fstests@vger.kernel.org Date: Wed, 5 Apr 2023 01:14:07 +0800 Message-Id: <20230404171411.699655-2-zlang@kernel.org> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20230404171411.699655-1-zlang@kernel.org> References: <20230404171411.699655-1-zlang@kernel.org> MIME-Version: 1.0 X-Headers-End: 1pjkEv-0001ZF-GR Subject: [f2fs-dev] [PATCH 1/5] fstests: add MAINTAINERS and get_maintainer.pl files X-BeenThere: linux-f2fs-devel@lists.sourceforge.net X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: brauner@kernel.org, linux-cifs@vger.kernel.org, linux-nfs@vger.kernel.org, ebiggers@google.com, djwong@kernel.org, amir73il@gmail.com, linux-unionfs@vger.kernel.org, anand.jain@oracle.com, linux-f2fs-devel@lists.sourceforge.net, linux-xfs@vger.kernel.org, fdmanana@suse.com, ocfs2-devel@oss.oracle.com, jack@suse.com, linux-fsdevel@vger.kernel.org, ceph-devel@vger.kernel.org, linux-ext4@vger.kernel.org, linux-btrfs@vger.kernel.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: linux-f2fs-devel-bounces@lists.sourceforge.net QXMgZnN0ZXN0cyBjb3ZlcnMgbW9yZSBhbmQgbW9yZSBmcyB0ZXN0aW5nLCBzbyB3ZSBhbHdheXMg Z2V0IGhlbHAKZnJvbSBmcyBzcGVjaWZpYyBtYWlsaW5nIGxpc3QsIGR1ZSB0byB0aGV5IGxlYXJu IGFib3V0IHRoZWlyIGZlYXR1cmVzCmFuZCBidWdzIG1vcmUuIEJlc2lkZXMgdGhhdCwgc29tZSBm b2xrcyBoZWxwIHRvIHJldmlldyBwYXRjaGVzCihyZWxldmFudCB3aXRoIHRoZW0pIG1vcmUgb2Z0 ZW4uCgpTbyBJJ2QgbGlrZSB0byBicmluZyBpbiB0aGUgc2ltaWxhciB3YXkgb2YgbGludXgvTUFJ TlRBSU5FUlMsIHJlY29yZHMKZnMgcmVsZXZhbnQgbWFpbGluZyBsaXN0cywgcmV2aWV3ZXJzIG9y IGNvLW1haW50YWluZXJzLiBUbyByZWNvZ25pemUKdGhlIGNvbnRyaWJ1dGlvbiBmcm9tIHRoZW0s IGFuZCBoZWxwIG1vcmUgdXNlcnMgdG8ga25vdyB3aG8gb3Igd2hhdAptYWlsaW5nIGxpc3QgY2Fu IGJlIGFkZGVkIGluIENDIGxpc3Qgb2YgYSBwYXRjaC4KClRoZSBNQUlOVEFJTkVSUyBhbmQgZ2V0 X21haW50YWluZXIucGwgYXJlIGNvcGllZCBmcm9tIGxpbnV4IHByb2plY3QsCnRoZW4gbWFkZSBz b21lIGNoYW5nZXMgZm9yIGZzdGVzdHMgc3BlY2lhbGx5LgoKU2lnbmVkLW9mZi1ieTogWm9ycm8g TGFuZyA8emxhbmdAa2VybmVsLm9yZz4KLS0tCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICB8ICAx MTYgKysKIHRvb2xzL2dldF9tYWludGFpbmVyLnBsIHwgMjYxNiArKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysKIDIgZmlsZXMgY2hhbmdlZCwgMjczMiBpbnNlcnRpb25zKCsp CiBjcmVhdGUgbW9kZSAxMDA2NDQgTUFJTlRBSU5FUlMKIGNyZWF0ZSBtb2RlIDEwMDc1NSB0b29s cy9nZXRfbWFpbnRhaW5lci5wbAoKZGlmZiAtLWdpdCBhL01BSU5UQUlORVJTIGIvTUFJTlRBSU5F UlMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAuLjA5YjFhNWEzCi0tLSAvZGV2 L251bGwKKysrIGIvTUFJTlRBSU5FUlMKQEAgLTAsMCArMSwxMTYgQEAKK0xpc3Qgb2YgcmV2aWV3 ZXJzLCBjby1tYWludGFpbmVycyBhbmQgaG93IHRvIHN1Ym1pdCBmc3Rlc3RzIGNoYW5nZXMKKz09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KKworUGxl YXNlIHRyeSB0byBmb2xsb3cgdGhlIGd1aWRlbGluZXMgYmVsb3cuICBUaGlzIHdpbGwgbWFrZSB0 aGluZ3MKK2Vhc2llciBvbiB0aGUgbWFpbnRhaW5lcnMuICBOb3QgYWxsIG9mIHRoZXNlIGd1aWRl bGluZXMgbWF0dGVyIGZvciBldmVyeQordHJpdmlhbCBwYXRjaCBzbyBhcHBseSBzb21lIGNvbW1v biBzZW5zZS4KKworVGlwcyBmb3IgcGF0Y2ggc3VibWl0dGVycworLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQorCisxLglBbHdheXMgKnRlc3QqIHlvdXIgY2hhbmdlcywgaG93ZXZlciBzbWFsbCwg b24gYXQgbGVhc3QgNCBvcgorCTUgcGVvcGxlLCBwcmVmZXJhYmx5IG1hbnkgbW9yZS4KKworMi4J TWFrZSBzdXJlIHlvdXIgY2hhbmdlcyBjb21waWxlIGNvcnJlY3RseSBpbiBtdWx0aXBsZQorCWNv bmZpZ3VyYXRpb25zLiBJbiBwYXJ0aWN1bGFyIGNoZWNrIHRoYXQgY2hhbmdlcyB3b3JrIGJvdGgg YXMgYQorCW1vZHVsZSBhbmQgYnVpbHQgaW50byB0aGUga2VybmVsLgorCiszLglXaGVuIHlvdSBh cmUgaGFwcHkgd2l0aCBhIGNoYW5nZSBtYWtlIGl0IGdlbmVyYWxseSBhdmFpbGFibGUgZm9yCisJ dGVzdGluZyBhbmQgYXdhaXQgZmVlZGJhY2suCisKKzQuCU1ha2UgYSBwYXRjaCBhdmFpbGFibGUg dG8gZnN0ZXN0c0AgbGlzdCBkaXJlY3RseSwgdGhhdCdzIHRoZSBvbmx5CisJb25lIG1haWxpbmcg bGlzdCB3aGljaCBtYWludGFpbiB0aGUgd2hvbGUgZnN0ZXN0cyBwcm9qZWN0LgorCisJUExFQVNF IENDOiB0aGUgcmVsZXZhbnQgcmV2aWV3ZXJzLCBjby1tYWludGFpbmVycyBhbmQgbWFpbGluZyBs aXN0cworCXRoYXQgYXJlIGdlbmVyYXRlZCBieSBgYHRvb2xzL2dldF9tYWludGFpbmVyLnBsLmBg CisKKwlQTEVBU0UgdHJ5IHRvIGluY2x1ZGUgYW55IGNyZWRpdCBsaW5lcyB5b3Ugd2FudCBhZGRl ZCB3aXRoIHRoZQorCXBhdGNoLiBJdCBhdm9pZHMgcGVvcGxlIGJlaW5nIG1pc3NlZCBvZmYgYnkg bWlzdGFrZSBhbmQgbWFrZXMKKwlpdCBlYXNpZXIgdG8ga25vdyB3aG8gd2FudHMgYWRkaW5nIGFu ZCB3aG8gZG9lc24ndC4KKworCVBMRUFTRSBkb2N1bWVudCBrbm93biBidWdzLiBJZiBpdCBkb2Vz bid0IHdvcmsgZm9yIGV2ZXJ5dGhpbmcKKwlvciBkb2VzIHNvbWV0aGluZyB2ZXJ5IG9kZCBvbmNl IGEgbW9udGggZG9jdW1lbnQgaXQuCisKKzUuCU1ha2Ugc3VyZSB5b3UgaGF2ZSB0aGUgcmlnaHQg dG8gc2VuZCBhbnkgY2hhbmdlcyB5b3UgbWFrZS4gSWYgeW91CisJZG8gY2hhbmdlcyBhdCB3b3Jr IHlvdSBtYXkgZmluZCB5b3VyIGVtcGxveWVyIG93bnMgdGhlIHBhdGNoCisJbm90IHlvdS4KKwor Ni4JSGFwcHkgaGFja2luZy4KKworRGVzY3JpcHRpb25zIG9mIHNlY3Rpb24gZW50cmllcyBhbmQg cHJlZmVycmVkIG9yZGVyCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0KKworCU06ICpNYWlsKiBwYXRjaGVzIHRvOiBGdWxsTmFtZSA8YWRkcmVzc0Bk b21haW4+CisJICAgVGhlc2UgcGVvcGxlIG1pZ2h0IGJlIGEgY28tbWFpbnRhaW5lciAod2l0aCBT dXBwb3J0ZWQgc3RhdHVzKSBvcgorCSAgIG1haW50YWluZXIgKHdpdGggTWFpbnRhaW5lZCBzdGF0 dXMpLgorCVI6IERlc2lnbmF0ZWQgKlJldmlld2VyKjogRnVsbE5hbWUgPGFkZHJlc3NAZG9tYWlu PgorCSAgIFRoZXNlIHJldmlld2VycyBzaG91bGQgYmUgQ0NlZCBvbiBwYXRjaGVzLgorCUw6IEJl c2lkZXMgZnN0ZXN0c0AgbGlzdCBpdHNlbGYsIHRoaXMgKk1haWxpbmcgbGlzdCogaXMgcmVsZXZh bnQgdG8KKwkgICB0aGlzIGFyZWEsIHNob3VsZCBiZSBDQ2VkLgorCVM6ICpTdGF0dXMqLCBvbmUg b2YgdGhlIGZvbGxvd2luZyAobm90ZTogYWxsIHRoaW5ncyBhcmUgbWFpbnRhaW5lZCBieQorCSAg IGZzdGVzdHNAdmdlci5rZXJuZWwub3JnKToKKwkgICBTdXBwb3J0ZWQ6CVNvbWVvbmUgaXMgYWN0 dWFsbHkgcGFpZCB0byBsb29rIGFmdGVyIHRoaXMuCisJICAgTWFpbnRhaW5lZDoJU29tZW9uZSBh Y3R1YWxseSBsb29rcyBhZnRlciBpdCwgaGFzIHRoZSBwcml2aWxlZ2UgdG8KKwkJCW1lcmdlICYg cHVzaC4KKwkgICBPZGQgRml4ZXM6CUl0IGhhcyBhIG1haW50YWluZXIgYnV0IHRoZXkgZG9uJ3Qg aGF2ZSB0aW1lIHRvIGRvCisJCQltdWNoIG90aGVyIHRoYW4gdGhyb3cgdGhlIG9kZCBwYXRjaCBp bi4gU2VlIGJlbG93Li4KKwkgICBPcnBoYW46CU5vIGN1cnJlbnQgbWFpbnRhaW5lciBbYnV0IG1h eWJlIHlvdSBjb3VsZCB0YWtlIHRoZQorCQkJcm9sZSBhcyB5b3Ugd3JpdGUgeW91ciBuZXcgY29k ZV0uCisJICAgT2Jzb2xldGU6CU9sZCBjb2RlLiBTb21ldGhpbmcgdGFnZ2VkIG9ic29sZXRlIGdl bmVyYWxseSBtZWFucworCQkJaXQgaGFzIGJlZW4gcmVwbGFjZWQgYnkgYSBiZXR0ZXIgc3lzdGVt IGFuZCB5b3UKKwkJCXNob3VsZCBiZSB1c2luZyB0aGF0LgorCVc6ICpXZWItcGFnZSogd2l0aCBz dGF0dXMvaW5mbworCVE6ICpQYXRjaHdvcmsqIHdlYiBiYXNlZCBwYXRjaCB0cmFja2luZyBzeXN0 ZW0gc2l0ZQorCUI6IFVSSSBmb3Igd2hlcmUgdG8gZmlsZSAqYnVncyouIEEgd2ViLXBhZ2Ugd2l0 aCBkZXRhaWxlZCBidWcKKwkgICBmaWxpbmcgaW5mbywgYSBkaXJlY3QgYnVnIHRyYWNrZXIgbGlu aywgb3IgYSBtYWlsdG86IFVSSS4KKwlDOiBVUkkgZm9yICpjaGF0KiBwcm90b2NvbCwgc2VydmVy IGFuZCBjaGFubmVsIHdoZXJlIGRldmVsb3BlcnMKKwkgICB1c3VhbGx5IGhhbmcgb3V0LCBmb3Ig ZXhhbXBsZSBpcmM6Ly9zZXJ2ZXIvY2hhbm5lbC4KKwlQOiBTdWJzeXN0ZW0gUHJvZmlsZSBkb2N1 bWVudCBmb3IgbW9yZSBkZXRhaWxzIHN1Ym1pdHRpbmcKKwkgICBwYXRjaGVzIHRvIHRoZSBnaXZl biBzdWJzeXN0ZW0uIFRoaXMgaXMgZWl0aGVyIGFuIGluLXRyZWUgZmlsZSwKKwkgICBvciBhIFVS SS4KKwlUOiAqU0NNKiB0cmVlIHR5cGUgYW5kIGxvY2F0aW9uLgorCSAgIFR5cGUgaXMgb25lIG9m OiBnaXQsIGhnLCBxdWlsdCwgc3RnaXQsIHRvcGdpdAorCUY6ICpGaWxlcyogYW5kIGRpcmVjdG9y aWVzIHdpbGRjYXJkIHBhdHRlcm5zLgorCSAgIEEgdHJhaWxpbmcgc2xhc2ggaW5jbHVkZXMgYWxs IGZpbGVzIGFuZCBzdWJkaXJlY3RvcnkgZmlsZXMuCisJICAgRjoJdGVzdHMveGZzLwlhbGwgZmls ZXMgaW4gYW5kIGJlbG93IHRlc3RzL3hmcworCSAgIEY6CXRlc3RzL2dlbmVyaWMvKglhbGwgZmls ZXMgaW4gdGVzdHMvZ2VuZXJpYywgYnV0IG5vdCBiZWxvdworCSAgIEY6CSovZXh0NC8qCWFsbCBm aWxlcyBpbiAiYW55IHRvcCBsZXZlbCBkaXJlY3RvcnkiL2V4dDQKKwkgICBPbmUgcGF0dGVybiBw ZXIgbGluZS4gIE11bHRpcGxlIEY6IGxpbmVzIGFjY2VwdGFibGUuCisJWDogKkV4Y2x1ZGVkKiBm aWxlcyBhbmQgZGlyZWN0b3JpZXMgdGhhdCBhcmUgTk9UIG1haW50YWluZWQsIHNhbWUKKwkgICBy dWxlcyBhcyBGOi4gRmlsZXMgZXhjbHVzaW9ucyBhcmUgdGVzdGVkIGJlZm9yZSBmaWxlIG1hdGNo ZXMuCisJICAgQ2FuIGJlIHVzZWZ1bCBmb3IgZXhjbHVkaW5nIGEgc3BlY2lmaWMgc3ViZGlyZWN0 b3J5LCBmb3IgaW5zdGFuY2U6CisJICAgRjoJc3JjLworCSAgIFg6CXNyYy92ZnMKKwkgICBtYXRj aGVzIGFsbCBmaWxlcyBpbiBhbmQgYmVsb3cgbmV0IGV4Y2x1ZGluZyBuZXQvaXB2Ni8KKwlOOiBG aWxlcyBhbmQgZGlyZWN0b3JpZXMgKlJlZ2V4KiBwYXR0ZXJucy4KKwkgICBOOglbXmEtel10ZWdy YQlhbGwgZmlsZXMgd2hvc2UgcGF0aCBjb250YWlucyB0ZWdyYQorCSAgICAgICAgICAgICAgICAg ICAgICAgIChub3QgaW5jbHVkaW5nIGZpbGVzIGxpa2UgaW50ZWdyYXRvcikKKwkgICBPbmUgcGF0 dGVybiBwZXIgbGluZS4gIE11bHRpcGxlIE46IGxpbmVzIGFjY2VwdGFibGUuCisJICAgdG9vbHMv Z2V0X21haW50YWluZXIucGwgaGFzIGRpZmZlcmVudCBiZWhhdmlvciBmb3IgZmlsZXMgdGhhdAor CSAgIG1hdGNoIEY6IHBhdHRlcm4gYW5kIG1hdGNoZXMgb2YgTjogcGF0dGVybnMuICBCeSBkZWZh dWx0LAorCSAgIGdldF9tYWludGFpbmVyIHdpbGwgbm90IGxvb2sgYXQgZ2l0IGxvZyBoaXN0b3J5 IHdoZW4gYW4gRjogcGF0dGVybgorCSAgIG1hdGNoIG9jY3Vycy4gIFdoZW4gYW4gTjogbWF0Y2gg b2NjdXJzLCBnaXQgbG9nIGhpc3RvcnkgaXMgdXNlZAorCSAgIHRvIGFsc28gbm90aWZ5IHRoZSBw ZW9wbGUgdGhhdCBoYXZlIGdpdCBjb21taXQgc2lnbmF0dXJlcy4KKwlLOiAqQ29udGVudCByZWdl eCogKHBlcmwgZXh0ZW5kZWQpIHBhdHRlcm4gbWF0Y2ggaW4gYSBwYXRjaCBvciBmaWxlLgorCSAg IEZvciBpbnN0YW5jZToKKwkgICBLOiBvZl9nZXRfcHJvZmlsZQorCSAgICAgIG1hdGNoZXMgcGF0 Y2hlcyBvciBmaWxlcyB0aGF0IGNvbnRhaW4gIm9mX2dldF9wcm9maWxlIgorCSAgIEs6IFxiKHBy aW50a3xwcl8oaW5mb3xlcnIpKVxiCisJICAgICAgbWF0Y2hlcyBwYXRjaGVzIG9yIGZpbGVzIHRo YXQgY29udGFpbiBvbmUgb3IgbW9yZSBvZiB0aGUgd29yZHMKKwkgICAgICBwcmludGssIHByX2lu Zm8gb3IgcHJfZXJyCisJICAgT25lIHJlZ2V4IHBhdHRlcm4gcGVyIGxpbmUuICBNdWx0aXBsZSBL OiBsaW5lcyBhY2NlcHRhYmxlLgorCitNYWludGFpbmVycyBMaXN0CistLS0tLS0tLS0tLS0tLS0t CisKKy4uIG5vdGU6OiBUaGUgd2hvbGUgZnN0ZXN0cyBhcmUgbWFpbnRhaW5lZCBieSBmc3Rlc3Rz QHZnZXIua2VybmVsLm9yZywgc28geW91CisJICBzaG91bGQgc2VuZCBwYXRjaCB0byBmc3Rlc3Rz QCBhdCBsZWFzdC4gT3RoZXIgcmVsZXZhbnQgbWFpbGluZyBsaXN0CisJICBvciByZXZpZXdlciBv ciBjby1tYWludGFpbmVyIGNhbiBiZSBpbiBjYyBsaXN0LgorCitBTEwKK006CVpvcnJvIExhbmcg PHpsYW5nQGtlcm5lbC5vcmc+CitMOglmc3Rlc3RzQHZnZXIua2VybmVsLm9yZworUzoJTWFpbnRh aW5lZAorVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vZnMveGZzL3hmc3Rlc3Rz LWRldi5naXQKK0Y6CSoKK0Y6CSovCmRpZmYgLS1naXQgYS90b29scy9nZXRfbWFpbnRhaW5lci5w bCBiL3Rvb2xzL2dldF9tYWludGFpbmVyLnBsCm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAw MDAwMDAwLi4zNzZjN2MwMgotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL2dldF9tYWludGFpbmVy LnBsCkBAIC0wLDAgKzEsMjYxNiBAQAorIyEvdXNyL2Jpbi9lbnYgcGVybAorIyBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMAorIworIyBUaGlzIHNjcmlwdCBpcyBjb3BpZWQgZnJvbSBs aW51eC9zY3JpcHRzL2dldF9tYWludGFpbmVyLnBsLCB0aGVuCisjIGNoYW5nZXMgZm9yIGZzdGVz dHMgc3BlY2lmaWNhbGx5LgorIworIyBQcmludCBzZWxlY3RlZCBNQUlOVEFJTkVSUyBpbmZvcm1h dGlvbiBmb3IKKyMgdGhlIGZpbGVzIG1vZGlmaWVkIGluIGEgcGF0Y2ggb3IgZm9yIGEgZmlsZQor IworIyB1c2FnZTogcGVybCB0b29scy9nZXRfbWFpbnRhaW5lci5wbCBbT1BUSU9OU10gPHBhdGNo PgorIyAgICAgICAgcGVybCB0b29scy9nZXRfbWFpbnRhaW5lci5wbCBbT1BUSU9OU10gLWYgPGZp bGU+CisKK3VzZSB3YXJuaW5nczsKK3VzZSBzdHJpY3Q7CisKK215ICRQID0gJDA7CitteSAkViA9 ICcwLjI2JzsKKwordXNlIEdldG9wdDo6TG9uZyBxdyg6Y29uZmlnIG5vX2F1dG9fYWJicmV2KTsK K3VzZSBDd2Q7Cit1c2UgRmlsZTo6RmluZDsKK3VzZSBGaWxlOjpTcGVjOjpGdW5jdGlvbnM7CisK K215ICRjdXJfcGF0aCA9IGZhc3RnZXRjd2QoKSAuICcvJzsKK215ICRsa19wYXRoID0gIi4vIjsK K215ICRlbWFpbCA9IDE7CitteSAkZW1haWxfdXNlbmFtZSA9IDE7CitteSAkZW1haWxfbWFpbnRh aW5lciA9IDE7CitteSAkZW1haWxfcmV2aWV3ZXIgPSAxOworbXkgJGVtYWlsX2ZpeGVzID0gMTsK K215ICRlbWFpbF9saXN0ID0gMTsKK215ICRlbWFpbF9tb2RlcmF0ZWRfbGlzdCA9IDE7CitteSAk ZW1haWxfc3Vic2NyaWJlcl9saXN0ID0gMDsKK215ICRlbWFpbF9naXRfcGVuZ3Vpbl9jaGllZnMg PSAwOworbXkgJGVtYWlsX2dpdCA9IDA7CitteSAkZW1haWxfZ2l0X2FsbF9zaWduYXR1cmVfdHlw ZXMgPSAwOworbXkgJGVtYWlsX2dpdF9ibGFtZSA9IDA7CitteSAkZW1haWxfZ2l0X2JsYW1lX3Np Z25hdHVyZXMgPSAxOworbXkgJGVtYWlsX2dpdF9mYWxsYmFjayA9IDE7CitteSAkZW1haWxfZ2l0 X21pbl9zaWduYXR1cmVzID0gMTsKK215ICRlbWFpbF9naXRfbWF4X21haW50YWluZXJzID0gNTsK K215ICRlbWFpbF9naXRfbWluX3BlcmNlbnQgPSA1OworbXkgJGVtYWlsX2dpdF9zaW5jZSA9ICIx LXllYXItYWdvIjsKK215ICRlbWFpbF9oZ19zaW5jZSA9ICItMzY1IjsKK215ICRpbnRlcmFjdGl2 ZSA9IDA7CitteSAkZW1haWxfcmVtb3ZlX2R1cGxpY2F0ZXMgPSAxOworbXkgJGVtYWlsX3VzZV9t YWlsbWFwID0gMTsKK215ICRvdXRwdXRfbXVsdGlsaW5lID0gMTsKK215ICRvdXRwdXRfc2VwYXJh dG9yID0gIiwgIjsKK215ICRvdXRwdXRfcm9sZXMgPSAwOworbXkgJG91dHB1dF9yb2xlc3RhdHMg PSAxOworbXkgJG91dHB1dF9zZWN0aW9uX21heGxlbiA9IDUwOworbXkgJHNjbSA9IDA7CitteSAk dHJlZSA9IDE7CitteSAkd2ViID0gMDsKK215ICRzdWJzeXN0ZW0gPSAwOworbXkgJHN0YXR1cyA9 IDA7CitteSAkbGV0dGVycyA9ICIiOworbXkgJGtleXdvcmRzID0gMTsKK215ICRzZWN0aW9ucyA9 IDA7CitteSAkZW1haWxfZmlsZV9lbWFpbHMgPSAwOworbXkgJGZyb21fZmlsZW5hbWUgPSAwOwor bXkgJHBhdHRlcm5fZGVwdGggPSAwOworbXkgJHNlbGZfdGVzdCA9IHVuZGVmOworbXkgJHZlcnNp b24gPSAwOworbXkgJGhlbHAgPSAwOworbXkgJGZpbmRfbWFpbnRhaW5lcl9maWxlcyA9IDA7Citt eSAkbWFpbnRhaW5lcl9wYXRoOworbXkgJHZjc191c2VkID0gMDsKKworbXkgJGV4aXQgPSAwOwor CitteSBAZmlsZXMgPSAoKTsKK215IEBmaXhlcyA9ICgpOwkJCSMgSWYgYSBwYXRjaCBkZXNjcmlw dGlvbiBpbmNsdWRlcyBGaXhlczogbGluZXMKK215IEByYW5nZSA9ICgpOworbXkgQGtleXdvcmRf dHZpID0gKCk7CitteSBAZmlsZV9lbWFpbHMgPSAoKTsKKworbXkgJWNvbW1pdF9hdXRob3JfaGFz aDsKK215ICVjb21taXRfc2lnbmVyX2hhc2g7CisKK215IEBwZW5ndWluX2NoaWVmID0gKCk7Citw dXNoKEBwZW5ndWluX2NoaWVmLCAiWm9ycm8gTGFuZzp6bGFuZ1xAa2VybmVsLm9yZyIpOworCitt eSBAcGVuZ3Vpbl9jaGllZl9uYW1lcyA9ICgpOworZm9yZWFjaCBteSAkY2hpZWYgKEBwZW5ndWlu X2NoaWVmKSB7CisgICAgaWYgKCRjaGllZiA9fiBtL14oLiopOiguKikvKSB7CisJbXkgJGNoaWVm X25hbWUgPSAkMTsKKwlteSAkY2hpZWZfYWRkciA9ICQyOworCXB1c2goQHBlbmd1aW5fY2hpZWZf bmFtZXMsICRjaGllZl9uYW1lKTsKKyAgICB9Cit9CitteSAkcGVuZ3Vpbl9jaGllZnMgPSAiXCgi IC4gam9pbigifCIsIEBwZW5ndWluX2NoaWVmX25hbWVzKSAuICJcKSI7CisKKyMgU2lnbmF0dXJl IHR5cGVzIG9mIHBlb3BsZSB3aG8gYXJlIGVpdGhlcgorIyAJYSkgcmVzcG9uc2libGUgZm9yIHRo ZSBjb2RlIGluIHF1ZXN0aW9uLCBvcgorIyAJYikgZmFtaWxpYXIgZW5vdWdoIHdpdGggaXQgdG8g Z2l2ZSByZWxldmFudCBmZWVkYmFjaworbXkgQHNpZ25hdHVyZV90YWdzID0gKCk7CitwdXNoKEBz aWduYXR1cmVfdGFncywgIlNpZ25lZC1vZmYtYnk6Iik7CitwdXNoKEBzaWduYXR1cmVfdGFncywg IlJldmlld2VkLWJ5OiIpOworcHVzaChAc2lnbmF0dXJlX3RhZ3MsICJBY2tlZC1ieToiKTsKKwor bXkgJHNpZ25hdHVyZV9wYXR0ZXJuID0gIlwoIiAuIGpvaW4oInwiLCBAc2lnbmF0dXJlX3RhZ3Mp IC4gIlwpIjsKKworIyByZmM4MjIgZW1haWwgYWRkcmVzcyAtIHByZWxvYWRlZCBtZXRob2RzIGdv IGhlcmUuCitteSAkcmZjODIyX2x3c3AgPSAiKD86KD86XFxyXFxuKT9bIFxcdF0pIjsKK215ICRy ZmM4MjJfY2hhciA9ICdbXFwwMDAtXFwzNzddJzsKKworIyBWQ1MgY29tbWFuZCBzdXBwb3J0OiBj bGFzcy1saWtlIGZ1bmN0aW9ucyBhbmQgc3RyaW5ncworCitteSAlVkNTX2NtZHM7CisKK215ICVW Q1NfY21kc19naXQgPSAoCisgICAgImV4ZWN1dGVfY21kIiA9PiBcJmdpdF9leGVjdXRlX2NtZCwK KyAgICAiYXZhaWxhYmxlIiA9PiAnKHdoaWNoKCJnaXQiKSBuZSAiIikgJiYgKC1lICIuZ2l0Iikn LAorICAgICJmaW5kX3NpZ25lcnNfY21kIiA9PgorCSJnaXQgbG9nIC0tbm8tY29sb3IgLS1mb2xs b3cgLS1zaW5jZT1cJGVtYWlsX2dpdF9zaW5jZSAiIC4KKwkgICAgJy0tbnVtc3RhdCAtLW5vLW1l cmdlcyAnIC4KKwkgICAgJy0tZm9ybWF0PSJHaXRDb21taXQ6ICVIJW4nIC4KKwkJICAgICAgJ0dp dEF1dGhvcjogJWFuIDwlYWU+JW4nIC4KKwkJICAgICAgJ0dpdERhdGU6ICVhRCVuJyAuCisJCSAg ICAgICdHaXRTdWJqZWN0OiAlcyVuJyAuCisJCSAgICAgICclYiVuIicgLgorCSAgICAiIC0tIFwk ZmlsZSIsCisgICAgImZpbmRfY29tbWl0X3NpZ25lcnNfY21kIiA9PgorCSJnaXQgbG9nIC0tbm8t Y29sb3IgIiAuCisJICAgICctLW51bXN0YXQgJyAuCisJICAgICctLWZvcm1hdD0iR2l0Q29tbWl0 OiAlSCVuJyAuCisJCSAgICAgICdHaXRBdXRob3I6ICVhbiA8JWFlPiVuJyAuCisJCSAgICAgICdH aXREYXRlOiAlYUQlbicgLgorCQkgICAgICAnR2l0U3ViamVjdDogJXMlbicgLgorCQkgICAgICAn JWIlbiInIC4KKwkgICAgIiAtMSBcJGNvbW1pdCIsCisgICAgImZpbmRfY29tbWl0X2F1dGhvcl9j bWQiID0+CisJImdpdCBsb2cgLS1uby1jb2xvciAiIC4KKwkgICAgJy0tbnVtc3RhdCAnIC4KKwkg ICAgJy0tZm9ybWF0PSJHaXRDb21taXQ6ICVIJW4nIC4KKwkJICAgICAgJ0dpdEF1dGhvcjogJWFu IDwlYWU+JW4nIC4KKwkJICAgICAgJ0dpdERhdGU6ICVhRCVuJyAuCisJCSAgICAgICdHaXRTdWJq ZWN0OiAlcyVuIicgLgorCSAgICAiIC0xIFwkY29tbWl0IiwKKyAgICAiYmxhbWVfcmFuZ2VfY21k IiA9PiAiZ2l0IGJsYW1lIC1sIC1MIFwkZGlmZl9zdGFydCwrXCRkaWZmX2xlbmd0aCBcJGZpbGUi LAorICAgICJibGFtZV9maWxlX2NtZCIgPT4gImdpdCBibGFtZSAtbCBcJGZpbGUiLAorICAgICJj b21taXRfcGF0dGVybiIgPT4gIl5HaXRDb21taXQ6IChbMC05YS1mXXs0MCw0MH0pIiwKKyAgICAi YmxhbWVfY29tbWl0X3BhdHRlcm4iID0+ICJeKFswLTlhLWZdKykgIiwKKyAgICAiYXV0aG9yX3Bh dHRlcm4iID0+ICJeR2l0QXV0aG9yOiAoLiopIiwKKyAgICAic3ViamVjdF9wYXR0ZXJuIiA9PiAi XkdpdFN1YmplY3Q6ICguKikiLAorICAgICJzdGF0X3BhdHRlcm4iID0+ICJeKFxcZCspXFx0KFxc ZCspXFx0XCRmaWxlXCQiLAorICAgICJmaWxlX2V4aXN0c19jbWQiID0+ICJnaXQgbHMtZmlsZXMg XCRmaWxlIiwKKyAgICAibGlzdF9maWxlc19jbWQiID0+ICJnaXQgbHMtZmlsZXMgXCRmaWxlIiwK Kyk7CisKK215ICVWQ1NfY21kc19oZyA9ICgKKyAgICAiZXhlY3V0ZV9jbWQiID0+IFwmaGdfZXhl Y3V0ZV9jbWQsCisgICAgImF2YWlsYWJsZSIgPT4gJyh3aGljaCgiaGciKSBuZSAiIikgJiYgKC1k ICIuaGciKScsCisgICAgImZpbmRfc2lnbmVyc19jbWQiID0+CisJImhnIGxvZyAtLWRhdGU9XCRl bWFpbF9oZ19zaW5jZSAiIC4KKwkgICAgIi0tdGVtcGxhdGU9J0hnQ29tbWl0OiB7bm9kZX1cXG4i IC4KKwkgICAgICAgICAgICAgICAgIkhnQXV0aG9yOiB7YXV0aG9yfVxcbiIgLgorCQkJIkhnU3Vi amVjdDoge2Rlc2N9XFxuJyIgLgorCSAgICAiIC0tIFwkZmlsZSIsCisgICAgImZpbmRfY29tbWl0 X3NpZ25lcnNfY21kIiA9PgorCSJoZyBsb2cgIiAuCisJICAgICItLXRlbXBsYXRlPSdIZ1N1Ympl Y3Q6IHtkZXNjfVxcbiciIC4KKwkgICAgIiAtciBcJGNvbW1pdCIsCisgICAgImZpbmRfY29tbWl0 X2F1dGhvcl9jbWQiID0+CisJImhnIGxvZyAiIC4KKwkgICAgIi0tdGVtcGxhdGU9J0hnQ29tbWl0 OiB7bm9kZX1cXG4iIC4KKwkJICAgICAgICAiSGdBdXRob3I6IHthdXRob3J9XFxuIiAuCisJCQki SGdTdWJqZWN0OiB7ZGVzY3xmaXJzdGxpbmV9XFxuJyIgLgorCSAgICAiIC1yIFwkY29tbWl0IiwK KyAgICAiYmxhbWVfcmFuZ2VfY21kIiA9PiAiIiwJCSMgbm90IHN1cHBvcnRlZAorICAgICJibGFt ZV9maWxlX2NtZCIgPT4gImhnIGJsYW1lIC1uIFwkZmlsZSIsCisgICAgImNvbW1pdF9wYXR0ZXJu IiA9PiAiXkhnQ29tbWl0OiAoWzAtOWEtZl17NDAsNDB9KSIsCisgICAgImJsYW1lX2NvbW1pdF9w YXR0ZXJuIiA9PiAiXihbIDAtOWEtZl0rKToiLAorICAgICJhdXRob3JfcGF0dGVybiIgPT4gIl5I Z0F1dGhvcjogKC4qKSIsCisgICAgInN1YmplY3RfcGF0dGVybiIgPT4gIl5IZ1N1YmplY3Q6ICgu KikiLAorICAgICJzdGF0X3BhdHRlcm4iID0+ICJeKFxcZCspXHQoXFxkKylcdFwkZmlsZVwkIiwK KyAgICAiZmlsZV9leGlzdHNfY21kIiA9PiAiaGcgZmlsZXMgXCRmaWxlIiwKKyAgICAibGlzdF9m aWxlc19jbWQiID0+ICJoZyBtYW5pZmVzdCAtUiBcJGZpbGUiLAorKTsKKworbXkgJGNvbmYgPSB3 aGljaF9jb25mKCIuZ2V0X21haW50YWluZXIuY29uZiIpOworaWYgKC1mICRjb25mKSB7CisgICAg bXkgQGNvbmZfYXJnczsKKyAgICBvcGVuKG15ICRjb25mZmlsZSwgJzwnLCAiJGNvbmYiKQorCW9y IHdhcm4gIiRQOiBDYW4ndCBmaW5kIGEgcmVhZGFibGUgLmdldF9tYWludGFpbmVyLmNvbmYgZmls ZSAkIVxuIjsKKworICAgIHdoaWxlICg8JGNvbmZmaWxlPikgeworCW15ICRsaW5lID0gJF87CisK KwkkbGluZSA9fiBzL1xzKlxuPyQvL2c7CisJJGxpbmUgPX4gcy9eXHMqLy9nOworCSRsaW5lID1+ IHMvXHMrLyAvZzsKKworCW5leHQgaWYgKCRsaW5lID1+IG0vXlxzKiMvKTsKKwluZXh0IGlmICgk bGluZSA9fiBtL15ccyokLyk7CisKKwlteSBAd29yZHMgPSBzcGxpdCgiICIsICRsaW5lKTsKKwlm b3JlYWNoIG15ICR3b3JkIChAd29yZHMpIHsKKwkgICAgbGFzdCBpZiAoJHdvcmQgPX4gbS9eIy8p OworCSAgICBwdXNoIChAY29uZl9hcmdzLCAkd29yZCk7CisJfQorICAgIH0KKyAgICBjbG9zZSgk Y29uZmZpbGUpOworICAgIHVuc2hpZnQoQEFSR1YsIEBjb25mX2FyZ3MpIGlmIEBjb25mX2FyZ3M7 Cit9CisKK215IEBpZ25vcmVfZW1haWxzID0gKCk7CitteSAkaWdub3JlX2ZpbGUgPSB3aGljaF9j b25mKCIuZ2V0X21haW50YWluZXIuaWdub3JlIik7CitpZiAoLWYgJGlnbm9yZV9maWxlKSB7Cisg ICAgb3BlbihteSAkaWdub3JlLCAnPCcsICIkaWdub3JlX2ZpbGUiKQorCW9yIHdhcm4gIiRQOiBD YW4ndCBmaW5kIGEgcmVhZGFibGUgLmdldF9tYWludGFpbmVyLmlnbm9yZSBmaWxlICQhXG4iOwor ICAgIHdoaWxlICg8JGlnbm9yZT4pIHsKKwlteSAkbGluZSA9ICRfOworCisJJGxpbmUgPX4gcy9c cypcbj8kLy87CisJJGxpbmUgPX4gcy9eXHMqLy87CisJJGxpbmUgPX4gcy9ccyskLy87CisJJGxp bmUgPX4gcy8jLiokLy87CisKKwluZXh0IGlmICgkbGluZSA9fiBtL15ccyokLyk7CisJaWYgKHJm YzgyMl92YWxpZCgkbGluZSkpIHsKKwkgICAgcHVzaChAaWdub3JlX2VtYWlscywgJGxpbmUpOwor CX0KKyAgICB9CisgICAgY2xvc2UoJGlnbm9yZSk7Cit9CisKK2lmICgkI0FSR1YgPiAwKSB7Cisg ICAgZm9yZWFjaCAoQEFSR1YpIHsKKyAgICAgICAgaWYgKCRfID1+IC9eLXsxLDJ9c2VsZi10ZXN0 KD86PXwkKS8pIHsKKyAgICAgICAgICAgIGRpZSAiJFA6IHVzaW5nIC0tc2VsZi10ZXN0IGRvZXMg bm90IGFsbG93IGFueSBvdGhlciBvcHRpb24gb3IgYXJndW1lbnRcbiI7CisgICAgICAgIH0KKyAg ICB9Cit9CisKK2lmICghR2V0T3B0aW9ucygKKwkJJ2VtYWlsIScgPT4gXCRlbWFpbCwKKwkJJ2dp dCEnID0+IFwkZW1haWxfZ2l0LAorCQknZ2l0LWFsbC1zaWduYXR1cmUtdHlwZXMhJyA9PiBcJGVt YWlsX2dpdF9hbGxfc2lnbmF0dXJlX3R5cGVzLAorCQknZ2l0LWJsYW1lIScgPT4gXCRlbWFpbF9n aXRfYmxhbWUsCisJCSdnaXQtYmxhbWUtc2lnbmF0dXJlcyEnID0+IFwkZW1haWxfZ2l0X2JsYW1l X3NpZ25hdHVyZXMsCisJCSdnaXQtZmFsbGJhY2shJyA9PiBcJGVtYWlsX2dpdF9mYWxsYmFjaywK KwkJJ2dpdC1jaGllZi1wZW5ndWlucyEnID0+IFwkZW1haWxfZ2l0X3Blbmd1aW5fY2hpZWZzLAor CQknZ2l0LW1pbi1zaWduYXR1cmVzPWknID0+IFwkZW1haWxfZ2l0X21pbl9zaWduYXR1cmVzLAor CQknZ2l0LW1heC1tYWludGFpbmVycz1pJyA9PiBcJGVtYWlsX2dpdF9tYXhfbWFpbnRhaW5lcnMs CisJCSdnaXQtbWluLXBlcmNlbnQ9aScgPT4gXCRlbWFpbF9naXRfbWluX3BlcmNlbnQsCisJCSdn aXQtc2luY2U9cycgPT4gXCRlbWFpbF9naXRfc2luY2UsCisJCSdoZy1zaW5jZT1zJyA9PiBcJGVt YWlsX2hnX3NpbmNlLAorCQknaXxpbnRlcmFjdGl2ZSEnID0+IFwkaW50ZXJhY3RpdmUsCisJCSdy ZW1vdmUtZHVwbGljYXRlcyEnID0+IFwkZW1haWxfcmVtb3ZlX2R1cGxpY2F0ZXMsCisJCSdtYWls bWFwIScgPT4gXCRlbWFpbF91c2VfbWFpbG1hcCwKKwkJJ20hJyA9PiBcJGVtYWlsX21haW50YWlu ZXIsCisJCSdyIScgPT4gXCRlbWFpbF9yZXZpZXdlciwKKwkJJ24hJyA9PiBcJGVtYWlsX3VzZW5h bWUsCisJCSdsIScgPT4gXCRlbWFpbF9saXN0LAorCQknZml4ZXMhJyA9PiBcJGVtYWlsX2ZpeGVz LAorCQknbW9kZXJhdGVkIScgPT4gXCRlbWFpbF9tb2RlcmF0ZWRfbGlzdCwKKwkJJ3MhJyA9PiBc JGVtYWlsX3N1YnNjcmliZXJfbGlzdCwKKwkJJ211bHRpbGluZSEnID0+IFwkb3V0cHV0X211bHRp bGluZSwKKwkJJ3JvbGVzIScgPT4gXCRvdXRwdXRfcm9sZXMsCisJCSdyb2xlc3RhdHMhJyA9PiBc JG91dHB1dF9yb2xlc3RhdHMsCisJCSdzZXBhcmF0b3I9cycgPT4gXCRvdXRwdXRfc2VwYXJhdG9y LAorCQknc3Vic3lzdGVtIScgPT4gXCRzdWJzeXN0ZW0sCisJCSdzdGF0dXMhJyA9PiBcJHN0YXR1 cywKKwkJJ3NjbSEnID0+IFwkc2NtLAorCQkndHJlZSEnID0+IFwkdHJlZSwKKwkJJ3dlYiEnID0+ IFwkd2ViLAorCQknbGV0dGVycz1zJyA9PiBcJGxldHRlcnMsCisJCSdwYXR0ZXJuLWRlcHRoPWkn ID0+IFwkcGF0dGVybl9kZXB0aCwKKwkJJ2t8a2V5d29yZHMhJyA9PiBcJGtleXdvcmRzLAorCQkn c2VjdGlvbnMhJyA9PiBcJHNlY3Rpb25zLAorCQknZmV8ZmlsZS1lbWFpbHMhJyA9PiBcJGVtYWls X2ZpbGVfZW1haWxzLAorCQknZnxmaWxlJyA9PiBcJGZyb21fZmlsZW5hbWUsCisJCSdmaW5kLW1h aW50YWluZXItZmlsZXMnID0+IFwkZmluZF9tYWludGFpbmVyX2ZpbGVzLAorCQknbXBhdGh8bWFp bnRhaW5lci1wYXRoPXMnID0+IFwkbWFpbnRhaW5lcl9wYXRoLAorCQknc2VsZi10ZXN0OnMnID0+ IFwkc2VsZl90ZXN0LAorCQkndnx2ZXJzaW9uJyA9PiBcJHZlcnNpb24sCisJCSdofGhlbHB8dXNh Z2UnID0+IFwkaGVscCwKKwkJKSkgeworICAgIGRpZSAiJFA6IGludmFsaWQgYXJndW1lbnQgLSB1 c2UgLS1oZWxwIGlmIG5lY2Vzc2FyeVxuIjsKK30KKworaWYgKCRoZWxwICE9IDApIHsKKyAgICB1 c2FnZSgpOworICAgIGV4aXQgMDsKK30KKworaWYgKCR2ZXJzaW9uICE9IDApIHsKKyAgICBwcmlu dCgiJHtQfSAke1Z9XG4iKTsKKyAgICBleGl0IDA7Cit9CisKK2lmIChkZWZpbmVkICRzZWxmX3Rl c3QpIHsKKyAgICByZWFkX2FsbF9tYWludGFpbmVyX2ZpbGVzKCk7CisgICAgc2VsZl90ZXN0KCk7 CisgICAgZXhpdCAwOworfQorCitpZiAoLXQgU1RESU4gJiYgIUBBUkdWKSB7CisgICAgIyBXZSdy ZSB0YWxraW5nIHRvIGEgdGVybWluYWwsIGJ1dCBoYXZlIG5vIGNvbW1hbmQgbGluZSBhcmd1bWVu dHMuCisgICAgZGllICIkUDogbWlzc2luZyBwYXRjaGZpbGUgb3IgLWYgZmlsZSAtIHVzZSAtLWhl bHAgaWYgbmVjZXNzYXJ5XG4iOworfQorCiskb3V0cHV0X211bHRpbGluZSA9IDAgaWYgKCRvdXRw dXRfc2VwYXJhdG9yIG5lICIsICIpOworJG91dHB1dF9yb2xlc3RhdHMgPSAxIGlmICgkaW50ZXJh Y3RpdmUpOworJG91dHB1dF9yb2xlcyA9IDEgaWYgKCRvdXRwdXRfcm9sZXN0YXRzKTsKKworaWYg KCRzZWN0aW9ucyB8fCAkbGV0dGVycyBuZSAiIikgeworICAgICRzZWN0aW9ucyA9IDE7CisgICAg JGVtYWlsID0gMDsKKyAgICAkZW1haWxfbGlzdCA9IDA7CisgICAgJHNjbSA9IDA7CisgICAgJHN0 YXR1cyA9IDA7CisgICAgJHN1YnN5c3RlbSA9IDA7CisgICAgJHdlYiA9IDA7CisgICAgJGtleXdv cmRzID0gMDsKKyAgICAkaW50ZXJhY3RpdmUgPSAwOworfSBlbHNlIHsKKyAgICBteSAkc2VsZWN0 aW9ucyA9ICRlbWFpbCArICRzY20gKyAkc3RhdHVzICsgJHN1YnN5c3RlbSArICR3ZWI7CisgICAg aWYgKCRzZWxlY3Rpb25zID09IDApIHsKKwlkaWUgIiRQOiAgTWlzc2luZyByZXF1aXJlZCBvcHRp b246IGVtYWlsLCBzY20sIHN0YXR1cywgc3Vic3lzdGVtIG9yIHdlYlxuIjsKKyAgICB9Cit9CisK K2lmICgkZW1haWwgJiYKKyAgICAoJGVtYWlsX21haW50YWluZXIgKyAkZW1haWxfcmV2aWV3ZXIg KworICAgICAkZW1haWxfbGlzdCArICRlbWFpbF9zdWJzY3JpYmVyX2xpc3QgKworICAgICAkZW1h aWxfZ2l0ICsgJGVtYWlsX2dpdF9wZW5ndWluX2NoaWVmcyArICRlbWFpbF9naXRfYmxhbWUpID09 IDApIHsKKyAgICBkaWUgIiRQOiBQbGVhc2Ugc2VsZWN0IGF0IGxlYXN0IDEgZW1haWwgb3B0aW9u XG4iOworfQorCitpZiAoJHRyZWUgJiYgIXRvcF9vZl9mc3Rlc3RzX3RyZWUoJGxrX3BhdGgpKSB7 CisgICAgZGllICIkUDogVGhlIGN1cnJlbnQgZGlyZWN0b3J5IGRvZXMgbm90IGFwcGVhciB0byBi ZSAiCisJLiAiYSBmc3Rlc3RzIHNvdXJjZSB0cmVlLlxuIjsKK30KKworIyMgUmVhZCBNQUlOVEFJ TkVSUyBmb3IgdHlwZS92YWx1ZSBwYWlycworCitteSBAdHlwZXZhbHVlID0gKCk7CitteSAla2V5 d29yZF9oYXNoOworbXkgQG1maWxlcyA9ICgpOworbXkgQHNlbGZfdGVzdF9pbmZvID0gKCk7CisK K3N1YiByZWFkX21haW50YWluZXJfZmlsZSB7CisgICAgbXkgKCRmaWxlKSA9IEBfOworCisgICAg b3BlbiAobXkgJG1haW50LCAnPCcsICIkZmlsZSIpCisJb3IgZGllICIkUDogQ2FuJ3Qgb3BlbiBN QUlOVEFJTkVSUyBmaWxlICckZmlsZSc6ICQhXG4iOworICAgIG15ICRpID0gMTsKKyAgICB3aGls ZSAoPCRtYWludD4pIHsKKwlteSAkbGluZSA9ICRfOworCWNob21wICRsaW5lOworCisJaWYgKCRs aW5lID1+IG0vXihbQS1aXSk6XHMqKC4qKS8pIHsKKwkgICAgbXkgJHR5cGUgPSAkMTsKKwkgICAg bXkgJHZhbHVlID0gJDI7CisKKwkgICAgIyNGaWxlbmFtZSBwYXR0ZXJuIG1hdGNoaW5nCisJICAg IGlmICgkdHlwZSBlcSAiRiIgfHwgJHR5cGUgZXEgIlgiKSB7CisJCSR2YWx1ZSA9fiBzQFwuQFxc XC5AZzsgICAgICAgIyNDb252ZXJ0IC4gdG8gXC4KKwkJJHZhbHVlID1+IHMvXCovXC5cKi9nOyAg ICAgICAjI0NvbnZlcnQgKiB0byAuKgorCQkkdmFsdWUgPX4gcy9cPy9cLi9nOyAgICAgICAgICMj Q29udmVydCA/IHRvIC4KKwkJIyNpZiBwYXR0ZXJuIGlzIGEgZGlyZWN0b3J5IGFuZCBpdCBsYWNr cyBhIHRyYWlsaW5nIHNsYXNoLCBhZGQgb25lCisJCWlmICgoLWQgJHZhbHVlKSkgeworCQkgICAg JHZhbHVlID1+IHNAKFteL10pJEAkMS9AOworCQl9CisJICAgIH0gZWxzaWYgKCR0eXBlIGVxICJL IikgeworCQkka2V5d29yZF9oYXNoe0B0eXBldmFsdWV9ID0gJHZhbHVlOworCSAgICB9CisJICAg IHB1c2goQHR5cGV2YWx1ZSwgIiR0eXBlOiR2YWx1ZSIpOworCX0gZWxzaWYgKCEoL15ccyokLyB8 fCAvXlxzKlwjLykpIHsKKwkgICAgcHVzaChAdHlwZXZhbHVlLCAkbGluZSk7CisJfQorCWlmIChk ZWZpbmVkICRzZWxmX3Rlc3QpIHsKKwkgICAgcHVzaChAc2VsZl90ZXN0X2luZm8sIHtmaWxlPT4k ZmlsZSwgbGluZW5yPT4kaSwgbGluZT0+JGxpbmV9KTsKKwl9CisJJGkrKzsKKyAgICB9CisgICAg Y2xvc2UoJG1haW50KTsKK30KKworc3ViIGZpbmRfaXNfbWFpbnRhaW5lcl9maWxlIHsKKyAgICBt eSAoJGZpbGUpID0gJF87CisgICAgcmV0dXJuIGlmICgkZmlsZSAhfiBtQC9NQUlOVEFJTkVSUyRA KTsKKyAgICAkZmlsZSA9ICRGaWxlOjpGaW5kOjpuYW1lOworICAgIHJldHVybiBpZiAoISAtZiAk ZmlsZSk7CisgICAgcHVzaChAbWZpbGVzLCAkZmlsZSk7Cit9CisKK3N1YiBmaW5kX2lnbm9yZV9n aXQgeworICAgIHJldHVybiBncmVwIHsgJF8gIX4gL15cLmdpdCQvOyB9IEBfOworfQorCityZWFk X2FsbF9tYWludGFpbmVyX2ZpbGVzKCk7CisKK3N1YiByZWFkX2FsbF9tYWludGFpbmVyX2ZpbGVz IHsKKyAgICBteSAkcGF0aCA9ICIke2xrX3BhdGh9TUFJTlRBSU5FUlMiOworICAgIGlmIChkZWZp bmVkICRtYWludGFpbmVyX3BhdGgpIHsKKwkkcGF0aCA9ICRtYWludGFpbmVyX3BhdGg7CisJIyBQ ZXJsIENvb2tib29rIHRpbGRlIGV4cGFuc2lvbiBpZiBuZWNlc3NhcnkKKwkkcGF0aCA9fiBzQF5+ KFteL10qKUAgJDEgPyAoZ2V0cHduYW0oJDEpKVs3XSA6ICggJEVOVntIT01FfSB8fCAkRU5We0xP R0RJUn0gfHwgKGdldHB3dWlkKCQ8KSlbN10pQGV4OworICAgIH0KKworICAgIGlmICgtZCAkcGF0 aCkgeworCSRwYXRoIC49ICcvJyBpZiAoJHBhdGggIX4gbUAvJEApOworCWlmICgkZmluZF9tYWlu dGFpbmVyX2ZpbGVzKSB7CisJICAgIGZpbmQoIHsgd2FudGVkID0+IFwmZmluZF9pc19tYWludGFp bmVyX2ZpbGUsCisJCSAgICBwcmVwcm9jZXNzID0+IFwmZmluZF9pZ25vcmVfZ2l0LAorCQkgICAg bm9fY2hkaXIgPT4gMSwKKwkJfSwgIiRwYXRoIik7CisJfSBlbHNlIHsKKwkgICAgb3BlbmRpcihE SVIsICIkcGF0aCIpIG9yIGRpZSAkITsKKwkgICAgbXkgQGZpbGVzID0gcmVhZGRpcihESVIpOwor CSAgICBjbG9zZWRpcihESVIpOworCSAgICBmb3JlYWNoIG15ICRmaWxlIChAZmlsZXMpIHsKKwkJ cHVzaChAbWZpbGVzLCAiJHBhdGgkZmlsZSIpIGlmICgkZmlsZSAhfiAvXlwuLyk7CisJICAgIH0K Kwl9CisgICAgfSBlbHNpZiAoLWYgIiRwYXRoIikgeworCXB1c2goQG1maWxlcywgIiRwYXRoIik7 CisgICAgfSBlbHNlIHsKKwlkaWUgIiRQOiBNQUlOVEFJTkVSIGZpbGUgbm90IGZvdW5kICckcGF0 aCdcbiI7CisgICAgfQorICAgIGRpZSAiJFA6IE5vIE1BSU5UQUlORVIgZmlsZXMgZm91bmQgaW4g JyRwYXRoJ1xuIiBpZiAoc2NhbGFyKEBtZmlsZXMpID09IDApOworICAgIGZvcmVhY2ggbXkgJGZp bGUgKEBtZmlsZXMpIHsKKwlyZWFkX21haW50YWluZXJfZmlsZSgiJGZpbGUiKTsKKyAgICB9Cit9 CisKK3N1YiBtYWludGFpbmVyc19pbl9maWxlIHsKKyAgICBteSAoJGZpbGUpID0gQF87CisKKyAg ICByZXR1cm4gaWYgKCRmaWxlID1+IG1AXGJNQUlOVEFJTkVSUyRAKTsKKworICAgIGlmICgtZiAk ZmlsZSAmJiAoJGVtYWlsX2ZpbGVfZW1haWxzIHx8ICRmaWxlID1+IC9cLnlhbWwkLykpIHsKKwlv cGVuKG15ICRmLCAnPCcsICRmaWxlKQorCSAgICBvciBkaWUgIiRQOiBDYW4ndCBvcGVuICRmaWxl OiAkIVxuIjsKKwlteSAkdGV4dCA9IGRvIHsgbG9jYWwoJC8pIDsgPCRmPiB9OworCWNsb3NlKCRm KTsKKworCW15IEBwb3NzX2FkZHIgPSAkdGV4dCA9fiBtJFtBLVphLXrDgC3Dv1wiXCcgXCxcLlwr LV0qXHMqW1wsXSpccypbXChcPFx7XXswLDF9W0EtWmEtejAtOV9cLlwrLV0rXEBbQS1aYS16MC05 XC4tXStcLltBLVphLXowLTldK1tcKVw+XH1dezAsMX0kZzsKKwlwdXNoKEBmaWxlX2VtYWlscywg Y2xlYW5fZmlsZV9lbWFpbHMoQHBvc3NfYWRkcikpOworICAgIH0KK30KKworIworIyBSZWFkIG1h aWwgYWRkcmVzcyBtYXAKKyMKKworbXkgJG1haWxtYXA7CisKK3JlYWRfbWFpbG1hcCgpOworCitz dWIgcmVhZF9tYWlsbWFwIHsKKyAgICAkbWFpbG1hcCA9IHsKKwluYW1lcyA9PiB7fSwKKwlhZGRy ZXNzZXMgPT4ge30KKyAgICB9OworCisgICAgcmV0dXJuIGlmICghJGVtYWlsX3VzZV9tYWlsbWFw IHx8ICEoLWYgIiR7bGtfcGF0aH0ubWFpbG1hcCIpKTsKKworICAgIG9wZW4obXkgJG1haWxtYXBf ZmlsZSwgJzwnLCAiJHtsa19wYXRofS5tYWlsbWFwIikKKwlvciB3YXJuICIkUDogQ2FuJ3Qgb3Bl biAubWFpbG1hcDogJCFcbiI7CisKKyAgICB3aGlsZSAoPCRtYWlsbWFwX2ZpbGU+KSB7CisJcy8j LiokLy87ICNzdHJpcCBjb21tZW50cworCXMvXlxzK3xccyskLy9nOyAjdHJpbQorCisJbmV4dCBp ZiAoL15ccyokLyk7ICNza2lwIGVtcHR5IGxpbmVzCisJI2VudHJpZXMgaGF2ZSBvbmUgb2YgdGhl IGZvbGxvd2luZyBmb3JtYXRzOgorCSMgbmFtZTEgPG1haWwxPgorCSMgPG1haWwxPiA8bWFpbDI+ CisJIyBuYW1lMSA8bWFpbDE+IDxtYWlsMj4KKwkjIG5hbWUxIDxtYWlsMT4gbmFtZTIgPG1haWwy PgorCSMgKHNlZSBtYW4gZ2l0LXNob3J0bG9nKQorCisJaWYgKC9eKFtePF0rKTwoW14+XSspPiQv KSB7CisJICAgIG15ICRyZWFsX25hbWUgPSAkMTsKKwkgICAgbXkgJGFkZHJlc3MgPSAkMjsKKwor CSAgICAkcmVhbF9uYW1lID1+IHMvXHMrJC8vOworCSAgICAoJHJlYWxfbmFtZSwgJGFkZHJlc3Mp ID0gcGFyc2VfZW1haWwoIiRyZWFsX25hbWUgPCRhZGRyZXNzPiIpOworCSAgICAkbWFpbG1hcC0+ e25hbWVzfS0+eyRhZGRyZXNzfSA9ICRyZWFsX25hbWU7CisKKwl9IGVsc2lmICgvXjwoW14+XSsp PlxzKjwoW14+XSspPiQvKSB7CisJICAgIG15ICRyZWFsX2FkZHJlc3MgPSAkMTsKKwkgICAgbXkg JHdyb25nX2FkZHJlc3MgPSAkMjsKKworCSAgICAkbWFpbG1hcC0+e2FkZHJlc3Nlc30tPnskd3Jv bmdfYWRkcmVzc30gPSAkcmVhbF9hZGRyZXNzOworCisJfSBlbHNpZiAoL14oLispPChbXj5dKyk+ XHMqPChbXj5dKyk+JC8pIHsKKwkgICAgbXkgJHJlYWxfbmFtZSA9ICQxOworCSAgICBteSAkcmVh bF9hZGRyZXNzID0gJDI7CisJICAgIG15ICR3cm9uZ19hZGRyZXNzID0gJDM7CisKKwkgICAgJHJl YWxfbmFtZSA9fiBzL1xzKyQvLzsKKwkgICAgKCRyZWFsX25hbWUsICRyZWFsX2FkZHJlc3MpID0K KwkJcGFyc2VfZW1haWwoIiRyZWFsX25hbWUgPCRyZWFsX2FkZHJlc3M+Iik7CisJICAgICRtYWls bWFwLT57bmFtZXN9LT57JHdyb25nX2FkZHJlc3N9ID0gJHJlYWxfbmFtZTsKKwkgICAgJG1haWxt YXAtPnthZGRyZXNzZXN9LT57JHdyb25nX2FkZHJlc3N9ID0gJHJlYWxfYWRkcmVzczsKKworCX0g ZWxzaWYgKC9eKC4rKTwoW14+XSspPlxzKiguKylccyo8KFtePl0rKT4kLykgeworCSAgICBteSAk cmVhbF9uYW1lID0gJDE7CisJICAgIG15ICRyZWFsX2FkZHJlc3MgPSAkMjsKKwkgICAgbXkgJHdy b25nX25hbWUgPSAkMzsKKwkgICAgbXkgJHdyb25nX2FkZHJlc3MgPSAkNDsKKworCSAgICAkcmVh bF9uYW1lID1+IHMvXHMrJC8vOworCSAgICAoJHJlYWxfbmFtZSwgJHJlYWxfYWRkcmVzcykgPQor CQlwYXJzZV9lbWFpbCgiJHJlYWxfbmFtZSA8JHJlYWxfYWRkcmVzcz4iKTsKKworCSAgICAkd3Jv bmdfbmFtZSA9fiBzL1xzKyQvLzsKKwkgICAgKCR3cm9uZ19uYW1lLCAkd3JvbmdfYWRkcmVzcykg PQorCQlwYXJzZV9lbWFpbCgiJHdyb25nX25hbWUgPCR3cm9uZ19hZGRyZXNzPiIpOworCisJICAg IG15ICR3cm9uZ19lbWFpbCA9IGZvcm1hdF9lbWFpbCgkd3JvbmdfbmFtZSwgJHdyb25nX2FkZHJl c3MsIDEpOworCSAgICAkbWFpbG1hcC0+e25hbWVzfS0+eyR3cm9uZ19lbWFpbH0gPSAkcmVhbF9u YW1lOworCSAgICAkbWFpbG1hcC0+e2FkZHJlc3Nlc30tPnskd3JvbmdfZW1haWx9ID0gJHJlYWxf YWRkcmVzczsKKwl9CisgICAgfQorICAgIGNsb3NlKCRtYWlsbWFwX2ZpbGUpOworfQorCisjIyB1 c2UgdGhlIGZpbGVuYW1lcyBvbiB0aGUgY29tbWFuZCBsaW5lIG9yIGZpbmQgdGhlIGZpbGVuYW1l cyBpbiB0aGUgcGF0Y2hmaWxlcworCitpZiAoIUBBUkdWKSB7CisgICAgcHVzaChAQVJHViwgIiZT VERJTiIpOworfQorCitmb3JlYWNoIG15ICRmaWxlIChAQVJHVikgeworICAgIGlmICgkZmlsZSBu ZSAiJlNURElOIikgeworCSRmaWxlID0gY2Fub25wYXRoKCRmaWxlKTsKKwkjI2lmICRmaWxlIGlz IGEgZGlyZWN0b3J5IGFuZCBpdCBsYWNrcyBhIHRyYWlsaW5nIHNsYXNoLCBhZGQgb25lCisJaWYg KCgtZCAkZmlsZSkpIHsKKwkgICAgJGZpbGUgPX4gc0AoW14vXSkkQCQxL0A7CisJfSBlbHNpZiAo ISgtZiAkZmlsZSkpIHsKKwkgICAgZGllICIkUDogZmlsZSAnJHtmaWxlfScgbm90IGZvdW5kXG4i OworCX0KKyAgICB9CisgICAgaWYgKCRmcm9tX2ZpbGVuYW1lICYmICh2Y3NfZXhpc3RzKCkgJiYg IXZjc19maWxlX2V4aXN0cygkZmlsZSkpKSB7CisJd2FybiAiJFA6IGZpbGUgJyRmaWxlJyBub3Qg Zm91bmQgaW4gdmVyc2lvbiBjb250cm9sICQhXG4iOworICAgIH0KKyAgICBpZiAoJGZyb21fZmls ZW5hbWUgfHwgKCRmaWxlIG5lICImU1RESU4iICYmIHZjc19maWxlX2V4aXN0cygkZmlsZSkpKSB7 CisJJGZpbGUgPX4gcy9eXFEke2N1cl9wYXRofVxFLy87CSNzdHJpcCBhbnkgYWJzb2x1dGUgcGF0 aAorCSRmaWxlID1+IHMvXlxRJHtsa19wYXRofVxFLy87CSNvciB0aGUgcGF0aCB0byB0aGUgbGsg dHJlZQorCXB1c2goQGZpbGVzLCAkZmlsZSk7CisJaWYgKCRmaWxlIG5lICJNQUlOVEFJTkVSUyIg JiYgLWYgJGZpbGUgJiYgJGtleXdvcmRzKSB7CisJICAgIG9wZW4obXkgJGYsICc8JywgJGZpbGUp CisJCW9yIGRpZSAiJFA6IENhbid0IG9wZW4gJGZpbGU6ICQhXG4iOworCSAgICBteSAkdGV4dCA9 IGRvIHsgbG9jYWwoJC8pIDsgPCRmPiB9OworCSAgICBjbG9zZSgkZik7CisJICAgIGlmICgka2V5 d29yZHMpIHsKKwkJZm9yZWFjaCBteSAkbGluZSAoa2V5cyAla2V5d29yZF9oYXNoKSB7CisJCSAg ICBpZiAoJHRleHQgPX4gbS8ka2V5d29yZF9oYXNoeyRsaW5lfS94KSB7CisJCQlwdXNoKEBrZXl3 b3JkX3R2aSwgJGxpbmUpOworCQkgICAgfQorCQl9CisJICAgIH0KKwl9CisgICAgfSBlbHNlIHsK KwlteSAkZmlsZV9jbnQgPSBAZmlsZXM7CisJbXkgJGxhc3RmaWxlOworCisJb3BlbihteSAkcGF0 Y2gsICI8ICRmaWxlIikKKwkgICAgb3IgZGllICIkUDogQ2FuJ3Qgb3BlbiAkZmlsZTogJCFcbiI7 CisKKwkjIFdlIGNhbiBjaGVjayBhcmJpdHJhcnkgaW5mb3JtYXRpb24gYmVmb3JlIHRoZSBwYXRj aAorCSMgbGlrZSB0aGUgY29tbWl0IG1lc3NhZ2UsIG1haWwgaGVhZGVycywgZXRjLi4uCisJIyBU aGlzIGFsbG93cyB1cyB0byBtYXRjaCBhcmJpdHJhcnkga2V5d29yZHMgYWdhaW5zdCBhbnkgcGFy dAorCSMgb2YgYSBnaXQgZm9ybWF0LXBhdGNoIGdlbmVyYXRlZCBmaWxlIChzdWJqZWN0IHRhZ3Ms IGV0Yy4uLikKKworCW15ICRwYXRjaF9wcmVmaXggPSAiIjsJCQkjUGFyc2luZyB0aGUgaW50cm8K KworCXdoaWxlICg8JHBhdGNoPikgeworCSAgICBteSAkcGF0Y2hfbGluZSA9ICRfOworCSAgICBp ZiAobS9eIG1vZGUgY2hhbmdlIFswLTddKyA9PiBbMC03XSsgKFxTKylccyokLykgeworCQlteSAk ZmlsZW5hbWUgPSAkMTsKKwkJcHVzaChAZmlsZXMsICRmaWxlbmFtZSk7CisJICAgIH0gZWxzaWYg KG0vXnJlbmFtZSAoPzpmcm9tfHRvKSAoXFMrKVxzKiQvKSB7CisJCW15ICRmaWxlbmFtZSA9ICQx OworCQlwdXNoKEBmaWxlcywgJGZpbGVuYW1lKTsKKwkgICAgfSBlbHNpZiAobS9eZGlmZiAtLWdp dCBhXC8oXFMrKSBiXC8oXFMrKVxzKiQvKSB7CisJCW15ICRmaWxlbmFtZTEgPSAkMTsKKwkJbXkg JGZpbGVuYW1lMiA9ICQyOworCQlwdXNoKEBmaWxlcywgJGZpbGVuYW1lMSk7CisJCXB1c2goQGZp bGVzLCAkZmlsZW5hbWUyKTsKKwkgICAgfSBlbHNpZiAobS9eRml4ZXM6XHMrKFswLTlhLWZBLUZd ezYsNDB9KS8pIHsKKwkJcHVzaChAZml4ZXMsICQxKSBpZiAoJGVtYWlsX2ZpeGVzKTsKKwkgICAg fSBlbHNpZiAobS9eXCtcK1wrXHMrKFxTKykvIG9yIG0vXi0tLVxzKyhcUyspLykgeworCQlteSAk ZmlsZW5hbWUgPSAkMTsKKwkJJGZpbGVuYW1lID1+IHNAXlteL10qL0BAOworCQkkZmlsZW5hbWUg PX4gc0BcbkBAOworCQkkbGFzdGZpbGUgPSAkZmlsZW5hbWU7CisJCXB1c2goQGZpbGVzLCAkZmls ZW5hbWUpOworCQkkcGF0Y2hfcHJlZml4ID0gIl5bKy1dLioiOwkjTm93IHBhcnNpbmcgdGhlIGFj dHVhbCBwYXRjaAorCSAgICB9IGVsc2lmIChtL15cQFxAIC0oXGQrKSwoXGQrKS8pIHsKKwkJaWYg KCRlbWFpbF9naXRfYmxhbWUpIHsKKwkJICAgIHB1c2goQHJhbmdlLCAiJGxhc3RmaWxlOiQxOiQy Iik7CisJCX0KKwkgICAgfSBlbHNpZiAoJGtleXdvcmRzKSB7CisJCWZvcmVhY2ggbXkgJGxpbmUg KGtleXMgJWtleXdvcmRfaGFzaCkgeworCQkgICAgaWYgKCRwYXRjaF9saW5lID1+IG0vJHtwYXRj aF9wcmVmaXh9JGtleXdvcmRfaGFzaHskbGluZX0veCkgeworCQkJcHVzaChAa2V5d29yZF90dmks ICRsaW5lKTsKKwkJICAgIH0KKwkJfQorCSAgICB9CisJfQorCWNsb3NlKCRwYXRjaCk7CisKKwlp ZiAoJGZpbGVfY250ID09IEBmaWxlcykgeworCSAgICB3YXJuICIkUDogZmlsZSAnJHtmaWxlfScg ZG9lc24ndCBhcHBlYXIgdG8gYmUgYSBwYXRjaC4gICIKKwkJLiAiQWRkIC1mIHRvIG9wdGlvbnM/ XG4iOworCX0KKwlAZmlsZXMgPSBzb3J0X2FuZF91bmlxKEBmaWxlcyk7CisgICAgfQorfQorCitA ZmlsZV9lbWFpbHMgPSB1bmlxKEBmaWxlX2VtYWlscyk7CitAZml4ZXMgPSB1bmlxKEBmaXhlcyk7 CisKK215ICVlbWFpbF9oYXNoX25hbWU7CitteSAlZW1haWxfaGFzaF9hZGRyZXNzOworbXkgQGVt YWlsX3RvID0gKCk7CitteSAlaGFzaF9saXN0X3RvOworbXkgQGxpc3RfdG8gPSAoKTsKK215IEBz Y20gPSAoKTsKK215IEB3ZWIgPSAoKTsKK215IEBzdWJzeXN0ZW0gPSAoKTsKK215IEBzdGF0dXMg PSAoKTsKK215ICVkZWR1cGxpY2F0ZV9uYW1lX2hhc2ggPSAoKTsKK215ICVkZWR1cGxpY2F0ZV9h ZGRyZXNzX2hhc2ggPSAoKTsKKworbXkgQG1haW50YWluZXJzID0gZ2V0X21haW50YWluZXJzKCk7 CitpZiAoQG1haW50YWluZXJzKSB7CisgICAgQG1haW50YWluZXJzID0gbWVyZ2VfZW1haWwoQG1h aW50YWluZXJzKTsKKyAgICBvdXRwdXQoQG1haW50YWluZXJzKTsKK30KKworaWYgKCRzY20pIHsK KyAgICBAc2NtID0gdW5pcShAc2NtKTsKKyAgICBvdXRwdXQoQHNjbSk7Cit9CisKK2lmICgkc3Rh dHVzKSB7CisgICAgQHN0YXR1cyA9IHVuaXEoQHN0YXR1cyk7CisgICAgb3V0cHV0KEBzdGF0dXMp OworfQorCitpZiAoJHN1YnN5c3RlbSkgeworICAgIEBzdWJzeXN0ZW0gPSB1bmlxKEBzdWJzeXN0 ZW0pOworICAgIG91dHB1dChAc3Vic3lzdGVtKTsKK30KKworaWYgKCR3ZWIpIHsKKyAgICBAd2Vi ID0gdW5pcShAd2ViKTsKKyAgICBvdXRwdXQoQHdlYik7Cit9CisKK2V4aXQoJGV4aXQpOworCitz dWIgc2VsZl90ZXN0IHsKKyAgICBteSBAbHNmaWxlcyA9ICgpOworICAgIG15IEBnb29kX2xpbmtz ID0gKCk7CisgICAgbXkgQGJhZF9saW5rcyA9ICgpOworICAgIG15IEBzZWN0aW9uX2hlYWRlcnMg PSAoKTsKKyAgICBteSAkaW5kZXggPSAwOworCisgICAgQGxzZmlsZXMgPSB2Y3NfbGlzdF9maWxl cygkbGtfcGF0aCk7CisKKyAgICBmb3IgbXkgJHggKEBzZWxmX3Rlc3RfaW5mbykgeworCSRpbmRl eCsrOworCisJIyMgU2VjdGlvbiBoZWFkZXIgZHVwbGljYXRpb24gYW5kIG1pc3Npbmcgc2VjdGlv biBjb250ZW50CisJaWYgKCgkc2VsZl90ZXN0IGVxICIiIHx8ICRzZWxmX3Rlc3QgPX4gL1xic2Vj dGlvbnNcYi8pICYmCisJICAgICR4LT57bGluZX0gPX4gL15cU1teOl0vICYmCisJICAgIGRlZmlu ZWQgJHNlbGZfdGVzdF9pbmZvWyRpbmRleF0gJiYKKwkgICAgJHNlbGZfdGVzdF9pbmZvWyRpbmRl eF0tPntsaW5lfSA9fiAvXihbQS1aXSk6XHMqXFMvKSB7CisJICAgIG15ICRoYXNfUyA9IDA7CisJ ICAgIG15ICRoYXNfRiA9IDA7CisJICAgIG15ICRoYXNfTUwgPSAwOworCSAgICBteSAkc3RhdHVz ID0gIiI7CisJICAgIGlmIChncmVwKG1AXlxRJHgtPntsaW5lfVxFQCwgQHNlY3Rpb25faGVhZGVy cykpIHsKKwkJcHJpbnQoIiR4LT57ZmlsZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBkdXBsaWNh dGUgc2VjdGlvbiBoZWFkZXJcdCR4LT57bGluZX1cbiIpOworCSAgICB9IGVsc2UgeworCQlwdXNo KEBzZWN0aW9uX2hlYWRlcnMsICR4LT57bGluZX0pOworCSAgICB9CisJICAgIG15ICRuZXh0bGlu ZSA9ICRpbmRleDsKKwkgICAgd2hpbGUgKGRlZmluZWQgJHNlbGZfdGVzdF9pbmZvWyRuZXh0bGlu ZV0gJiYKKwkJICAgJHNlbGZfdGVzdF9pbmZvWyRuZXh0bGluZV0tPntsaW5lfSA9fiAvXihbQS1a XSk6XHMqKFxTLiopLykgeworCQlteSAkdHlwZSA9ICQxOworCQlteSAkdmFsdWUgPSAkMjsKKwkJ aWYgKCR0eXBlIGVxICJTIikgeworCQkgICAgJGhhc19TID0gMTsKKwkJICAgICRzdGF0dXMgPSAk dmFsdWU7CisJCX0gZWxzaWYgKCR0eXBlIGVxICJGIiB8fCAkdHlwZSBlcSAiTiIpIHsKKwkJICAg ICRoYXNfRiA9IDE7CisJCX0gZWxzaWYgKCR0eXBlIGVxICJNIiB8fCAkdHlwZSBlcSAiUiIgfHwg JHR5cGUgZXEgIkwiKSB7CisJCSAgICAkaGFzX01MID0gMTsKKwkJfQorCQkkbmV4dGxpbmUrKzsK KwkgICAgfQorCSAgICBpZiAoISRoYXNfTUwgJiYgJHN0YXR1cyAhfiAvb3JwaGFufG9ic29sZXRl L2kpIHsKKwkJcHJpbnQoIiR4LT57ZmlsZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBzZWN0aW9u IHdpdGhvdXQgZW1haWwgYWRkcmVzc1x0JHgtPntsaW5lfVxuIik7CisJICAgIH0KKwkgICAgaWYg KCEkaGFzX1MpIHsKKwkJcHJpbnQoIiR4LT57ZmlsZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBz ZWN0aW9uIHdpdGhvdXQgc3RhdHVzIFx0JHgtPntsaW5lfVxuIik7CisJICAgIH0KKwkgICAgaWYg KCEkaGFzX0YpIHsKKwkJcHJpbnQoIiR4LT57ZmlsZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBz ZWN0aW9uIHdpdGhvdXQgZmlsZSBwYXR0ZXJuXHQkeC0+e2xpbmV9XG4iKTsKKwkgICAgfQorCX0K KworCW5leHQgaWYgKCR4LT57bGluZX0gIX4gL14oW0EtWl0pOlxzKiguKikvKTsKKworCW15ICR0 eXBlID0gJDE7CisJbXkgJHZhbHVlID0gJDI7CisKKwkjIyBGaWxlbmFtZSBwYXR0ZXJuIG1hdGNo aW5nCisJaWYgKCgkdHlwZSBlcSAiRiIgfHwgJHR5cGUgZXEgIlgiKSAmJgorCSAgICAoJHNlbGZf dGVzdCBlcSAiIiB8fCAkc2VsZl90ZXN0ID1+IC9cYnBhdHRlcm5zXGIvKSkgeworCSAgICAkdmFs dWUgPX4gc0BcLkBcXFwuQGc7ICAgICAgICMjQ29udmVydCAuIHRvIFwuCisJICAgICR2YWx1ZSA9 fiBzL1wqL1wuXCovZzsgICAgICAgIyNDb252ZXJ0ICogdG8gLioKKwkgICAgJHZhbHVlID1+IHMv XD8vXC4vZzsgICAgICAgICAjI0NvbnZlcnQgPyB0byAuCisJICAgICMjaWYgcGF0dGVybiBpcyBh IGRpcmVjdG9yeSBhbmQgaXQgbGFja3MgYSB0cmFpbGluZyBzbGFzaCwgYWRkIG9uZQorCSAgICBp ZiAoKC1kICR2YWx1ZSkpIHsKKwkJJHZhbHVlID1+IHNAKFteL10pJEAkMS9AOworCSAgICB9CisJ ICAgIGlmICghZ3JlcChtQF4kdmFsdWVALCBAbHNmaWxlcykpIHsKKwkJcHJpbnQoIiR4LT57Zmls ZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBubyBmaWxlIG1hdGNoZXNcdCR4LT57bGluZX1cbiIp OworCSAgICB9CisKKwkjIyBMaW5rIHJlYWNoYWJpbGl0eQorCX0gZWxzaWYgKCgkdHlwZSBlcSAi VyIgfHwgJHR5cGUgZXEgIlEiIHx8ICR0eXBlIGVxICJCIikgJiYKKwkJICR2YWx1ZSA9fiAvXmh0 dHBzPzovICYmCisJCSAoJHNlbGZfdGVzdCBlcSAiIiB8fCAkc2VsZl90ZXN0ID1+IC9cYmxpbmtz XGIvKSkgeworCSAgICBuZXh0IGlmIChncmVwKG1AXlxRJHZhbHVlXEUkQCwgQGdvb2RfbGlua3Mp KTsKKwkgICAgbXkgJGlzYmFkID0gMDsKKwkgICAgaWYgKGdyZXAobUBeXFEkdmFsdWVcRSRALCBA YmFkX2xpbmtzKSkgeworCSAgICAgICAgJGlzYmFkID0gMTsKKwkgICAgfSBlbHNlIHsKKwkJbXkg JG91dHB1dCA9IGB3Z2V0IC0tc3BpZGVyIC1xIC0tbm8tY2hlY2stY2VydGlmaWNhdGUgLS10aW1l b3V0IDEwIC0tdHJpZXMgMSAkdmFsdWVgOworCQlpZiAoJD8gPT0gMCkgeworCQkgICAgcHVzaChA Z29vZF9saW5rcywgJHZhbHVlKTsKKwkJfSBlbHNlIHsKKwkJICAgIHB1c2goQGJhZF9saW5rcywg JHZhbHVlKTsKKwkJICAgICRpc2JhZCA9IDE7CisJCX0KKwkgICAgfQorCSAgICBpZiAoJGlzYmFk KSB7CisJICAgICAgICBwcmludCgiJHgtPntmaWxlfTokeC0+e2xpbmVucn06IHdhcm5pbmc6IHBv c3NpYmxlIGJhZCBsaW5rXHQkeC0+e2xpbmV9XG4iKTsKKwkgICAgfQorCisJIyMgU0NNIHJlYWNo YWJpbGl0eQorCX0gZWxzaWYgKCR0eXBlIGVxICJUIiAmJgorCQkgKCRzZWxmX3Rlc3QgZXEgIiIg fHwgJHNlbGZfdGVzdCA9fiAvXGJzY21cYi8pKSB7CisJICAgIG5leHQgaWYgKGdyZXAobUBeXFEk dmFsdWVcRSRALCBAZ29vZF9saW5rcykpOworCSAgICBteSAkaXNiYWQgPSAwOworCSAgICBpZiAo Z3JlcChtQF5cUSR2YWx1ZVxFJEAsIEBiYWRfbGlua3MpKSB7CisJICAgICAgICAkaXNiYWQgPSAx OworICAgICAgICAgICAgfSBlbHNpZiAoJHZhbHVlICF+IC9eKD86Z2l0fHF1aWx0fGhnKVxzK1xT LykgeworCQlwcmludCgiJHgtPntmaWxlfTokeC0+e2xpbmVucn06IHdhcm5pbmc6IG1hbGZvcm1l ZCBlbnRyeVx0JHgtPntsaW5lfVxuIik7CisJICAgIH0gZWxzaWYgKCR2YWx1ZSA9fiAvXmdpdFxz KyhcUyspKFxzKyhbXlwoXStcUyspKT8vKSB7CisJCW15ICR1cmwgPSAkMTsKKwkJbXkgJGJyYW5j aCA9ICIiOworCQkkYnJhbmNoID0gJDMgaWYgJDM7CisJCW15ICRvdXRwdXQgPSBgZ2l0IGxzLXJl bW90ZSAtLWV4aXQtY29kZSAtaCAiJHVybCIgJGJyYW5jaCA+IC9kZXYvbnVsbCAyPiYxYDsKKwkJ aWYgKCQ/ID09IDApIHsKKwkJICAgIHB1c2goQGdvb2RfbGlua3MsICR2YWx1ZSk7CisJCX0gZWxz ZSB7CisJCSAgICBwdXNoKEBiYWRfbGlua3MsICR2YWx1ZSk7CisJCSAgICAkaXNiYWQgPSAxOwor CQl9CisJICAgIH0gZWxzaWYgKCR2YWx1ZSA9fiAvXig/OnF1aWx0fGhnKVxzKyhodHRwcz86XFMr KS8pIHsKKwkJbXkgJHVybCA9ICQxOworCQlteSAkb3V0cHV0ID0gYHdnZXQgLS1zcGlkZXIgLXEg LS1uby1jaGVjay1jZXJ0aWZpY2F0ZSAtLXRpbWVvdXQgMTAgLS10cmllcyAxICR1cmxgOworCQlp ZiAoJD8gPT0gMCkgeworCQkgICAgcHVzaChAZ29vZF9saW5rcywgJHZhbHVlKTsKKwkJfSBlbHNl IHsKKwkJICAgIHB1c2goQGJhZF9saW5rcywgJHZhbHVlKTsKKwkJICAgICRpc2JhZCA9IDE7CisJ CX0KKwkgICAgfQorCSAgICBpZiAoJGlzYmFkKSB7CisJCXByaW50KCIkeC0+e2ZpbGV9OiR4LT57 bGluZW5yfTogd2FybmluZzogcG9zc2libGUgYmFkIGxpbmtcdCR4LT57bGluZX1cbiIpOworCSAg ICB9CisJfQorICAgIH0KK30KKworc3ViIGlnbm9yZV9lbWFpbF9hZGRyZXNzIHsKKyAgICBteSAo JGFkZHJlc3MpID0gQF87CisKKyAgICBmb3JlYWNoIG15ICRpZ25vcmUgKEBpZ25vcmVfZW1haWxz KSB7CisJcmV0dXJuIDEgaWYgKCRpZ25vcmUgZXEgJGFkZHJlc3MpOworICAgIH0KKworICAgIHJl dHVybiAwOworfQorCitzdWIgcmFuZ2VfaXNfbWFpbnRhaW5lZCB7CisgICAgbXkgKCRzdGFydCwg JGVuZCkgPSBAXzsKKworICAgIGZvciAobXkgJGkgPSAkc3RhcnQ7ICRpIDwgJGVuZDsgJGkrKykg eworCW15ICRsaW5lID0gJHR5cGV2YWx1ZVskaV07CisJaWYgKCRsaW5lID1+IG0vXihbQS1aXSk6 XHMqKC4qKS8pIHsKKwkgICAgbXkgJHR5cGUgPSAkMTsKKwkgICAgbXkgJHZhbHVlID0gJDI7CisJ ICAgIGlmICgkdHlwZSBlcSAnUycpIHsKKwkJaWYgKCR2YWx1ZSA9fiAvKG1haW50YWlufHN1cHBv cnQpL2kpIHsKKwkJICAgIHJldHVybiAxOworCQl9CisJICAgIH0KKwl9CisgICAgfQorICAgIHJl dHVybiAwOworfQorCitzdWIgcmFuZ2VfaGFzX21haW50YWluZXIgeworICAgIG15ICgkc3RhcnQs ICRlbmQpID0gQF87CisKKyAgICBmb3IgKG15ICRpID0gJHN0YXJ0OyAkaSA8ICRlbmQ7ICRpKysp IHsKKwlteSAkbGluZSA9ICR0eXBldmFsdWVbJGldOworCWlmICgkbGluZSA9fiBtL14oW0EtWl0p OlxzKiguKikvKSB7CisJICAgIG15ICR0eXBlID0gJDE7CisJICAgIG15ICR2YWx1ZSA9ICQyOwor CSAgICBpZiAoJHR5cGUgZXEgJ00nKSB7CisJCXJldHVybiAxOworCSAgICB9CisJfQorICAgIH0K KyAgICByZXR1cm4gMDsKK30KKworc3ViIGdldF9tYWludGFpbmVycyB7CisgICAgJWVtYWlsX2hh c2hfbmFtZSA9ICgpOworICAgICVlbWFpbF9oYXNoX2FkZHJlc3MgPSAoKTsKKyAgICAlY29tbWl0 X2F1dGhvcl9oYXNoID0gKCk7CisgICAgJWNvbW1pdF9zaWduZXJfaGFzaCA9ICgpOworICAgIEBl bWFpbF90byA9ICgpOworICAgICVoYXNoX2xpc3RfdG8gPSAoKTsKKyAgICBAbGlzdF90byA9ICgp OworICAgIEBzY20gPSAoKTsKKyAgICBAd2ViID0gKCk7CisgICAgQHN1YnN5c3RlbSA9ICgpOwor ICAgIEBzdGF0dXMgPSAoKTsKKyAgICAlZGVkdXBsaWNhdGVfbmFtZV9oYXNoID0gKCk7CisgICAg JWRlZHVwbGljYXRlX2FkZHJlc3NfaGFzaCA9ICgpOworICAgIGlmICgkZW1haWxfZ2l0X2FsbF9z aWduYXR1cmVfdHlwZXMpIHsKKwkkc2lnbmF0dXJlX3BhdHRlcm4gPSAiKC4rPylbQmJdW1l5XToi OworICAgIH0gZWxzZSB7CisJJHNpZ25hdHVyZV9wYXR0ZXJuID0gIlwoIiAuIGpvaW4oInwiLCBA c2lnbmF0dXJlX3RhZ3MpIC4gIlwpIjsKKyAgICB9CisKKyAgICAjIEZpbmQgcmVzcG9uc2libGUg cGFydGllcworCisgICAgbXkgJWV4YWN0X3BhdHRlcm5fbWF0Y2hfaGFzaCA9ICgpOworCisgICAg Zm9yZWFjaCBteSAkZmlsZSAoQGZpbGVzKSB7CisKKwlteSAlaGFzaDsKKwlteSAkdHZpID0gZmlu ZF9maXJzdF9zZWN0aW9uKCk7CisJd2hpbGUgKCR0dmkgPCBAdHlwZXZhbHVlKSB7CisJICAgIG15 ICRzdGFydCA9IGZpbmRfc3RhcnRpbmdfaW5kZXgoJHR2aSk7CisJICAgIG15ICRlbmQgPSBmaW5k X2VuZGluZ19pbmRleCgkdHZpKTsKKwkgICAgbXkgJGV4Y2x1ZGUgPSAwOworCSAgICBteSAkaTsK KworCSAgICAjRG8gbm90IG1hdGNoIGV4Y2x1ZGVkIGZpbGUgcGF0dGVybnMKKworCSAgICBmb3Ig KCRpID0gJHN0YXJ0OyAkaSA8ICRlbmQ7ICRpKyspIHsKKwkJbXkgJGxpbmUgPSAkdHlwZXZhbHVl WyRpXTsKKwkJaWYgKCRsaW5lID1+IG0vXihbQS1aXSk6XHMqKC4qKS8pIHsKKwkJICAgIG15ICR0 eXBlID0gJDE7CisJCSAgICBteSAkdmFsdWUgPSAkMjsKKwkJICAgIGlmICgkdHlwZSBlcSAnWCcp IHsKKwkJCWlmIChmaWxlX21hdGNoX3BhdHRlcm4oJGZpbGUsICR2YWx1ZSkpIHsKKwkJCSAgICAk ZXhjbHVkZSA9IDE7CisJCQkgICAgbGFzdDsKKwkJCX0KKwkJICAgIH0KKwkJfQorCSAgICB9CisK KwkgICAgaWYgKCEkZXhjbHVkZSkgeworCQlmb3IgKCRpID0gJHN0YXJ0OyAkaSA8ICRlbmQ7ICRp KyspIHsKKwkJICAgIG15ICRsaW5lID0gJHR5cGV2YWx1ZVskaV07CisJCSAgICBpZiAoJGxpbmUg PX4gbS9eKFtBLVpdKTpccyooLiopLykgeworCQkJbXkgJHR5cGUgPSAkMTsKKwkJCW15ICR2YWx1 ZSA9ICQyOworCQkJaWYgKCR0eXBlIGVxICdGJykgeworCQkJICAgIGlmIChmaWxlX21hdGNoX3Bh dHRlcm4oJGZpbGUsICR2YWx1ZSkpIHsKKwkJCQlteSAkdmFsdWVfcGQgPSAoJHZhbHVlID1+IHRy QC9AQCk7CisJCQkJbXkgJGZpbGVfcGQgPSAoJGZpbGUgID1+IHRyQC9AQCk7CisJCQkJJHZhbHVl X3BkKysgaWYgKHN1YnN0cigkdmFsdWUsLTEsMSkgbmUgIi8iKTsKKwkJCQkkdmFsdWVfcGQgPSAt MSBpZiAoJHZhbHVlID1+IC9eXC5cKi8pOworCQkJCWlmICgkdmFsdWVfcGQgPj0gJGZpbGVfcGQg JiYKKwkJCQkgICAgcmFuZ2VfaXNfbWFpbnRhaW5lZCgkc3RhcnQsICRlbmQpICYmCisJCQkJICAg IHJhbmdlX2hhc19tYWludGFpbmVyKCRzdGFydCwgJGVuZCkpIHsKKwkJCQkgICAgJGV4YWN0X3Bh dHRlcm5fbWF0Y2hfaGFzaHskZmlsZX0gPSAxOworCQkJCX0KKwkJCQlpZiAoJHBhdHRlcm5fZGVw dGggPT0gMCB8fAorCQkJCSAgICAoKCRmaWxlX3BkIC0gJHZhbHVlX3BkKSA8ICRwYXR0ZXJuX2Rl cHRoKSkgeworCQkJCSAgICAkaGFzaHskdHZpfSA9ICR2YWx1ZV9wZDsKKwkJCQl9CisJCQkgICAg fQorCQkJfSBlbHNpZiAoJHR5cGUgZXEgJ04nKSB7CisJCQkgICAgaWYgKCRmaWxlID1+IG0vJHZh bHVlL3gpIHsKKwkJCQkkaGFzaHskdHZpfSA9IDA7CisJCQkgICAgfQorCQkJfQorCQkgICAgfQor CQl9CisJICAgIH0KKwkgICAgJHR2aSA9ICRlbmQgKyAxOworCX0KKworCWZvcmVhY2ggbXkgJGxp bmUgKHNvcnQgeyRoYXNoeyRifSA8PT4gJGhhc2h7JGF9fSBrZXlzICVoYXNoKSB7CisJICAgIGFk ZF9jYXRlZ29yaWVzKCRsaW5lKTsKKwkgICAgaWYgKCRzZWN0aW9ucykgeworCQlteSAkaTsKKwkJ bXkgJHN0YXJ0ID0gZmluZF9zdGFydGluZ19pbmRleCgkbGluZSk7CisJCW15ICRlbmQgPSBmaW5k X2VuZGluZ19pbmRleCgkbGluZSk7CisJCWZvciAoJGkgPSAkc3RhcnQ7ICRpIDwgJGVuZDsgJGkr KykgeworCQkgICAgbXkgJGxpbmUgPSAkdHlwZXZhbHVlWyRpXTsKKwkJICAgIGlmICgkbGluZSA9 fiAvXltGWF06LykgewkJIyNSZXN0b3JlIGZpbGUgcGF0dGVybnMKKwkJCSRsaW5lID1+IHMvKFte XFxdKVwuKFteXCpdKS8kMVw/JDIvZzsKKwkJCSRsaW5lID1+IHMvKFteXFxdKVwuJC8kMVw/L2c7 CSMjQ29udmVydCAuIGJhY2sgdG8gPworCQkJJGxpbmUgPX4gcy9cXFwuL1wuL2c7ICAgICAgIAkj I0NvbnZlcnQgXC4gdG8gLgorCQkJJGxpbmUgPX4gcy9cLlwqL1wqL2c7ICAgICAgIAkjI0NvbnZl cnQgLiogdG8gKgorCQkgICAgfQorCQkgICAgbXkgJGNvdW50ID0gJGxpbmUgPX4gcy9eKFtBLVpd KTovJDE6XHQvZzsKKwkJICAgIGlmICgkbGV0dGVycyBlcSAiIiB8fCAoISRjb3VudCB8fCAkbGV0 dGVycyA9fiAvJDEvaSkpIHsKKwkJCXByaW50KCIkbGluZVxuIik7CisJCSAgICB9CisJCX0KKwkJ cHJpbnQoIlxuIik7CisJICAgIH0KKwl9CisKKwltYWludGFpbmVyc19pbl9maWxlKCRmaWxlKTsK KyAgICB9CisKKyAgICBpZiAoJGtleXdvcmRzKSB7CisJQGtleXdvcmRfdHZpID0gc29ydF9hbmRf dW5pcShAa2V5d29yZF90dmkpOworCWZvcmVhY2ggbXkgJGxpbmUgKEBrZXl3b3JkX3R2aSkgewor CSAgICBhZGRfY2F0ZWdvcmllcygkbGluZSk7CisJfQorICAgIH0KKworICAgIGZvcmVhY2ggbXkg JGVtYWlsIChAZW1haWxfdG8sIEBsaXN0X3RvKSB7CisJJGVtYWlsLT5bMF0gPSBkZWR1cGxpY2F0 ZV9lbWFpbCgkZW1haWwtPlswXSk7CisgICAgfQorCisgICAgZm9yZWFjaCBteSAkZmlsZSAoQGZp bGVzKSB7CisJaWYgKCRlbWFpbCAmJgorCSAgICAoJGVtYWlsX2dpdCB8fAorCSAgICAgKCRlbWFp bF9naXRfZmFsbGJhY2sgJiYKKwkgICAgICAkZmlsZSAhfiAvTUFJTlRBSU5FUlMkLyAmJgorCSAg ICAgICEkZXhhY3RfcGF0dGVybl9tYXRjaF9oYXNoeyRmaWxlfSkpKSB7CisJICAgIHZjc19maWxl X3NpZ25vZmZzKCRmaWxlKTsKKwl9CisJaWYgKCRlbWFpbCAmJiAkZW1haWxfZ2l0X2JsYW1lKSB7 CisJICAgIHZjc19maWxlX2JsYW1lKCRmaWxlKTsKKwl9CisgICAgfQorCisgICAgaWYgKCRlbWFp bCkgeworCWZvcmVhY2ggbXkgJGNoaWVmIChAcGVuZ3Vpbl9jaGllZikgeworCSAgICBpZiAoJGNo aWVmID1+IG0vXiguKik6KC4qKS8pIHsKKwkJbXkgJGVtYWlsX2FkZHJlc3M7CisKKwkJJGVtYWls X2FkZHJlc3MgPSBmb3JtYXRfZW1haWwoJDEsICQyLCAkZW1haWxfdXNlbmFtZSk7CisJCWlmICgk ZW1haWxfZ2l0X3Blbmd1aW5fY2hpZWZzKSB7CisJCSAgICBwdXNoKEBlbWFpbF90bywgWyRlbWFp bF9hZGRyZXNzLCAnY2hpZWYgcGVuZ3VpbiddKTsKKwkJfSBlbHNlIHsKKwkJICAgIEBlbWFpbF90 byA9IGdyZXAoJF8tPlswXSAhfiAvJHtlbWFpbF9hZGRyZXNzfS8sIEBlbWFpbF90byk7CisJCX0K KwkgICAgfQorCX0KKworCWZvcmVhY2ggbXkgJGVtYWlsIChAZmlsZV9lbWFpbHMpIHsKKwkgICAg JGVtYWlsID0gbWFpbG1hcF9lbWFpbCgkZW1haWwpOworCSAgICBteSAoJG5hbWUsICRhZGRyZXNz KSA9IHBhcnNlX2VtYWlsKCRlbWFpbCk7CisKKwkgICAgbXkgJHRtcF9lbWFpbCA9IGZvcm1hdF9l bWFpbCgkbmFtZSwgJGFkZHJlc3MsICRlbWFpbF91c2VuYW1lKTsKKwkgICAgcHVzaF9lbWFpbF9h ZGRyZXNzKCR0bXBfZW1haWwsICcnKTsKKwkgICAgYWRkX3JvbGUoJHRtcF9lbWFpbCwgJ2luIGZp bGUnKTsKKwl9CisgICAgfQorCisgICAgZm9yZWFjaCBteSAkZml4IChAZml4ZXMpIHsKKwl2Y3Nf YWRkX2NvbW1pdF9zaWduZXJzKCRmaXgsICJibGFtZWRfZml4ZXMiKTsKKyAgICB9CisKKyAgICBt eSBAdG8gPSAoKTsKKyAgICBpZiAoJGVtYWlsIHx8ICRlbWFpbF9saXN0KSB7CisJaWYgKCRlbWFp bCkgeworCSAgICBAdG8gPSAoQHRvLCBAZW1haWxfdG8pOworCX0KKwlpZiAoJGVtYWlsX2xpc3Qp IHsKKwkgICAgQHRvID0gKEB0bywgQGxpc3RfdG8pOworCX0KKyAgICB9CisKKyAgICBpZiAoJGlu dGVyYWN0aXZlKSB7CisJQHRvID0gaW50ZXJhY3RpdmVfZ2V0X21haW50YWluZXJzKFxAdG8pOwor ICAgIH0KKworICAgIHJldHVybiBAdG87Cit9CisKK3N1YiBmaWxlX21hdGNoX3BhdHRlcm4gewor ICAgIG15ICgkZmlsZSwgJHBhdHRlcm4pID0gQF87CisgICAgaWYgKHN1YnN0cigkcGF0dGVybiwg LTEpIGVxICIvIikgeworCWlmICgkZmlsZSA9fiBtQF4kcGF0dGVybkApIHsKKwkgICAgcmV0dXJu IDE7CisJfQorICAgIH0gZWxzZSB7CisJaWYgKCRmaWxlID1+IG1AXiRwYXR0ZXJuQCkgeworCSAg ICBteSAkczEgPSAoJGZpbGUgPX4gdHJAL0BAKTsKKwkgICAgbXkgJHMyID0gKCRwYXR0ZXJuID1+ IHRyQC9AQCk7CisJICAgIGlmICgkczEgPT0gJHMyKSB7CisJCXJldHVybiAxOworCSAgICB9CisJ fQorICAgIH0KKyAgICByZXR1cm4gMDsKK30KKworc3ViIHVzYWdlIHsKKyAgICBwcmludCA8PEVP VDsKK3VzYWdlOiAkUCBbb3B0aW9uc10gcGF0Y2hmaWxlCisgICAgICAgJFAgW29wdGlvbnNdIC1m IGZpbGV8ZGlyZWN0b3J5Cit2ZXJzaW9uOiAkVgorCitNQUlOVEFJTkVSIGZpZWxkIHNlbGVjdGlv biBvcHRpb25zOgorICAtLWVtYWlsID0+IHByaW50IGVtYWlsIGFkZHJlc3MoZXMpIGlmIGFueQor ICAgIC0tZ2l0ID0+IGluY2x1ZGUgcmVjZW50IGdpdCBcKi1ieTogc2lnbmVycworICAgIC0tZ2l0 LWFsbC1zaWduYXR1cmUtdHlwZXMgPT4gaW5jbHVkZSBzaWduZXJzIHJlZ2FyZGxlc3Mgb2Ygc2ln bmF0dXJlIHR5cGUKKyAgICAgICAgb3IgdXNlIG9ubHkgJHtzaWduYXR1cmVfcGF0dGVybn0gc2ln bmVycyAoZGVmYXVsdDogJGVtYWlsX2dpdF9hbGxfc2lnbmF0dXJlX3R5cGVzKQorICAgIC0tZ2l0 LWZhbGxiYWNrID0+IHVzZSBnaXQgd2hlbiBubyBleGFjdCBNQUlOVEFJTkVSUyBwYXR0ZXJuIChk ZWZhdWx0OiAkZW1haWxfZ2l0X2ZhbGxiYWNrKQorICAgIC0tZ2l0LWNoaWVmLXBlbmd1aW5zID0+ IGluY2x1ZGUgJHtwZW5ndWluX2NoaWVmc30KKyAgICAtLWdpdC1taW4tc2lnbmF0dXJlcyA9PiBu dW1iZXIgb2Ygc2lnbmF0dXJlcyByZXF1aXJlZCAoZGVmYXVsdDogJGVtYWlsX2dpdF9taW5fc2ln bmF0dXJlcykKKyAgICAtLWdpdC1tYXgtbWFpbnRhaW5lcnMgPT4gbWF4aW11bSBtYWludGFpbmVy cyB0byBhZGQgKGRlZmF1bHQ6ICRlbWFpbF9naXRfbWF4X21haW50YWluZXJzKQorICAgIC0tZ2l0 LW1pbi1wZXJjZW50ID0+IG1pbmltdW0gcGVyY2VudGFnZSBvZiBjb21taXRzIHJlcXVpcmVkIChk ZWZhdWx0OiAkZW1haWxfZ2l0X21pbl9wZXJjZW50KQorICAgIC0tZ2l0LWJsYW1lID0+IHVzZSBn aXQgYmxhbWUgdG8gZmluZCBtb2RpZmllZCBjb21taXRzIGZvciBwYXRjaCBvciBmaWxlCisgICAg LS1naXQtYmxhbWUtc2lnbmF0dXJlcyA9PiB3aGVuIHVzZWQgd2l0aCAtLWdpdC1ibGFtZSwgYWxz byBpbmNsdWRlIGFsbCBjb21taXQgc2lnbmVycworICAgIC0tZ2l0LXNpbmNlID0+IGdpdCBoaXN0 b3J5IHRvIHVzZSAoZGVmYXVsdDogJGVtYWlsX2dpdF9zaW5jZSkKKyAgICAtLWhnLXNpbmNlID0+ IGhnIGhpc3RvcnkgdG8gdXNlIChkZWZhdWx0OiAkZW1haWxfaGdfc2luY2UpCisgICAgLS1pbnRl cmFjdGl2ZSA9PiBkaXNwbGF5IGEgbWVudSAobW9zdGx5IHVzZWZ1bCBpZiB1c2VkIHdpdGggdGhl IC0tZ2l0IG9wdGlvbikKKyAgICAtLW0gPT4gaW5jbHVkZSBtYWludGFpbmVyKHMpIGlmIGFueQor ICAgIC0tciA9PiBpbmNsdWRlIHJldmlld2VyKHMpIGlmIGFueQorICAgIC0tbiA9PiBpbmNsdWRl IG5hbWUgJ0Z1bGwgTmFtZSA8YWRkclxAZG9tYWluLnRsZD4nCisgICAgLS1sID0+IGluY2x1ZGUg bGlzdChzKSBpZiBhbnkKKyAgICAtLW1vZGVyYXRlZCA9PiBpbmNsdWRlIG1vZGVyYXRlZCBsaXN0 cyhzKSBpZiBhbnkgKGRlZmF1bHQ6IHRydWUpCisgICAgLS1zID0+IGluY2x1ZGUgc3Vic2NyaWJl ciBvbmx5IGxpc3QocykgaWYgYW55IChkZWZhdWx0OiBmYWxzZSkKKyAgICAtLXJlbW92ZS1kdXBs aWNhdGVzID0+IG1pbmltaXplIGR1cGxpY2F0ZSBlbWFpbCBuYW1lcy9hZGRyZXNzZXMKKyAgICAt LXJvbGVzID0+IHNob3cgcm9sZXMgKHN0YXR1czpzdWJzeXN0ZW0sIGdpdC1zaWduZXIsIGxpc3Qs IGV0Yy4uLikKKyAgICAtLXJvbGVzdGF0cyA9PiBzaG93IHJvbGVzIGFuZCBzdGF0aXN0aWNzIChj b21taXRzL3RvdGFsX2NvbW1pdHMsICUpCisgICAgLS1maWxlLWVtYWlscyA9PiBhZGQgZW1haWwg YWRkcmVzc2VzIGZvdW5kIGluIC1mIGZpbGUgKGRlZmF1bHQ6IDAgKG9mZikpCisgICAgLS1maXhl cyA9PiBmb3IgcGF0Y2hlcywgYWRkIHNpZ25hdHVyZXMgb2YgY29tbWl0cyB3aXRoICdGaXhlczog PGNvbW1pdD4nIChkZWZhdWx0OiAxIChvbikpCisgIC0tc2NtID0+IHByaW50IFNDTSB0cmVlKHMp IGlmIGFueQorICAtLXN0YXR1cyA9PiBwcmludCBzdGF0dXMgaWYgYW55CisgIC0tc3Vic3lzdGVt ID0+IHByaW50IHN1YnN5c3RlbSBuYW1lIGlmIGFueQorICAtLXdlYiA9PiBwcmludCB3ZWJzaXRl KHMpIGlmIGFueQorCitPdXRwdXQgdHlwZSBvcHRpb25zOgorICAtLXNlcGFyYXRvciBbLCBdID0+ IHNlcGFyYXRvciBmb3IgbXVsdGlwbGUgZW50cmllcyBvbiAxIGxpbmUKKyAgICB1c2luZyAtLXNl cGFyYXRvciBhbHNvIHNldHMgLS1ub211bHRpbGluZSBpZiAtLXNlcGFyYXRvciBpcyBub3QgWywg XQorICAtLW11bHRpbGluZSA9PiBwcmludCAxIGVudHJ5IHBlciBsaW5lCisKK090aGVyIG9wdGlv bnM6CisgIC0tcGF0dGVybi1kZXB0aCA9PiBOdW1iZXIgb2YgcGF0dGVybiBkaXJlY3RvcnkgdHJh dmVyc2FscyAoZGVmYXVsdDogMCAoYWxsKSkKKyAgLS1rZXl3b3JkcyA9PiBzY2FuIHBhdGNoIGZv ciBrZXl3b3JkcyAoZGVmYXVsdDogJGtleXdvcmRzKQorICAtLXNlY3Rpb25zID0+IHByaW50IGFs bCBvZiB0aGUgc3Vic3lzdGVtIHNlY3Rpb25zIHdpdGggcGF0dGVybiBtYXRjaGVzCisgIC0tbGV0 dGVycyA9PiBwcmludCBhbGwgbWF0Y2hpbmcgJ2xldHRlcicgdHlwZXMgZnJvbSBhbGwgbWF0Y2hp bmcgc2VjdGlvbnMKKyAgLS1tYWlsbWFwID0+IHVzZSAubWFpbG1hcCBmaWxlIChkZWZhdWx0OiAk ZW1haWxfdXNlX21haWxtYXApCisgIC0tbm8tdHJlZSA9PiBydW4gd2l0aG91dCBhIGtlcm5lbCB0 cmVlCisgIC0tc2VsZi10ZXN0ID0+IHNob3cgcG90ZW50aWFsIGlzc3VlcyB3aXRoIE1BSU5UQUlO RVJTIGZpbGUgY29udGVudAorICAtLXZlcnNpb24gPT4gc2hvdyB2ZXJzaW9uCisgIC0taGVscCA9 PiBzaG93IHRoaXMgaGVscCBpbmZvcm1hdGlvbgorCitEZWZhdWx0IG9wdGlvbnM6CisgIFstLWVt YWlsIC0tdHJlZSAtLW5vZ2l0IC0tZ2l0LWZhbGxiYWNrIC0tbSAtLXIgLS1uIC0tbCAtLW11bHRp bGluZQorICAgLS1wYXR0ZXJuLWRlcHRoPTAgLS1yZW1vdmUtZHVwbGljYXRlcyAtLXJvbGVzdGF0 c10KKworTm90ZXM6CisgIFVzaW5nICItZiBkaXJlY3RvcnkiIG1heSBnaXZlIHVuZXhwZWN0ZWQg cmVzdWx0czoKKyAgICAgIFVzZWQgd2l0aCAiLS1naXQiLCBnaXQgc2lnbmF0b3JzIGZvciBfYWxs XyBmaWxlcyBpbiBhbmQgYmVsb3cKKyAgICAgICAgICBkaXJlY3RvcnkgYXJlIGV4YW1pbmVkIGFz IGdpdCByZWN1cnNlcyBkaXJlY3Rvcmllcy4KKyAgICAgICAgICBBbnkgc3BlY2lmaWVkIFg6IChl eGNsdWRlKSBwYXR0ZXJuIG1hdGNoZXMgYXJlIF9ub3RfIGlnbm9yZWQuCisgICAgICBVc2VkIHdp dGggIi0tbm9naXQiLCBkaXJlY3RvcnkgaXMgdXNlZCBhcyBhIHBhdHRlcm4gbWF0Y2gsCisgICAg ICAgICAgbm8gaW5kaXZpZHVhbCBmaWxlIHdpdGhpbiB0aGUgZGlyZWN0b3J5IG9yIHN1YmRpcmVj dG9yeQorICAgICAgICAgIGlzIG1hdGNoZWQuCisgICAgICBVc2VkIHdpdGggIi0tZ2l0LWJsYW1l IiwgZG9lcyBub3QgaXRlcmF0ZSBhbGwgZmlsZXMgaW4gZGlyZWN0b3J5CisgIFVzaW5nICItLWdp dC1ibGFtZSIgaXMgc2xvdyBhbmQgbWF5IGFkZCBvbGQgY29tbWl0dGVycyBhbmQgYXV0aG9ycwor ICAgICAgdGhhdCBhcmUgbm8gbG9uZ2VyIGFjdGl2ZSBtYWludGFpbmVycyB0byB0aGUgb3V0cHV0 LgorICBVc2luZyAiLS1yb2xlcyIgb3IgIi0tcm9sZXN0YXRzIiB3aXRoIGdpdCBzZW5kLWVtYWls IC0tY2MtY21kIG9yIGFueQorICAgICAgb3RoZXIgYXV0b21hdGVkIHRvb2xzIHRoYXQgZXhwZWN0 IG9ubHkgWyJuYW1lIl0gPGVtYWlsIGFkZHJlc3M+CisgICAgICBtYXkgbm90IHdvcmsgYmVjYXVz ZSBvZiBhZGRpdGlvbmFsIG91dHB1dCBhZnRlciA8ZW1haWwgYWRkcmVzcz4uCisgIFVzaW5nICIt LXJvbGVzdGF0cyIgYW5kICItLWdpdC1ibGFtZSIgc2hvd3MgdGhlICMvdG90YWw9JSBjb21taXRz LAorICAgICAgbm90IHRoZSBwZXJjZW50YWdlIG9mIHRoZSBlbnRpcmUgZmlsZSBhdXRob3JlZC4g ICMgb2YgY29tbWl0cyBpcworICAgICAgbm90IGEgZ29vZCBtZWFzdXJlIG9mIGFtb3VudCBvZiBj b2RlIGF1dGhvcmVkLiAgMSBtYWpvciBjb21taXQgbWF5CisgICAgICBjb250YWluIGEgdGhvdXNh bmQgbGluZXMsIDUgdHJpdmlhbCBjb21taXRzIG1heSBtb2RpZnkgYSBzaW5nbGUgbGluZS4KKyAg SWYgZ2l0IGlzIG5vdCBpbnN0YWxsZWQsIGJ1dCBtZXJjdXJpYWwgKGhnKSBpcyBpbnN0YWxsZWQg YW5kIGFuIC5oZworICAgICAgcmVwb3NpdG9yeSBleGlzdHMsIHRoZSBmb2xsb3dpbmcgb3B0aW9u cyBhcHBseSB0byBtZXJjdXJpYWw6CisgICAgICAgICAgLS1naXQsCisgICAgICAgICAgLS1naXQt bWluLXNpZ25hdHVyZXMsIC0tZ2l0LW1heC1tYWludGFpbmVycywgLS1naXQtbWluLXBlcmNlbnQs IGFuZAorICAgICAgICAgIC0tZ2l0LWJsYW1lCisgICAgICBVc2UgLS1oZy1zaW5jZSBub3QgLS1n aXQtc2luY2UgdG8gY29udHJvbCBkYXRlIHNlbGVjdGlvbgorICBGaWxlICIuZ2V0X21haW50YWlu ZXIuY29uZiIsIGlmIGl0IGV4aXN0cyBpbiB0aGUgZnN0ZXN0cyBzb3VyY2Ugcm9vdAorICAgICAg ZGlyZWN0b3J5LCBjYW4gY2hhbmdlIHdoYXRldmVyIGdldF9tYWludGFpbmVyIGRlZmF1bHRzIGFy ZSBkZXNpcmVkLgorICAgICAgRW50cmllcyBpbiB0aGlzIGZpbGUgY2FuIGJlIGFueSBjb21tYW5k IGxpbmUgYXJndW1lbnQuCisgICAgICBUaGlzIGZpbGUgaXMgcHJlcGVuZGVkIHRvIGFueSBhZGRp dGlvbmFsIGNvbW1hbmQgbGluZSBhcmd1bWVudHMuCisgICAgICBNdWx0aXBsZSBsaW5lcyBhbmQg IyBjb21tZW50cyBhcmUgYWxsb3dlZC4KKyAgTW9zdCBvcHRpb25zIGhhdmUgYm90aCBwb3NpdGl2 ZSBhbmQgbmVnYXRpdmUgZm9ybXMuCisgICAgICBUaGUgbmVnYXRpdmUgZm9ybXMgZm9yIC0tPGZv bz4gYXJlIC0tbm88Zm9vPiBhbmQgLS1uby08Zm9vPi4KKworRU9UCit9CisKK3N1YiB0b3Bfb2Zf ZnN0ZXN0c190cmVlIHsKKyAgICBteSAoJGxrX3BhdGgpID0gQF87CisKKyAgICBpZiAoJGxrX3Bh dGggbmUgIiIgJiYgc3Vic3RyKCRsa19wYXRoLGxlbmd0aCgkbGtfcGF0aCktMSwxKSBuZSAiLyIp IHsKKwkkbGtfcGF0aCAuPSAiLyI7CisgICAgfQorICAgIGlmICggICAoLWYgIiR7bGtfcGF0aH1j aGVjayIpCisJJiYgKC1mICIke2xrX3BhdGh9bG9jYWwuY29uZmlnLmV4YW1wbGUiKQorCSYmICgt ZSAiJHtsa19wYXRofU1BSU5UQUlORVJTIikKKwkmJiAoLWYgIiR7bGtfcGF0aH1NYWtlZmlsZSIp CisJJiYgKC1mICIke2xrX3BhdGh9UkVBRE1FIikKKwkmJiAoLWYgIiR7bGtfcGF0aH1uZXciKQor CSYmICgtZCAiJHtsa19wYXRofUxJQ0VOU0VTIikKKwkmJiAoLWQgIiR7bGtfcGF0aH10ZXN0cyIp CisJJiYgKC1kICIke2xrX3BhdGh9Y29tbW9uIikKKwkmJiAoLWQgIiR7bGtfcGF0aH1zcmMiKQor CSYmICgtZCAiJHtsa19wYXRofXRvb2xzIikKKwkmJiAoLWQgIiR7bGtfcGF0aH1pbmNsdWRlIikK KwkmJiAoLWQgIiR7bGtfcGF0aH1tNCIpCisJJiYgKC1kICIke2xrX3BhdGh9bGliIikKKwkmJiAo LWQgIiR7bGtfcGF0aH1kb2MiKSkgeworCXJldHVybiAxOworICAgIH0KKyAgICByZXR1cm4gMDsK K30KKworc3ViIHBhcnNlX2VtYWlsIHsKKyAgICBteSAoJGZvcm1hdHRlZF9lbWFpbCkgPSBAXzsK KworICAgIG15ICRuYW1lID0gIiI7CisgICAgbXkgJGFkZHJlc3MgPSAiIjsKKworICAgIGlmICgk Zm9ybWF0dGVkX2VtYWlsID1+IC9eKFtePF0rKTwoLitcQC4qKT4uKiQvKSB7CisJJG5hbWUgPSAk MTsKKwkkYWRkcmVzcyA9ICQyOworICAgIH0gZWxzaWYgKCRmb3JtYXR0ZWRfZW1haWwgPX4gL15c cyo8KC4rXEBcUyopPi4qJC8pIHsKKwkkYWRkcmVzcyA9ICQxOworICAgIH0gZWxzaWYgKCRmb3Jt YXR0ZWRfZW1haWwgPX4gL14oLitcQFxTKikuKiQvKSB7CisJJGFkZHJlc3MgPSAkMTsKKyAgICB9 CisKKyAgICAkbmFtZSA9fiBzL15ccyt8XHMrJC8vZzsKKyAgICAkbmFtZSA9fiBzL15cInxcIiQv L2c7CisgICAgJGFkZHJlc3MgPX4gcy9eXHMrfFxzKyQvL2c7CisKKyAgICBpZiAoJG5hbWUgPX4g L1teXHcgXC1dL2kpIHsgIAkgIyNoYXMgIm11c3QgcXVvdGUiIGNoYXJzCisJJG5hbWUgPX4gcy8o PzwhXFwpIi9cXCIvZzsgICAgICAgIyNlc2NhcGUgcXVvdGVzCisJJG5hbWUgPSAiXCIkbmFtZVwi IjsKKyAgICB9CisKKyAgICByZXR1cm4gKCRuYW1lLCAkYWRkcmVzcyk7Cit9CisKK3N1YiBmb3Jt YXRfZW1haWwgeworICAgIG15ICgkbmFtZSwgJGFkZHJlc3MsICR1c2VuYW1lKSA9IEBfOworCisg ICAgbXkgJGZvcm1hdHRlZF9lbWFpbDsKKworICAgICRuYW1lID1+IHMvXlxzK3xccyskLy9nOwor ICAgICRuYW1lID1+IHMvXlwifFwiJC8vZzsKKyAgICAkYWRkcmVzcyA9fiBzL15ccyt8XHMrJC8v ZzsKKworICAgIGlmICgkbmFtZSA9fiAvW15cdyBcLV0vaSkgeyAgICAgICAgICAjI2hhcyAibXVz dCBxdW90ZSIgY2hhcnMKKwkkbmFtZSA9fiBzLyg/PCFcXCkiL1xcIi9nOyAgICAgICAjI2VzY2Fw ZSBxdW90ZXMKKwkkbmFtZSA9ICJcIiRuYW1lXCIiOworICAgIH0KKworICAgIGlmICgkdXNlbmFt ZSkgeworCWlmICgiJG5hbWUiIGVxICIiKSB7CisJICAgICRmb3JtYXR0ZWRfZW1haWwgPSAiJGFk ZHJlc3MiOworCX0gZWxzZSB7CisJICAgICRmb3JtYXR0ZWRfZW1haWwgPSAiJG5hbWUgPCRhZGRy ZXNzPiI7CisJfQorICAgIH0gZWxzZSB7CisJJGZvcm1hdHRlZF9lbWFpbCA9ICRhZGRyZXNzOwor ICAgIH0KKworICAgIHJldHVybiAkZm9ybWF0dGVkX2VtYWlsOworfQorCitzdWIgZmluZF9maXJz dF9zZWN0aW9uIHsKKyAgICBteSAkaW5kZXggPSAwOworCisgICAgd2hpbGUgKCRpbmRleCA8IEB0 eXBldmFsdWUpIHsKKwlteSAkdHYgPSAkdHlwZXZhbHVlWyRpbmRleF07CisJaWYgKCgkdHYgPX4g bS9eKFtBLVpdKTpccyooLiopLykpIHsKKwkgICAgbGFzdDsKKwl9CisJJGluZGV4Kys7CisgICAg fQorCisgICAgcmV0dXJuICRpbmRleDsKK30KKworc3ViIGZpbmRfc3RhcnRpbmdfaW5kZXggewor ICAgIG15ICgkaW5kZXgpID0gQF87CisKKyAgICB3aGlsZSAoJGluZGV4ID4gMCkgeworCW15ICR0 diA9ICR0eXBldmFsdWVbJGluZGV4XTsKKwlpZiAoISgkdHYgPX4gbS9eKFtBLVpdKTpccyooLiop LykpIHsKKwkgICAgbGFzdDsKKwl9CisJJGluZGV4LS07CisgICAgfQorCisgICAgcmV0dXJuICRp bmRleDsKK30KKworc3ViIGZpbmRfZW5kaW5nX2luZGV4IHsKKyAgICBteSAoJGluZGV4KSA9IEBf OworCisgICAgd2hpbGUgKCRpbmRleCA8IEB0eXBldmFsdWUpIHsKKwlteSAkdHYgPSAkdHlwZXZh bHVlWyRpbmRleF07CisJaWYgKCEoJHR2ID1+IG0vXihbQS1aXSk6XHMqKC4qKS8pKSB7CisJICAg IGxhc3Q7CisJfQorCSRpbmRleCsrOworICAgIH0KKworICAgIHJldHVybiAkaW5kZXg7Cit9CisK K3N1YiBnZXRfc3Vic3lzdGVtX25hbWUgeworICAgIG15ICgkaW5kZXgpID0gQF87CisKKyAgICBt eSAkc3RhcnQgPSBmaW5kX3N0YXJ0aW5nX2luZGV4KCRpbmRleCk7CisKKyAgICBteSAkc3Vic3lz dGVtID0gJHR5cGV2YWx1ZVskc3RhcnRdOworICAgIGlmICgkb3V0cHV0X3NlY3Rpb25fbWF4bGVu ICYmIGxlbmd0aCgkc3Vic3lzdGVtKSA+ICRvdXRwdXRfc2VjdGlvbl9tYXhsZW4pIHsKKwkkc3Vi c3lzdGVtID0gc3Vic3RyKCRzdWJzeXN0ZW0sIDAsICRvdXRwdXRfc2VjdGlvbl9tYXhsZW4gLSAz KTsKKwkkc3Vic3lzdGVtID1+IHMvXHMqJC8vOworCSRzdWJzeXN0ZW0gPSAkc3Vic3lzdGVtIC4g Ii4uLiI7CisgICAgfQorICAgIHJldHVybiAkc3Vic3lzdGVtOworfQorCitzdWIgZ2V0X21haW50 YWluZXJfcm9sZSB7CisgICAgbXkgKCRpbmRleCkgPSBAXzsKKworICAgIG15ICRpOworICAgIG15 ICRzdGFydCA9IGZpbmRfc3RhcnRpbmdfaW5kZXgoJGluZGV4KTsKKyAgICBteSAkZW5kID0gZmlu ZF9lbmRpbmdfaW5kZXgoJGluZGV4KTsKKworICAgIG15ICRyb2xlID0gInVua25vd24iOworICAg IG15ICRzdWJzeXN0ZW0gPSBnZXRfc3Vic3lzdGVtX25hbWUoJGluZGV4KTsKKworICAgIGZvciAo JGkgPSAkc3RhcnQgKyAxOyAkaSA8ICRlbmQ7ICRpKyspIHsKKwlteSAkdHYgPSAkdHlwZXZhbHVl WyRpXTsKKwlpZiAoJHR2ID1+IG0vXihbQS1aXSk6XHMqKC4qKS8pIHsKKwkgICAgbXkgJHB0eXBl ID0gJDE7CisJICAgIG15ICRwdmFsdWUgPSAkMjsKKwkgICAgaWYgKCRwdHlwZSBlcSAiUyIpIHsK KwkJJHJvbGUgPSAkcHZhbHVlOworCSAgICB9CisJfQorICAgIH0KKworICAgICRyb2xlID0gbGMo JHJvbGUpOworICAgIGlmICAgICAgKCRyb2xlIGVxICJzdXBwb3J0ZWQiKSB7CisJJHJvbGUgPSAi c3VwcG9ydGVyIjsKKyAgICB9IGVsc2lmICgkcm9sZSBlcSAibWFpbnRhaW5lZCIpIHsKKwkkcm9s ZSA9ICJtYWludGFpbmVyIjsKKyAgICB9IGVsc2lmICgkcm9sZSBlcSAib2RkIGZpeGVzIikgewor CSRyb2xlID0gIm9kZCBmaXhlciI7CisgICAgfSBlbHNpZiAoJHJvbGUgZXEgIm9ycGhhbiIpIHsK Kwkkcm9sZSA9ICJvcnBoYW4gbWluZGVyIjsKKyAgICB9IGVsc2lmICgkcm9sZSBlcSAib2Jzb2xl dGUiKSB7CisJJHJvbGUgPSAib2Jzb2xldGUgbWluZGVyIjsKKyAgICB9IGVsc2lmICgkcm9sZSBl cSAiYnVyaWVkIGFsaXZlIGluIHJlcG9ydGVycyIpIHsKKwkkcm9sZSA9ICJjaGllZiBwZW5ndWlu IjsKKyAgICB9CisKKyAgICByZXR1cm4gJHJvbGUgLiAiOiIgLiAkc3Vic3lzdGVtOworfQorCitz dWIgZ2V0X2xpc3Rfcm9sZSB7CisgICAgbXkgKCRpbmRleCkgPSBAXzsKKworICAgIG15ICRzdWJz eXN0ZW0gPSBnZXRfc3Vic3lzdGVtX25hbWUoJGluZGV4KTsKKworICAgIGlmICgkc3Vic3lzdGVt IGVxICJBTEwiKSB7CisJJHN1YnN5c3RlbSA9ICJTZW5kIFRvIE1lIjsKKyAgICB9CisKKyAgICBy ZXR1cm4gJHN1YnN5c3RlbTsKK30KKworc3ViIGFkZF9jYXRlZ29yaWVzIHsKKyAgICBteSAoJGlu ZGV4KSA9IEBfOworCisgICAgbXkgJGk7CisgICAgbXkgJHN0YXJ0ID0gZmluZF9zdGFydGluZ19p bmRleCgkaW5kZXgpOworICAgIG15ICRlbmQgPSBmaW5kX2VuZGluZ19pbmRleCgkaW5kZXgpOwor CisgICAgcHVzaChAc3Vic3lzdGVtLCAkdHlwZXZhbHVlWyRzdGFydF0pOworCisgICAgZm9yICgk aSA9ICRzdGFydCArIDE7ICRpIDwgJGVuZDsgJGkrKykgeworCW15ICR0diA9ICR0eXBldmFsdWVb JGldOworCWlmICgkdHYgPX4gbS9eKFtBLVpdKTpccyooLiopLykgeworCSAgICBteSAkcHR5cGUg PSAkMTsKKwkgICAgbXkgJHB2YWx1ZSA9ICQyOworCSAgICBpZiAoJHB0eXBlIGVxICJMIikgewor CQlteSAkbGlzdF9hZGRyZXNzID0gJHB2YWx1ZTsKKwkJbXkgJGxpc3RfYWRkaXRpb25hbCA9ICIi OworCQlteSAkbGlzdF9yb2xlID0gZ2V0X2xpc3Rfcm9sZSgkaSk7CisKKwkJaWYgKCRsaXN0X3Jv bGUgbmUgIiIpIHsKKwkJICAgICRsaXN0X3JvbGUgPSAiOiIgLiAkbGlzdF9yb2xlOworCQl9CisJ CWlmICgkbGlzdF9hZGRyZXNzID1+IG0vKFteXHNdKylccysoLiopJC8pIHsKKwkJICAgICRsaXN0 X2FkZHJlc3MgPSAkMTsKKwkJICAgICRsaXN0X2FkZGl0aW9uYWwgPSAkMjsKKwkJfQorCQlpZiAo JGxpc3RfYWRkaXRpb25hbCA9fiBtL3N1YnNjcmliZXJzLW9ubHkvKSB7CisJCSAgICBpZiAoJGVt YWlsX3N1YnNjcmliZXJfbGlzdCkgeworCQkJaWYgKCEkaGFzaF9saXN0X3Rve2xjKCRsaXN0X2Fk ZHJlc3MpfSkgeworCQkJICAgICRoYXNoX2xpc3RfdG97bGMoJGxpc3RfYWRkcmVzcyl9ID0gMTsK KwkJCSAgICBwdXNoKEBsaXN0X3RvLCBbJGxpc3RfYWRkcmVzcywKKwkJCQkJICAgICJzdWJzY3Jp YmVyIGxpc3Qke2xpc3Rfcm9sZX0iXSk7CisJCQl9CisJCSAgICB9CisJCX0gZWxzZSB7CisJCSAg ICBpZiAoJGVtYWlsX2xpc3QpIHsKKwkJCWlmICghJGhhc2hfbGlzdF90b3tsYygkbGlzdF9hZGRy ZXNzKX0pIHsKKwkJCSAgICBpZiAoJGxpc3RfYWRkaXRpb25hbCA9fiBtL21vZGVyYXRlZC8pIHsK KwkJCQlpZiAoJGVtYWlsX21vZGVyYXRlZF9saXN0KSB7CisJCQkJICAgICRoYXNoX2xpc3RfdG97 bGMoJGxpc3RfYWRkcmVzcyl9ID0gMTsKKwkJCQkgICAgcHVzaChAbGlzdF90bywgWyRsaXN0X2Fk ZHJlc3MsCisJCQkJCQkgICAgIm1vZGVyYXRlZCBsaXN0JHtsaXN0X3JvbGV9Il0pOworCQkJCX0K KwkJCSAgICB9IGVsc2UgeworCQkJCSRoYXNoX2xpc3RfdG97bGMoJGxpc3RfYWRkcmVzcyl9ID0g MTsKKwkJCQlwdXNoKEBsaXN0X3RvLCBbJGxpc3RfYWRkcmVzcywKKwkJCQkJCSJvcGVuIGxpc3Qk e2xpc3Rfcm9sZX0iXSk7CisJCQkgICAgfQorCQkJfQorCQkgICAgfQorCQl9CisJICAgIH0gZWxz aWYgKCRwdHlwZSBlcSAiTSIpIHsKKwkJaWYgKCRlbWFpbF9tYWludGFpbmVyKSB7CisJCSAgICBt eSAkcm9sZSA9IGdldF9tYWludGFpbmVyX3JvbGUoJGkpOworCQkgICAgcHVzaF9lbWFpbF9hZGRy ZXNzZXMoJHB2YWx1ZSwgJHJvbGUpOworCQl9CisJICAgIH0gZWxzaWYgKCRwdHlwZSBlcSAiUiIp IHsKKwkJaWYgKCRlbWFpbF9yZXZpZXdlcikgeworCQkgICAgbXkgJHN1YnN5c3RlbSA9IGdldF9z dWJzeXN0ZW1fbmFtZSgkaSk7CisJCSAgICBwdXNoX2VtYWlsX2FkZHJlc3NlcygkcHZhbHVlLCAi cmV2aWV3ZXI6JHN1YnN5c3RlbSIpOworCQl9CisJICAgIH0gZWxzaWYgKCRwdHlwZSBlcSAiVCIp IHsKKwkJcHVzaChAc2NtLCAkcHZhbHVlKTsKKwkgICAgfSBlbHNpZiAoJHB0eXBlIGVxICJXIikg eworCQlwdXNoKEB3ZWIsICRwdmFsdWUpOworCSAgICB9IGVsc2lmICgkcHR5cGUgZXEgIlMiKSB7 CisJCXB1c2goQHN0YXR1cywgJHB2YWx1ZSk7CisJICAgIH0KKwl9CisgICAgfQorfQorCitzdWIg ZW1haWxfaW51c2UgeworICAgIG15ICgkbmFtZSwgJGFkZHJlc3MpID0gQF87CisKKyAgICByZXR1 cm4gMSBpZiAoKCRuYW1lIGVxICIiKSAmJiAoJGFkZHJlc3MgZXEgIiIpKTsKKyAgICByZXR1cm4g MSBpZiAoKCRuYW1lIG5lICIiKSAmJiBleGlzdHMoJGVtYWlsX2hhc2hfbmFtZXtsYygkbmFtZSl9 KSk7CisgICAgcmV0dXJuIDEgaWYgKCgkYWRkcmVzcyBuZSAiIikgJiYgZXhpc3RzKCRlbWFpbF9o YXNoX2FkZHJlc3N7bGMoJGFkZHJlc3MpfSkpOworCisgICAgcmV0dXJuIDA7Cit9CisKK3N1YiBw dXNoX2VtYWlsX2FkZHJlc3MgeworICAgIG15ICgkbGluZSwgJHJvbGUpID0gQF87CisKKyAgICBt eSAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRsaW5lKTsKKworICAgIGlmICgkYWRk cmVzcyBlcSAiIikgeworCXJldHVybiAwOworICAgIH0KKworICAgIGlmICghJGVtYWlsX3JlbW92 ZV9kdXBsaWNhdGVzKSB7CisJcHVzaChAZW1haWxfdG8sIFtmb3JtYXRfZW1haWwoJG5hbWUsICRh ZGRyZXNzLCAkZW1haWxfdXNlbmFtZSksICRyb2xlXSk7CisgICAgfSBlbHNpZiAoIWVtYWlsX2lu dXNlKCRuYW1lLCAkYWRkcmVzcykpIHsKKwlwdXNoKEBlbWFpbF90bywgW2Zvcm1hdF9lbWFpbCgk bmFtZSwgJGFkZHJlc3MsICRlbWFpbF91c2VuYW1lKSwgJHJvbGVdKTsKKwkkZW1haWxfaGFzaF9u YW1le2xjKCRuYW1lKX0rKyBpZiAoJG5hbWUgbmUgIiIpOworCSRlbWFpbF9oYXNoX2FkZHJlc3N7 bGMoJGFkZHJlc3MpfSsrOworICAgIH0KKworICAgIHJldHVybiAxOworfQorCitzdWIgcHVzaF9l bWFpbF9hZGRyZXNzZXMgeworICAgIG15ICgkYWRkcmVzcywgJHJvbGUpID0gQF87CisKKyAgICBt eSBAYWRkcmVzc19saXN0ID0gKCk7CisKKyAgICBpZiAocmZjODIyX3ZhbGlkKCRhZGRyZXNzKSkg eworCXB1c2hfZW1haWxfYWRkcmVzcygkYWRkcmVzcywgJHJvbGUpOworICAgIH0gZWxzaWYgKEBh ZGRyZXNzX2xpc3QgPSByZmM4MjJfdmFsaWRsaXN0KCRhZGRyZXNzKSkgeworCW15ICRhcnJheV9j b3VudCA9IHNoaWZ0KEBhZGRyZXNzX2xpc3QpOworCXdoaWxlIChteSAkZW50cnkgPSBzaGlmdChA YWRkcmVzc19saXN0KSkgeworCSAgICBwdXNoX2VtYWlsX2FkZHJlc3MoJGVudHJ5LCAkcm9sZSk7 CisJfQorICAgIH0gZWxzZSB7CisJaWYgKCFwdXNoX2VtYWlsX2FkZHJlc3MoJGFkZHJlc3MsICRy b2xlKSkgeworCSAgICB3YXJuKCJJbnZhbGlkIE1BSU5UQUlORVJTIGFkZHJlc3M6ICciIC4gJGFk ZHJlc3MgLiAiJ1xuIik7CisJfQorICAgIH0KK30KKworc3ViIGFkZF9yb2xlIHsKKyAgICBteSAo JGxpbmUsICRyb2xlKSA9IEBfOworCisgICAgbXkgKCRuYW1lLCAkYWRkcmVzcykgPSBwYXJzZV9l bWFpbCgkbGluZSk7CisgICAgbXkgJGVtYWlsID0gZm9ybWF0X2VtYWlsKCRuYW1lLCAkYWRkcmVz cywgJGVtYWlsX3VzZW5hbWUpOworCisgICAgZm9yZWFjaCBteSAkZW50cnkgKEBlbWFpbF90bykg eworCWlmICgkZW1haWxfcmVtb3ZlX2R1cGxpY2F0ZXMpIHsKKwkgICAgbXkgKCRlbnRyeV9uYW1l LCAkZW50cnlfYWRkcmVzcykgPSBwYXJzZV9lbWFpbCgkZW50cnktPlswXSk7CisJICAgIGlmICgo JG5hbWUgZXEgJGVudHJ5X25hbWUgfHwgJGFkZHJlc3MgZXEgJGVudHJ5X2FkZHJlc3MpCisJCSYm ICgkcm9sZSBlcSAiIiB8fCAhKCRlbnRyeS0+WzFdID1+IG0vJHJvbGUvKSkKKwkgICAgKSB7CisJ CWlmICgkZW50cnktPlsxXSBlcSAiIikgeworCQkgICAgJGVudHJ5LT5bMV0gPSAiJHJvbGUiOwor CQl9IGVsc2UgeworCQkgICAgJGVudHJ5LT5bMV0gPSAiJGVudHJ5LT5bMV0sJHJvbGUiOworCQl9 CisJICAgIH0KKwl9IGVsc2UgeworCSAgICBpZiAoJGVtYWlsIGVxICRlbnRyeS0+WzBdCisJCSYm ICgkcm9sZSBlcSAiIiB8fCAhKCRlbnRyeS0+WzFdID1+IG0vJHJvbGUvKSkKKwkgICAgKSB7CisJ CWlmICgkZW50cnktPlsxXSBlcSAiIikgeworCQkgICAgJGVudHJ5LT5bMV0gPSAiJHJvbGUiOwor CQl9IGVsc2UgeworCQkgICAgJGVudHJ5LT5bMV0gPSAiJGVudHJ5LT5bMV0sJHJvbGUiOworCQl9 CisJICAgIH0KKwl9CisgICAgfQorfQorCitzdWIgd2hpY2ggeworICAgIG15ICgkYmluKSA9IEBf OworCisgICAgZm9yZWFjaCBteSAkcGF0aCAoc3BsaXQoLzovLCAkRU5We1BBVEh9KSkgeworCWlm ICgtZSAiJHBhdGgvJGJpbiIpIHsKKwkgICAgcmV0dXJuICIkcGF0aC8kYmluIjsKKwl9CisgICAg fQorCisgICAgcmV0dXJuICIiOworfQorCitzdWIgd2hpY2hfY29uZiB7CisgICAgbXkgKCRjb25m KSA9IEBfOworCisgICAgZm9yZWFjaCBteSAkcGF0aCAoc3BsaXQoLzovLCAiLjokRU5We0hPTUV9 Oi5zY3JpcHRzIikpIHsKKwlpZiAoLWUgIiRwYXRoLyRjb25mIikgeworCSAgICByZXR1cm4gIiRw YXRoLyRjb25mIjsKKwl9CisgICAgfQorCisgICAgcmV0dXJuICIiOworfQorCitzdWIgbWFpbG1h cF9lbWFpbCB7CisgICAgbXkgKCRsaW5lKSA9IEBfOworCisgICAgbXkgKCRuYW1lLCAkYWRkcmVz cykgPSBwYXJzZV9lbWFpbCgkbGluZSk7CisgICAgbXkgJGVtYWlsID0gZm9ybWF0X2VtYWlsKCRu YW1lLCAkYWRkcmVzcywgMSk7CisgICAgbXkgJHJlYWxfbmFtZSA9ICRuYW1lOworICAgIG15ICRy ZWFsX2FkZHJlc3MgPSAkYWRkcmVzczsKKworICAgIGlmIChleGlzdHMgJG1haWxtYXAtPntuYW1l c30tPnskZW1haWx9IHx8CisJZXhpc3RzICRtYWlsbWFwLT57YWRkcmVzc2VzfS0+eyRlbWFpbH0p IHsKKwlpZiAoZXhpc3RzICRtYWlsbWFwLT57bmFtZXN9LT57JGVtYWlsfSkgeworCSAgICAkcmVh bF9uYW1lID0gJG1haWxtYXAtPntuYW1lc30tPnskZW1haWx9OworCX0KKwlpZiAoZXhpc3RzICRt YWlsbWFwLT57YWRkcmVzc2VzfS0+eyRlbWFpbH0pIHsKKwkgICAgJHJlYWxfYWRkcmVzcyA9ICRt YWlsbWFwLT57YWRkcmVzc2VzfS0+eyRlbWFpbH07CisJfQorICAgIH0gZWxzZSB7CisJaWYgKGV4 aXN0cyAkbWFpbG1hcC0+e25hbWVzfS0+eyRhZGRyZXNzfSkgeworCSAgICAkcmVhbF9uYW1lID0g JG1haWxtYXAtPntuYW1lc30tPnskYWRkcmVzc307CisJfQorCWlmIChleGlzdHMgJG1haWxtYXAt PnthZGRyZXNzZXN9LT57JGFkZHJlc3N9KSB7CisJICAgICRyZWFsX2FkZHJlc3MgPSAkbWFpbG1h cC0+e2FkZHJlc3Nlc30tPnskYWRkcmVzc307CisJfQorICAgIH0KKyAgICByZXR1cm4gZm9ybWF0 X2VtYWlsKCRyZWFsX25hbWUsICRyZWFsX2FkZHJlc3MsIDEpOworfQorCitzdWIgbWFpbG1hcCB7 CisgICAgbXkgKEBhZGRyZXNzZXMpID0gQF87CisKKyAgICBteSBAbWFwcGVkX2VtYWlscyA9ICgp OworICAgIGZvcmVhY2ggbXkgJGxpbmUgKEBhZGRyZXNzZXMpIHsKKwlwdXNoKEBtYXBwZWRfZW1h aWxzLCBtYWlsbWFwX2VtYWlsKCRsaW5lKSk7CisgICAgfQorICAgIG1lcmdlX2J5X3JlYWxuYW1l KEBtYXBwZWRfZW1haWxzKSBpZiAoJGVtYWlsX3VzZV9tYWlsbWFwKTsKKyAgICByZXR1cm4gQG1h cHBlZF9lbWFpbHM7Cit9CisKK3N1YiBtZXJnZV9ieV9yZWFsbmFtZSB7CisgICAgbXkgJWFkZHJl c3NfbWFwOworICAgIG15IChAZW1haWxzKSA9IEBfOworCisgICAgZm9yZWFjaCBteSAkZW1haWwg KEBlbWFpbHMpIHsKKwlteSAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRlbWFpbCk7 CisJaWYgKGV4aXN0cyAkYWRkcmVzc19tYXB7JG5hbWV9KSB7CisJICAgICRhZGRyZXNzID0gJGFk ZHJlc3NfbWFweyRuYW1lfTsKKwkgICAgJGVtYWlsID0gZm9ybWF0X2VtYWlsKCRuYW1lLCAkYWRk cmVzcywgMSk7CisJfSBlbHNlIHsKKwkgICAgJGFkZHJlc3NfbWFweyRuYW1lfSA9ICRhZGRyZXNz OworCX0KKyAgICB9Cit9CisKK3N1YiBnaXRfZXhlY3V0ZV9jbWQgeworICAgIG15ICgkY21kKSA9 IEBfOworICAgIG15IEBsaW5lcyA9ICgpOworCisgICAgbXkgJG91dHB1dCA9IGAkY21kYDsKKyAg ICAkb3V0cHV0ID1+IHMvXlxzKi8vZ207CisgICAgQGxpbmVzID0gc3BsaXQoIlxuIiwgJG91dHB1 dCk7CisKKyAgICByZXR1cm4gQGxpbmVzOworfQorCitzdWIgaGdfZXhlY3V0ZV9jbWQgeworICAg IG15ICgkY21kKSA9IEBfOworICAgIG15IEBsaW5lcyA9ICgpOworCisgICAgbXkgJG91dHB1dCA9 IGAkY21kYDsKKyAgICBAbGluZXMgPSBzcGxpdCgiXG4iLCAkb3V0cHV0KTsKKworICAgIHJldHVy biBAbGluZXM7Cit9CisKK3N1YiBleHRyYWN0X2Zvcm1hdHRlZF9zaWduYXR1cmVzIHsKKyAgICBt eSAoQHNpZ25hdHVyZV9saW5lcykgPSBAXzsKKworICAgIG15IEB0eXBlID0gQHNpZ25hdHVyZV9s aW5lczsKKworICAgIHMvXHMqKC4qKTouKi8kMS8gZm9yIChAdHlwZSk7CisKKyAgICAjIGN1dCAt ZjItIC1kIjoiCisgICAgcy9ccyouKjpccyooLispXHMqLyQxLyBmb3IgKEBzaWduYXR1cmVfbGlu ZXMpOworCisjIyBSZWZvcm1hdCBlbWFpbCBhZGRyZXNzZXMgKHdpdGggbmFtZXMpIHRvIGF2b2lk IGJhZGx5IHdyaXR0ZW4gc2lnbmF0dXJlcworCisgICAgZm9yZWFjaCBteSAkc2lnbmVyIChAc2ln bmF0dXJlX2xpbmVzKSB7CisJJHNpZ25lciA9IGRlZHVwbGljYXRlX2VtYWlsKCRzaWduZXIpOwor ICAgIH0KKworICAgIHJldHVybiAoXEB0eXBlLCBcQHNpZ25hdHVyZV9saW5lcyk7Cit9CisKK3N1 YiB2Y3NfZmluZF9zaWduZXJzIHsKKyAgICBteSAoJGNtZCwgJGZpbGUpID0gQF87CisgICAgbXkg JGNvbW1pdHM7CisgICAgbXkgQGxpbmVzID0gKCk7CisgICAgbXkgQHNpZ25hdHVyZXMgPSAoKTsK KyAgICBteSBAYXV0aG9ycyA9ICgpOworICAgIG15IEBzdGF0cyA9ICgpOworCisgICAgQGxpbmVz ID0gJnskVkNTX2NtZHN7ImV4ZWN1dGVfY21kIn19KCRjbWQpOworCisgICAgbXkgJHBhdHRlcm4g PSAkVkNTX2NtZHN7ImNvbW1pdF9wYXR0ZXJuIn07CisgICAgbXkgJGF1dGhvcl9wYXR0ZXJuID0g JFZDU19jbWRzeyJhdXRob3JfcGF0dGVybiJ9OworICAgIG15ICRzdGF0X3BhdHRlcm4gPSAkVkNT X2NtZHN7InN0YXRfcGF0dGVybiJ9OworCisgICAgJHN0YXRfcGF0dGVybiA9fiBzLyhcJFx3Kykv JDEvZWVnOwkJI2ludGVycG9sYXRlICRzdGF0X3BhdHRlcm4KKworICAgICRjb21taXRzID0gZ3Jl cCgvJHBhdHRlcm4vLCBAbGluZXMpOwkjIG9mIGNvbW1pdHMKKworICAgIEBhdXRob3JzID0gZ3Jl cCgvJGF1dGhvcl9wYXR0ZXJuLywgQGxpbmVzKTsKKyAgICBAc2lnbmF0dXJlcyA9IGdyZXAoL15b IFx0XSoke3NpZ25hdHVyZV9wYXR0ZXJufS4qXEAuKiQvLCBAbGluZXMpOworICAgIEBzdGF0cyA9 IGdyZXAoLyRzdGF0X3BhdHRlcm4vLCBAbGluZXMpOworCisjICAgIHByaW50KCJzdGF0czogPEBz dGF0cz5cbiIpOworCisgICAgcmV0dXJuICgwLCBcQHNpZ25hdHVyZXMsIFxAYXV0aG9ycywgXEBz dGF0cykgaWYgIUBzaWduYXR1cmVzOworCisgICAgc2F2ZV9jb21taXRzX2J5X2F1dGhvcihAbGlu ZXMpIGlmICgkaW50ZXJhY3RpdmUpOworICAgIHNhdmVfY29tbWl0c19ieV9zaWduZXIoQGxpbmVz KSBpZiAoJGludGVyYWN0aXZlKTsKKworICAgIGlmICghJGVtYWlsX2dpdF9wZW5ndWluX2NoaWVm cykgeworCUBzaWduYXR1cmVzID0gZ3JlcCghLyR7cGVuZ3Vpbl9jaGllZnN9L2ksIEBzaWduYXR1 cmVzKTsKKyAgICB9CisKKyAgICBteSAoJGF1dGhvcl9yZWYsICRhdXRob3JzX3JlZikgPSBleHRy YWN0X2Zvcm1hdHRlZF9zaWduYXR1cmVzKEBhdXRob3JzKTsKKyAgICBteSAoJHR5cGVzX3JlZiwg JHNpZ25lcnNfcmVmKSA9IGV4dHJhY3RfZm9ybWF0dGVkX3NpZ25hdHVyZXMoQHNpZ25hdHVyZXMp OworCisgICAgcmV0dXJuICgkY29tbWl0cywgJHNpZ25lcnNfcmVmLCAkYXV0aG9yc19yZWYsIFxA c3RhdHMpOworfQorCitzdWIgdmNzX2ZpbmRfYXV0aG9yIHsKKyAgICBteSAoJGNtZCkgPSBAXzsK KyAgICBteSBAbGluZXMgPSAoKTsKKworICAgIEBsaW5lcyA9ICZ7JFZDU19jbWRzeyJleGVjdXRl X2NtZCJ9fSgkY21kKTsKKworICAgIGlmICghJGVtYWlsX2dpdF9wZW5ndWluX2NoaWVmcykgewor CUBsaW5lcyA9IGdyZXAoIS8ke3Blbmd1aW5fY2hpZWZzfS9pLCBAbGluZXMpOworICAgIH0KKwor ICAgIHJldHVybiBAbGluZXMgaWYgIUBsaW5lczsKKworICAgIG15IEBhdXRob3JzID0gKCk7Cisg ICAgZm9yZWFjaCBteSAkbGluZSAoQGxpbmVzKSB7CisJaWYgKCRsaW5lID1+IG0vJFZDU19jbWRz eyJhdXRob3JfcGF0dGVybiJ9LykgeworCSAgICBteSAkYXV0aG9yID0gJDE7CisJICAgIG15ICgk bmFtZSwgJGFkZHJlc3MpID0gcGFyc2VfZW1haWwoJGF1dGhvcik7CisJICAgICRhdXRob3IgPSBm b3JtYXRfZW1haWwoJG5hbWUsICRhZGRyZXNzLCAxKTsKKwkgICAgcHVzaChAYXV0aG9ycywgJGF1 dGhvcik7CisJfQorICAgIH0KKworICAgIHNhdmVfY29tbWl0c19ieV9hdXRob3IoQGxpbmVzKSBp ZiAoJGludGVyYWN0aXZlKTsKKyAgICBzYXZlX2NvbW1pdHNfYnlfc2lnbmVyKEBsaW5lcykgaWYg KCRpbnRlcmFjdGl2ZSk7CisKKyAgICByZXR1cm4gQGF1dGhvcnM7Cit9CisKK3N1YiB2Y3Nfc2F2 ZV9jb21taXRzIHsKKyAgICBteSAoJGNtZCkgPSBAXzsKKyAgICBteSBAbGluZXMgPSAoKTsKKyAg ICBteSBAY29tbWl0cyA9ICgpOworCisgICAgQGxpbmVzID0gJnskVkNTX2NtZHN7ImV4ZWN1dGVf Y21kIn19KCRjbWQpOworCisgICAgZm9yZWFjaCBteSAkbGluZSAoQGxpbmVzKSB7CisJaWYgKCRs aW5lID1+IG0vJFZDU19jbWRzeyJibGFtZV9jb21taXRfcGF0dGVybiJ9LykgeworCSAgICBwdXNo KEBjb21taXRzLCAkMSk7CisJfQorICAgIH0KKworICAgIHJldHVybiBAY29tbWl0czsKK30KKwor c3ViIHZjc19ibGFtZSB7CisgICAgbXkgKCRmaWxlKSA9IEBfOworICAgIG15ICRjbWQ7CisgICAg bXkgQGNvbW1pdHMgPSAoKTsKKworICAgIHJldHVybiBAY29tbWl0cyBpZiAoISgtZiAkZmlsZSkp OworCisgICAgaWYgKEByYW5nZSAmJiAkVkNTX2NtZHN7ImJsYW1lX3JhbmdlX2NtZCJ9IGVxICIi KSB7CisJbXkgQGFsbF9jb21taXRzID0gKCk7CisKKwkkY21kID0gJFZDU19jbWRzeyJibGFtZV9m aWxlX2NtZCJ9OworCSRjbWQgPX4gcy8oXCRcdyspLyQxL2VlZzsJCSNpbnRlcnBvbGF0ZSAkY21k CisJQGFsbF9jb21taXRzID0gdmNzX3NhdmVfY29tbWl0cygkY21kKTsKKworCWZvcmVhY2ggbXkg JGZpbGVfcmFuZ2VfZGlmZiAoQHJhbmdlKSB7CisJICAgIG5leHQgaWYgKCEoJGZpbGVfcmFuZ2Vf ZGlmZiA9fiBtLyguKyk6KC4rKTooLispLykpOworCSAgICBteSAkZGlmZl9maWxlID0gJDE7CisJ ICAgIG15ICRkaWZmX3N0YXJ0ID0gJDI7CisJICAgIG15ICRkaWZmX2xlbmd0aCA9ICQzOworCSAg ICBuZXh0IGlmICgiJGZpbGUiIG5lICIkZGlmZl9maWxlIik7CisJICAgIGZvciAobXkgJGkgPSAk ZGlmZl9zdGFydDsgJGkgPCAkZGlmZl9zdGFydCArICRkaWZmX2xlbmd0aDsgJGkrKykgeworCQlw dXNoKEBjb21taXRzLCAkYWxsX2NvbW1pdHNbJGldKTsKKwkgICAgfQorCX0KKyAgICB9IGVsc2lm IChAcmFuZ2UpIHsKKwlmb3JlYWNoIG15ICRmaWxlX3JhbmdlX2RpZmYgKEByYW5nZSkgeworCSAg ICBuZXh0IGlmICghKCRmaWxlX3JhbmdlX2RpZmYgPX4gbS8oLispOiguKyk6KC4rKS8pKTsKKwkg ICAgbXkgJGRpZmZfZmlsZSA9ICQxOworCSAgICBteSAkZGlmZl9zdGFydCA9ICQyOworCSAgICBt eSAkZGlmZl9sZW5ndGggPSAkMzsKKwkgICAgbmV4dCBpZiAoIiRmaWxlIiBuZSAiJGRpZmZfZmls ZSIpOworCSAgICAkY21kID0gJFZDU19jbWRzeyJibGFtZV9yYW5nZV9jbWQifTsKKwkgICAgJGNt ZCA9fiBzLyhcJFx3KykvJDEvZWVnOwkJI2ludGVycG9sYXRlICRjbWQKKwkgICAgcHVzaChAY29t bWl0cywgdmNzX3NhdmVfY29tbWl0cygkY21kKSk7CisJfQorICAgIH0gZWxzZSB7CisJJGNtZCA9 ICRWQ1NfY21kc3siYmxhbWVfZmlsZV9jbWQifTsKKwkkY21kID1+IHMvKFwkXHcrKS8kMS9lZWc7 CQkjaW50ZXJwb2xhdGUgJGNtZAorCUBjb21taXRzID0gdmNzX3NhdmVfY29tbWl0cygkY21kKTsK KyAgICB9CisKKyAgICBmb3JlYWNoIG15ICRjb21taXQgKEBjb21taXRzKSB7CisJJGNvbW1pdCA9 fiBzL15cXi8vZzsKKyAgICB9CisKKyAgICByZXR1cm4gQGNvbW1pdHM7Cit9CisKK215ICRwcmlu dGVkX25vdmNzID0gMDsKK3N1YiB2Y3NfZXhpc3RzIHsKKyAgICAlVkNTX2NtZHMgPSAlVkNTX2Nt ZHNfZ2l0OworICAgIHJldHVybiAxIGlmIGV2YWwgJFZDU19jbWRzeyJhdmFpbGFibGUifTsKKyAg ICAlVkNTX2NtZHMgPSAlVkNTX2NtZHNfaGc7CisgICAgcmV0dXJuIDIgaWYgZXZhbCAkVkNTX2Nt ZHN7ImF2YWlsYWJsZSJ9OworICAgICVWQ1NfY21kcyA9ICgpOworICAgIGlmICghJHByaW50ZWRf bm92Y3MgJiYgJGVtYWlsX2dpdCkgeworCXdhcm4oIiRQOiBObyBzdXBwb3J0ZWQgVkNTIGZvdW5k LiAgQWRkIC0tbm9naXQgdG8gb3B0aW9ucz9cbiIpOworCXdhcm4oIlVzaW5nIGEgZ2l0IHJlcG9z aXRvcnkgcHJvZHVjZXMgYmV0dGVyIHJlc3VsdHMuXG4iKTsKKwl3YXJuKCJUcnkgTGludXMgVG9y dmFsZHMnIGxhdGVzdCBnaXQgcmVwb3NpdG9yeSB1c2luZzpcbiIpOworCXdhcm4oImdpdCBjbG9u ZSBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2ZzL3hmcy94ZnN0ZXN0cy1kZXYuZ2l0XG4i KTsKKwkkcHJpbnRlZF9ub3ZjcyA9IDE7CisgICAgfQorICAgIHJldHVybiAwOworfQorCitzdWIg dmNzX2lzX2dpdCB7CisgICAgdmNzX2V4aXN0cygpOworICAgIHJldHVybiAkdmNzX3VzZWQgPT0g MTsKK30KKworc3ViIHZjc19pc19oZyB7CisgICAgcmV0dXJuICR2Y3NfdXNlZCA9PSAyOworfQor CitzdWIgdmNzX2FkZF9jb21taXRfc2lnbmVycyB7CisgICAgcmV0dXJuIGlmICghdmNzX2V4aXN0 cygpKTsKKworICAgIG15ICgkY29tbWl0LCAkZGVzYykgPSBAXzsKKyAgICBteSAkY29tbWl0X2Nv dW50ID0gMDsKKyAgICBteSAkY29tbWl0X2F1dGhvcnNfcmVmOworICAgIG15ICRjb21taXRfc2ln bmVyc19yZWY7CisgICAgbXkgJHN0YXRzX3JlZjsKKyAgICBteSBAY29tbWl0X2F1dGhvcnMgPSAo KTsKKyAgICBteSBAY29tbWl0X3NpZ25lcnMgPSAoKTsKKyAgICBteSAkY21kOworCisgICAgJGNt ZCA9ICRWQ1NfY21kc3siZmluZF9jb21taXRfc2lnbmVyc19jbWQifTsKKyAgICAkY21kID1+IHMv KFwkXHcrKS8kMS9lZWc7CSNzdWJzdGl0dXRlIHZhcmlhYmxlcyBpbiAkY21kCisKKyAgICAoJGNv bW1pdF9jb3VudCwgJGNvbW1pdF9zaWduZXJzX3JlZiwgJGNvbW1pdF9hdXRob3JzX3JlZiwgJHN0 YXRzX3JlZikgPSB2Y3NfZmluZF9zaWduZXJzKCRjbWQsICIiKTsKKyAgICBAY29tbWl0X2F1dGhv cnMgPSBAeyRjb21taXRfYXV0aG9yc19yZWZ9IGlmIGRlZmluZWQgJGNvbW1pdF9hdXRob3JzX3Jl ZjsKKyAgICBAY29tbWl0X3NpZ25lcnMgPSBAeyRjb21taXRfc2lnbmVyc19yZWZ9IGlmIGRlZmlu ZWQgJGNvbW1pdF9zaWduZXJzX3JlZjsKKworICAgIGZvcmVhY2ggbXkgJHNpZ25lciAoQGNvbW1p dF9zaWduZXJzKSB7CisJJHNpZ25lciA9IGRlZHVwbGljYXRlX2VtYWlsKCRzaWduZXIpOworICAg IH0KKworICAgIHZjc19hc3NpZ24oJGRlc2MsIDEsIEBjb21taXRfc2lnbmVycyk7Cit9CisKK3N1 YiBpbnRlcmFjdGl2ZV9nZXRfbWFpbnRhaW5lcnMgeworICAgIG15ICgkbGlzdF9yZWYpID0gQF87 CisgICAgbXkgQGxpc3QgPSBAJGxpc3RfcmVmOworCisgICAgdmNzX2V4aXN0cygpOworCisgICAg bXkgJXNlbGVjdGVkOworICAgIG15ICVhdXRob3JlZDsKKyAgICBteSAlc2lnbmVkOworICAgIG15 ICRjb3VudCA9IDA7CisgICAgbXkgJG1haW50YWluZWQgPSAwOworICAgIGZvcmVhY2ggbXkgJGVu dHJ5IChAbGlzdCkgeworCSRtYWludGFpbmVkID0gMSBpZiAoJGVudHJ5LT5bMV0gPX4gL14obWFp bnRhaW5lcnxzdXBwb3J0ZXIpL2kpOworCSRzZWxlY3RlZHskY291bnR9ID0gMTsKKwkkYXV0aG9y ZWR7JGNvdW50fSA9IDA7CisJJHNpZ25lZHskY291bnR9ID0gMDsKKwkkY291bnQrKzsKKyAgICB9 CisKKyAgICAjbWVudSBsb29wCisgICAgbXkgJGRvbmUgPSAwOworICAgIG15ICRwcmludF9vcHRp b25zID0gMDsKKyAgICBteSAkcmVkcmF3ID0gMTsKKyAgICB3aGlsZSAoISRkb25lKSB7CisJJGNv dW50ID0gMDsKKwlpZiAoJHJlZHJhdykgeworCSAgICBwcmludGYgU1RERVJSICJcbiUxcyAlMnMg JS02NXMiLAorCQkJICAiKiIsICIjIiwgImVtYWlsL2xpc3QgYW5kIHJvbGU6c3RhdHMiOworCSAg ICBpZiAoJGVtYWlsX2dpdCB8fAorCQkoJGVtYWlsX2dpdF9mYWxsYmFjayAmJiAhJG1haW50YWlu ZWQpIHx8CisJCSRlbWFpbF9naXRfYmxhbWUpIHsKKwkJcHJpbnQgU1RERVJSICJhdXRoIHNpZ24i OworCSAgICB9CisJICAgIHByaW50IFNUREVSUiAiXG4iOworCSAgICBmb3JlYWNoIG15ICRlbnRy eSAoQGxpc3QpIHsKKwkJbXkgJGVtYWlsID0gJGVudHJ5LT5bMF07CisJCW15ICRyb2xlID0gJGVu dHJ5LT5bMV07CisJCW15ICRzZWwgPSAiIjsKKwkJJHNlbCA9ICIqIiBpZiAoJHNlbGVjdGVkeyRj b3VudH0pOworCQlteSAkY29tbWl0X2F1dGhvciA9ICRjb21taXRfYXV0aG9yX2hhc2h7JGVtYWls fTsKKwkJbXkgJGNvbW1pdF9zaWduZXIgPSAkY29tbWl0X3NpZ25lcl9oYXNoeyRlbWFpbH07CisJ CW15ICRhdXRob3JlZCA9IDA7CisJCW15ICRzaWduZWQgPSAwOworCQkkYXV0aG9yZWQrKyBmb3Ig KEB7JGNvbW1pdF9hdXRob3J9KTsKKwkJJHNpZ25lZCsrIGZvciAoQHskY29tbWl0X3NpZ25lcn0p OworCQlwcmludGYgU1RERVJSICIlMXMgJTJkICUtNjVzIiwgJHNlbCwgJGNvdW50ICsgMSwgJGVt YWlsOworCQlwcmludGYgU1RERVJSICIlNGQgJTRkIiwgJGF1dGhvcmVkLCAkc2lnbmVkCisJCSAg ICBpZiAoJGF1dGhvcmVkID4gMCB8fCAkc2lnbmVkID4gMCk7CisJCXByaW50ZiBTVERFUlIgIlxu ICAgICAlc1xuIiwgJHJvbGU7CisJCWlmICgkYXV0aG9yZWR7JGNvdW50fSkgeworCQkgICAgbXkg JGNvbW1pdF9hdXRob3IgPSAkY29tbWl0X2F1dGhvcl9oYXNoeyRlbWFpbH07CisJCSAgICBmb3Jl YWNoIG15ICRyZWYgKEB7JGNvbW1pdF9hdXRob3J9KSB7CisJCQlwcmludCBTVERFUlIgIiAgICAg QXV0aG9yOiBAeyRyZWZ9WzFdXG4iOworCQkgICAgfQorCQl9CisJCWlmICgkc2lnbmVkeyRjb3Vu dH0pIHsKKwkJICAgIG15ICRjb21taXRfc2lnbmVyID0gJGNvbW1pdF9zaWduZXJfaGFzaHskZW1h aWx9OworCQkgICAgZm9yZWFjaCBteSAkcmVmIChAeyRjb21taXRfc2lnbmVyfSkgeworCQkJcHJp bnQgU1RERVJSICIgICAgIEB7JHJlZn1bMl06IEB7JHJlZn1bMV1cbiI7CisJCSAgICB9CisJCX0K KworCQkkY291bnQrKzsKKwkgICAgfQorCX0KKwlteSAkZGF0ZV9yZWYgPSBcJGVtYWlsX2dpdF9z aW5jZTsKKwkkZGF0ZV9yZWYgPSBcJGVtYWlsX2hnX3NpbmNlIGlmICh2Y3NfaXNfaGcoKSk7CisJ aWYgKCRwcmludF9vcHRpb25zKSB7CisJICAgICRwcmludF9vcHRpb25zID0gMDsKKwkgICAgaWYg KHZjc19leGlzdHMoKSkgeworCQlwcmludCBTVERFUlIgPDxFT1QKKworVmVyc2lvbiBDb250cm9s IG9wdGlvbnM6CitnICB1c2UgZ2l0IGhpc3RvcnkgICAgICBbJGVtYWlsX2dpdF0KK2dmIHVzZSBn aXQtZmFsbGJhY2sgICAgIFskZW1haWxfZ2l0X2ZhbGxiYWNrXQorYiAgdXNlIGdpdCBibGFtZSAg ICAgICAgWyRlbWFpbF9naXRfYmxhbWVdCiticyB1c2UgYmxhbWUgc2lnbmF0dXJlcyBbJGVtYWls X2dpdF9ibGFtZV9zaWduYXR1cmVzXQorYyMgbWluaW11bSBjb21taXRzICAgICAgWyRlbWFpbF9n aXRfbWluX3NpZ25hdHVyZXNdCislIyBtaW4gcGVyY2VudCAgICAgICAgICBbJGVtYWlsX2dpdF9t aW5fcGVyY2VudF0KK2QjIGhpc3RvcnkgdG8gdXNlICAgICAgIFskJGRhdGVfcmVmXQoreCMgbWF4 IG1haW50YWluZXJzICAgICAgWyRlbWFpbF9naXRfbWF4X21haW50YWluZXJzXQordCAgYWxsIHNp Z25hdHVyZSB0eXBlcyAgWyRlbWFpbF9naXRfYWxsX3NpZ25hdHVyZV90eXBlc10KK20gIHVzZSAu bWFpbG1hcCAgICAgICAgIFskZW1haWxfdXNlX21haWxtYXBdCitFT1QKKwkgICAgfQorCSAgICBw cmludCBTVERFUlIgPDxFT1QKKworQWRkaXRpb25hbCBvcHRpb25zOgorMCAgdG9nZ2xlIGFsbAor dG0gdG9nZ2xlIG1haW50YWluZXJzCit0ZyB0b2dnbGUgZ2l0IGVudHJpZXMKK3RsIHRvZ2dsZSBv cGVuIGxpc3QgZW50cmllcwordHMgdG9nZ2xlIHN1YnNjcmliZXIgbGlzdCBlbnRyaWVzCitmICBl bWFpbHMgaW4gZmlsZSAgICAgICBbJGVtYWlsX2ZpbGVfZW1haWxzXQorayAga2V5d29yZHMgaW4g ZmlsZSAgICAgWyRrZXl3b3Jkc10KK3IgIHJlbW92ZSBkdXBsaWNhdGVzICAgIFskZW1haWxfcmVt b3ZlX2R1cGxpY2F0ZXNdCitwIyBwYXR0ZXJuIG1hdGNoIGRlcHRoICBbJHBhdHRlcm5fZGVwdGhd CitFT1QKKwl9CisJcHJpbnQgU1RERVJSCisiXG4jKHRvZ2dsZSksIEEjKGF1dGhvciksIFMjKHNp Z25lZCkgKihhbGwpLCBeKG5vbmUpLCBPKG9wdGlvbnMpLCBZKGFwcHJvdmUpOiAiOworCisJbXkg JGlucHV0ID0gPFNURElOPjsKKwljaG9tcCgkaW5wdXQpOworCisJJHJlZHJhdyA9IDE7CisJbXkg JHJlcnVuID0gMDsKKwlteSBAd2lzaCA9IHNwbGl0KC9bLCBdKy8sICRpbnB1dCk7CisJZm9yZWFj aCBteSAkbnIgKEB3aXNoKSB7CisJICAgICRuciA9IGxjKCRucik7CisJICAgIG15ICRzZWwgPSBz dWJzdHIoJG5yLCAwLCAxKTsKKwkgICAgbXkgJHN0ciA9IHN1YnN0cigkbnIsIDEpOworCSAgICBt eSAkdmFsID0gMDsKKwkgICAgJHZhbCA9ICQxIGlmICRzdHIgPX4gL14oXGQrKSQvOworCisJICAg IGlmICgkc2VsIGVxICJ5IikgeworCQkkaW50ZXJhY3RpdmUgPSAwOworCQkkZG9uZSA9IDE7CisJ CSRvdXRwdXRfcm9sZXN0YXRzID0gMDsKKwkJJG91dHB1dF9yb2xlcyA9IDA7CisJCWxhc3Q7CisJ ICAgIH0gZWxzaWYgKCRuciA9fiAvXlxkKyQvICYmICRuciA+IDAgJiYgJG5yIDw9ICRjb3VudCkg eworCQkkc2VsZWN0ZWR7JG5yIC0gMX0gPSAhJHNlbGVjdGVkeyRuciAtIDF9OworCSAgICB9IGVs c2lmICgkc2VsIGVxICIqIiB8fCAkc2VsIGVxICdeJykgeworCQlteSAkdG9nZ2xlID0gMDsKKwkJ JHRvZ2dsZSA9IDEgaWYgKCRzZWwgZXEgJyonKTsKKwkJZm9yIChteSAkaSA9IDA7ICRpIDwgJGNv dW50OyAkaSsrKSB7CisJCSAgICAkc2VsZWN0ZWR7JGl9ID0gJHRvZ2dsZTsKKwkJfQorCSAgICB9 IGVsc2lmICgkc2VsIGVxICIwIikgeworCQlmb3IgKG15ICRpID0gMDsgJGkgPCAkY291bnQ7ICRp KyspIHsKKwkJICAgICRzZWxlY3RlZHskaX0gPSAhJHNlbGVjdGVkeyRpfTsKKwkJfQorCSAgICB9 IGVsc2lmICgkc2VsIGVxICJ0IikgeworCQlpZiAobGMoJHN0cikgZXEgIm0iKSB7CisJCSAgICBm b3IgKG15ICRpID0gMDsgJGkgPCAkY291bnQ7ICRpKyspIHsKKwkJCSRzZWxlY3RlZHskaX0gPSAh JHNlbGVjdGVkeyRpfQorCQkJICAgIGlmICgkbGlzdFskaV0tPlsxXSA9fiAvXihtYWludGFpbmVy fHN1cHBvcnRlcikvaSk7CisJCSAgICB9CisJCX0gZWxzaWYgKGxjKCRzdHIpIGVxICJnIikgewor CQkgICAgZm9yIChteSAkaSA9IDA7ICRpIDwgJGNvdW50OyAkaSsrKSB7CisJCQkkc2VsZWN0ZWR7 JGl9ID0gISRzZWxlY3RlZHskaX0KKwkJCSAgICBpZiAoJGxpc3RbJGldLT5bMV0gPX4gL14oYXV0 aG9yfGNvbW1pdHxzaWduZXIpL2kpOworCQkgICAgfQorCQl9IGVsc2lmIChsYygkc3RyKSBlcSAi bCIpIHsKKwkJICAgIGZvciAobXkgJGkgPSAwOyAkaSA8ICRjb3VudDsgJGkrKykgeworCQkJJHNl bGVjdGVkeyRpfSA9ICEkc2VsZWN0ZWR7JGl9CisJCQkgICAgaWYgKCRsaXN0WyRpXS0+WzFdID1+ IC9eKG9wZW4gbGlzdCkvaSk7CisJCSAgICB9CisJCX0gZWxzaWYgKGxjKCRzdHIpIGVxICJzIikg eworCQkgICAgZm9yIChteSAkaSA9IDA7ICRpIDwgJGNvdW50OyAkaSsrKSB7CisJCQkkc2VsZWN0 ZWR7JGl9ID0gISRzZWxlY3RlZHskaX0KKwkJCSAgICBpZiAoJGxpc3RbJGldLT5bMV0gPX4gL14o c3Vic2NyaWJlciBsaXN0KS9pKTsKKwkJICAgIH0KKwkJfQorCSAgICB9IGVsc2lmICgkc2VsIGVx ICJhIikgeworCQlpZiAoJHZhbCA+IDAgJiYgJHZhbCA8PSAkY291bnQpIHsKKwkJICAgICRhdXRo b3JlZHskdmFsIC0gMX0gPSAhJGF1dGhvcmVkeyR2YWwgLSAxfTsKKwkJfSBlbHNpZiAoJHN0ciBl cSAnKicgfHwgJHN0ciBlcSAnXicpIHsKKwkJICAgIG15ICR0b2dnbGUgPSAwOworCQkgICAgJHRv Z2dsZSA9IDEgaWYgKCRzdHIgZXEgJyonKTsKKwkJICAgIGZvciAobXkgJGkgPSAwOyAkaSA8ICRj b3VudDsgJGkrKykgeworCQkJJGF1dGhvcmVkeyRpfSA9ICR0b2dnbGU7CisJCSAgICB9CisJCX0K KwkgICAgfSBlbHNpZiAoJHNlbCBlcSAicyIpIHsKKwkJaWYgKCR2YWwgPiAwICYmICR2YWwgPD0g JGNvdW50KSB7CisJCSAgICAkc2lnbmVkeyR2YWwgLSAxfSA9ICEkc2lnbmVkeyR2YWwgLSAxfTsK KwkJfSBlbHNpZiAoJHN0ciBlcSAnKicgfHwgJHN0ciBlcSAnXicpIHsKKwkJICAgIG15ICR0b2dn bGUgPSAwOworCQkgICAgJHRvZ2dsZSA9IDEgaWYgKCRzdHIgZXEgJyonKTsKKwkJICAgIGZvciAo bXkgJGkgPSAwOyAkaSA8ICRjb3VudDsgJGkrKykgeworCQkJJHNpZ25lZHskaX0gPSAkdG9nZ2xl OworCQkgICAgfQorCQl9CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgIm8iKSB7CisJCSRwcmludF9v cHRpb25zID0gMTsKKwkJJHJlZHJhdyA9IDE7CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgImciKSB7 CisJCWlmICgkc3RyIGVxICJmIikgeworCQkgICAgYm9vbF9pbnZlcnQoXCRlbWFpbF9naXRfZmFs bGJhY2spOworCQl9IGVsc2UgeworCQkgICAgYm9vbF9pbnZlcnQoXCRlbWFpbF9naXQpOworCQl9 CisJCSRyZXJ1biA9IDE7CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgImIiKSB7CisJCWlmICgkc3Ry IGVxICJzIikgeworCQkgICAgYm9vbF9pbnZlcnQoXCRlbWFpbF9naXRfYmxhbWVfc2lnbmF0dXJl cyk7CisJCX0gZWxzZSB7CisJCSAgICBib29sX2ludmVydChcJGVtYWlsX2dpdF9ibGFtZSk7CisJ CX0KKwkJJHJlcnVuID0gMTsKKwkgICAgfSBlbHNpZiAoJHNlbCBlcSAiYyIpIHsKKwkJaWYgKCR2 YWwgPiAwKSB7CisJCSAgICAkZW1haWxfZ2l0X21pbl9zaWduYXR1cmVzID0gJHZhbDsKKwkJICAg ICRyZXJ1biA9IDE7CisJCX0KKwkgICAgfSBlbHNpZiAoJHNlbCBlcSAieCIpIHsKKwkJaWYgKCR2 YWwgPiAwKSB7CisJCSAgICAkZW1haWxfZ2l0X21heF9tYWludGFpbmVycyA9ICR2YWw7CisJCSAg ICAkcmVydW4gPSAxOworCQl9CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgIiUiKSB7CisJCWlmICgk c3RyIG5lICIiICYmICR2YWwgPj0gMCkgeworCQkgICAgJGVtYWlsX2dpdF9taW5fcGVyY2VudCA9 ICR2YWw7CisJCSAgICAkcmVydW4gPSAxOworCQl9CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgImQi KSB7CisJCWlmICh2Y3NfaXNfZ2l0KCkpIHsKKwkJICAgICRlbWFpbF9naXRfc2luY2UgPSAkc3Ry OworCQl9IGVsc2lmICh2Y3NfaXNfaGcoKSkgeworCQkgICAgJGVtYWlsX2hnX3NpbmNlID0gJHN0 cjsKKwkJfQorCQkkcmVydW4gPSAxOworCSAgICB9IGVsc2lmICgkc2VsIGVxICJ0IikgeworCQli b29sX2ludmVydChcJGVtYWlsX2dpdF9hbGxfc2lnbmF0dXJlX3R5cGVzKTsKKwkJJHJlcnVuID0g MTsKKwkgICAgfSBlbHNpZiAoJHNlbCBlcSAiZiIpIHsKKwkJYm9vbF9pbnZlcnQoXCRlbWFpbF9m aWxlX2VtYWlscyk7CisJCSRyZXJ1biA9IDE7CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgInIiKSB7 CisJCWJvb2xfaW52ZXJ0KFwkZW1haWxfcmVtb3ZlX2R1cGxpY2F0ZXMpOworCQkkcmVydW4gPSAx OworCSAgICB9IGVsc2lmICgkc2VsIGVxICJtIikgeworCQlib29sX2ludmVydChcJGVtYWlsX3Vz ZV9tYWlsbWFwKTsKKwkJcmVhZF9tYWlsbWFwKCk7CisJCSRyZXJ1biA9IDE7CisJICAgIH0gZWxz aWYgKCRzZWwgZXEgImsiKSB7CisJCWJvb2xfaW52ZXJ0KFwka2V5d29yZHMpOworCQkkcmVydW4g PSAxOworCSAgICB9IGVsc2lmICgkc2VsIGVxICJwIikgeworCQlpZiAoJHN0ciBuZSAiIiAmJiAk dmFsID49IDApIHsKKwkJICAgICRwYXR0ZXJuX2RlcHRoID0gJHZhbDsKKwkJICAgICRyZXJ1biA9 IDE7CisJCX0KKwkgICAgfSBlbHNpZiAoJHNlbCBlcSAiaCIgfHwgJHNlbCBlcSAiPyIpIHsKKwkJ cHJpbnQgU1RERVJSIDw8RU9UCisKK0ludGVyYWN0aXZlIG1vZGUgYWxsb3dzIHlvdSB0byBzZWxl Y3QgdGhlIHZhcmlvdXMgbWFpbnRhaW5lcnMsIHN1Ym1pdHRlcnMsCitjb21taXQgc2lnbmVycyBh bmQgbWFpbGluZyBsaXN0cyB0aGF0IGNvdWxkIGJlIENDJ2Qgb24gYSBwYXRjaC4KKworQW55ICon ZCBlbnRyeSBpcyBzZWxlY3RlZC4KKworSWYgeW91IGhhdmUgZ2l0IG9yIGhnIGluc3RhbGxlZCwg eW91IGNhbiBjaG9vc2UgdG8gc3VtbWFyaXplIHRoZSBjb21taXQKK2hpc3Rvcnkgb2YgZmlsZXMg aW4gdGhlIHBhdGNoLiAgQWxzbywgZWFjaCBsaW5lIG9mIHRoZSBjdXJyZW50IGZpbGUgY2FuCiti ZSBtYXRjaGVkIHRvIGl0cyBjb21taXQgYXV0aG9yIGFuZCB0aGF0IGNvbW1pdHMgc2lnbmVycyB3 aXRoIGJsYW1lLgorCitWYXJpb3VzIGtub2JzIGV4aXN0IHRvIGNvbnRyb2wgdGhlIGxlbmd0aCBv ZiB0aW1lIGZvciBhY3RpdmUgY29tbWl0Cit0cmFja2luZywgdGhlIG1heGltdW0gbnVtYmVyIG9m IGNvbW1pdCBhdXRob3JzIGFuZCBzaWduZXJzIHRvIGFkZCwKK2FuZCBzdWNoLgorCitFbnRlciBz ZWxlY3Rpb25zIGF0IHRoZSBwcm9tcHQgdW50aWwgeW91IGFyZSBzYXRpc2ZpZWQgdGhhdCB0aGUg c2VsZWN0ZWQKK21haW50YWluZXJzIGFyZSBhcHByb3ByaWF0ZS4gIFlvdSBtYXkgZW50ZXIgbXVs dGlwbGUgc2VsZWN0aW9ucyBzZXBhcmF0ZWQKK2J5IGVpdGhlciBjb21tYXMgb3Igc3BhY2VzLgor CitFT1QKKwkgICAgfSBlbHNlIHsKKwkJcHJpbnQgU1RERVJSICJpbnZhbGlkIG9wdGlvbjogJyRu cidcbiI7CisJCSRyZWRyYXcgPSAwOworCSAgICB9CisJfQorCWlmICgkcmVydW4pIHsKKwkgICAg cHJpbnQgU1RERVJSICJnaXQtYmxhbWUgY2FuIGJlIHZlcnkgc2xvdywgcGxlYXNlIGhhdmUgcGF0 aWVuY2UuLi4iCisJCWlmICgkZW1haWxfZ2l0X2JsYW1lKTsKKwkgICAgZ290byAmZ2V0X21haW50 YWluZXJzOworCX0KKyAgICB9CisKKyAgICAjZHJvcCBub3Qgc2VsZWN0ZWQgZW50cmllcworICAg ICRjb3VudCA9IDA7CisgICAgbXkgQG5ld19lbWFpbHRvID0gKCk7CisgICAgZm9yZWFjaCBteSAk ZW50cnkgKEBsaXN0KSB7CisJaWYgKCRzZWxlY3RlZHskY291bnR9KSB7CisJICAgIHB1c2goQG5l d19lbWFpbHRvLCAkbGlzdFskY291bnRdKTsKKwl9CisJJGNvdW50Kys7CisgICAgfQorICAgIHJl dHVybiBAbmV3X2VtYWlsdG87Cit9CisKK3N1YiBib29sX2ludmVydCB7CisgICAgbXkgKCRib29s X3JlZikgPSBAXzsKKworICAgIGlmICgkJGJvb2xfcmVmKSB7CisJJCRib29sX3JlZiA9IDA7Cisg ICAgfSBlbHNlIHsKKwkkJGJvb2xfcmVmID0gMTsKKyAgICB9Cit9CisKK3N1YiBkZWR1cGxpY2F0 ZV9lbWFpbCB7CisgICAgbXkgKCRlbWFpbCkgPSBAXzsKKworICAgIG15ICRtYXRjaGVkID0gMDsK KyAgICBteSAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRlbWFpbCk7CisgICAgJGVt YWlsID0gZm9ybWF0X2VtYWlsKCRuYW1lLCAkYWRkcmVzcywgMSk7CisgICAgJGVtYWlsID0gbWFp bG1hcF9lbWFpbCgkZW1haWwpOworCisgICAgcmV0dXJuICRlbWFpbCBpZiAoISRlbWFpbF9yZW1v dmVfZHVwbGljYXRlcyk7CisKKyAgICAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRl bWFpbCk7CisKKyAgICBpZiAoJG5hbWUgbmUgIiIgJiYgJGRlZHVwbGljYXRlX25hbWVfaGFzaHts YygkbmFtZSl9KSB7CisJJG5hbWUgPSAkZGVkdXBsaWNhdGVfbmFtZV9oYXNoe2xjKCRuYW1lKX0t PlswXTsKKwkkYWRkcmVzcyA9ICRkZWR1cGxpY2F0ZV9uYW1lX2hhc2h7bGMoJG5hbWUpfS0+WzFd OworCSRtYXRjaGVkID0gMTsKKyAgICB9IGVsc2lmICgkZGVkdXBsaWNhdGVfYWRkcmVzc19oYXNo e2xjKCRhZGRyZXNzKX0pIHsKKwkkbmFtZSA9ICRkZWR1cGxpY2F0ZV9hZGRyZXNzX2hhc2h7bGMo JGFkZHJlc3MpfS0+WzBdOworCSRhZGRyZXNzID0gJGRlZHVwbGljYXRlX2FkZHJlc3NfaGFzaHts YygkYWRkcmVzcyl9LT5bMV07CisJJG1hdGNoZWQgPSAxOworICAgIH0KKyAgICBpZiAoISRtYXRj aGVkKSB7CisJJGRlZHVwbGljYXRlX25hbWVfaGFzaHtsYygkbmFtZSl9ID0gWyAkbmFtZSwgJGFk ZHJlc3MgXTsKKwkkZGVkdXBsaWNhdGVfYWRkcmVzc19oYXNoe2xjKCRhZGRyZXNzKX0gPSBbICRu YW1lLCAkYWRkcmVzcyBdOworICAgIH0KKyAgICAkZW1haWwgPSBmb3JtYXRfZW1haWwoJG5hbWUs ICRhZGRyZXNzLCAxKTsKKyAgICAkZW1haWwgPSBtYWlsbWFwX2VtYWlsKCRlbWFpbCk7CisgICAg cmV0dXJuICRlbWFpbDsKK30KKworc3ViIHNhdmVfY29tbWl0c19ieV9hdXRob3IgeworICAgIG15 IChAbGluZXMpID0gQF87CisKKyAgICBteSBAYXV0aG9ycyA9ICgpOworICAgIG15IEBjb21taXRz ID0gKCk7CisgICAgbXkgQHN1YmplY3RzID0gKCk7CisKKyAgICBmb3JlYWNoIG15ICRsaW5lIChA bGluZXMpIHsKKwlpZiAoJGxpbmUgPX4gbS8kVkNTX2NtZHN7ImF1dGhvcl9wYXR0ZXJuIn0vKSB7 CisJICAgIG15ICRhdXRob3IgPSAkMTsKKwkgICAgJGF1dGhvciA9IGRlZHVwbGljYXRlX2VtYWls KCRhdXRob3IpOworCSAgICBwdXNoKEBhdXRob3JzLCAkYXV0aG9yKTsKKwl9CisJcHVzaChAY29t bWl0cywgJDEpIGlmICgkbGluZSA9fiBtLyRWQ1NfY21kc3siY29tbWl0X3BhdHRlcm4ifS8pOwor CXB1c2goQHN1YmplY3RzLCAkMSkgaWYgKCRsaW5lID1+IG0vJFZDU19jbWRzeyJzdWJqZWN0X3Bh dHRlcm4ifS8pOworICAgIH0KKworICAgIGZvciAobXkgJGkgPSAwOyAkaSA8IEBhdXRob3JzOyAk aSsrKSB7CisJbXkgJGV4aXN0cyA9IDA7CisJZm9yZWFjaCBteSAkcmVmKEB7JGNvbW1pdF9hdXRo b3JfaGFzaHskYXV0aG9yc1skaV19fSkgeworCSAgICBpZiAoQHskcmVmfVswXSBlcSAkY29tbWl0 c1skaV0gJiYKKwkJQHskcmVmfVsxXSBlcSAkc3ViamVjdHNbJGldKSB7CisJCSRleGlzdHMgPSAx OworCQlsYXN0OworCSAgICB9CisJfQorCWlmICghJGV4aXN0cykgeworCSAgICBwdXNoKEB7JGNv bW1pdF9hdXRob3JfaGFzaHskYXV0aG9yc1skaV19fSwKKwkJIFsgKCRjb21taXRzWyRpXSwgJHN1 YmplY3RzWyRpXSkgXSk7CisJfQorICAgIH0KK30KKworc3ViIHNhdmVfY29tbWl0c19ieV9zaWdu ZXIgeworICAgIG15IChAbGluZXMpID0gQF87CisKKyAgICBteSAkY29tbWl0ID0gIiI7CisgICAg bXkgJHN1YmplY3QgPSAiIjsKKworICAgIGZvcmVhY2ggbXkgJGxpbmUgKEBsaW5lcykgeworCSRj b21taXQgPSAkMSBpZiAoJGxpbmUgPX4gbS8kVkNTX2NtZHN7ImNvbW1pdF9wYXR0ZXJuIn0vKTsK Kwkkc3ViamVjdCA9ICQxIGlmICgkbGluZSA9fiBtLyRWQ1NfY21kc3sic3ViamVjdF9wYXR0ZXJu In0vKTsKKwlpZiAoJGxpbmUgPX4gL15bIFx0XSoke3NpZ25hdHVyZV9wYXR0ZXJufS4qXEAuKiQv KSB7CisJICAgIG15IEBzaWduYXR1cmVzID0gKCRsaW5lKTsKKwkgICAgbXkgKCR0eXBlc19yZWYs ICRzaWduZXJzX3JlZikgPSBleHRyYWN0X2Zvcm1hdHRlZF9zaWduYXR1cmVzKEBzaWduYXR1cmVz KTsKKwkgICAgbXkgQHR5cGVzID0gQCR0eXBlc19yZWY7CisJICAgIG15IEBzaWduZXJzID0gQCRz aWduZXJzX3JlZjsKKworCSAgICBteSAkdHlwZSA9ICR0eXBlc1swXTsKKwkgICAgbXkgJHNpZ25l ciA9ICRzaWduZXJzWzBdOworCisJICAgICRzaWduZXIgPSBkZWR1cGxpY2F0ZV9lbWFpbCgkc2ln bmVyKTsKKworCSAgICBteSAkZXhpc3RzID0gMDsKKwkgICAgZm9yZWFjaCBteSAkcmVmKEB7JGNv bW1pdF9zaWduZXJfaGFzaHskc2lnbmVyfX0pIHsKKwkJaWYgKEB7JHJlZn1bMF0gZXEgJGNvbW1p dCAmJgorCQkgICAgQHskcmVmfVsxXSBlcSAkc3ViamVjdCAmJgorCQkgICAgQHskcmVmfVsyXSBl cSAkdHlwZSkgeworCQkgICAgJGV4aXN0cyA9IDE7CisJCSAgICBsYXN0OworCQl9CisJICAgIH0K KwkgICAgaWYgKCEkZXhpc3RzKSB7CisJCXB1c2goQHskY29tbWl0X3NpZ25lcl9oYXNoeyRzaWdu ZXJ9fSwKKwkJICAgICBbICgkY29tbWl0LCAkc3ViamVjdCwgJHR5cGUpIF0pOworCSAgICB9CisJ fQorICAgIH0KK30KKworc3ViIHZjc19hc3NpZ24geworICAgIG15ICgkcm9sZSwgJGRpdmlzb3Is IEBsaW5lcykgPSBAXzsKKworICAgIG15ICVoYXNoOworICAgIG15ICRjb3VudCA9IDA7CisKKyAg ICByZXR1cm4gaWYgKEBsaW5lcyA8PSAwKTsKKworICAgIGlmICgkZGl2aXNvciA8PSAwKSB7CisJ d2FybigiQmFkIGRpdmlzb3IgaW4gIiAuIChjYWxsZXIoMCkpWzNdIC4gIjogJGRpdmlzb3JcbiIp OworCSRkaXZpc29yID0gMTsKKyAgICB9CisKKyAgICBAbGluZXMgPSBtYWlsbWFwKEBsaW5lcyk7 CisKKyAgICByZXR1cm4gaWYgKEBsaW5lcyA8PSAwKTsKKworICAgIEBsaW5lcyA9IHNvcnQoQGxp bmVzKTsKKworICAgICMgdW5pcSAtYworICAgICRoYXNoeyRffSsrIGZvciBAbGluZXM7CisKKyAg ICAjIHNvcnQgLXJuCisgICAgZm9yZWFjaCBteSAkbGluZSAoc29ydCB7JGhhc2h7JGJ9IDw9PiAk aGFzaHskYX19IGtleXMgJWhhc2gpIHsKKwlteSAkc2lnbl9vZmZzID0gJGhhc2h7JGxpbmV9Owor CW15ICRwZXJjZW50ID0gJHNpZ25fb2ZmcyAqIDEwMCAvICRkaXZpc29yOworCisJJHBlcmNlbnQg PSAxMDAgaWYgKCRwZXJjZW50ID4gMTAwKTsKKwluZXh0IGlmIChpZ25vcmVfZW1haWxfYWRkcmVz cygkbGluZSkpOworCSRjb3VudCsrOworCWxhc3QgaWYgKCRzaWduX29mZnMgPCAkZW1haWxfZ2l0 X21pbl9zaWduYXR1cmVzIHx8CisJCSAkY291bnQgPiAkZW1haWxfZ2l0X21heF9tYWludGFpbmVy cyB8fAorCQkgJHBlcmNlbnQgPCAkZW1haWxfZ2l0X21pbl9wZXJjZW50KTsKKwlwdXNoX2VtYWls X2FkZHJlc3MoJGxpbmUsICcnKTsKKwlpZiAoJG91dHB1dF9yb2xlc3RhdHMpIHsKKwkgICAgbXkg JGZtdF9wZXJjZW50ID0gc3ByaW50ZigiJS4wZiIsICRwZXJjZW50KTsKKwkgICAgYWRkX3JvbGUo JGxpbmUsICIkcm9sZTokc2lnbl9vZmZzLyRkaXZpc29yPSRmbXRfcGVyY2VudCUiKTsKKwl9IGVs c2UgeworCSAgICBhZGRfcm9sZSgkbGluZSwgJHJvbGUpOworCX0KKyAgICB9Cit9CisKK3N1YiB2 Y3NfZmlsZV9zaWdub2ZmcyB7CisgICAgbXkgKCRmaWxlKSA9IEBfOworCisgICAgbXkgJGF1dGhv cnNfcmVmOworICAgIG15ICRzaWduZXJzX3JlZjsKKyAgICBteSAkc3RhdHNfcmVmOworICAgIG15 IEBhdXRob3JzID0gKCk7CisgICAgbXkgQHNpZ25lcnMgPSAoKTsKKyAgICBteSBAc3RhdHMgPSAo KTsKKyAgICBteSAkY29tbWl0czsKKworICAgICR2Y3NfdXNlZCA9IHZjc19leGlzdHMoKTsKKyAg ICByZXR1cm4gaWYgKCEkdmNzX3VzZWQpOworCisgICAgbXkgJGNtZCA9ICRWQ1NfY21kc3siZmlu ZF9zaWduZXJzX2NtZCJ9OworICAgICRjbWQgPX4gcy8oXCRcdyspLyQxL2VlZzsJCSMgaW50ZXJw b2xhdGUgJGNtZAorCisgICAgKCRjb21taXRzLCAkc2lnbmVyc19yZWYsICRhdXRob3JzX3JlZiwg JHN0YXRzX3JlZikgPSB2Y3NfZmluZF9zaWduZXJzKCRjbWQsICRmaWxlKTsKKworICAgIEBzaWdu ZXJzID0gQHskc2lnbmVyc19yZWZ9IGlmIGRlZmluZWQgJHNpZ25lcnNfcmVmOworICAgIEBhdXRo b3JzID0gQHskYXV0aG9yc19yZWZ9IGlmIGRlZmluZWQgJGF1dGhvcnNfcmVmOworICAgIEBzdGF0 cyA9IEB7JHN0YXRzX3JlZn0gaWYgZGVmaW5lZCAkc3RhdHNfcmVmOworCisjICAgIHByaW50KCJj b21taXRzOiA8JGNvbW1pdHM+XG5zaWduZXJzOjxAc2lnbmVycz5cbmF1dGhvcnM6IDxAYXV0aG9y cz5cbnN0YXRzOiA8QHN0YXRzPlxuIik7CisKKyAgICBmb3JlYWNoIG15ICRzaWduZXIgKEBzaWdu ZXJzKSB7CisJJHNpZ25lciA9IGRlZHVwbGljYXRlX2VtYWlsKCRzaWduZXIpOworICAgIH0KKwor ICAgIHZjc19hc3NpZ24oImNvbW1pdF9zaWduZXIiLCAkY29tbWl0cywgQHNpZ25lcnMpOworICAg IHZjc19hc3NpZ24oImF1dGhvcmVkIiwgJGNvbW1pdHMsIEBhdXRob3JzKTsKKyAgICBpZiAoJCNh dXRob3JzID09ICQjc3RhdHMpIHsKKwlteSAkc3RhdF9wYXR0ZXJuID0gJFZDU19jbWRzeyJzdGF0 X3BhdHRlcm4ifTsKKwkkc3RhdF9wYXR0ZXJuID1+IHMvKFwkXHcrKS8kMS9lZWc7CSNpbnRlcnBv bGF0ZSAkc3RhdF9wYXR0ZXJuCisKKwlteSAkYWRkZWQgPSAwOworCW15ICRkZWxldGVkID0gMDsK Kwlmb3IgKG15ICRpID0gMDsgJGkgPD0gJCNzdGF0czsgJGkrKykgeworCSAgICBpZiAoJHN0YXRz WyRpXSA9fiAvJHN0YXRfcGF0dGVybi8pIHsKKwkJJGFkZGVkICs9ICQxOworCQkkZGVsZXRlZCAr PSAkMjsKKwkgICAgfQorCX0KKwlteSBAdG1wX2F1dGhvcnMgPSB1bmlxKEBhdXRob3JzKTsKKwlm b3JlYWNoIG15ICRhdXRob3IgKEB0bXBfYXV0aG9ycykgeworCSAgICAkYXV0aG9yID0gZGVkdXBs aWNhdGVfZW1haWwoJGF1dGhvcik7CisJfQorCUB0bXBfYXV0aG9ycyA9IHVuaXEoQHRtcF9hdXRo b3JzKTsKKwlteSBAbGlzdF9hZGRlZCA9ICgpOworCW15IEBsaXN0X2RlbGV0ZWQgPSAoKTsKKwlm b3JlYWNoIG15ICRhdXRob3IgKEB0bXBfYXV0aG9ycykgeworCSAgICBteSAkYXV0aF9hZGRlZCA9 IDA7CisJICAgIG15ICRhdXRoX2RlbGV0ZWQgPSAwOworCSAgICBmb3IgKG15ICRpID0gMDsgJGkg PD0gJCNzdGF0czsgJGkrKykgeworCQlpZiAoJGF1dGhvciBlcSBkZWR1cGxpY2F0ZV9lbWFpbCgk YXV0aG9yc1skaV0pICYmCisJCSAgICAkc3RhdHNbJGldID1+IC8kc3RhdF9wYXR0ZXJuLykgewor CQkgICAgJGF1dGhfYWRkZWQgKz0gJDE7CisJCSAgICAkYXV0aF9kZWxldGVkICs9ICQyOworCQl9 CisJICAgIH0KKwkgICAgZm9yIChteSAkaSA9IDA7ICRpIDwgJGF1dGhfYWRkZWQ7ICRpKyspIHsK KwkJcHVzaChAbGlzdF9hZGRlZCwgJGF1dGhvcik7CisJICAgIH0KKwkgICAgZm9yIChteSAkaSA9 IDA7ICRpIDwgJGF1dGhfZGVsZXRlZDsgJGkrKykgeworCQlwdXNoKEBsaXN0X2RlbGV0ZWQsICRh dXRob3IpOworCSAgICB9CisJfQorCXZjc19hc3NpZ24oImFkZGVkX2xpbmVzIiwgJGFkZGVkLCBA bGlzdF9hZGRlZCk7CisJdmNzX2Fzc2lnbigicmVtb3ZlZF9saW5lcyIsICRkZWxldGVkLCBAbGlz dF9kZWxldGVkKTsKKyAgICB9Cit9CisKK3N1YiB2Y3NfZmlsZV9ibGFtZSB7CisgICAgbXkgKCRm aWxlKSA9IEBfOworCisgICAgbXkgQHNpZ25lcnMgPSAoKTsKKyAgICBteSBAYWxsX2NvbW1pdHMg PSAoKTsKKyAgICBteSBAY29tbWl0cyA9ICgpOworICAgIG15ICR0b3RhbF9jb21taXRzOworICAg IG15ICR0b3RhbF9saW5lczsKKworICAgICR2Y3NfdXNlZCA9IHZjc19leGlzdHMoKTsKKyAgICBy ZXR1cm4gaWYgKCEkdmNzX3VzZWQpOworCisgICAgQGFsbF9jb21taXRzID0gdmNzX2JsYW1lKCRm aWxlKTsKKyAgICBAY29tbWl0cyA9IHVuaXEoQGFsbF9jb21taXRzKTsKKyAgICAkdG90YWxfY29t bWl0cyA9IEBjb21taXRzOworICAgICR0b3RhbF9saW5lcyA9IEBhbGxfY29tbWl0czsKKworICAg IGlmICgkZW1haWxfZ2l0X2JsYW1lX3NpZ25hdHVyZXMpIHsKKwlpZiAodmNzX2lzX2hnKCkpIHsK KwkgICAgbXkgJGNvbW1pdF9jb3VudDsKKwkgICAgbXkgJGNvbW1pdF9hdXRob3JzX3JlZjsKKwkg ICAgbXkgJGNvbW1pdF9zaWduZXJzX3JlZjsKKwkgICAgbXkgJHN0YXRzX3JlZjsKKwkgICAgbXkg QGNvbW1pdF9hdXRob3JzID0gKCk7CisJICAgIG15IEBjb21taXRfc2lnbmVycyA9ICgpOworCSAg ICBteSAkY29tbWl0ID0gam9pbigiIC1yICIsIEBjb21taXRzKTsKKwkgICAgbXkgJGNtZDsKKwor CSAgICAkY21kID0gJFZDU19jbWRzeyJmaW5kX2NvbW1pdF9zaWduZXJzX2NtZCJ9OworCSAgICAk Y21kID1+IHMvKFwkXHcrKS8kMS9lZWc7CSNzdWJzdGl0dXRlIHZhcmlhYmxlcyBpbiAkY21kCisK KwkgICAgKCRjb21taXRfY291bnQsICRjb21taXRfc2lnbmVyc19yZWYsICRjb21taXRfYXV0aG9y c19yZWYsICRzdGF0c19yZWYpID0gdmNzX2ZpbmRfc2lnbmVycygkY21kLCAkZmlsZSk7CisJICAg IEBjb21taXRfYXV0aG9ycyA9IEB7JGNvbW1pdF9hdXRob3JzX3JlZn0gaWYgZGVmaW5lZCAkY29t bWl0X2F1dGhvcnNfcmVmOworCSAgICBAY29tbWl0X3NpZ25lcnMgPSBAeyRjb21taXRfc2lnbmVy c19yZWZ9IGlmIGRlZmluZWQgJGNvbW1pdF9zaWduZXJzX3JlZjsKKworCSAgICBwdXNoKEBzaWdu ZXJzLCBAY29tbWl0X3NpZ25lcnMpOworCX0gZWxzZSB7CisJICAgIGZvcmVhY2ggbXkgJGNvbW1p dCAoQGNvbW1pdHMpIHsKKwkJbXkgJGNvbW1pdF9jb3VudDsKKwkJbXkgJGNvbW1pdF9hdXRob3Jz X3JlZjsKKwkJbXkgJGNvbW1pdF9zaWduZXJzX3JlZjsKKwkJbXkgJHN0YXRzX3JlZjsKKwkJbXkg QGNvbW1pdF9hdXRob3JzID0gKCk7CisJCW15IEBjb21taXRfc2lnbmVycyA9ICgpOworCQlteSAk Y21kOworCisJCSRjbWQgPSAkVkNTX2NtZHN7ImZpbmRfY29tbWl0X3NpZ25lcnNfY21kIn07CisJ CSRjbWQgPX4gcy8oXCRcdyspLyQxL2VlZzsJI3N1YnN0aXR1dGUgdmFyaWFibGVzIGluICRjbWQK KworCQkoJGNvbW1pdF9jb3VudCwgJGNvbW1pdF9zaWduZXJzX3JlZiwgJGNvbW1pdF9hdXRob3Jz X3JlZiwgJHN0YXRzX3JlZikgPSB2Y3NfZmluZF9zaWduZXJzKCRjbWQsICRmaWxlKTsKKwkJQGNv bW1pdF9hdXRob3JzID0gQHskY29tbWl0X2F1dGhvcnNfcmVmfSBpZiBkZWZpbmVkICRjb21taXRf YXV0aG9yc19yZWY7CisJCUBjb21taXRfc2lnbmVycyA9IEB7JGNvbW1pdF9zaWduZXJzX3JlZn0g aWYgZGVmaW5lZCAkY29tbWl0X3NpZ25lcnNfcmVmOworCisJCXB1c2goQHNpZ25lcnMsIEBjb21t aXRfc2lnbmVycyk7CisJICAgIH0KKwl9CisgICAgfQorCisgICAgaWYgKCRmcm9tX2ZpbGVuYW1l KSB7CisJaWYgKCRvdXRwdXRfcm9sZXN0YXRzKSB7CisJICAgIG15IEBibGFtZV9zaWduZXJzOwor CSAgICBpZiAodmNzX2lzX2hnKCkpIHt7CQkjIERvdWJsZSBicmFjZSBmb3IgbGFzdCBleGl0CisJ CW15ICRjb21taXRfY291bnQ7CisJCW15IEBjb21taXRfc2lnbmVycyA9ICgpOworCQlAY29tbWl0 cyA9IHVuaXEoQGNvbW1pdHMpOworCQlAY29tbWl0cyA9IHNvcnQoQGNvbW1pdHMpOworCQlteSAk Y29tbWl0ID0gam9pbigiIC1yICIsIEBjb21taXRzKTsKKwkJbXkgJGNtZDsKKworCQkkY21kID0g JFZDU19jbWRzeyJmaW5kX2NvbW1pdF9hdXRob3JfY21kIn07CisJCSRjbWQgPX4gcy8oXCRcdysp LyQxL2VlZzsJI3N1YnN0aXR1dGUgdmFyaWFibGVzIGluICRjbWQKKworCQlteSBAbGluZXMgPSAo KTsKKworCQlAbGluZXMgPSAmeyRWQ1NfY21kc3siZXhlY3V0ZV9jbWQifX0oJGNtZCk7CisKKwkJ aWYgKCEkZW1haWxfZ2l0X3Blbmd1aW5fY2hpZWZzKSB7CisJCSAgICBAbGluZXMgPSBncmVwKCEv JHtwZW5ndWluX2NoaWVmc30vaSwgQGxpbmVzKTsKKwkJfQorCisJCWxhc3QgaWYgIUBsaW5lczsK KworCQlteSBAYXV0aG9ycyA9ICgpOworCQlmb3JlYWNoIG15ICRsaW5lIChAbGluZXMpIHsKKwkJ ICAgIGlmICgkbGluZSA9fiBtLyRWQ1NfY21kc3siYXV0aG9yX3BhdHRlcm4ifS8pIHsKKwkJCW15 ICRhdXRob3IgPSAkMTsKKwkJCSRhdXRob3IgPSBkZWR1cGxpY2F0ZV9lbWFpbCgkYXV0aG9yKTsK KwkJCXB1c2goQGF1dGhvcnMsICRhdXRob3IpOworCQkgICAgfQorCQl9CisKKwkJc2F2ZV9jb21t aXRzX2J5X2F1dGhvcihAbGluZXMpIGlmICgkaW50ZXJhY3RpdmUpOworCQlzYXZlX2NvbW1pdHNf Ynlfc2lnbmVyKEBsaW5lcykgaWYgKCRpbnRlcmFjdGl2ZSk7CisKKwkJcHVzaChAc2lnbmVycywg QGF1dGhvcnMpOworCSAgICB9fQorCSAgICBlbHNlIHsKKwkJZm9yZWFjaCBteSAkY29tbWl0IChA Y29tbWl0cykgeworCQkgICAgbXkgJGk7CisJCSAgICBteSAkY21kID0gJFZDU19jbWRzeyJmaW5k X2NvbW1pdF9hdXRob3JfY21kIn07CisJCSAgICAkY21kID1+IHMvKFwkXHcrKS8kMS9lZWc7CSNp bnRlcnBvbGF0ZSAkY21kCisJCSAgICBteSBAYXV0aG9yID0gdmNzX2ZpbmRfYXV0aG9yKCRjbWQp OworCQkgICAgbmV4dCBpZiAhQGF1dGhvcjsKKworCQkgICAgbXkgJGZvcm1hdHRlZF9hdXRob3Ig PSBkZWR1cGxpY2F0ZV9lbWFpbCgkYXV0aG9yWzBdKTsKKworCQkgICAgbXkgJGNvdW50ID0gZ3Jl cCgvJGNvbW1pdC8sIEBhbGxfY29tbWl0cyk7CisJCSAgICBmb3IgKCRpID0gMDsgJGkgPCAkY291 bnQgOyAkaSsrKSB7CisJCQlwdXNoKEBibGFtZV9zaWduZXJzLCAkZm9ybWF0dGVkX2F1dGhvcik7 CisJCSAgICB9CisJCX0KKwkgICAgfQorCSAgICBpZiAoQGJsYW1lX3NpZ25lcnMpIHsKKwkJdmNz X2Fzc2lnbigiYXV0aG9yZWQgbGluZXMiLCAkdG90YWxfbGluZXMsIEBibGFtZV9zaWduZXJzKTsK KwkgICAgfQorCX0KKwlmb3JlYWNoIG15ICRzaWduZXIgKEBzaWduZXJzKSB7CisJICAgICRzaWdu ZXIgPSBkZWR1cGxpY2F0ZV9lbWFpbCgkc2lnbmVyKTsKKwl9CisJdmNzX2Fzc2lnbigiY29tbWl0 cyIsICR0b3RhbF9jb21taXRzLCBAc2lnbmVycyk7CisgICAgfSBlbHNlIHsKKwlmb3JlYWNoIG15 ICRzaWduZXIgKEBzaWduZXJzKSB7CisJICAgICRzaWduZXIgPSBkZWR1cGxpY2F0ZV9lbWFpbCgk c2lnbmVyKTsKKwl9CisJdmNzX2Fzc2lnbigibW9kaWZpZWQgY29tbWl0cyIsICR0b3RhbF9jb21t aXRzLCBAc2lnbmVycyk7CisgICAgfQorfQorCitzdWIgdmNzX2ZpbGVfZXhpc3RzIHsKKyAgICBt eSAoJGZpbGUpID0gQF87CisKKyAgICBteSAkZXhpc3RzOworCisgICAgbXkgJHZjc191c2VkID0g dmNzX2V4aXN0cygpOworICAgIHJldHVybiAwIGlmICghJHZjc191c2VkKTsKKworICAgIG15ICRj bWQgPSAkVkNTX2NtZHN7ImZpbGVfZXhpc3RzX2NtZCJ9OworICAgICRjbWQgPX4gcy8oXCRcdysp LyQxL2VlZzsJCSMgaW50ZXJwb2xhdGUgJGNtZAorICAgICRjbWQgLj0gIiAyPiYxIjsKKyAgICAk ZXhpc3RzID0gJnskVkNTX2NtZHN7ImV4ZWN1dGVfY21kIn19KCRjbWQpOworCisgICAgcmV0dXJu IDAgaWYgKCQ/ICE9IDApOworCisgICAgcmV0dXJuICRleGlzdHM7Cit9CisKK3N1YiB2Y3NfbGlz dF9maWxlcyB7CisgICAgbXkgKCRmaWxlKSA9IEBfOworCisgICAgbXkgQGxzZmlsZXMgPSAoKTsK KworICAgIG15ICR2Y3NfdXNlZCA9IHZjc19leGlzdHMoKTsKKyAgICByZXR1cm4gMCBpZiAoISR2 Y3NfdXNlZCk7CisKKyAgICBteSAkY21kID0gJFZDU19jbWRzeyJsaXN0X2ZpbGVzX2NtZCJ9Owor ICAgICRjbWQgPX4gcy8oXCRcdyspLyQxL2VlZzsgICAjIGludGVycG9sYXRlICRjbWQKKyAgICBA bHNmaWxlcyA9ICZ7JFZDU19jbWRzeyJleGVjdXRlX2NtZCJ9fSgkY21kKTsKKworICAgIHJldHVy biAoKSBpZiAoJD8gIT0gMCk7CisKKyAgICByZXR1cm4gQGxzZmlsZXM7Cit9CisKK3N1YiB1bmlx IHsKKyAgICBteSAoQHBhcm1zKSA9IEBfOworCisgICAgbXkgJXNhdzsKKyAgICBAcGFybXMgPSBn cmVwKCEkc2F3eyRffSsrLCBAcGFybXMpOworICAgIHJldHVybiBAcGFybXM7Cit9CisKK3N1YiBz b3J0X2FuZF91bmlxIHsKKyAgICBteSAoQHBhcm1zKSA9IEBfOworCisgICAgbXkgJXNhdzsKKyAg ICBAcGFybXMgPSBzb3J0IEBwYXJtczsKKyAgICBAcGFybXMgPSBncmVwKCEkc2F3eyRffSsrLCBA cGFybXMpOworICAgIHJldHVybiBAcGFybXM7Cit9CisKK3N1YiBjbGVhbl9maWxlX2VtYWlscyB7 CisgICAgbXkgKEBmaWxlX2VtYWlscykgPSBAXzsKKyAgICBteSBAZm10X2VtYWlscyA9ICgpOwor CisgICAgZm9yZWFjaCBteSAkZW1haWwgKEBmaWxlX2VtYWlscykgeworCSRlbWFpbCA9fiBzL1tc KFw8XHtdezAsMX0oW0EtWmEtejAtOV9cLlwrLV0rXEBbQS1aYS16MC05XC4tXSspW1wpXD5cfV17 MCwxfS9cPCQxXD4vZzsKKwlteSAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRlbWFp bCk7CisJaWYgKCRuYW1lIGVxICciWyxcLl0iJykgeworCSAgICAkbmFtZSA9ICIiOworCX0KKwor CW15IEBudyA9IHNwbGl0KC9bXkEtWmEtesOALcO/XCdcLFwuXCstXS8sICRuYW1lKTsKKwlpZiAo QG53ID4gMikgeworCSAgICBteSAkZmlyc3QgPSAkbndbQG53IC0gM107CisJICAgIG15ICRtaWRk bGUgPSAkbndbQG53IC0gMl07CisJICAgIG15ICRsYXN0ID0gJG53W0BudyAtIDFdOworCisJICAg IGlmICgoKGxlbmd0aCgkZmlyc3QpID09IDEgJiYgJGZpcnN0ID1+IG0vW0EtWmEtel0vKSB8fAor CQkgKGxlbmd0aCgkZmlyc3QpID09IDIgJiYgc3Vic3RyKCRmaXJzdCwgLTEpIGVxICIuIikpIHx8 CisJCShsZW5ndGgoJG1pZGRsZSkgPT0gMSB8fAorCQkgKGxlbmd0aCgkbWlkZGxlKSA9PSAyICYm IHN1YnN0cigkbWlkZGxlLCAtMSkgZXEgIi4iKSkpIHsKKwkJJG5hbWUgPSAiJGZpcnN0ICRtaWRk bGUgJGxhc3QiOworCSAgICB9IGVsc2UgeworCQkkbmFtZSA9ICIkbWlkZGxlICRsYXN0IjsKKwkg ICAgfQorCX0KKworCWlmIChzdWJzdHIoJG5hbWUsIC0xKSA9fiAvWyxcLl0vKSB7CisJICAgICRu YW1lID0gc3Vic3RyKCRuYW1lLCAwLCBsZW5ndGgoJG5hbWUpIC0gMSk7CisJfSBlbHNpZiAoc3Vi c3RyKCRuYW1lLCAtMikgPX4gL1ssXC5dIi8pIHsKKwkgICAgJG5hbWUgPSBzdWJzdHIoJG5hbWUs IDAsIGxlbmd0aCgkbmFtZSkgLSAyKSAuICciJzsKKwl9CisKKwlpZiAoc3Vic3RyKCRuYW1lLCAw LCAxKSA9fiAvWyxcLl0vKSB7CisJICAgICRuYW1lID0gc3Vic3RyKCRuYW1lLCAxLCBsZW5ndGgo JG5hbWUpIC0gMSk7CisJfSBlbHNpZiAoc3Vic3RyKCRuYW1lLCAwLCAyKSA9fiAvIlssXC5dLykg eworCSAgICAkbmFtZSA9ICciJyAuIHN1YnN0cigkbmFtZSwgMiwgbGVuZ3RoKCRuYW1lKSAtIDIp OworCX0KKworCW15ICRmbXRfZW1haWwgPSBmb3JtYXRfZW1haWwoJG5hbWUsICRhZGRyZXNzLCAk ZW1haWxfdXNlbmFtZSk7CisJcHVzaChAZm10X2VtYWlscywgJGZtdF9lbWFpbCk7CisgICAgfQor ICAgIHJldHVybiBAZm10X2VtYWlsczsKK30KKworc3ViIG1lcmdlX2VtYWlsIHsKKyAgICBteSBA bGluZXM7CisgICAgbXkgJXNhdzsKKworICAgIGZvciAoQF8pIHsKKwlteSAoJGFkZHJlc3MsICRy b2xlKSA9IEAkXzsKKwlpZiAoISRzYXd7JGFkZHJlc3N9KSB7CisJICAgIGlmICgkb3V0cHV0X3Jv bGVzKSB7CisJCXB1c2goQGxpbmVzLCAiJGFkZHJlc3MgKCRyb2xlKSIpOworCSAgICB9IGVsc2Ug eworCQlwdXNoKEBsaW5lcywgJGFkZHJlc3MpOworCSAgICB9CisJICAgICRzYXd7JGFkZHJlc3N9 ID0gMTsKKwl9CisgICAgfQorCisgICAgcmV0dXJuIEBsaW5lczsKK30KKworc3ViIG91dHB1dCB7 CisgICAgbXkgKEBwYXJtcykgPSBAXzsKKworICAgIGlmICgkb3V0cHV0X211bHRpbGluZSkgewor CWZvcmVhY2ggbXkgJGxpbmUgKEBwYXJtcykgeworCSAgICBwcmludCgiJHtsaW5lfVxuIik7CisJ fQorICAgIH0gZWxzZSB7CisJcHJpbnQoam9pbigkb3V0cHV0X3NlcGFyYXRvciwgQHBhcm1zKSk7 CisJcHJpbnQoIlxuIik7CisgICAgfQorfQorCitteSAkcmZjODIycmU7CisKK3N1YiBtYWtlX3Jm YzgyMnJlIHsKKyMgICBCYXNpYyBsZXhpY2FsIHRva2VucyBhcmUgc3BlY2lhbHMsIGRvbWFpbl9s aXRlcmFsLCBxdW90ZWRfc3RyaW5nLCBhdG9tLCBhbmQKKyMgICBjb21tZW50LiAgV2UgbXVzdCBh bGxvdyBmb3IgcmZjODIyX2x3c3AgKG9yIGNvbW1lbnRzKSBhZnRlciBlYWNoIG9mIHRoZXNlLgor IyAgIFRoaXMgcmVnZXhwIHdpbGwgb25seSB3b3JrIG9uIGFkZHJlc3NlcyB3aGljaCBoYXZlIGhh ZCBjb21tZW50cyBzdHJpcHBlZAorIyAgIGFuZCByZXBsYWNlZCB3aXRoIHJmYzgyMl9sd3NwLgor CisgICAgbXkgJHNwZWNpYWxzID0gJygpPD5ALDs6XFxcXCIuXFxbXFxdJzsKKyAgICBteSAkY29u dHJvbHMgPSAnXFwwMDAtXFwwMzdcXDE3Nyc7CisKKyAgICBteSAkZHRleHQgPSAiW15cXFtcXF1c XHJcXFxcXSI7CisgICAgbXkgJGRvbWFpbl9saXRlcmFsID0gIlxcWyg/OiRkdGV4dHxcXFxcLikq XFxdJHJmYzgyMl9sd3NwKiI7CisKKyAgICBteSAkcXVvdGVkX3N0cmluZyA9ICJcIig/OlteXFxc IlxcclxcXFxdfFxcXFwufCRyZmM4MjJfbHdzcCkqXCIkcmZjODIyX2x3c3AqIjsKKworIyAgIFVz ZSB6ZXJvLXdpZHRoIGFzc2VydGlvbiB0byBzcG90IHRoZSBsaW1pdCBvZiBhbiBhdG9tLiAgQSBz aW1wbGUKKyMgICAkcmZjODIyX2x3c3AqIGNhdXNlcyB0aGUgcmVnZXhwIGVuZ2luZSB0byBoYW5n IG9jY2FzaW9uYWxseS4KKyAgICBteSAkYXRvbSA9ICJbXiRzcGVjaWFscyAkY29udHJvbHNdKyg/ OiRyZmM4MjJfbHdzcCt8XFxafCg/PVtcXFtcIiRzcGVjaWFsc10pKSI7CisgICAgbXkgJHdvcmQg PSAiKD86JGF0b218JHF1b3RlZF9zdHJpbmcpIjsKKyAgICBteSAkbG9jYWxwYXJ0ID0gIiR3b3Jk KD86XFwuJHJmYzgyMl9sd3NwKiR3b3JkKSoiOworCisgICAgbXkgJHN1Yl9kb21haW4gPSAiKD86 JGF0b218JGRvbWFpbl9saXRlcmFsKSI7CisgICAgbXkgJGRvbWFpbiA9ICIkc3ViX2RvbWFpbig/ OlxcLiRyZmM4MjJfbHdzcCokc3ViX2RvbWFpbikqIjsKKworICAgIG15ICRhZGRyX3NwZWMgPSAi JGxvY2FscGFydFxAJHJmYzgyMl9sd3NwKiRkb21haW4iOworCisgICAgbXkgJHBocmFzZSA9ICIk d29yZCoiOworICAgIG15ICRyb3V0ZSA9ICIoPzpcQCRkb21haW4oPzosXEAkcmZjODIyX2x3c3Aq JGRvbWFpbikqOiRyZmM4MjJfbHdzcCopIjsKKyAgICBteSAkcm91dGVfYWRkciA9ICJcXDwkcmZj ODIyX2x3c3AqJHJvdXRlPyRhZGRyX3NwZWNcXD4kcmZjODIyX2x3c3AqIjsKKyAgICBteSAkbWFp bGJveCA9ICIoPzokYWRkcl9zcGVjfCRwaHJhc2Ukcm91dGVfYWRkcikiOworCisgICAgbXkgJGdy b3VwID0gIiRwaHJhc2U6JHJmYzgyMl9sd3NwKig/OiRtYWlsYm94KD86LFxccyokbWFpbGJveCkq KT87XFxzKiI7CisgICAgbXkgJGFkZHJlc3MgPSAiKD86JG1haWxib3h8JGdyb3VwKSI7CisKKyAg ICByZXR1cm4gIiRyZmM4MjJfbHdzcCokYWRkcmVzcyI7Cit9CisKK3N1YiByZmM4MjJfc3RyaXBf Y29tbWVudHMgeworICAgIG15ICRzID0gc2hpZnQ7CisjICAgUmVjdXJzaXZlbHkgcmVtb3ZlIGNv bW1lbnRzLCBhbmQgcmVwbGFjZSB3aXRoIGEgc2luZ2xlIHNwYWNlLiAgVGhlIHNpbXBsZXIKKyMg ICByZWdleHBzIGluIHRoZSBFbWFpbCBBZGRyZXNzaW5nIEZBUSBhcmUgaW1wZXJmZWN0IC0gdGhl eSB3aWxsIG1pc3MgZXNjYXBlZAorIyAgIGNoYXJzIGluIGF0b21zLCBmb3IgZXhhbXBsZS4KKwor ICAgIHdoaWxlICgkcyA9fiBzL14oKD86W14iXFxdfFxcLikqCisgICAgICAgICAgICAgICAgICAg ICg/OiIoPzpbXiJcXF18XFwuKSoiKD86W14iXFxdfFxcLikqKSopCisgICAgICAgICAgICAgICAg ICAgIFwoKD86W14oKVxcXXxcXC4pKlwpLyQxIC9vc3gpIHt9CisgICAgcmV0dXJuICRzOworfQor CisjICAgdmFsaWQ6IHJldHVybnMgdHJ1ZSBpZiB0aGUgcGFyYW1ldGVyIGlzIGFuIFJGQzgyMiB2 YWxpZCBhZGRyZXNzCisjCitzdWIgcmZjODIyX3ZhbGlkIHsKKyAgICBteSAkcyA9IHJmYzgyMl9z dHJpcF9jb21tZW50cyhzaGlmdCk7CisKKyAgICBpZiAoISRyZmM4MjJyZSkgeworICAgICAgICAk cmZjODIycmUgPSBtYWtlX3JmYzgyMnJlKCk7CisgICAgfQorCisgICAgcmV0dXJuICRzID1+IG0v XiRyZmM4MjJyZSQvc28gJiYgJHMgPX4gbS9eJHJmYzgyMl9jaGFyKiQvOworfQorCisjICAgdmFs aWRsaXN0OiBJbiBzY2FsYXIgY29udGV4dCwgcmV0dXJucyB0cnVlIGlmIHRoZSBwYXJhbWV0ZXIg aXMgYW4gUkZDODIyCisjICAgICAgICAgICAgICB2YWxpZCBsaXN0IG9mIGFkZHJlc3Nlcy4KKyMK KyMgICAgICAgICAgICAgIEluIGxpc3QgY29udGV4dCwgcmV0dXJucyBhbiBlbXB0eSBsaXN0IG9u IGZhaWx1cmUgKGFuIGludmFsaWQKKyMgICAgICAgICAgICAgIGFkZHJlc3Mgd2FzIGZvdW5kKTsg b3RoZXJ3aXNlIGEgbGlzdCB3aG9zZSBmaXJzdCBlbGVtZW50IGlzIHRoZQorIyAgICAgICAgICAg ICAgbnVtYmVyIG9mIGFkZHJlc3NlcyBmb3VuZCBhbmQgd2hvc2UgcmVtYWluaW5nIGVsZW1lbnRz IGFyZSB0aGUKKyMgICAgICAgICAgICAgIGFkZHJlc3Nlcy4gIFRoaXMgaXMgbmVlZGVkIHRvIGRp c2FtYmlndWF0ZSBmYWlsdXJlIChpbnZhbGlkKQorIyAgICAgICAgICAgICAgZnJvbSBzdWNjZXNz IHdpdGggbm8gYWRkcmVzc2VzIGZvdW5kLCBiZWNhdXNlIGFuIGVtcHR5IHN0cmluZyBpcworIyAg ICAgICAgICAgICAgYSB2YWxpZCBsaXN0LgorCitzdWIgcmZjODIyX3ZhbGlkbGlzdCB7CisgICAg bXkgJHMgPSByZmM4MjJfc3RyaXBfY29tbWVudHMoc2hpZnQpOworCisgICAgaWYgKCEkcmZjODIy cmUpIHsKKyAgICAgICAgJHJmYzgyMnJlID0gbWFrZV9yZmM4MjJyZSgpOworICAgIH0KKyAgICAj ICogbnVsbCBsaXN0IGl0ZW1zIGFyZSB2YWxpZCBhY2NvcmRpbmcgdG8gdGhlIFJGQworICAgICMg KiB0aGUgJzEnIGJ1c2luZXNzIGlzIHRvIGFpZCBpbiBkaXN0aW5ndWlzaGluZyBmYWlsdXJlIGZy b20gbm8gcmVzdWx0cworCisgICAgbXkgQHI7CisgICAgaWYgKCRzID1+IG0vXig/OiRyZmM4MjJy ZSk/KD86LCg/OiRyZmM4MjJyZSk/KSokL3NvICYmCisJJHMgPX4gbS9eJHJmYzgyMl9jaGFyKiQv KSB7CisgICAgICAgIHdoaWxlICgkcyA9fiBtLyg/Ol58LCRyZmM4MjJfbHdzcCopKCRyZmM4MjJy ZSkvZ29zKSB7CisgICAgICAgICAgICBwdXNoKEByLCAkMSk7CisgICAgICAgIH0KKyAgICAgICAg cmV0dXJuIHdhbnRhcnJheSA/IChzY2FsYXIoQHIpLCBAcikgOiAxOworICAgIH0KKyAgICByZXR1 cm4gd2FudGFycmF5ID8gKCkgOiAwOworfQotLSAKMi4zOS4yCgoKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkxpbnV4LWYyZnMtZGV2ZWwgbWFpbGluZyBs aXN0CkxpbnV4LWYyZnMtZGV2ZWxAbGlzdHMuc291cmNlZm9yZ2UubmV0Cmh0dHBzOi8vbGlzdHMu c291cmNlZm9yZ2UubmV0L2xpc3RzL2xpc3RpbmZvL2xpbnV4LWYyZnMtZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from aib29ajc247.phx1.oracleemaildelivery.com (aib29ajc247.phx1.oracleemaildelivery.com [192.29.103.247]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 25677C77B60 for ; Tue, 4 Apr 2023 17:24:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; s=oss-phx-1109; d=oss.oracle.com; h=Date:To:From:Subject:Message-Id:MIME-Version:Sender; bh=qRSJlan+oDczHqWsNDrB0IBh2hkH1clNhEZC1njwzUs=; b=PEknA5xmYNqtveIZpcfOxxCHvUToBM/rNuHaTITtGaZbG9gBapTgv6O7j0n9jjpex69PLTFFnDVV aDvmIFblVXtNuWoWAq5HCxwnreMn+c2abaeGjN+t215IZk0GS5cngU9FGD0RmeqmWuBJZ9Qsttua GsYBh1T0HBe93Sh+lzlwjwFIohMOIV3vmilpnHee7lLKUwSuU8IZ0kox+5VPcUQwXCV49+u1d2qW DE0jtm3lE8fdUKV2opmncKGMp3To/wuCssfyYgRjnCKDlrajE24/lT88KZE1FeSfIZiG9gJXqc3I FGp5QQxvfjTmJ3et3E5bnGifzyEh6WMzJ0P2sQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; s=prod-phx-20191217; d=phx1.rp.oracleemaildelivery.com; h=Date:To:From:Subject:Message-Id:MIME-Version:Sender; bh=qRSJlan+oDczHqWsNDrB0IBh2hkH1clNhEZC1njwzUs=; b=s1SXZCzNI4vdgrJjXdIS3lkV/04TCUhGtReEHlSMg6PNLI9EzLhf0L/DtRRXEy/D3bMxBeNyIOKg CElRaBO4r2J5mQWPpZdz/+a3ESCUQqpbMoavOgj6g/WUGUkbIpgFskAfwLhoEBKOkECkDEp2E3xD 9PHrSNEUZ8XNeM0U7M550U7p+7U6U8VOC9QG6r3u/AG7gls2daT610xcFP+arP8uRLmrzguA1ify eSCeYZPio0RaoD8BnZnevV4OAJFyZBbTOdz+xQoQcdlRWdX+rkN0JC22DQMP9wbGVFj013HesJPO U8N39zBUgvJVh057nmudSH67Oa+wGHS6Z634gw== Received: by omta-ad1-fd3-102-us-phoenix-1.omtaad1.vcndpphx.oraclevcn.com (Oracle Communications Messaging Server 8.1.0.1.20230317 64bit (built Mar 17 2023)) with ESMTPS id <0RSL00BL2POUN860@omta-ad1-fd3-102-us-phoenix-1.omtaad1.vcndpphx.oraclevcn.com> for ocfs2-devel@archiver.kernel.org; Tue, 04 Apr 2023 17:24:30 +0000 (GMT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1680628468; bh=RDhAalIr7SbY9i/gonqpJqUhnY/gKX0tENUa/Gexl1c=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=hnz2sUUlVV0mBAJ7nZemrq3FX/QaQ9bz/plf8FINrTpgLYRyHbQcZZljDYYW68wZW tvMZ65XN1EjpTtuRMFaR6bB3XYR41nS9KJdbIEIz8D2fmBleQ++C6Yf1k26cLxpxuF +wWl0MTv/scHDZex8leGJwfxwIZFuPiU0q7htmH+8JAWLEaKaZtc+L8sM3Rzf/Q202 mJtkpUwWT0eKImgFrCFamFa2lOwPSXJJQj/7kcNNi7HPYMzEpuICmsCcbhfH0VyGoo 5qNTsbV2JsPEtwVFxxuY30g4a2tXMgc9Z9Z7NRW9i4XCfeRkRhJn3oqem+z957Dwi+ bps75EJMcjreQ== To: fstests@vger.kernel.org Date: Wed, 5 Apr 2023 01:14:07 +0800 Message-id: <20230404171411.699655-2-zlang@kernel.org> X-Mailer: git-send-email 2.39.2 In-reply-to: <20230404171411.699655-1-zlang@kernel.org> References: <20230404171411.699655-1-zlang@kernel.org> MIME-version: 1.0 X-Source-IP: 139.178.84.217 X-Proofpoint-Virus-Version: vendor=nai engine=6500 definitions=10670 signatures=596816 Cc: brauner@kernel.org, linux-cifs@vger.kernel.org, linux-nfs@vger.kernel.org, ebiggers@google.com, amir73il@gmail.com, linux-unionfs@vger.kernel.org, anand.jain@oracle.com, linux-f2fs-devel@lists.sourceforge.net, linux-xfs@vger.kernel.org, fdmanana@suse.com, ocfs2-devel@oss.oracle.com, jack@suse.com, linux-fsdevel@vger.kernel.org, ceph-devel@vger.kernel.org, linux-ext4@vger.kernel.org, linux-btrfs@vger.kernel.org Subject: [Ocfs2-devel] [PATCH 1/5] fstests: add MAINTAINERS and get_maintainer.pl files X-BeenThere: ocfs2-devel@oss.oracle.com X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Zorro Lang via Ocfs2-devel Reply-to: Zorro Lang Content-type: text/plain; charset="utf-8" Content-transfer-encoding: base64 Errors-to: ocfs2-devel-bounces@oss.oracle.com X-ServerName: dfw.source.kernel.org X-Proofpoint-SPF-Result: pass X-Proofpoint-SPF-Record: v=spf1 include:_spf.kernel.org ~all X-Proofpoint-Spam-Reason: safe X-Spam: OrgSafeList X-SpamRule: orgsafelist X-Proofpoint-ORIG-GUID: 7jmWiyeKZ4aFWnpLGXglq7YMyBH8_JDK X-Proofpoint-GUID: 7jmWiyeKZ4aFWnpLGXglq7YMyBH8_JDK X-Mailman-Approved-At: Tue, 04 Apr 2023 17:24:27 +0000 Reporting-Meta: AAEHTOj+S1MwozJ/3M6CwhBwRL7qHXwyE2zdMO8k6NpDHnVH6YycC8Ga57f3ZdO9 rYpVgFPMrRAY6mpd9SF4MIJgw3WQUGUhhzuUiaLuSlQ10+3AqQM6cJ+gNIzDuZMt 15MVgvxHjC38JK5a3R1hPYcgZWSkiH3EiRgcUDAkA5vwacUOBUPjSMg/VPFFkyRd Zc3WH8z6G9mMFBzzTPGsrX1U6VN024nbl+1r32jfk6casanv/wX0eUnrbzryCdQY 5Aaa50BklbaQrb2q/KCwX6aPsMrN4N9g95uf3q8fX5NDqgJRqjBBobd/l21ewPTG hLxxpjRkRYHrVeHx7muNrz3PvC3KcOvYyK1CoAT27WLPwY3tHgELpSKn9V6mI9gL j6wWM2Ak2yeoLpIjc0huGCSU2okkq+qYdNcg6jYjl5JCIdZhDuys/XiGG+9cyu+3 A+7oAwX4C5rc2rzlvevyN6JNUt7FPCMUvgU/BVliVksqiAg7CYi77NMke7EvBvSQ yz6PmJ3CN0sa4No7mQsV2wNetROiaG4wjqW/wnwFp7cE QXMgZnN0ZXN0cyBjb3ZlcnMgbW9yZSBhbmQgbW9yZSBmcyB0ZXN0aW5nLCBzbyB3ZSBhbHdheXMg Z2V0IGhlbHAKZnJvbSBmcyBzcGVjaWZpYyBtYWlsaW5nIGxpc3QsIGR1ZSB0byB0aGV5IGxlYXJu IGFib3V0IHRoZWlyIGZlYXR1cmVzCmFuZCBidWdzIG1vcmUuIEJlc2lkZXMgdGhhdCwgc29tZSBm b2xrcyBoZWxwIHRvIHJldmlldyBwYXRjaGVzCihyZWxldmFudCB3aXRoIHRoZW0pIG1vcmUgb2Z0 ZW4uCgpTbyBJJ2QgbGlrZSB0byBicmluZyBpbiB0aGUgc2ltaWxhciB3YXkgb2YgbGludXgvTUFJ TlRBSU5FUlMsIHJlY29yZHMKZnMgcmVsZXZhbnQgbWFpbGluZyBsaXN0cywgcmV2aWV3ZXJzIG9y IGNvLW1haW50YWluZXJzLiBUbyByZWNvZ25pemUKdGhlIGNvbnRyaWJ1dGlvbiBmcm9tIHRoZW0s IGFuZCBoZWxwIG1vcmUgdXNlcnMgdG8ga25vdyB3aG8gb3Igd2hhdAptYWlsaW5nIGxpc3QgY2Fu IGJlIGFkZGVkIGluIENDIGxpc3Qgb2YgYSBwYXRjaC4KClRoZSBNQUlOVEFJTkVSUyBhbmQgZ2V0 X21haW50YWluZXIucGwgYXJlIGNvcGllZCBmcm9tIGxpbnV4IHByb2plY3QsCnRoZW4gbWFkZSBz b21lIGNoYW5nZXMgZm9yIGZzdGVzdHMgc3BlY2lhbGx5LgoKU2lnbmVkLW9mZi1ieTogWm9ycm8g TGFuZyA8emxhbmdAa2VybmVsLm9yZz4KLS0tCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICB8ICAx MTYgKysKIHRvb2xzL2dldF9tYWludGFpbmVyLnBsIHwgMjYxNiArKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysKIDIgZmlsZXMgY2hhbmdlZCwgMjczMiBpbnNlcnRpb25zKCsp CiBjcmVhdGUgbW9kZSAxMDA2NDQgTUFJTlRBSU5FUlMKIGNyZWF0ZSBtb2RlIDEwMDc1NSB0b29s cy9nZXRfbWFpbnRhaW5lci5wbAoKZGlmZiAtLWdpdCBhL01BSU5UQUlORVJTIGIvTUFJTlRBSU5F UlMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAuLjA5YjFhNWEzCi0tLSAvZGV2 L251bGwKKysrIGIvTUFJTlRBSU5FUlMKQEAgLTAsMCArMSwxMTYgQEAKK0xpc3Qgb2YgcmV2aWV3 ZXJzLCBjby1tYWludGFpbmVycyBhbmQgaG93IHRvIHN1Ym1pdCBmc3Rlc3RzIGNoYW5nZXMKKz09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KKworUGxl YXNlIHRyeSB0byBmb2xsb3cgdGhlIGd1aWRlbGluZXMgYmVsb3cuICBUaGlzIHdpbGwgbWFrZSB0 aGluZ3MKK2Vhc2llciBvbiB0aGUgbWFpbnRhaW5lcnMuICBOb3QgYWxsIG9mIHRoZXNlIGd1aWRl bGluZXMgbWF0dGVyIGZvciBldmVyeQordHJpdmlhbCBwYXRjaCBzbyBhcHBseSBzb21lIGNvbW1v biBzZW5zZS4KKworVGlwcyBmb3IgcGF0Y2ggc3VibWl0dGVycworLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQorCisxLglBbHdheXMgKnRlc3QqIHlvdXIgY2hhbmdlcywgaG93ZXZlciBzbWFsbCwg b24gYXQgbGVhc3QgNCBvcgorCTUgcGVvcGxlLCBwcmVmZXJhYmx5IG1hbnkgbW9yZS4KKworMi4J TWFrZSBzdXJlIHlvdXIgY2hhbmdlcyBjb21waWxlIGNvcnJlY3RseSBpbiBtdWx0aXBsZQorCWNv bmZpZ3VyYXRpb25zLiBJbiBwYXJ0aWN1bGFyIGNoZWNrIHRoYXQgY2hhbmdlcyB3b3JrIGJvdGgg YXMgYQorCW1vZHVsZSBhbmQgYnVpbHQgaW50byB0aGUga2VybmVsLgorCiszLglXaGVuIHlvdSBh cmUgaGFwcHkgd2l0aCBhIGNoYW5nZSBtYWtlIGl0IGdlbmVyYWxseSBhdmFpbGFibGUgZm9yCisJ dGVzdGluZyBhbmQgYXdhaXQgZmVlZGJhY2suCisKKzQuCU1ha2UgYSBwYXRjaCBhdmFpbGFibGUg dG8gZnN0ZXN0c0AgbGlzdCBkaXJlY3RseSwgdGhhdCdzIHRoZSBvbmx5CisJb25lIG1haWxpbmcg bGlzdCB3aGljaCBtYWludGFpbiB0aGUgd2hvbGUgZnN0ZXN0cyBwcm9qZWN0LgorCisJUExFQVNF IENDOiB0aGUgcmVsZXZhbnQgcmV2aWV3ZXJzLCBjby1tYWludGFpbmVycyBhbmQgbWFpbGluZyBs aXN0cworCXRoYXQgYXJlIGdlbmVyYXRlZCBieSBgYHRvb2xzL2dldF9tYWludGFpbmVyLnBsLmBg CisKKwlQTEVBU0UgdHJ5IHRvIGluY2x1ZGUgYW55IGNyZWRpdCBsaW5lcyB5b3Ugd2FudCBhZGRl ZCB3aXRoIHRoZQorCXBhdGNoLiBJdCBhdm9pZHMgcGVvcGxlIGJlaW5nIG1pc3NlZCBvZmYgYnkg bWlzdGFrZSBhbmQgbWFrZXMKKwlpdCBlYXNpZXIgdG8ga25vdyB3aG8gd2FudHMgYWRkaW5nIGFu ZCB3aG8gZG9lc24ndC4KKworCVBMRUFTRSBkb2N1bWVudCBrbm93biBidWdzLiBJZiBpdCBkb2Vz bid0IHdvcmsgZm9yIGV2ZXJ5dGhpbmcKKwlvciBkb2VzIHNvbWV0aGluZyB2ZXJ5IG9kZCBvbmNl IGEgbW9udGggZG9jdW1lbnQgaXQuCisKKzUuCU1ha2Ugc3VyZSB5b3UgaGF2ZSB0aGUgcmlnaHQg dG8gc2VuZCBhbnkgY2hhbmdlcyB5b3UgbWFrZS4gSWYgeW91CisJZG8gY2hhbmdlcyBhdCB3b3Jr IHlvdSBtYXkgZmluZCB5b3VyIGVtcGxveWVyIG93bnMgdGhlIHBhdGNoCisJbm90IHlvdS4KKwor Ni4JSGFwcHkgaGFja2luZy4KKworRGVzY3JpcHRpb25zIG9mIHNlY3Rpb24gZW50cmllcyBhbmQg cHJlZmVycmVkIG9yZGVyCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0KKworCU06ICpNYWlsKiBwYXRjaGVzIHRvOiBGdWxsTmFtZSA8YWRkcmVzc0Bk b21haW4+CisJICAgVGhlc2UgcGVvcGxlIG1pZ2h0IGJlIGEgY28tbWFpbnRhaW5lciAod2l0aCBT dXBwb3J0ZWQgc3RhdHVzKSBvcgorCSAgIG1haW50YWluZXIgKHdpdGggTWFpbnRhaW5lZCBzdGF0 dXMpLgorCVI6IERlc2lnbmF0ZWQgKlJldmlld2VyKjogRnVsbE5hbWUgPGFkZHJlc3NAZG9tYWlu PgorCSAgIFRoZXNlIHJldmlld2VycyBzaG91bGQgYmUgQ0NlZCBvbiBwYXRjaGVzLgorCUw6IEJl c2lkZXMgZnN0ZXN0c0AgbGlzdCBpdHNlbGYsIHRoaXMgKk1haWxpbmcgbGlzdCogaXMgcmVsZXZh bnQgdG8KKwkgICB0aGlzIGFyZWEsIHNob3VsZCBiZSBDQ2VkLgorCVM6ICpTdGF0dXMqLCBvbmUg b2YgdGhlIGZvbGxvd2luZyAobm90ZTogYWxsIHRoaW5ncyBhcmUgbWFpbnRhaW5lZCBieQorCSAg IGZzdGVzdHNAdmdlci5rZXJuZWwub3JnKToKKwkgICBTdXBwb3J0ZWQ6CVNvbWVvbmUgaXMgYWN0 dWFsbHkgcGFpZCB0byBsb29rIGFmdGVyIHRoaXMuCisJICAgTWFpbnRhaW5lZDoJU29tZW9uZSBh Y3R1YWxseSBsb29rcyBhZnRlciBpdCwgaGFzIHRoZSBwcml2aWxlZ2UgdG8KKwkJCW1lcmdlICYg cHVzaC4KKwkgICBPZGQgRml4ZXM6CUl0IGhhcyBhIG1haW50YWluZXIgYnV0IHRoZXkgZG9uJ3Qg aGF2ZSB0aW1lIHRvIGRvCisJCQltdWNoIG90aGVyIHRoYW4gdGhyb3cgdGhlIG9kZCBwYXRjaCBp bi4gU2VlIGJlbG93Li4KKwkgICBPcnBoYW46CU5vIGN1cnJlbnQgbWFpbnRhaW5lciBbYnV0IG1h eWJlIHlvdSBjb3VsZCB0YWtlIHRoZQorCQkJcm9sZSBhcyB5b3Ugd3JpdGUgeW91ciBuZXcgY29k ZV0uCisJICAgT2Jzb2xldGU6CU9sZCBjb2RlLiBTb21ldGhpbmcgdGFnZ2VkIG9ic29sZXRlIGdl bmVyYWxseSBtZWFucworCQkJaXQgaGFzIGJlZW4gcmVwbGFjZWQgYnkgYSBiZXR0ZXIgc3lzdGVt IGFuZCB5b3UKKwkJCXNob3VsZCBiZSB1c2luZyB0aGF0LgorCVc6ICpXZWItcGFnZSogd2l0aCBz dGF0dXMvaW5mbworCVE6ICpQYXRjaHdvcmsqIHdlYiBiYXNlZCBwYXRjaCB0cmFja2luZyBzeXN0 ZW0gc2l0ZQorCUI6IFVSSSBmb3Igd2hlcmUgdG8gZmlsZSAqYnVncyouIEEgd2ViLXBhZ2Ugd2l0 aCBkZXRhaWxlZCBidWcKKwkgICBmaWxpbmcgaW5mbywgYSBkaXJlY3QgYnVnIHRyYWNrZXIgbGlu aywgb3IgYSBtYWlsdG86IFVSSS4KKwlDOiBVUkkgZm9yICpjaGF0KiBwcm90b2NvbCwgc2VydmVy IGFuZCBjaGFubmVsIHdoZXJlIGRldmVsb3BlcnMKKwkgICB1c3VhbGx5IGhhbmcgb3V0LCBmb3Ig ZXhhbXBsZSBpcmM6Ly9zZXJ2ZXIvY2hhbm5lbC4KKwlQOiBTdWJzeXN0ZW0gUHJvZmlsZSBkb2N1 bWVudCBmb3IgbW9yZSBkZXRhaWxzIHN1Ym1pdHRpbmcKKwkgICBwYXRjaGVzIHRvIHRoZSBnaXZl biBzdWJzeXN0ZW0uIFRoaXMgaXMgZWl0aGVyIGFuIGluLXRyZWUgZmlsZSwKKwkgICBvciBhIFVS SS4KKwlUOiAqU0NNKiB0cmVlIHR5cGUgYW5kIGxvY2F0aW9uLgorCSAgIFR5cGUgaXMgb25lIG9m OiBnaXQsIGhnLCBxdWlsdCwgc3RnaXQsIHRvcGdpdAorCUY6ICpGaWxlcyogYW5kIGRpcmVjdG9y aWVzIHdpbGRjYXJkIHBhdHRlcm5zLgorCSAgIEEgdHJhaWxpbmcgc2xhc2ggaW5jbHVkZXMgYWxs IGZpbGVzIGFuZCBzdWJkaXJlY3RvcnkgZmlsZXMuCisJICAgRjoJdGVzdHMveGZzLwlhbGwgZmls ZXMgaW4gYW5kIGJlbG93IHRlc3RzL3hmcworCSAgIEY6CXRlc3RzL2dlbmVyaWMvKglhbGwgZmls ZXMgaW4gdGVzdHMvZ2VuZXJpYywgYnV0IG5vdCBiZWxvdworCSAgIEY6CSovZXh0NC8qCWFsbCBm aWxlcyBpbiAiYW55IHRvcCBsZXZlbCBkaXJlY3RvcnkiL2V4dDQKKwkgICBPbmUgcGF0dGVybiBw ZXIgbGluZS4gIE11bHRpcGxlIEY6IGxpbmVzIGFjY2VwdGFibGUuCisJWDogKkV4Y2x1ZGVkKiBm aWxlcyBhbmQgZGlyZWN0b3JpZXMgdGhhdCBhcmUgTk9UIG1haW50YWluZWQsIHNhbWUKKwkgICBy dWxlcyBhcyBGOi4gRmlsZXMgZXhjbHVzaW9ucyBhcmUgdGVzdGVkIGJlZm9yZSBmaWxlIG1hdGNo ZXMuCisJICAgQ2FuIGJlIHVzZWZ1bCBmb3IgZXhjbHVkaW5nIGEgc3BlY2lmaWMgc3ViZGlyZWN0 b3J5LCBmb3IgaW5zdGFuY2U6CisJICAgRjoJc3JjLworCSAgIFg6CXNyYy92ZnMKKwkgICBtYXRj aGVzIGFsbCBmaWxlcyBpbiBhbmQgYmVsb3cgbmV0IGV4Y2x1ZGluZyBuZXQvaXB2Ni8KKwlOOiBG aWxlcyBhbmQgZGlyZWN0b3JpZXMgKlJlZ2V4KiBwYXR0ZXJucy4KKwkgICBOOglbXmEtel10ZWdy YQlhbGwgZmlsZXMgd2hvc2UgcGF0aCBjb250YWlucyB0ZWdyYQorCSAgICAgICAgICAgICAgICAg ICAgICAgIChub3QgaW5jbHVkaW5nIGZpbGVzIGxpa2UgaW50ZWdyYXRvcikKKwkgICBPbmUgcGF0 dGVybiBwZXIgbGluZS4gIE11bHRpcGxlIE46IGxpbmVzIGFjY2VwdGFibGUuCisJICAgdG9vbHMv Z2V0X21haW50YWluZXIucGwgaGFzIGRpZmZlcmVudCBiZWhhdmlvciBmb3IgZmlsZXMgdGhhdAor CSAgIG1hdGNoIEY6IHBhdHRlcm4gYW5kIG1hdGNoZXMgb2YgTjogcGF0dGVybnMuICBCeSBkZWZh dWx0LAorCSAgIGdldF9tYWludGFpbmVyIHdpbGwgbm90IGxvb2sgYXQgZ2l0IGxvZyBoaXN0b3J5 IHdoZW4gYW4gRjogcGF0dGVybgorCSAgIG1hdGNoIG9jY3Vycy4gIFdoZW4gYW4gTjogbWF0Y2gg b2NjdXJzLCBnaXQgbG9nIGhpc3RvcnkgaXMgdXNlZAorCSAgIHRvIGFsc28gbm90aWZ5IHRoZSBw ZW9wbGUgdGhhdCBoYXZlIGdpdCBjb21taXQgc2lnbmF0dXJlcy4KKwlLOiAqQ29udGVudCByZWdl eCogKHBlcmwgZXh0ZW5kZWQpIHBhdHRlcm4gbWF0Y2ggaW4gYSBwYXRjaCBvciBmaWxlLgorCSAg IEZvciBpbnN0YW5jZToKKwkgICBLOiBvZl9nZXRfcHJvZmlsZQorCSAgICAgIG1hdGNoZXMgcGF0 Y2hlcyBvciBmaWxlcyB0aGF0IGNvbnRhaW4gIm9mX2dldF9wcm9maWxlIgorCSAgIEs6IFxiKHBy aW50a3xwcl8oaW5mb3xlcnIpKVxiCisJICAgICAgbWF0Y2hlcyBwYXRjaGVzIG9yIGZpbGVzIHRo YXQgY29udGFpbiBvbmUgb3IgbW9yZSBvZiB0aGUgd29yZHMKKwkgICAgICBwcmludGssIHByX2lu Zm8gb3IgcHJfZXJyCisJICAgT25lIHJlZ2V4IHBhdHRlcm4gcGVyIGxpbmUuICBNdWx0aXBsZSBL OiBsaW5lcyBhY2NlcHRhYmxlLgorCitNYWludGFpbmVycyBMaXN0CistLS0tLS0tLS0tLS0tLS0t CisKKy4uIG5vdGU6OiBUaGUgd2hvbGUgZnN0ZXN0cyBhcmUgbWFpbnRhaW5lZCBieSBmc3Rlc3Rz QHZnZXIua2VybmVsLm9yZywgc28geW91CisJICBzaG91bGQgc2VuZCBwYXRjaCB0byBmc3Rlc3Rz QCBhdCBsZWFzdC4gT3RoZXIgcmVsZXZhbnQgbWFpbGluZyBsaXN0CisJICBvciByZXZpZXdlciBv ciBjby1tYWludGFpbmVyIGNhbiBiZSBpbiBjYyBsaXN0LgorCitBTEwKK006CVpvcnJvIExhbmcg PHpsYW5nQGtlcm5lbC5vcmc+CitMOglmc3Rlc3RzQHZnZXIua2VybmVsLm9yZworUzoJTWFpbnRh aW5lZAorVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vZnMveGZzL3hmc3Rlc3Rz LWRldi5naXQKK0Y6CSoKK0Y6CSovCmRpZmYgLS1naXQgYS90b29scy9nZXRfbWFpbnRhaW5lci5w bCBiL3Rvb2xzL2dldF9tYWludGFpbmVyLnBsCm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAw MDAwMDAwLi4zNzZjN2MwMgotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL2dldF9tYWludGFpbmVy LnBsCkBAIC0wLDAgKzEsMjYxNiBAQAorIyEvdXNyL2Jpbi9lbnYgcGVybAorIyBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMAorIworIyBUaGlzIHNjcmlwdCBpcyBjb3BpZWQgZnJvbSBs aW51eC9zY3JpcHRzL2dldF9tYWludGFpbmVyLnBsLCB0aGVuCisjIGNoYW5nZXMgZm9yIGZzdGVz dHMgc3BlY2lmaWNhbGx5LgorIworIyBQcmludCBzZWxlY3RlZCBNQUlOVEFJTkVSUyBpbmZvcm1h dGlvbiBmb3IKKyMgdGhlIGZpbGVzIG1vZGlmaWVkIGluIGEgcGF0Y2ggb3IgZm9yIGEgZmlsZQor IworIyB1c2FnZTogcGVybCB0b29scy9nZXRfbWFpbnRhaW5lci5wbCBbT1BUSU9OU10gPHBhdGNo PgorIyAgICAgICAgcGVybCB0b29scy9nZXRfbWFpbnRhaW5lci5wbCBbT1BUSU9OU10gLWYgPGZp bGU+CisKK3VzZSB3YXJuaW5nczsKK3VzZSBzdHJpY3Q7CisKK215ICRQID0gJDA7CitteSAkViA9 ICcwLjI2JzsKKwordXNlIEdldG9wdDo6TG9uZyBxdyg6Y29uZmlnIG5vX2F1dG9fYWJicmV2KTsK K3VzZSBDd2Q7Cit1c2UgRmlsZTo6RmluZDsKK3VzZSBGaWxlOjpTcGVjOjpGdW5jdGlvbnM7CisK K215ICRjdXJfcGF0aCA9IGZhc3RnZXRjd2QoKSAuICcvJzsKK215ICRsa19wYXRoID0gIi4vIjsK K215ICRlbWFpbCA9IDE7CitteSAkZW1haWxfdXNlbmFtZSA9IDE7CitteSAkZW1haWxfbWFpbnRh aW5lciA9IDE7CitteSAkZW1haWxfcmV2aWV3ZXIgPSAxOworbXkgJGVtYWlsX2ZpeGVzID0gMTsK K215ICRlbWFpbF9saXN0ID0gMTsKK215ICRlbWFpbF9tb2RlcmF0ZWRfbGlzdCA9IDE7CitteSAk ZW1haWxfc3Vic2NyaWJlcl9saXN0ID0gMDsKK215ICRlbWFpbF9naXRfcGVuZ3Vpbl9jaGllZnMg PSAwOworbXkgJGVtYWlsX2dpdCA9IDA7CitteSAkZW1haWxfZ2l0X2FsbF9zaWduYXR1cmVfdHlw ZXMgPSAwOworbXkgJGVtYWlsX2dpdF9ibGFtZSA9IDA7CitteSAkZW1haWxfZ2l0X2JsYW1lX3Np Z25hdHVyZXMgPSAxOworbXkgJGVtYWlsX2dpdF9mYWxsYmFjayA9IDE7CitteSAkZW1haWxfZ2l0 X21pbl9zaWduYXR1cmVzID0gMTsKK215ICRlbWFpbF9naXRfbWF4X21haW50YWluZXJzID0gNTsK K215ICRlbWFpbF9naXRfbWluX3BlcmNlbnQgPSA1OworbXkgJGVtYWlsX2dpdF9zaW5jZSA9ICIx LXllYXItYWdvIjsKK215ICRlbWFpbF9oZ19zaW5jZSA9ICItMzY1IjsKK215ICRpbnRlcmFjdGl2 ZSA9IDA7CitteSAkZW1haWxfcmVtb3ZlX2R1cGxpY2F0ZXMgPSAxOworbXkgJGVtYWlsX3VzZV9t YWlsbWFwID0gMTsKK215ICRvdXRwdXRfbXVsdGlsaW5lID0gMTsKK215ICRvdXRwdXRfc2VwYXJh dG9yID0gIiwgIjsKK215ICRvdXRwdXRfcm9sZXMgPSAwOworbXkgJG91dHB1dF9yb2xlc3RhdHMg PSAxOworbXkgJG91dHB1dF9zZWN0aW9uX21heGxlbiA9IDUwOworbXkgJHNjbSA9IDA7CitteSAk dHJlZSA9IDE7CitteSAkd2ViID0gMDsKK215ICRzdWJzeXN0ZW0gPSAwOworbXkgJHN0YXR1cyA9 IDA7CitteSAkbGV0dGVycyA9ICIiOworbXkgJGtleXdvcmRzID0gMTsKK215ICRzZWN0aW9ucyA9 IDA7CitteSAkZW1haWxfZmlsZV9lbWFpbHMgPSAwOworbXkgJGZyb21fZmlsZW5hbWUgPSAwOwor bXkgJHBhdHRlcm5fZGVwdGggPSAwOworbXkgJHNlbGZfdGVzdCA9IHVuZGVmOworbXkgJHZlcnNp b24gPSAwOworbXkgJGhlbHAgPSAwOworbXkgJGZpbmRfbWFpbnRhaW5lcl9maWxlcyA9IDA7Citt eSAkbWFpbnRhaW5lcl9wYXRoOworbXkgJHZjc191c2VkID0gMDsKKworbXkgJGV4aXQgPSAwOwor CitteSBAZmlsZXMgPSAoKTsKK215IEBmaXhlcyA9ICgpOwkJCSMgSWYgYSBwYXRjaCBkZXNjcmlw dGlvbiBpbmNsdWRlcyBGaXhlczogbGluZXMKK215IEByYW5nZSA9ICgpOworbXkgQGtleXdvcmRf dHZpID0gKCk7CitteSBAZmlsZV9lbWFpbHMgPSAoKTsKKworbXkgJWNvbW1pdF9hdXRob3JfaGFz aDsKK215ICVjb21taXRfc2lnbmVyX2hhc2g7CisKK215IEBwZW5ndWluX2NoaWVmID0gKCk7Citw dXNoKEBwZW5ndWluX2NoaWVmLCAiWm9ycm8gTGFuZzp6bGFuZ1xAa2VybmVsLm9yZyIpOworCitt eSBAcGVuZ3Vpbl9jaGllZl9uYW1lcyA9ICgpOworZm9yZWFjaCBteSAkY2hpZWYgKEBwZW5ndWlu X2NoaWVmKSB7CisgICAgaWYgKCRjaGllZiA9fiBtL14oLiopOiguKikvKSB7CisJbXkgJGNoaWVm X25hbWUgPSAkMTsKKwlteSAkY2hpZWZfYWRkciA9ICQyOworCXB1c2goQHBlbmd1aW5fY2hpZWZf bmFtZXMsICRjaGllZl9uYW1lKTsKKyAgICB9Cit9CitteSAkcGVuZ3Vpbl9jaGllZnMgPSAiXCgi IC4gam9pbigifCIsIEBwZW5ndWluX2NoaWVmX25hbWVzKSAuICJcKSI7CisKKyMgU2lnbmF0dXJl IHR5cGVzIG9mIHBlb3BsZSB3aG8gYXJlIGVpdGhlcgorIyAJYSkgcmVzcG9uc2libGUgZm9yIHRo ZSBjb2RlIGluIHF1ZXN0aW9uLCBvcgorIyAJYikgZmFtaWxpYXIgZW5vdWdoIHdpdGggaXQgdG8g Z2l2ZSByZWxldmFudCBmZWVkYmFjaworbXkgQHNpZ25hdHVyZV90YWdzID0gKCk7CitwdXNoKEBz aWduYXR1cmVfdGFncywgIlNpZ25lZC1vZmYtYnk6Iik7CitwdXNoKEBzaWduYXR1cmVfdGFncywg IlJldmlld2VkLWJ5OiIpOworcHVzaChAc2lnbmF0dXJlX3RhZ3MsICJBY2tlZC1ieToiKTsKKwor bXkgJHNpZ25hdHVyZV9wYXR0ZXJuID0gIlwoIiAuIGpvaW4oInwiLCBAc2lnbmF0dXJlX3RhZ3Mp IC4gIlwpIjsKKworIyByZmM4MjIgZW1haWwgYWRkcmVzcyAtIHByZWxvYWRlZCBtZXRob2RzIGdv IGhlcmUuCitteSAkcmZjODIyX2x3c3AgPSAiKD86KD86XFxyXFxuKT9bIFxcdF0pIjsKK215ICRy ZmM4MjJfY2hhciA9ICdbXFwwMDAtXFwzNzddJzsKKworIyBWQ1MgY29tbWFuZCBzdXBwb3J0OiBj bGFzcy1saWtlIGZ1bmN0aW9ucyBhbmQgc3RyaW5ncworCitteSAlVkNTX2NtZHM7CisKK215ICVW Q1NfY21kc19naXQgPSAoCisgICAgImV4ZWN1dGVfY21kIiA9PiBcJmdpdF9leGVjdXRlX2NtZCwK KyAgICAiYXZhaWxhYmxlIiA9PiAnKHdoaWNoKCJnaXQiKSBuZSAiIikgJiYgKC1lICIuZ2l0Iikn LAorICAgICJmaW5kX3NpZ25lcnNfY21kIiA9PgorCSJnaXQgbG9nIC0tbm8tY29sb3IgLS1mb2xs b3cgLS1zaW5jZT1cJGVtYWlsX2dpdF9zaW5jZSAiIC4KKwkgICAgJy0tbnVtc3RhdCAtLW5vLW1l cmdlcyAnIC4KKwkgICAgJy0tZm9ybWF0PSJHaXRDb21taXQ6ICVIJW4nIC4KKwkJICAgICAgJ0dp dEF1dGhvcjogJWFuIDwlYWU+JW4nIC4KKwkJICAgICAgJ0dpdERhdGU6ICVhRCVuJyAuCisJCSAg ICAgICdHaXRTdWJqZWN0OiAlcyVuJyAuCisJCSAgICAgICclYiVuIicgLgorCSAgICAiIC0tIFwk ZmlsZSIsCisgICAgImZpbmRfY29tbWl0X3NpZ25lcnNfY21kIiA9PgorCSJnaXQgbG9nIC0tbm8t Y29sb3IgIiAuCisJICAgICctLW51bXN0YXQgJyAuCisJICAgICctLWZvcm1hdD0iR2l0Q29tbWl0 OiAlSCVuJyAuCisJCSAgICAgICdHaXRBdXRob3I6ICVhbiA8JWFlPiVuJyAuCisJCSAgICAgICdH aXREYXRlOiAlYUQlbicgLgorCQkgICAgICAnR2l0U3ViamVjdDogJXMlbicgLgorCQkgICAgICAn JWIlbiInIC4KKwkgICAgIiAtMSBcJGNvbW1pdCIsCisgICAgImZpbmRfY29tbWl0X2F1dGhvcl9j bWQiID0+CisJImdpdCBsb2cgLS1uby1jb2xvciAiIC4KKwkgICAgJy0tbnVtc3RhdCAnIC4KKwkg ICAgJy0tZm9ybWF0PSJHaXRDb21taXQ6ICVIJW4nIC4KKwkJICAgICAgJ0dpdEF1dGhvcjogJWFu IDwlYWU+JW4nIC4KKwkJICAgICAgJ0dpdERhdGU6ICVhRCVuJyAuCisJCSAgICAgICdHaXRTdWJq ZWN0OiAlcyVuIicgLgorCSAgICAiIC0xIFwkY29tbWl0IiwKKyAgICAiYmxhbWVfcmFuZ2VfY21k IiA9PiAiZ2l0IGJsYW1lIC1sIC1MIFwkZGlmZl9zdGFydCwrXCRkaWZmX2xlbmd0aCBcJGZpbGUi LAorICAgICJibGFtZV9maWxlX2NtZCIgPT4gImdpdCBibGFtZSAtbCBcJGZpbGUiLAorICAgICJj b21taXRfcGF0dGVybiIgPT4gIl5HaXRDb21taXQ6IChbMC05YS1mXXs0MCw0MH0pIiwKKyAgICAi YmxhbWVfY29tbWl0X3BhdHRlcm4iID0+ICJeKFswLTlhLWZdKykgIiwKKyAgICAiYXV0aG9yX3Bh dHRlcm4iID0+ICJeR2l0QXV0aG9yOiAoLiopIiwKKyAgICAic3ViamVjdF9wYXR0ZXJuIiA9PiAi XkdpdFN1YmplY3Q6ICguKikiLAorICAgICJzdGF0X3BhdHRlcm4iID0+ICJeKFxcZCspXFx0KFxc ZCspXFx0XCRmaWxlXCQiLAorICAgICJmaWxlX2V4aXN0c19jbWQiID0+ICJnaXQgbHMtZmlsZXMg XCRmaWxlIiwKKyAgICAibGlzdF9maWxlc19jbWQiID0+ICJnaXQgbHMtZmlsZXMgXCRmaWxlIiwK Kyk7CisKK215ICVWQ1NfY21kc19oZyA9ICgKKyAgICAiZXhlY3V0ZV9jbWQiID0+IFwmaGdfZXhl Y3V0ZV9jbWQsCisgICAgImF2YWlsYWJsZSIgPT4gJyh3aGljaCgiaGciKSBuZSAiIikgJiYgKC1k ICIuaGciKScsCisgICAgImZpbmRfc2lnbmVyc19jbWQiID0+CisJImhnIGxvZyAtLWRhdGU9XCRl bWFpbF9oZ19zaW5jZSAiIC4KKwkgICAgIi0tdGVtcGxhdGU9J0hnQ29tbWl0OiB7bm9kZX1cXG4i IC4KKwkgICAgICAgICAgICAgICAgIkhnQXV0aG9yOiB7YXV0aG9yfVxcbiIgLgorCQkJIkhnU3Vi amVjdDoge2Rlc2N9XFxuJyIgLgorCSAgICAiIC0tIFwkZmlsZSIsCisgICAgImZpbmRfY29tbWl0 X3NpZ25lcnNfY21kIiA9PgorCSJoZyBsb2cgIiAuCisJICAgICItLXRlbXBsYXRlPSdIZ1N1Ympl Y3Q6IHtkZXNjfVxcbiciIC4KKwkgICAgIiAtciBcJGNvbW1pdCIsCisgICAgImZpbmRfY29tbWl0 X2F1dGhvcl9jbWQiID0+CisJImhnIGxvZyAiIC4KKwkgICAgIi0tdGVtcGxhdGU9J0hnQ29tbWl0 OiB7bm9kZX1cXG4iIC4KKwkJICAgICAgICAiSGdBdXRob3I6IHthdXRob3J9XFxuIiAuCisJCQki SGdTdWJqZWN0OiB7ZGVzY3xmaXJzdGxpbmV9XFxuJyIgLgorCSAgICAiIC1yIFwkY29tbWl0IiwK KyAgICAiYmxhbWVfcmFuZ2VfY21kIiA9PiAiIiwJCSMgbm90IHN1cHBvcnRlZAorICAgICJibGFt ZV9maWxlX2NtZCIgPT4gImhnIGJsYW1lIC1uIFwkZmlsZSIsCisgICAgImNvbW1pdF9wYXR0ZXJu IiA9PiAiXkhnQ29tbWl0OiAoWzAtOWEtZl17NDAsNDB9KSIsCisgICAgImJsYW1lX2NvbW1pdF9w YXR0ZXJuIiA9PiAiXihbIDAtOWEtZl0rKToiLAorICAgICJhdXRob3JfcGF0dGVybiIgPT4gIl5I Z0F1dGhvcjogKC4qKSIsCisgICAgInN1YmplY3RfcGF0dGVybiIgPT4gIl5IZ1N1YmplY3Q6ICgu KikiLAorICAgICJzdGF0X3BhdHRlcm4iID0+ICJeKFxcZCspXHQoXFxkKylcdFwkZmlsZVwkIiwK KyAgICAiZmlsZV9leGlzdHNfY21kIiA9PiAiaGcgZmlsZXMgXCRmaWxlIiwKKyAgICAibGlzdF9m aWxlc19jbWQiID0+ICJoZyBtYW5pZmVzdCAtUiBcJGZpbGUiLAorKTsKKworbXkgJGNvbmYgPSB3 aGljaF9jb25mKCIuZ2V0X21haW50YWluZXIuY29uZiIpOworaWYgKC1mICRjb25mKSB7CisgICAg bXkgQGNvbmZfYXJnczsKKyAgICBvcGVuKG15ICRjb25mZmlsZSwgJzwnLCAiJGNvbmYiKQorCW9y IHdhcm4gIiRQOiBDYW4ndCBmaW5kIGEgcmVhZGFibGUgLmdldF9tYWludGFpbmVyLmNvbmYgZmls ZSAkIVxuIjsKKworICAgIHdoaWxlICg8JGNvbmZmaWxlPikgeworCW15ICRsaW5lID0gJF87CisK KwkkbGluZSA9fiBzL1xzKlxuPyQvL2c7CisJJGxpbmUgPX4gcy9eXHMqLy9nOworCSRsaW5lID1+ IHMvXHMrLyAvZzsKKworCW5leHQgaWYgKCRsaW5lID1+IG0vXlxzKiMvKTsKKwluZXh0IGlmICgk bGluZSA9fiBtL15ccyokLyk7CisKKwlteSBAd29yZHMgPSBzcGxpdCgiICIsICRsaW5lKTsKKwlm b3JlYWNoIG15ICR3b3JkIChAd29yZHMpIHsKKwkgICAgbGFzdCBpZiAoJHdvcmQgPX4gbS9eIy8p OworCSAgICBwdXNoIChAY29uZl9hcmdzLCAkd29yZCk7CisJfQorICAgIH0KKyAgICBjbG9zZSgk Y29uZmZpbGUpOworICAgIHVuc2hpZnQoQEFSR1YsIEBjb25mX2FyZ3MpIGlmIEBjb25mX2FyZ3M7 Cit9CisKK215IEBpZ25vcmVfZW1haWxzID0gKCk7CitteSAkaWdub3JlX2ZpbGUgPSB3aGljaF9j b25mKCIuZ2V0X21haW50YWluZXIuaWdub3JlIik7CitpZiAoLWYgJGlnbm9yZV9maWxlKSB7Cisg ICAgb3BlbihteSAkaWdub3JlLCAnPCcsICIkaWdub3JlX2ZpbGUiKQorCW9yIHdhcm4gIiRQOiBD YW4ndCBmaW5kIGEgcmVhZGFibGUgLmdldF9tYWludGFpbmVyLmlnbm9yZSBmaWxlICQhXG4iOwor ICAgIHdoaWxlICg8JGlnbm9yZT4pIHsKKwlteSAkbGluZSA9ICRfOworCisJJGxpbmUgPX4gcy9c cypcbj8kLy87CisJJGxpbmUgPX4gcy9eXHMqLy87CisJJGxpbmUgPX4gcy9ccyskLy87CisJJGxp bmUgPX4gcy8jLiokLy87CisKKwluZXh0IGlmICgkbGluZSA9fiBtL15ccyokLyk7CisJaWYgKHJm YzgyMl92YWxpZCgkbGluZSkpIHsKKwkgICAgcHVzaChAaWdub3JlX2VtYWlscywgJGxpbmUpOwor CX0KKyAgICB9CisgICAgY2xvc2UoJGlnbm9yZSk7Cit9CisKK2lmICgkI0FSR1YgPiAwKSB7Cisg ICAgZm9yZWFjaCAoQEFSR1YpIHsKKyAgICAgICAgaWYgKCRfID1+IC9eLXsxLDJ9c2VsZi10ZXN0 KD86PXwkKS8pIHsKKyAgICAgICAgICAgIGRpZSAiJFA6IHVzaW5nIC0tc2VsZi10ZXN0IGRvZXMg bm90IGFsbG93IGFueSBvdGhlciBvcHRpb24gb3IgYXJndW1lbnRcbiI7CisgICAgICAgIH0KKyAg ICB9Cit9CisKK2lmICghR2V0T3B0aW9ucygKKwkJJ2VtYWlsIScgPT4gXCRlbWFpbCwKKwkJJ2dp dCEnID0+IFwkZW1haWxfZ2l0LAorCQknZ2l0LWFsbC1zaWduYXR1cmUtdHlwZXMhJyA9PiBcJGVt YWlsX2dpdF9hbGxfc2lnbmF0dXJlX3R5cGVzLAorCQknZ2l0LWJsYW1lIScgPT4gXCRlbWFpbF9n aXRfYmxhbWUsCisJCSdnaXQtYmxhbWUtc2lnbmF0dXJlcyEnID0+IFwkZW1haWxfZ2l0X2JsYW1l X3NpZ25hdHVyZXMsCisJCSdnaXQtZmFsbGJhY2shJyA9PiBcJGVtYWlsX2dpdF9mYWxsYmFjaywK KwkJJ2dpdC1jaGllZi1wZW5ndWlucyEnID0+IFwkZW1haWxfZ2l0X3Blbmd1aW5fY2hpZWZzLAor CQknZ2l0LW1pbi1zaWduYXR1cmVzPWknID0+IFwkZW1haWxfZ2l0X21pbl9zaWduYXR1cmVzLAor CQknZ2l0LW1heC1tYWludGFpbmVycz1pJyA9PiBcJGVtYWlsX2dpdF9tYXhfbWFpbnRhaW5lcnMs CisJCSdnaXQtbWluLXBlcmNlbnQ9aScgPT4gXCRlbWFpbF9naXRfbWluX3BlcmNlbnQsCisJCSdn aXQtc2luY2U9cycgPT4gXCRlbWFpbF9naXRfc2luY2UsCisJCSdoZy1zaW5jZT1zJyA9PiBcJGVt YWlsX2hnX3NpbmNlLAorCQknaXxpbnRlcmFjdGl2ZSEnID0+IFwkaW50ZXJhY3RpdmUsCisJCSdy ZW1vdmUtZHVwbGljYXRlcyEnID0+IFwkZW1haWxfcmVtb3ZlX2R1cGxpY2F0ZXMsCisJCSdtYWls bWFwIScgPT4gXCRlbWFpbF91c2VfbWFpbG1hcCwKKwkJJ20hJyA9PiBcJGVtYWlsX21haW50YWlu ZXIsCisJCSdyIScgPT4gXCRlbWFpbF9yZXZpZXdlciwKKwkJJ24hJyA9PiBcJGVtYWlsX3VzZW5h bWUsCisJCSdsIScgPT4gXCRlbWFpbF9saXN0LAorCQknZml4ZXMhJyA9PiBcJGVtYWlsX2ZpeGVz LAorCQknbW9kZXJhdGVkIScgPT4gXCRlbWFpbF9tb2RlcmF0ZWRfbGlzdCwKKwkJJ3MhJyA9PiBc JGVtYWlsX3N1YnNjcmliZXJfbGlzdCwKKwkJJ211bHRpbGluZSEnID0+IFwkb3V0cHV0X211bHRp bGluZSwKKwkJJ3JvbGVzIScgPT4gXCRvdXRwdXRfcm9sZXMsCisJCSdyb2xlc3RhdHMhJyA9PiBc JG91dHB1dF9yb2xlc3RhdHMsCisJCSdzZXBhcmF0b3I9cycgPT4gXCRvdXRwdXRfc2VwYXJhdG9y LAorCQknc3Vic3lzdGVtIScgPT4gXCRzdWJzeXN0ZW0sCisJCSdzdGF0dXMhJyA9PiBcJHN0YXR1 cywKKwkJJ3NjbSEnID0+IFwkc2NtLAorCQkndHJlZSEnID0+IFwkdHJlZSwKKwkJJ3dlYiEnID0+ IFwkd2ViLAorCQknbGV0dGVycz1zJyA9PiBcJGxldHRlcnMsCisJCSdwYXR0ZXJuLWRlcHRoPWkn ID0+IFwkcGF0dGVybl9kZXB0aCwKKwkJJ2t8a2V5d29yZHMhJyA9PiBcJGtleXdvcmRzLAorCQkn c2VjdGlvbnMhJyA9PiBcJHNlY3Rpb25zLAorCQknZmV8ZmlsZS1lbWFpbHMhJyA9PiBcJGVtYWls X2ZpbGVfZW1haWxzLAorCQknZnxmaWxlJyA9PiBcJGZyb21fZmlsZW5hbWUsCisJCSdmaW5kLW1h aW50YWluZXItZmlsZXMnID0+IFwkZmluZF9tYWludGFpbmVyX2ZpbGVzLAorCQknbXBhdGh8bWFp bnRhaW5lci1wYXRoPXMnID0+IFwkbWFpbnRhaW5lcl9wYXRoLAorCQknc2VsZi10ZXN0OnMnID0+ IFwkc2VsZl90ZXN0LAorCQkndnx2ZXJzaW9uJyA9PiBcJHZlcnNpb24sCisJCSdofGhlbHB8dXNh Z2UnID0+IFwkaGVscCwKKwkJKSkgeworICAgIGRpZSAiJFA6IGludmFsaWQgYXJndW1lbnQgLSB1 c2UgLS1oZWxwIGlmIG5lY2Vzc2FyeVxuIjsKK30KKworaWYgKCRoZWxwICE9IDApIHsKKyAgICB1 c2FnZSgpOworICAgIGV4aXQgMDsKK30KKworaWYgKCR2ZXJzaW9uICE9IDApIHsKKyAgICBwcmlu dCgiJHtQfSAke1Z9XG4iKTsKKyAgICBleGl0IDA7Cit9CisKK2lmIChkZWZpbmVkICRzZWxmX3Rl c3QpIHsKKyAgICByZWFkX2FsbF9tYWludGFpbmVyX2ZpbGVzKCk7CisgICAgc2VsZl90ZXN0KCk7 CisgICAgZXhpdCAwOworfQorCitpZiAoLXQgU1RESU4gJiYgIUBBUkdWKSB7CisgICAgIyBXZSdy ZSB0YWxraW5nIHRvIGEgdGVybWluYWwsIGJ1dCBoYXZlIG5vIGNvbW1hbmQgbGluZSBhcmd1bWVu dHMuCisgICAgZGllICIkUDogbWlzc2luZyBwYXRjaGZpbGUgb3IgLWYgZmlsZSAtIHVzZSAtLWhl bHAgaWYgbmVjZXNzYXJ5XG4iOworfQorCiskb3V0cHV0X211bHRpbGluZSA9IDAgaWYgKCRvdXRw dXRfc2VwYXJhdG9yIG5lICIsICIpOworJG91dHB1dF9yb2xlc3RhdHMgPSAxIGlmICgkaW50ZXJh Y3RpdmUpOworJG91dHB1dF9yb2xlcyA9IDEgaWYgKCRvdXRwdXRfcm9sZXN0YXRzKTsKKworaWYg KCRzZWN0aW9ucyB8fCAkbGV0dGVycyBuZSAiIikgeworICAgICRzZWN0aW9ucyA9IDE7CisgICAg JGVtYWlsID0gMDsKKyAgICAkZW1haWxfbGlzdCA9IDA7CisgICAgJHNjbSA9IDA7CisgICAgJHN0 YXR1cyA9IDA7CisgICAgJHN1YnN5c3RlbSA9IDA7CisgICAgJHdlYiA9IDA7CisgICAgJGtleXdv cmRzID0gMDsKKyAgICAkaW50ZXJhY3RpdmUgPSAwOworfSBlbHNlIHsKKyAgICBteSAkc2VsZWN0 aW9ucyA9ICRlbWFpbCArICRzY20gKyAkc3RhdHVzICsgJHN1YnN5c3RlbSArICR3ZWI7CisgICAg aWYgKCRzZWxlY3Rpb25zID09IDApIHsKKwlkaWUgIiRQOiAgTWlzc2luZyByZXF1aXJlZCBvcHRp b246IGVtYWlsLCBzY20sIHN0YXR1cywgc3Vic3lzdGVtIG9yIHdlYlxuIjsKKyAgICB9Cit9CisK K2lmICgkZW1haWwgJiYKKyAgICAoJGVtYWlsX21haW50YWluZXIgKyAkZW1haWxfcmV2aWV3ZXIg KworICAgICAkZW1haWxfbGlzdCArICRlbWFpbF9zdWJzY3JpYmVyX2xpc3QgKworICAgICAkZW1h aWxfZ2l0ICsgJGVtYWlsX2dpdF9wZW5ndWluX2NoaWVmcyArICRlbWFpbF9naXRfYmxhbWUpID09 IDApIHsKKyAgICBkaWUgIiRQOiBQbGVhc2Ugc2VsZWN0IGF0IGxlYXN0IDEgZW1haWwgb3B0aW9u XG4iOworfQorCitpZiAoJHRyZWUgJiYgIXRvcF9vZl9mc3Rlc3RzX3RyZWUoJGxrX3BhdGgpKSB7 CisgICAgZGllICIkUDogVGhlIGN1cnJlbnQgZGlyZWN0b3J5IGRvZXMgbm90IGFwcGVhciB0byBi ZSAiCisJLiAiYSBmc3Rlc3RzIHNvdXJjZSB0cmVlLlxuIjsKK30KKworIyMgUmVhZCBNQUlOVEFJ TkVSUyBmb3IgdHlwZS92YWx1ZSBwYWlycworCitteSBAdHlwZXZhbHVlID0gKCk7CitteSAla2V5 d29yZF9oYXNoOworbXkgQG1maWxlcyA9ICgpOworbXkgQHNlbGZfdGVzdF9pbmZvID0gKCk7CisK K3N1YiByZWFkX21haW50YWluZXJfZmlsZSB7CisgICAgbXkgKCRmaWxlKSA9IEBfOworCisgICAg b3BlbiAobXkgJG1haW50LCAnPCcsICIkZmlsZSIpCisJb3IgZGllICIkUDogQ2FuJ3Qgb3BlbiBN QUlOVEFJTkVSUyBmaWxlICckZmlsZSc6ICQhXG4iOworICAgIG15ICRpID0gMTsKKyAgICB3aGls ZSAoPCRtYWludD4pIHsKKwlteSAkbGluZSA9ICRfOworCWNob21wICRsaW5lOworCisJaWYgKCRs aW5lID1+IG0vXihbQS1aXSk6XHMqKC4qKS8pIHsKKwkgICAgbXkgJHR5cGUgPSAkMTsKKwkgICAg bXkgJHZhbHVlID0gJDI7CisKKwkgICAgIyNGaWxlbmFtZSBwYXR0ZXJuIG1hdGNoaW5nCisJICAg IGlmICgkdHlwZSBlcSAiRiIgfHwgJHR5cGUgZXEgIlgiKSB7CisJCSR2YWx1ZSA9fiBzQFwuQFxc XC5AZzsgICAgICAgIyNDb252ZXJ0IC4gdG8gXC4KKwkJJHZhbHVlID1+IHMvXCovXC5cKi9nOyAg ICAgICAjI0NvbnZlcnQgKiB0byAuKgorCQkkdmFsdWUgPX4gcy9cPy9cLi9nOyAgICAgICAgICMj Q29udmVydCA/IHRvIC4KKwkJIyNpZiBwYXR0ZXJuIGlzIGEgZGlyZWN0b3J5IGFuZCBpdCBsYWNr cyBhIHRyYWlsaW5nIHNsYXNoLCBhZGQgb25lCisJCWlmICgoLWQgJHZhbHVlKSkgeworCQkgICAg JHZhbHVlID1+IHNAKFteL10pJEAkMS9AOworCQl9CisJICAgIH0gZWxzaWYgKCR0eXBlIGVxICJL IikgeworCQkka2V5d29yZF9oYXNoe0B0eXBldmFsdWV9ID0gJHZhbHVlOworCSAgICB9CisJICAg IHB1c2goQHR5cGV2YWx1ZSwgIiR0eXBlOiR2YWx1ZSIpOworCX0gZWxzaWYgKCEoL15ccyokLyB8 fCAvXlxzKlwjLykpIHsKKwkgICAgcHVzaChAdHlwZXZhbHVlLCAkbGluZSk7CisJfQorCWlmIChk ZWZpbmVkICRzZWxmX3Rlc3QpIHsKKwkgICAgcHVzaChAc2VsZl90ZXN0X2luZm8sIHtmaWxlPT4k ZmlsZSwgbGluZW5yPT4kaSwgbGluZT0+JGxpbmV9KTsKKwl9CisJJGkrKzsKKyAgICB9CisgICAg Y2xvc2UoJG1haW50KTsKK30KKworc3ViIGZpbmRfaXNfbWFpbnRhaW5lcl9maWxlIHsKKyAgICBt eSAoJGZpbGUpID0gJF87CisgICAgcmV0dXJuIGlmICgkZmlsZSAhfiBtQC9NQUlOVEFJTkVSUyRA KTsKKyAgICAkZmlsZSA9ICRGaWxlOjpGaW5kOjpuYW1lOworICAgIHJldHVybiBpZiAoISAtZiAk ZmlsZSk7CisgICAgcHVzaChAbWZpbGVzLCAkZmlsZSk7Cit9CisKK3N1YiBmaW5kX2lnbm9yZV9n aXQgeworICAgIHJldHVybiBncmVwIHsgJF8gIX4gL15cLmdpdCQvOyB9IEBfOworfQorCityZWFk X2FsbF9tYWludGFpbmVyX2ZpbGVzKCk7CisKK3N1YiByZWFkX2FsbF9tYWludGFpbmVyX2ZpbGVz IHsKKyAgICBteSAkcGF0aCA9ICIke2xrX3BhdGh9TUFJTlRBSU5FUlMiOworICAgIGlmIChkZWZp bmVkICRtYWludGFpbmVyX3BhdGgpIHsKKwkkcGF0aCA9ICRtYWludGFpbmVyX3BhdGg7CisJIyBQ ZXJsIENvb2tib29rIHRpbGRlIGV4cGFuc2lvbiBpZiBuZWNlc3NhcnkKKwkkcGF0aCA9fiBzQF5+ KFteL10qKUAgJDEgPyAoZ2V0cHduYW0oJDEpKVs3XSA6ICggJEVOVntIT01FfSB8fCAkRU5We0xP R0RJUn0gfHwgKGdldHB3dWlkKCQ8KSlbN10pQGV4OworICAgIH0KKworICAgIGlmICgtZCAkcGF0 aCkgeworCSRwYXRoIC49ICcvJyBpZiAoJHBhdGggIX4gbUAvJEApOworCWlmICgkZmluZF9tYWlu dGFpbmVyX2ZpbGVzKSB7CisJICAgIGZpbmQoIHsgd2FudGVkID0+IFwmZmluZF9pc19tYWludGFp bmVyX2ZpbGUsCisJCSAgICBwcmVwcm9jZXNzID0+IFwmZmluZF9pZ25vcmVfZ2l0LAorCQkgICAg bm9fY2hkaXIgPT4gMSwKKwkJfSwgIiRwYXRoIik7CisJfSBlbHNlIHsKKwkgICAgb3BlbmRpcihE SVIsICIkcGF0aCIpIG9yIGRpZSAkITsKKwkgICAgbXkgQGZpbGVzID0gcmVhZGRpcihESVIpOwor CSAgICBjbG9zZWRpcihESVIpOworCSAgICBmb3JlYWNoIG15ICRmaWxlIChAZmlsZXMpIHsKKwkJ cHVzaChAbWZpbGVzLCAiJHBhdGgkZmlsZSIpIGlmICgkZmlsZSAhfiAvXlwuLyk7CisJICAgIH0K Kwl9CisgICAgfSBlbHNpZiAoLWYgIiRwYXRoIikgeworCXB1c2goQG1maWxlcywgIiRwYXRoIik7 CisgICAgfSBlbHNlIHsKKwlkaWUgIiRQOiBNQUlOVEFJTkVSIGZpbGUgbm90IGZvdW5kICckcGF0 aCdcbiI7CisgICAgfQorICAgIGRpZSAiJFA6IE5vIE1BSU5UQUlORVIgZmlsZXMgZm91bmQgaW4g JyRwYXRoJ1xuIiBpZiAoc2NhbGFyKEBtZmlsZXMpID09IDApOworICAgIGZvcmVhY2ggbXkgJGZp bGUgKEBtZmlsZXMpIHsKKwlyZWFkX21haW50YWluZXJfZmlsZSgiJGZpbGUiKTsKKyAgICB9Cit9 CisKK3N1YiBtYWludGFpbmVyc19pbl9maWxlIHsKKyAgICBteSAoJGZpbGUpID0gQF87CisKKyAg ICByZXR1cm4gaWYgKCRmaWxlID1+IG1AXGJNQUlOVEFJTkVSUyRAKTsKKworICAgIGlmICgtZiAk ZmlsZSAmJiAoJGVtYWlsX2ZpbGVfZW1haWxzIHx8ICRmaWxlID1+IC9cLnlhbWwkLykpIHsKKwlv cGVuKG15ICRmLCAnPCcsICRmaWxlKQorCSAgICBvciBkaWUgIiRQOiBDYW4ndCBvcGVuICRmaWxl OiAkIVxuIjsKKwlteSAkdGV4dCA9IGRvIHsgbG9jYWwoJC8pIDsgPCRmPiB9OworCWNsb3NlKCRm KTsKKworCW15IEBwb3NzX2FkZHIgPSAkdGV4dCA9fiBtJFtBLVphLXrDgC3Dv1wiXCcgXCxcLlwr LV0qXHMqW1wsXSpccypbXChcPFx7XXswLDF9W0EtWmEtejAtOV9cLlwrLV0rXEBbQS1aYS16MC05 XC4tXStcLltBLVphLXowLTldK1tcKVw+XH1dezAsMX0kZzsKKwlwdXNoKEBmaWxlX2VtYWlscywg Y2xlYW5fZmlsZV9lbWFpbHMoQHBvc3NfYWRkcikpOworICAgIH0KK30KKworIworIyBSZWFkIG1h aWwgYWRkcmVzcyBtYXAKKyMKKworbXkgJG1haWxtYXA7CisKK3JlYWRfbWFpbG1hcCgpOworCitz dWIgcmVhZF9tYWlsbWFwIHsKKyAgICAkbWFpbG1hcCA9IHsKKwluYW1lcyA9PiB7fSwKKwlhZGRy ZXNzZXMgPT4ge30KKyAgICB9OworCisgICAgcmV0dXJuIGlmICghJGVtYWlsX3VzZV9tYWlsbWFw IHx8ICEoLWYgIiR7bGtfcGF0aH0ubWFpbG1hcCIpKTsKKworICAgIG9wZW4obXkgJG1haWxtYXBf ZmlsZSwgJzwnLCAiJHtsa19wYXRofS5tYWlsbWFwIikKKwlvciB3YXJuICIkUDogQ2FuJ3Qgb3Bl biAubWFpbG1hcDogJCFcbiI7CisKKyAgICB3aGlsZSAoPCRtYWlsbWFwX2ZpbGU+KSB7CisJcy8j LiokLy87ICNzdHJpcCBjb21tZW50cworCXMvXlxzK3xccyskLy9nOyAjdHJpbQorCisJbmV4dCBp ZiAoL15ccyokLyk7ICNza2lwIGVtcHR5IGxpbmVzCisJI2VudHJpZXMgaGF2ZSBvbmUgb2YgdGhl IGZvbGxvd2luZyBmb3JtYXRzOgorCSMgbmFtZTEgPG1haWwxPgorCSMgPG1haWwxPiA8bWFpbDI+ CisJIyBuYW1lMSA8bWFpbDE+IDxtYWlsMj4KKwkjIG5hbWUxIDxtYWlsMT4gbmFtZTIgPG1haWwy PgorCSMgKHNlZSBtYW4gZ2l0LXNob3J0bG9nKQorCisJaWYgKC9eKFtePF0rKTwoW14+XSspPiQv KSB7CisJICAgIG15ICRyZWFsX25hbWUgPSAkMTsKKwkgICAgbXkgJGFkZHJlc3MgPSAkMjsKKwor CSAgICAkcmVhbF9uYW1lID1+IHMvXHMrJC8vOworCSAgICAoJHJlYWxfbmFtZSwgJGFkZHJlc3Mp ID0gcGFyc2VfZW1haWwoIiRyZWFsX25hbWUgPCRhZGRyZXNzPiIpOworCSAgICAkbWFpbG1hcC0+ e25hbWVzfS0+eyRhZGRyZXNzfSA9ICRyZWFsX25hbWU7CisKKwl9IGVsc2lmICgvXjwoW14+XSsp PlxzKjwoW14+XSspPiQvKSB7CisJICAgIG15ICRyZWFsX2FkZHJlc3MgPSAkMTsKKwkgICAgbXkg JHdyb25nX2FkZHJlc3MgPSAkMjsKKworCSAgICAkbWFpbG1hcC0+e2FkZHJlc3Nlc30tPnskd3Jv bmdfYWRkcmVzc30gPSAkcmVhbF9hZGRyZXNzOworCisJfSBlbHNpZiAoL14oLispPChbXj5dKyk+ XHMqPChbXj5dKyk+JC8pIHsKKwkgICAgbXkgJHJlYWxfbmFtZSA9ICQxOworCSAgICBteSAkcmVh bF9hZGRyZXNzID0gJDI7CisJICAgIG15ICR3cm9uZ19hZGRyZXNzID0gJDM7CisKKwkgICAgJHJl YWxfbmFtZSA9fiBzL1xzKyQvLzsKKwkgICAgKCRyZWFsX25hbWUsICRyZWFsX2FkZHJlc3MpID0K KwkJcGFyc2VfZW1haWwoIiRyZWFsX25hbWUgPCRyZWFsX2FkZHJlc3M+Iik7CisJICAgICRtYWls bWFwLT57bmFtZXN9LT57JHdyb25nX2FkZHJlc3N9ID0gJHJlYWxfbmFtZTsKKwkgICAgJG1haWxt YXAtPnthZGRyZXNzZXN9LT57JHdyb25nX2FkZHJlc3N9ID0gJHJlYWxfYWRkcmVzczsKKworCX0g ZWxzaWYgKC9eKC4rKTwoW14+XSspPlxzKiguKylccyo8KFtePl0rKT4kLykgeworCSAgICBteSAk cmVhbF9uYW1lID0gJDE7CisJICAgIG15ICRyZWFsX2FkZHJlc3MgPSAkMjsKKwkgICAgbXkgJHdy b25nX25hbWUgPSAkMzsKKwkgICAgbXkgJHdyb25nX2FkZHJlc3MgPSAkNDsKKworCSAgICAkcmVh bF9uYW1lID1+IHMvXHMrJC8vOworCSAgICAoJHJlYWxfbmFtZSwgJHJlYWxfYWRkcmVzcykgPQor CQlwYXJzZV9lbWFpbCgiJHJlYWxfbmFtZSA8JHJlYWxfYWRkcmVzcz4iKTsKKworCSAgICAkd3Jv bmdfbmFtZSA9fiBzL1xzKyQvLzsKKwkgICAgKCR3cm9uZ19uYW1lLCAkd3JvbmdfYWRkcmVzcykg PQorCQlwYXJzZV9lbWFpbCgiJHdyb25nX25hbWUgPCR3cm9uZ19hZGRyZXNzPiIpOworCisJICAg IG15ICR3cm9uZ19lbWFpbCA9IGZvcm1hdF9lbWFpbCgkd3JvbmdfbmFtZSwgJHdyb25nX2FkZHJl c3MsIDEpOworCSAgICAkbWFpbG1hcC0+e25hbWVzfS0+eyR3cm9uZ19lbWFpbH0gPSAkcmVhbF9u YW1lOworCSAgICAkbWFpbG1hcC0+e2FkZHJlc3Nlc30tPnskd3JvbmdfZW1haWx9ID0gJHJlYWxf YWRkcmVzczsKKwl9CisgICAgfQorICAgIGNsb3NlKCRtYWlsbWFwX2ZpbGUpOworfQorCisjIyB1 c2UgdGhlIGZpbGVuYW1lcyBvbiB0aGUgY29tbWFuZCBsaW5lIG9yIGZpbmQgdGhlIGZpbGVuYW1l cyBpbiB0aGUgcGF0Y2hmaWxlcworCitpZiAoIUBBUkdWKSB7CisgICAgcHVzaChAQVJHViwgIiZT VERJTiIpOworfQorCitmb3JlYWNoIG15ICRmaWxlIChAQVJHVikgeworICAgIGlmICgkZmlsZSBu ZSAiJlNURElOIikgeworCSRmaWxlID0gY2Fub25wYXRoKCRmaWxlKTsKKwkjI2lmICRmaWxlIGlz IGEgZGlyZWN0b3J5IGFuZCBpdCBsYWNrcyBhIHRyYWlsaW5nIHNsYXNoLCBhZGQgb25lCisJaWYg KCgtZCAkZmlsZSkpIHsKKwkgICAgJGZpbGUgPX4gc0AoW14vXSkkQCQxL0A7CisJfSBlbHNpZiAo ISgtZiAkZmlsZSkpIHsKKwkgICAgZGllICIkUDogZmlsZSAnJHtmaWxlfScgbm90IGZvdW5kXG4i OworCX0KKyAgICB9CisgICAgaWYgKCRmcm9tX2ZpbGVuYW1lICYmICh2Y3NfZXhpc3RzKCkgJiYg IXZjc19maWxlX2V4aXN0cygkZmlsZSkpKSB7CisJd2FybiAiJFA6IGZpbGUgJyRmaWxlJyBub3Qg Zm91bmQgaW4gdmVyc2lvbiBjb250cm9sICQhXG4iOworICAgIH0KKyAgICBpZiAoJGZyb21fZmls ZW5hbWUgfHwgKCRmaWxlIG5lICImU1RESU4iICYmIHZjc19maWxlX2V4aXN0cygkZmlsZSkpKSB7 CisJJGZpbGUgPX4gcy9eXFEke2N1cl9wYXRofVxFLy87CSNzdHJpcCBhbnkgYWJzb2x1dGUgcGF0 aAorCSRmaWxlID1+IHMvXlxRJHtsa19wYXRofVxFLy87CSNvciB0aGUgcGF0aCB0byB0aGUgbGsg dHJlZQorCXB1c2goQGZpbGVzLCAkZmlsZSk7CisJaWYgKCRmaWxlIG5lICJNQUlOVEFJTkVSUyIg JiYgLWYgJGZpbGUgJiYgJGtleXdvcmRzKSB7CisJICAgIG9wZW4obXkgJGYsICc8JywgJGZpbGUp CisJCW9yIGRpZSAiJFA6IENhbid0IG9wZW4gJGZpbGU6ICQhXG4iOworCSAgICBteSAkdGV4dCA9 IGRvIHsgbG9jYWwoJC8pIDsgPCRmPiB9OworCSAgICBjbG9zZSgkZik7CisJICAgIGlmICgka2V5 d29yZHMpIHsKKwkJZm9yZWFjaCBteSAkbGluZSAoa2V5cyAla2V5d29yZF9oYXNoKSB7CisJCSAg ICBpZiAoJHRleHQgPX4gbS8ka2V5d29yZF9oYXNoeyRsaW5lfS94KSB7CisJCQlwdXNoKEBrZXl3 b3JkX3R2aSwgJGxpbmUpOworCQkgICAgfQorCQl9CisJICAgIH0KKwl9CisgICAgfSBlbHNlIHsK KwlteSAkZmlsZV9jbnQgPSBAZmlsZXM7CisJbXkgJGxhc3RmaWxlOworCisJb3BlbihteSAkcGF0 Y2gsICI8ICRmaWxlIikKKwkgICAgb3IgZGllICIkUDogQ2FuJ3Qgb3BlbiAkZmlsZTogJCFcbiI7 CisKKwkjIFdlIGNhbiBjaGVjayBhcmJpdHJhcnkgaW5mb3JtYXRpb24gYmVmb3JlIHRoZSBwYXRj aAorCSMgbGlrZSB0aGUgY29tbWl0IG1lc3NhZ2UsIG1haWwgaGVhZGVycywgZXRjLi4uCisJIyBU aGlzIGFsbG93cyB1cyB0byBtYXRjaCBhcmJpdHJhcnkga2V5d29yZHMgYWdhaW5zdCBhbnkgcGFy dAorCSMgb2YgYSBnaXQgZm9ybWF0LXBhdGNoIGdlbmVyYXRlZCBmaWxlIChzdWJqZWN0IHRhZ3Ms IGV0Yy4uLikKKworCW15ICRwYXRjaF9wcmVmaXggPSAiIjsJCQkjUGFyc2luZyB0aGUgaW50cm8K KworCXdoaWxlICg8JHBhdGNoPikgeworCSAgICBteSAkcGF0Y2hfbGluZSA9ICRfOworCSAgICBp ZiAobS9eIG1vZGUgY2hhbmdlIFswLTddKyA9PiBbMC03XSsgKFxTKylccyokLykgeworCQlteSAk ZmlsZW5hbWUgPSAkMTsKKwkJcHVzaChAZmlsZXMsICRmaWxlbmFtZSk7CisJICAgIH0gZWxzaWYg KG0vXnJlbmFtZSAoPzpmcm9tfHRvKSAoXFMrKVxzKiQvKSB7CisJCW15ICRmaWxlbmFtZSA9ICQx OworCQlwdXNoKEBmaWxlcywgJGZpbGVuYW1lKTsKKwkgICAgfSBlbHNpZiAobS9eZGlmZiAtLWdp dCBhXC8oXFMrKSBiXC8oXFMrKVxzKiQvKSB7CisJCW15ICRmaWxlbmFtZTEgPSAkMTsKKwkJbXkg JGZpbGVuYW1lMiA9ICQyOworCQlwdXNoKEBmaWxlcywgJGZpbGVuYW1lMSk7CisJCXB1c2goQGZp bGVzLCAkZmlsZW5hbWUyKTsKKwkgICAgfSBlbHNpZiAobS9eRml4ZXM6XHMrKFswLTlhLWZBLUZd ezYsNDB9KS8pIHsKKwkJcHVzaChAZml4ZXMsICQxKSBpZiAoJGVtYWlsX2ZpeGVzKTsKKwkgICAg fSBlbHNpZiAobS9eXCtcK1wrXHMrKFxTKykvIG9yIG0vXi0tLVxzKyhcUyspLykgeworCQlteSAk ZmlsZW5hbWUgPSAkMTsKKwkJJGZpbGVuYW1lID1+IHNAXlteL10qL0BAOworCQkkZmlsZW5hbWUg PX4gc0BcbkBAOworCQkkbGFzdGZpbGUgPSAkZmlsZW5hbWU7CisJCXB1c2goQGZpbGVzLCAkZmls ZW5hbWUpOworCQkkcGF0Y2hfcHJlZml4ID0gIl5bKy1dLioiOwkjTm93IHBhcnNpbmcgdGhlIGFj dHVhbCBwYXRjaAorCSAgICB9IGVsc2lmIChtL15cQFxAIC0oXGQrKSwoXGQrKS8pIHsKKwkJaWYg KCRlbWFpbF9naXRfYmxhbWUpIHsKKwkJICAgIHB1c2goQHJhbmdlLCAiJGxhc3RmaWxlOiQxOiQy Iik7CisJCX0KKwkgICAgfSBlbHNpZiAoJGtleXdvcmRzKSB7CisJCWZvcmVhY2ggbXkgJGxpbmUg KGtleXMgJWtleXdvcmRfaGFzaCkgeworCQkgICAgaWYgKCRwYXRjaF9saW5lID1+IG0vJHtwYXRj aF9wcmVmaXh9JGtleXdvcmRfaGFzaHskbGluZX0veCkgeworCQkJcHVzaChAa2V5d29yZF90dmks ICRsaW5lKTsKKwkJICAgIH0KKwkJfQorCSAgICB9CisJfQorCWNsb3NlKCRwYXRjaCk7CisKKwlp ZiAoJGZpbGVfY250ID09IEBmaWxlcykgeworCSAgICB3YXJuICIkUDogZmlsZSAnJHtmaWxlfScg ZG9lc24ndCBhcHBlYXIgdG8gYmUgYSBwYXRjaC4gICIKKwkJLiAiQWRkIC1mIHRvIG9wdGlvbnM/ XG4iOworCX0KKwlAZmlsZXMgPSBzb3J0X2FuZF91bmlxKEBmaWxlcyk7CisgICAgfQorfQorCitA ZmlsZV9lbWFpbHMgPSB1bmlxKEBmaWxlX2VtYWlscyk7CitAZml4ZXMgPSB1bmlxKEBmaXhlcyk7 CisKK215ICVlbWFpbF9oYXNoX25hbWU7CitteSAlZW1haWxfaGFzaF9hZGRyZXNzOworbXkgQGVt YWlsX3RvID0gKCk7CitteSAlaGFzaF9saXN0X3RvOworbXkgQGxpc3RfdG8gPSAoKTsKK215IEBz Y20gPSAoKTsKK215IEB3ZWIgPSAoKTsKK215IEBzdWJzeXN0ZW0gPSAoKTsKK215IEBzdGF0dXMg PSAoKTsKK215ICVkZWR1cGxpY2F0ZV9uYW1lX2hhc2ggPSAoKTsKK215ICVkZWR1cGxpY2F0ZV9h ZGRyZXNzX2hhc2ggPSAoKTsKKworbXkgQG1haW50YWluZXJzID0gZ2V0X21haW50YWluZXJzKCk7 CitpZiAoQG1haW50YWluZXJzKSB7CisgICAgQG1haW50YWluZXJzID0gbWVyZ2VfZW1haWwoQG1h aW50YWluZXJzKTsKKyAgICBvdXRwdXQoQG1haW50YWluZXJzKTsKK30KKworaWYgKCRzY20pIHsK KyAgICBAc2NtID0gdW5pcShAc2NtKTsKKyAgICBvdXRwdXQoQHNjbSk7Cit9CisKK2lmICgkc3Rh dHVzKSB7CisgICAgQHN0YXR1cyA9IHVuaXEoQHN0YXR1cyk7CisgICAgb3V0cHV0KEBzdGF0dXMp OworfQorCitpZiAoJHN1YnN5c3RlbSkgeworICAgIEBzdWJzeXN0ZW0gPSB1bmlxKEBzdWJzeXN0 ZW0pOworICAgIG91dHB1dChAc3Vic3lzdGVtKTsKK30KKworaWYgKCR3ZWIpIHsKKyAgICBAd2Vi ID0gdW5pcShAd2ViKTsKKyAgICBvdXRwdXQoQHdlYik7Cit9CisKK2V4aXQoJGV4aXQpOworCitz dWIgc2VsZl90ZXN0IHsKKyAgICBteSBAbHNmaWxlcyA9ICgpOworICAgIG15IEBnb29kX2xpbmtz ID0gKCk7CisgICAgbXkgQGJhZF9saW5rcyA9ICgpOworICAgIG15IEBzZWN0aW9uX2hlYWRlcnMg PSAoKTsKKyAgICBteSAkaW5kZXggPSAwOworCisgICAgQGxzZmlsZXMgPSB2Y3NfbGlzdF9maWxl cygkbGtfcGF0aCk7CisKKyAgICBmb3IgbXkgJHggKEBzZWxmX3Rlc3RfaW5mbykgeworCSRpbmRl eCsrOworCisJIyMgU2VjdGlvbiBoZWFkZXIgZHVwbGljYXRpb24gYW5kIG1pc3Npbmcgc2VjdGlv biBjb250ZW50CisJaWYgKCgkc2VsZl90ZXN0IGVxICIiIHx8ICRzZWxmX3Rlc3QgPX4gL1xic2Vj dGlvbnNcYi8pICYmCisJICAgICR4LT57bGluZX0gPX4gL15cU1teOl0vICYmCisJICAgIGRlZmlu ZWQgJHNlbGZfdGVzdF9pbmZvWyRpbmRleF0gJiYKKwkgICAgJHNlbGZfdGVzdF9pbmZvWyRpbmRl eF0tPntsaW5lfSA9fiAvXihbQS1aXSk6XHMqXFMvKSB7CisJICAgIG15ICRoYXNfUyA9IDA7CisJ ICAgIG15ICRoYXNfRiA9IDA7CisJICAgIG15ICRoYXNfTUwgPSAwOworCSAgICBteSAkc3RhdHVz ID0gIiI7CisJICAgIGlmIChncmVwKG1AXlxRJHgtPntsaW5lfVxFQCwgQHNlY3Rpb25faGVhZGVy cykpIHsKKwkJcHJpbnQoIiR4LT57ZmlsZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBkdXBsaWNh dGUgc2VjdGlvbiBoZWFkZXJcdCR4LT57bGluZX1cbiIpOworCSAgICB9IGVsc2UgeworCQlwdXNo KEBzZWN0aW9uX2hlYWRlcnMsICR4LT57bGluZX0pOworCSAgICB9CisJICAgIG15ICRuZXh0bGlu ZSA9ICRpbmRleDsKKwkgICAgd2hpbGUgKGRlZmluZWQgJHNlbGZfdGVzdF9pbmZvWyRuZXh0bGlu ZV0gJiYKKwkJICAgJHNlbGZfdGVzdF9pbmZvWyRuZXh0bGluZV0tPntsaW5lfSA9fiAvXihbQS1a XSk6XHMqKFxTLiopLykgeworCQlteSAkdHlwZSA9ICQxOworCQlteSAkdmFsdWUgPSAkMjsKKwkJ aWYgKCR0eXBlIGVxICJTIikgeworCQkgICAgJGhhc19TID0gMTsKKwkJICAgICRzdGF0dXMgPSAk dmFsdWU7CisJCX0gZWxzaWYgKCR0eXBlIGVxICJGIiB8fCAkdHlwZSBlcSAiTiIpIHsKKwkJICAg ICRoYXNfRiA9IDE7CisJCX0gZWxzaWYgKCR0eXBlIGVxICJNIiB8fCAkdHlwZSBlcSAiUiIgfHwg JHR5cGUgZXEgIkwiKSB7CisJCSAgICAkaGFzX01MID0gMTsKKwkJfQorCQkkbmV4dGxpbmUrKzsK KwkgICAgfQorCSAgICBpZiAoISRoYXNfTUwgJiYgJHN0YXR1cyAhfiAvb3JwaGFufG9ic29sZXRl L2kpIHsKKwkJcHJpbnQoIiR4LT57ZmlsZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBzZWN0aW9u IHdpdGhvdXQgZW1haWwgYWRkcmVzc1x0JHgtPntsaW5lfVxuIik7CisJICAgIH0KKwkgICAgaWYg KCEkaGFzX1MpIHsKKwkJcHJpbnQoIiR4LT57ZmlsZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBz ZWN0aW9uIHdpdGhvdXQgc3RhdHVzIFx0JHgtPntsaW5lfVxuIik7CisJICAgIH0KKwkgICAgaWYg KCEkaGFzX0YpIHsKKwkJcHJpbnQoIiR4LT57ZmlsZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBz ZWN0aW9uIHdpdGhvdXQgZmlsZSBwYXR0ZXJuXHQkeC0+e2xpbmV9XG4iKTsKKwkgICAgfQorCX0K KworCW5leHQgaWYgKCR4LT57bGluZX0gIX4gL14oW0EtWl0pOlxzKiguKikvKTsKKworCW15ICR0 eXBlID0gJDE7CisJbXkgJHZhbHVlID0gJDI7CisKKwkjIyBGaWxlbmFtZSBwYXR0ZXJuIG1hdGNo aW5nCisJaWYgKCgkdHlwZSBlcSAiRiIgfHwgJHR5cGUgZXEgIlgiKSAmJgorCSAgICAoJHNlbGZf dGVzdCBlcSAiIiB8fCAkc2VsZl90ZXN0ID1+IC9cYnBhdHRlcm5zXGIvKSkgeworCSAgICAkdmFs dWUgPX4gc0BcLkBcXFwuQGc7ICAgICAgICMjQ29udmVydCAuIHRvIFwuCisJICAgICR2YWx1ZSA9 fiBzL1wqL1wuXCovZzsgICAgICAgIyNDb252ZXJ0ICogdG8gLioKKwkgICAgJHZhbHVlID1+IHMv XD8vXC4vZzsgICAgICAgICAjI0NvbnZlcnQgPyB0byAuCisJICAgICMjaWYgcGF0dGVybiBpcyBh IGRpcmVjdG9yeSBhbmQgaXQgbGFja3MgYSB0cmFpbGluZyBzbGFzaCwgYWRkIG9uZQorCSAgICBp ZiAoKC1kICR2YWx1ZSkpIHsKKwkJJHZhbHVlID1+IHNAKFteL10pJEAkMS9AOworCSAgICB9CisJ ICAgIGlmICghZ3JlcChtQF4kdmFsdWVALCBAbHNmaWxlcykpIHsKKwkJcHJpbnQoIiR4LT57Zmls ZX06JHgtPntsaW5lbnJ9OiB3YXJuaW5nOiBubyBmaWxlIG1hdGNoZXNcdCR4LT57bGluZX1cbiIp OworCSAgICB9CisKKwkjIyBMaW5rIHJlYWNoYWJpbGl0eQorCX0gZWxzaWYgKCgkdHlwZSBlcSAi VyIgfHwgJHR5cGUgZXEgIlEiIHx8ICR0eXBlIGVxICJCIikgJiYKKwkJICR2YWx1ZSA9fiAvXmh0 dHBzPzovICYmCisJCSAoJHNlbGZfdGVzdCBlcSAiIiB8fCAkc2VsZl90ZXN0ID1+IC9cYmxpbmtz XGIvKSkgeworCSAgICBuZXh0IGlmIChncmVwKG1AXlxRJHZhbHVlXEUkQCwgQGdvb2RfbGlua3Mp KTsKKwkgICAgbXkgJGlzYmFkID0gMDsKKwkgICAgaWYgKGdyZXAobUBeXFEkdmFsdWVcRSRALCBA YmFkX2xpbmtzKSkgeworCSAgICAgICAgJGlzYmFkID0gMTsKKwkgICAgfSBlbHNlIHsKKwkJbXkg JG91dHB1dCA9IGB3Z2V0IC0tc3BpZGVyIC1xIC0tbm8tY2hlY2stY2VydGlmaWNhdGUgLS10aW1l b3V0IDEwIC0tdHJpZXMgMSAkdmFsdWVgOworCQlpZiAoJD8gPT0gMCkgeworCQkgICAgcHVzaChA Z29vZF9saW5rcywgJHZhbHVlKTsKKwkJfSBlbHNlIHsKKwkJICAgIHB1c2goQGJhZF9saW5rcywg JHZhbHVlKTsKKwkJICAgICRpc2JhZCA9IDE7CisJCX0KKwkgICAgfQorCSAgICBpZiAoJGlzYmFk KSB7CisJICAgICAgICBwcmludCgiJHgtPntmaWxlfTokeC0+e2xpbmVucn06IHdhcm5pbmc6IHBv c3NpYmxlIGJhZCBsaW5rXHQkeC0+e2xpbmV9XG4iKTsKKwkgICAgfQorCisJIyMgU0NNIHJlYWNo YWJpbGl0eQorCX0gZWxzaWYgKCR0eXBlIGVxICJUIiAmJgorCQkgKCRzZWxmX3Rlc3QgZXEgIiIg fHwgJHNlbGZfdGVzdCA9fiAvXGJzY21cYi8pKSB7CisJICAgIG5leHQgaWYgKGdyZXAobUBeXFEk dmFsdWVcRSRALCBAZ29vZF9saW5rcykpOworCSAgICBteSAkaXNiYWQgPSAwOworCSAgICBpZiAo Z3JlcChtQF5cUSR2YWx1ZVxFJEAsIEBiYWRfbGlua3MpKSB7CisJICAgICAgICAkaXNiYWQgPSAx OworICAgICAgICAgICAgfSBlbHNpZiAoJHZhbHVlICF+IC9eKD86Z2l0fHF1aWx0fGhnKVxzK1xT LykgeworCQlwcmludCgiJHgtPntmaWxlfTokeC0+e2xpbmVucn06IHdhcm5pbmc6IG1hbGZvcm1l ZCBlbnRyeVx0JHgtPntsaW5lfVxuIik7CisJICAgIH0gZWxzaWYgKCR2YWx1ZSA9fiAvXmdpdFxz KyhcUyspKFxzKyhbXlwoXStcUyspKT8vKSB7CisJCW15ICR1cmwgPSAkMTsKKwkJbXkgJGJyYW5j aCA9ICIiOworCQkkYnJhbmNoID0gJDMgaWYgJDM7CisJCW15ICRvdXRwdXQgPSBgZ2l0IGxzLXJl bW90ZSAtLWV4aXQtY29kZSAtaCAiJHVybCIgJGJyYW5jaCA+IC9kZXYvbnVsbCAyPiYxYDsKKwkJ aWYgKCQ/ID09IDApIHsKKwkJICAgIHB1c2goQGdvb2RfbGlua3MsICR2YWx1ZSk7CisJCX0gZWxz ZSB7CisJCSAgICBwdXNoKEBiYWRfbGlua3MsICR2YWx1ZSk7CisJCSAgICAkaXNiYWQgPSAxOwor CQl9CisJICAgIH0gZWxzaWYgKCR2YWx1ZSA9fiAvXig/OnF1aWx0fGhnKVxzKyhodHRwcz86XFMr KS8pIHsKKwkJbXkgJHVybCA9ICQxOworCQlteSAkb3V0cHV0ID0gYHdnZXQgLS1zcGlkZXIgLXEg LS1uby1jaGVjay1jZXJ0aWZpY2F0ZSAtLXRpbWVvdXQgMTAgLS10cmllcyAxICR1cmxgOworCQlp ZiAoJD8gPT0gMCkgeworCQkgICAgcHVzaChAZ29vZF9saW5rcywgJHZhbHVlKTsKKwkJfSBlbHNl IHsKKwkJICAgIHB1c2goQGJhZF9saW5rcywgJHZhbHVlKTsKKwkJICAgICRpc2JhZCA9IDE7CisJ CX0KKwkgICAgfQorCSAgICBpZiAoJGlzYmFkKSB7CisJCXByaW50KCIkeC0+e2ZpbGV9OiR4LT57 bGluZW5yfTogd2FybmluZzogcG9zc2libGUgYmFkIGxpbmtcdCR4LT57bGluZX1cbiIpOworCSAg ICB9CisJfQorICAgIH0KK30KKworc3ViIGlnbm9yZV9lbWFpbF9hZGRyZXNzIHsKKyAgICBteSAo JGFkZHJlc3MpID0gQF87CisKKyAgICBmb3JlYWNoIG15ICRpZ25vcmUgKEBpZ25vcmVfZW1haWxz KSB7CisJcmV0dXJuIDEgaWYgKCRpZ25vcmUgZXEgJGFkZHJlc3MpOworICAgIH0KKworICAgIHJl dHVybiAwOworfQorCitzdWIgcmFuZ2VfaXNfbWFpbnRhaW5lZCB7CisgICAgbXkgKCRzdGFydCwg JGVuZCkgPSBAXzsKKworICAgIGZvciAobXkgJGkgPSAkc3RhcnQ7ICRpIDwgJGVuZDsgJGkrKykg eworCW15ICRsaW5lID0gJHR5cGV2YWx1ZVskaV07CisJaWYgKCRsaW5lID1+IG0vXihbQS1aXSk6 XHMqKC4qKS8pIHsKKwkgICAgbXkgJHR5cGUgPSAkMTsKKwkgICAgbXkgJHZhbHVlID0gJDI7CisJ ICAgIGlmICgkdHlwZSBlcSAnUycpIHsKKwkJaWYgKCR2YWx1ZSA9fiAvKG1haW50YWlufHN1cHBv cnQpL2kpIHsKKwkJICAgIHJldHVybiAxOworCQl9CisJICAgIH0KKwl9CisgICAgfQorICAgIHJl dHVybiAwOworfQorCitzdWIgcmFuZ2VfaGFzX21haW50YWluZXIgeworICAgIG15ICgkc3RhcnQs ICRlbmQpID0gQF87CisKKyAgICBmb3IgKG15ICRpID0gJHN0YXJ0OyAkaSA8ICRlbmQ7ICRpKysp IHsKKwlteSAkbGluZSA9ICR0eXBldmFsdWVbJGldOworCWlmICgkbGluZSA9fiBtL14oW0EtWl0p OlxzKiguKikvKSB7CisJICAgIG15ICR0eXBlID0gJDE7CisJICAgIG15ICR2YWx1ZSA9ICQyOwor CSAgICBpZiAoJHR5cGUgZXEgJ00nKSB7CisJCXJldHVybiAxOworCSAgICB9CisJfQorICAgIH0K KyAgICByZXR1cm4gMDsKK30KKworc3ViIGdldF9tYWludGFpbmVycyB7CisgICAgJWVtYWlsX2hh c2hfbmFtZSA9ICgpOworICAgICVlbWFpbF9oYXNoX2FkZHJlc3MgPSAoKTsKKyAgICAlY29tbWl0 X2F1dGhvcl9oYXNoID0gKCk7CisgICAgJWNvbW1pdF9zaWduZXJfaGFzaCA9ICgpOworICAgIEBl bWFpbF90byA9ICgpOworICAgICVoYXNoX2xpc3RfdG8gPSAoKTsKKyAgICBAbGlzdF90byA9ICgp OworICAgIEBzY20gPSAoKTsKKyAgICBAd2ViID0gKCk7CisgICAgQHN1YnN5c3RlbSA9ICgpOwor ICAgIEBzdGF0dXMgPSAoKTsKKyAgICAlZGVkdXBsaWNhdGVfbmFtZV9oYXNoID0gKCk7CisgICAg JWRlZHVwbGljYXRlX2FkZHJlc3NfaGFzaCA9ICgpOworICAgIGlmICgkZW1haWxfZ2l0X2FsbF9z aWduYXR1cmVfdHlwZXMpIHsKKwkkc2lnbmF0dXJlX3BhdHRlcm4gPSAiKC4rPylbQmJdW1l5XToi OworICAgIH0gZWxzZSB7CisJJHNpZ25hdHVyZV9wYXR0ZXJuID0gIlwoIiAuIGpvaW4oInwiLCBA c2lnbmF0dXJlX3RhZ3MpIC4gIlwpIjsKKyAgICB9CisKKyAgICAjIEZpbmQgcmVzcG9uc2libGUg cGFydGllcworCisgICAgbXkgJWV4YWN0X3BhdHRlcm5fbWF0Y2hfaGFzaCA9ICgpOworCisgICAg Zm9yZWFjaCBteSAkZmlsZSAoQGZpbGVzKSB7CisKKwlteSAlaGFzaDsKKwlteSAkdHZpID0gZmlu ZF9maXJzdF9zZWN0aW9uKCk7CisJd2hpbGUgKCR0dmkgPCBAdHlwZXZhbHVlKSB7CisJICAgIG15 ICRzdGFydCA9IGZpbmRfc3RhcnRpbmdfaW5kZXgoJHR2aSk7CisJICAgIG15ICRlbmQgPSBmaW5k X2VuZGluZ19pbmRleCgkdHZpKTsKKwkgICAgbXkgJGV4Y2x1ZGUgPSAwOworCSAgICBteSAkaTsK KworCSAgICAjRG8gbm90IG1hdGNoIGV4Y2x1ZGVkIGZpbGUgcGF0dGVybnMKKworCSAgICBmb3Ig KCRpID0gJHN0YXJ0OyAkaSA8ICRlbmQ7ICRpKyspIHsKKwkJbXkgJGxpbmUgPSAkdHlwZXZhbHVl WyRpXTsKKwkJaWYgKCRsaW5lID1+IG0vXihbQS1aXSk6XHMqKC4qKS8pIHsKKwkJICAgIG15ICR0 eXBlID0gJDE7CisJCSAgICBteSAkdmFsdWUgPSAkMjsKKwkJICAgIGlmICgkdHlwZSBlcSAnWCcp IHsKKwkJCWlmIChmaWxlX21hdGNoX3BhdHRlcm4oJGZpbGUsICR2YWx1ZSkpIHsKKwkJCSAgICAk ZXhjbHVkZSA9IDE7CisJCQkgICAgbGFzdDsKKwkJCX0KKwkJICAgIH0KKwkJfQorCSAgICB9CisK KwkgICAgaWYgKCEkZXhjbHVkZSkgeworCQlmb3IgKCRpID0gJHN0YXJ0OyAkaSA8ICRlbmQ7ICRp KyspIHsKKwkJICAgIG15ICRsaW5lID0gJHR5cGV2YWx1ZVskaV07CisJCSAgICBpZiAoJGxpbmUg PX4gbS9eKFtBLVpdKTpccyooLiopLykgeworCQkJbXkgJHR5cGUgPSAkMTsKKwkJCW15ICR2YWx1 ZSA9ICQyOworCQkJaWYgKCR0eXBlIGVxICdGJykgeworCQkJICAgIGlmIChmaWxlX21hdGNoX3Bh dHRlcm4oJGZpbGUsICR2YWx1ZSkpIHsKKwkJCQlteSAkdmFsdWVfcGQgPSAoJHZhbHVlID1+IHRy QC9AQCk7CisJCQkJbXkgJGZpbGVfcGQgPSAoJGZpbGUgID1+IHRyQC9AQCk7CisJCQkJJHZhbHVl X3BkKysgaWYgKHN1YnN0cigkdmFsdWUsLTEsMSkgbmUgIi8iKTsKKwkJCQkkdmFsdWVfcGQgPSAt MSBpZiAoJHZhbHVlID1+IC9eXC5cKi8pOworCQkJCWlmICgkdmFsdWVfcGQgPj0gJGZpbGVfcGQg JiYKKwkJCQkgICAgcmFuZ2VfaXNfbWFpbnRhaW5lZCgkc3RhcnQsICRlbmQpICYmCisJCQkJICAg IHJhbmdlX2hhc19tYWludGFpbmVyKCRzdGFydCwgJGVuZCkpIHsKKwkJCQkgICAgJGV4YWN0X3Bh dHRlcm5fbWF0Y2hfaGFzaHskZmlsZX0gPSAxOworCQkJCX0KKwkJCQlpZiAoJHBhdHRlcm5fZGVw dGggPT0gMCB8fAorCQkJCSAgICAoKCRmaWxlX3BkIC0gJHZhbHVlX3BkKSA8ICRwYXR0ZXJuX2Rl cHRoKSkgeworCQkJCSAgICAkaGFzaHskdHZpfSA9ICR2YWx1ZV9wZDsKKwkJCQl9CisJCQkgICAg fQorCQkJfSBlbHNpZiAoJHR5cGUgZXEgJ04nKSB7CisJCQkgICAgaWYgKCRmaWxlID1+IG0vJHZh bHVlL3gpIHsKKwkJCQkkaGFzaHskdHZpfSA9IDA7CisJCQkgICAgfQorCQkJfQorCQkgICAgfQor CQl9CisJICAgIH0KKwkgICAgJHR2aSA9ICRlbmQgKyAxOworCX0KKworCWZvcmVhY2ggbXkgJGxp bmUgKHNvcnQgeyRoYXNoeyRifSA8PT4gJGhhc2h7JGF9fSBrZXlzICVoYXNoKSB7CisJICAgIGFk ZF9jYXRlZ29yaWVzKCRsaW5lKTsKKwkgICAgaWYgKCRzZWN0aW9ucykgeworCQlteSAkaTsKKwkJ bXkgJHN0YXJ0ID0gZmluZF9zdGFydGluZ19pbmRleCgkbGluZSk7CisJCW15ICRlbmQgPSBmaW5k X2VuZGluZ19pbmRleCgkbGluZSk7CisJCWZvciAoJGkgPSAkc3RhcnQ7ICRpIDwgJGVuZDsgJGkr KykgeworCQkgICAgbXkgJGxpbmUgPSAkdHlwZXZhbHVlWyRpXTsKKwkJICAgIGlmICgkbGluZSA9 fiAvXltGWF06LykgewkJIyNSZXN0b3JlIGZpbGUgcGF0dGVybnMKKwkJCSRsaW5lID1+IHMvKFte XFxdKVwuKFteXCpdKS8kMVw/JDIvZzsKKwkJCSRsaW5lID1+IHMvKFteXFxdKVwuJC8kMVw/L2c7 CSMjQ29udmVydCAuIGJhY2sgdG8gPworCQkJJGxpbmUgPX4gcy9cXFwuL1wuL2c7ICAgICAgIAkj I0NvbnZlcnQgXC4gdG8gLgorCQkJJGxpbmUgPX4gcy9cLlwqL1wqL2c7ICAgICAgIAkjI0NvbnZl cnQgLiogdG8gKgorCQkgICAgfQorCQkgICAgbXkgJGNvdW50ID0gJGxpbmUgPX4gcy9eKFtBLVpd KTovJDE6XHQvZzsKKwkJICAgIGlmICgkbGV0dGVycyBlcSAiIiB8fCAoISRjb3VudCB8fCAkbGV0 dGVycyA9fiAvJDEvaSkpIHsKKwkJCXByaW50KCIkbGluZVxuIik7CisJCSAgICB9CisJCX0KKwkJ cHJpbnQoIlxuIik7CisJICAgIH0KKwl9CisKKwltYWludGFpbmVyc19pbl9maWxlKCRmaWxlKTsK KyAgICB9CisKKyAgICBpZiAoJGtleXdvcmRzKSB7CisJQGtleXdvcmRfdHZpID0gc29ydF9hbmRf dW5pcShAa2V5d29yZF90dmkpOworCWZvcmVhY2ggbXkgJGxpbmUgKEBrZXl3b3JkX3R2aSkgewor CSAgICBhZGRfY2F0ZWdvcmllcygkbGluZSk7CisJfQorICAgIH0KKworICAgIGZvcmVhY2ggbXkg JGVtYWlsIChAZW1haWxfdG8sIEBsaXN0X3RvKSB7CisJJGVtYWlsLT5bMF0gPSBkZWR1cGxpY2F0 ZV9lbWFpbCgkZW1haWwtPlswXSk7CisgICAgfQorCisgICAgZm9yZWFjaCBteSAkZmlsZSAoQGZp bGVzKSB7CisJaWYgKCRlbWFpbCAmJgorCSAgICAoJGVtYWlsX2dpdCB8fAorCSAgICAgKCRlbWFp bF9naXRfZmFsbGJhY2sgJiYKKwkgICAgICAkZmlsZSAhfiAvTUFJTlRBSU5FUlMkLyAmJgorCSAg ICAgICEkZXhhY3RfcGF0dGVybl9tYXRjaF9oYXNoeyRmaWxlfSkpKSB7CisJICAgIHZjc19maWxl X3NpZ25vZmZzKCRmaWxlKTsKKwl9CisJaWYgKCRlbWFpbCAmJiAkZW1haWxfZ2l0X2JsYW1lKSB7 CisJICAgIHZjc19maWxlX2JsYW1lKCRmaWxlKTsKKwl9CisgICAgfQorCisgICAgaWYgKCRlbWFp bCkgeworCWZvcmVhY2ggbXkgJGNoaWVmIChAcGVuZ3Vpbl9jaGllZikgeworCSAgICBpZiAoJGNo aWVmID1+IG0vXiguKik6KC4qKS8pIHsKKwkJbXkgJGVtYWlsX2FkZHJlc3M7CisKKwkJJGVtYWls X2FkZHJlc3MgPSBmb3JtYXRfZW1haWwoJDEsICQyLCAkZW1haWxfdXNlbmFtZSk7CisJCWlmICgk ZW1haWxfZ2l0X3Blbmd1aW5fY2hpZWZzKSB7CisJCSAgICBwdXNoKEBlbWFpbF90bywgWyRlbWFp bF9hZGRyZXNzLCAnY2hpZWYgcGVuZ3VpbiddKTsKKwkJfSBlbHNlIHsKKwkJICAgIEBlbWFpbF90 byA9IGdyZXAoJF8tPlswXSAhfiAvJHtlbWFpbF9hZGRyZXNzfS8sIEBlbWFpbF90byk7CisJCX0K KwkgICAgfQorCX0KKworCWZvcmVhY2ggbXkgJGVtYWlsIChAZmlsZV9lbWFpbHMpIHsKKwkgICAg JGVtYWlsID0gbWFpbG1hcF9lbWFpbCgkZW1haWwpOworCSAgICBteSAoJG5hbWUsICRhZGRyZXNz KSA9IHBhcnNlX2VtYWlsKCRlbWFpbCk7CisKKwkgICAgbXkgJHRtcF9lbWFpbCA9IGZvcm1hdF9l bWFpbCgkbmFtZSwgJGFkZHJlc3MsICRlbWFpbF91c2VuYW1lKTsKKwkgICAgcHVzaF9lbWFpbF9h ZGRyZXNzKCR0bXBfZW1haWwsICcnKTsKKwkgICAgYWRkX3JvbGUoJHRtcF9lbWFpbCwgJ2luIGZp bGUnKTsKKwl9CisgICAgfQorCisgICAgZm9yZWFjaCBteSAkZml4IChAZml4ZXMpIHsKKwl2Y3Nf YWRkX2NvbW1pdF9zaWduZXJzKCRmaXgsICJibGFtZWRfZml4ZXMiKTsKKyAgICB9CisKKyAgICBt eSBAdG8gPSAoKTsKKyAgICBpZiAoJGVtYWlsIHx8ICRlbWFpbF9saXN0KSB7CisJaWYgKCRlbWFp bCkgeworCSAgICBAdG8gPSAoQHRvLCBAZW1haWxfdG8pOworCX0KKwlpZiAoJGVtYWlsX2xpc3Qp IHsKKwkgICAgQHRvID0gKEB0bywgQGxpc3RfdG8pOworCX0KKyAgICB9CisKKyAgICBpZiAoJGlu dGVyYWN0aXZlKSB7CisJQHRvID0gaW50ZXJhY3RpdmVfZ2V0X21haW50YWluZXJzKFxAdG8pOwor ICAgIH0KKworICAgIHJldHVybiBAdG87Cit9CisKK3N1YiBmaWxlX21hdGNoX3BhdHRlcm4gewor ICAgIG15ICgkZmlsZSwgJHBhdHRlcm4pID0gQF87CisgICAgaWYgKHN1YnN0cigkcGF0dGVybiwg LTEpIGVxICIvIikgeworCWlmICgkZmlsZSA9fiBtQF4kcGF0dGVybkApIHsKKwkgICAgcmV0dXJu IDE7CisJfQorICAgIH0gZWxzZSB7CisJaWYgKCRmaWxlID1+IG1AXiRwYXR0ZXJuQCkgeworCSAg ICBteSAkczEgPSAoJGZpbGUgPX4gdHJAL0BAKTsKKwkgICAgbXkgJHMyID0gKCRwYXR0ZXJuID1+ IHRyQC9AQCk7CisJICAgIGlmICgkczEgPT0gJHMyKSB7CisJCXJldHVybiAxOworCSAgICB9CisJ fQorICAgIH0KKyAgICByZXR1cm4gMDsKK30KKworc3ViIHVzYWdlIHsKKyAgICBwcmludCA8PEVP VDsKK3VzYWdlOiAkUCBbb3B0aW9uc10gcGF0Y2hmaWxlCisgICAgICAgJFAgW29wdGlvbnNdIC1m IGZpbGV8ZGlyZWN0b3J5Cit2ZXJzaW9uOiAkVgorCitNQUlOVEFJTkVSIGZpZWxkIHNlbGVjdGlv biBvcHRpb25zOgorICAtLWVtYWlsID0+IHByaW50IGVtYWlsIGFkZHJlc3MoZXMpIGlmIGFueQor ICAgIC0tZ2l0ID0+IGluY2x1ZGUgcmVjZW50IGdpdCBcKi1ieTogc2lnbmVycworICAgIC0tZ2l0 LWFsbC1zaWduYXR1cmUtdHlwZXMgPT4gaW5jbHVkZSBzaWduZXJzIHJlZ2FyZGxlc3Mgb2Ygc2ln bmF0dXJlIHR5cGUKKyAgICAgICAgb3IgdXNlIG9ubHkgJHtzaWduYXR1cmVfcGF0dGVybn0gc2ln bmVycyAoZGVmYXVsdDogJGVtYWlsX2dpdF9hbGxfc2lnbmF0dXJlX3R5cGVzKQorICAgIC0tZ2l0 LWZhbGxiYWNrID0+IHVzZSBnaXQgd2hlbiBubyBleGFjdCBNQUlOVEFJTkVSUyBwYXR0ZXJuIChk ZWZhdWx0OiAkZW1haWxfZ2l0X2ZhbGxiYWNrKQorICAgIC0tZ2l0LWNoaWVmLXBlbmd1aW5zID0+ IGluY2x1ZGUgJHtwZW5ndWluX2NoaWVmc30KKyAgICAtLWdpdC1taW4tc2lnbmF0dXJlcyA9PiBu dW1iZXIgb2Ygc2lnbmF0dXJlcyByZXF1aXJlZCAoZGVmYXVsdDogJGVtYWlsX2dpdF9taW5fc2ln bmF0dXJlcykKKyAgICAtLWdpdC1tYXgtbWFpbnRhaW5lcnMgPT4gbWF4aW11bSBtYWludGFpbmVy cyB0byBhZGQgKGRlZmF1bHQ6ICRlbWFpbF9naXRfbWF4X21haW50YWluZXJzKQorICAgIC0tZ2l0 LW1pbi1wZXJjZW50ID0+IG1pbmltdW0gcGVyY2VudGFnZSBvZiBjb21taXRzIHJlcXVpcmVkIChk ZWZhdWx0OiAkZW1haWxfZ2l0X21pbl9wZXJjZW50KQorICAgIC0tZ2l0LWJsYW1lID0+IHVzZSBn aXQgYmxhbWUgdG8gZmluZCBtb2RpZmllZCBjb21taXRzIGZvciBwYXRjaCBvciBmaWxlCisgICAg LS1naXQtYmxhbWUtc2lnbmF0dXJlcyA9PiB3aGVuIHVzZWQgd2l0aCAtLWdpdC1ibGFtZSwgYWxz byBpbmNsdWRlIGFsbCBjb21taXQgc2lnbmVycworICAgIC0tZ2l0LXNpbmNlID0+IGdpdCBoaXN0 b3J5IHRvIHVzZSAoZGVmYXVsdDogJGVtYWlsX2dpdF9zaW5jZSkKKyAgICAtLWhnLXNpbmNlID0+ IGhnIGhpc3RvcnkgdG8gdXNlIChkZWZhdWx0OiAkZW1haWxfaGdfc2luY2UpCisgICAgLS1pbnRl cmFjdGl2ZSA9PiBkaXNwbGF5IGEgbWVudSAobW9zdGx5IHVzZWZ1bCBpZiB1c2VkIHdpdGggdGhl IC0tZ2l0IG9wdGlvbikKKyAgICAtLW0gPT4gaW5jbHVkZSBtYWludGFpbmVyKHMpIGlmIGFueQor ICAgIC0tciA9PiBpbmNsdWRlIHJldmlld2VyKHMpIGlmIGFueQorICAgIC0tbiA9PiBpbmNsdWRl IG5hbWUgJ0Z1bGwgTmFtZSA8YWRkclxAZG9tYWluLnRsZD4nCisgICAgLS1sID0+IGluY2x1ZGUg bGlzdChzKSBpZiBhbnkKKyAgICAtLW1vZGVyYXRlZCA9PiBpbmNsdWRlIG1vZGVyYXRlZCBsaXN0 cyhzKSBpZiBhbnkgKGRlZmF1bHQ6IHRydWUpCisgICAgLS1zID0+IGluY2x1ZGUgc3Vic2NyaWJl ciBvbmx5IGxpc3QocykgaWYgYW55IChkZWZhdWx0OiBmYWxzZSkKKyAgICAtLXJlbW92ZS1kdXBs aWNhdGVzID0+IG1pbmltaXplIGR1cGxpY2F0ZSBlbWFpbCBuYW1lcy9hZGRyZXNzZXMKKyAgICAt LXJvbGVzID0+IHNob3cgcm9sZXMgKHN0YXR1czpzdWJzeXN0ZW0sIGdpdC1zaWduZXIsIGxpc3Qs IGV0Yy4uLikKKyAgICAtLXJvbGVzdGF0cyA9PiBzaG93IHJvbGVzIGFuZCBzdGF0aXN0aWNzIChj b21taXRzL3RvdGFsX2NvbW1pdHMsICUpCisgICAgLS1maWxlLWVtYWlscyA9PiBhZGQgZW1haWwg YWRkcmVzc2VzIGZvdW5kIGluIC1mIGZpbGUgKGRlZmF1bHQ6IDAgKG9mZikpCisgICAgLS1maXhl cyA9PiBmb3IgcGF0Y2hlcywgYWRkIHNpZ25hdHVyZXMgb2YgY29tbWl0cyB3aXRoICdGaXhlczog PGNvbW1pdD4nIChkZWZhdWx0OiAxIChvbikpCisgIC0tc2NtID0+IHByaW50IFNDTSB0cmVlKHMp IGlmIGFueQorICAtLXN0YXR1cyA9PiBwcmludCBzdGF0dXMgaWYgYW55CisgIC0tc3Vic3lzdGVt ID0+IHByaW50IHN1YnN5c3RlbSBuYW1lIGlmIGFueQorICAtLXdlYiA9PiBwcmludCB3ZWJzaXRl KHMpIGlmIGFueQorCitPdXRwdXQgdHlwZSBvcHRpb25zOgorICAtLXNlcGFyYXRvciBbLCBdID0+ IHNlcGFyYXRvciBmb3IgbXVsdGlwbGUgZW50cmllcyBvbiAxIGxpbmUKKyAgICB1c2luZyAtLXNl cGFyYXRvciBhbHNvIHNldHMgLS1ub211bHRpbGluZSBpZiAtLXNlcGFyYXRvciBpcyBub3QgWywg XQorICAtLW11bHRpbGluZSA9PiBwcmludCAxIGVudHJ5IHBlciBsaW5lCisKK090aGVyIG9wdGlv bnM6CisgIC0tcGF0dGVybi1kZXB0aCA9PiBOdW1iZXIgb2YgcGF0dGVybiBkaXJlY3RvcnkgdHJh dmVyc2FscyAoZGVmYXVsdDogMCAoYWxsKSkKKyAgLS1rZXl3b3JkcyA9PiBzY2FuIHBhdGNoIGZv ciBrZXl3b3JkcyAoZGVmYXVsdDogJGtleXdvcmRzKQorICAtLXNlY3Rpb25zID0+IHByaW50IGFs bCBvZiB0aGUgc3Vic3lzdGVtIHNlY3Rpb25zIHdpdGggcGF0dGVybiBtYXRjaGVzCisgIC0tbGV0 dGVycyA9PiBwcmludCBhbGwgbWF0Y2hpbmcgJ2xldHRlcicgdHlwZXMgZnJvbSBhbGwgbWF0Y2hp bmcgc2VjdGlvbnMKKyAgLS1tYWlsbWFwID0+IHVzZSAubWFpbG1hcCBmaWxlIChkZWZhdWx0OiAk ZW1haWxfdXNlX21haWxtYXApCisgIC0tbm8tdHJlZSA9PiBydW4gd2l0aG91dCBhIGtlcm5lbCB0 cmVlCisgIC0tc2VsZi10ZXN0ID0+IHNob3cgcG90ZW50aWFsIGlzc3VlcyB3aXRoIE1BSU5UQUlO RVJTIGZpbGUgY29udGVudAorICAtLXZlcnNpb24gPT4gc2hvdyB2ZXJzaW9uCisgIC0taGVscCA9 PiBzaG93IHRoaXMgaGVscCBpbmZvcm1hdGlvbgorCitEZWZhdWx0IG9wdGlvbnM6CisgIFstLWVt YWlsIC0tdHJlZSAtLW5vZ2l0IC0tZ2l0LWZhbGxiYWNrIC0tbSAtLXIgLS1uIC0tbCAtLW11bHRp bGluZQorICAgLS1wYXR0ZXJuLWRlcHRoPTAgLS1yZW1vdmUtZHVwbGljYXRlcyAtLXJvbGVzdGF0 c10KKworTm90ZXM6CisgIFVzaW5nICItZiBkaXJlY3RvcnkiIG1heSBnaXZlIHVuZXhwZWN0ZWQg cmVzdWx0czoKKyAgICAgIFVzZWQgd2l0aCAiLS1naXQiLCBnaXQgc2lnbmF0b3JzIGZvciBfYWxs XyBmaWxlcyBpbiBhbmQgYmVsb3cKKyAgICAgICAgICBkaXJlY3RvcnkgYXJlIGV4YW1pbmVkIGFz IGdpdCByZWN1cnNlcyBkaXJlY3Rvcmllcy4KKyAgICAgICAgICBBbnkgc3BlY2lmaWVkIFg6IChl eGNsdWRlKSBwYXR0ZXJuIG1hdGNoZXMgYXJlIF9ub3RfIGlnbm9yZWQuCisgICAgICBVc2VkIHdp dGggIi0tbm9naXQiLCBkaXJlY3RvcnkgaXMgdXNlZCBhcyBhIHBhdHRlcm4gbWF0Y2gsCisgICAg ICAgICAgbm8gaW5kaXZpZHVhbCBmaWxlIHdpdGhpbiB0aGUgZGlyZWN0b3J5IG9yIHN1YmRpcmVj dG9yeQorICAgICAgICAgIGlzIG1hdGNoZWQuCisgICAgICBVc2VkIHdpdGggIi0tZ2l0LWJsYW1l IiwgZG9lcyBub3QgaXRlcmF0ZSBhbGwgZmlsZXMgaW4gZGlyZWN0b3J5CisgIFVzaW5nICItLWdp dC1ibGFtZSIgaXMgc2xvdyBhbmQgbWF5IGFkZCBvbGQgY29tbWl0dGVycyBhbmQgYXV0aG9ycwor ICAgICAgdGhhdCBhcmUgbm8gbG9uZ2VyIGFjdGl2ZSBtYWludGFpbmVycyB0byB0aGUgb3V0cHV0 LgorICBVc2luZyAiLS1yb2xlcyIgb3IgIi0tcm9sZXN0YXRzIiB3aXRoIGdpdCBzZW5kLWVtYWls IC0tY2MtY21kIG9yIGFueQorICAgICAgb3RoZXIgYXV0b21hdGVkIHRvb2xzIHRoYXQgZXhwZWN0 IG9ubHkgWyJuYW1lIl0gPGVtYWlsIGFkZHJlc3M+CisgICAgICBtYXkgbm90IHdvcmsgYmVjYXVz ZSBvZiBhZGRpdGlvbmFsIG91dHB1dCBhZnRlciA8ZW1haWwgYWRkcmVzcz4uCisgIFVzaW5nICIt LXJvbGVzdGF0cyIgYW5kICItLWdpdC1ibGFtZSIgc2hvd3MgdGhlICMvdG90YWw9JSBjb21taXRz LAorICAgICAgbm90IHRoZSBwZXJjZW50YWdlIG9mIHRoZSBlbnRpcmUgZmlsZSBhdXRob3JlZC4g ICMgb2YgY29tbWl0cyBpcworICAgICAgbm90IGEgZ29vZCBtZWFzdXJlIG9mIGFtb3VudCBvZiBj b2RlIGF1dGhvcmVkLiAgMSBtYWpvciBjb21taXQgbWF5CisgICAgICBjb250YWluIGEgdGhvdXNh bmQgbGluZXMsIDUgdHJpdmlhbCBjb21taXRzIG1heSBtb2RpZnkgYSBzaW5nbGUgbGluZS4KKyAg SWYgZ2l0IGlzIG5vdCBpbnN0YWxsZWQsIGJ1dCBtZXJjdXJpYWwgKGhnKSBpcyBpbnN0YWxsZWQg YW5kIGFuIC5oZworICAgICAgcmVwb3NpdG9yeSBleGlzdHMsIHRoZSBmb2xsb3dpbmcgb3B0aW9u cyBhcHBseSB0byBtZXJjdXJpYWw6CisgICAgICAgICAgLS1naXQsCisgICAgICAgICAgLS1naXQt bWluLXNpZ25hdHVyZXMsIC0tZ2l0LW1heC1tYWludGFpbmVycywgLS1naXQtbWluLXBlcmNlbnQs IGFuZAorICAgICAgICAgIC0tZ2l0LWJsYW1lCisgICAgICBVc2UgLS1oZy1zaW5jZSBub3QgLS1n aXQtc2luY2UgdG8gY29udHJvbCBkYXRlIHNlbGVjdGlvbgorICBGaWxlICIuZ2V0X21haW50YWlu ZXIuY29uZiIsIGlmIGl0IGV4aXN0cyBpbiB0aGUgZnN0ZXN0cyBzb3VyY2Ugcm9vdAorICAgICAg ZGlyZWN0b3J5LCBjYW4gY2hhbmdlIHdoYXRldmVyIGdldF9tYWludGFpbmVyIGRlZmF1bHRzIGFy ZSBkZXNpcmVkLgorICAgICAgRW50cmllcyBpbiB0aGlzIGZpbGUgY2FuIGJlIGFueSBjb21tYW5k IGxpbmUgYXJndW1lbnQuCisgICAgICBUaGlzIGZpbGUgaXMgcHJlcGVuZGVkIHRvIGFueSBhZGRp dGlvbmFsIGNvbW1hbmQgbGluZSBhcmd1bWVudHMuCisgICAgICBNdWx0aXBsZSBsaW5lcyBhbmQg IyBjb21tZW50cyBhcmUgYWxsb3dlZC4KKyAgTW9zdCBvcHRpb25zIGhhdmUgYm90aCBwb3NpdGl2 ZSBhbmQgbmVnYXRpdmUgZm9ybXMuCisgICAgICBUaGUgbmVnYXRpdmUgZm9ybXMgZm9yIC0tPGZv bz4gYXJlIC0tbm88Zm9vPiBhbmQgLS1uby08Zm9vPi4KKworRU9UCit9CisKK3N1YiB0b3Bfb2Zf ZnN0ZXN0c190cmVlIHsKKyAgICBteSAoJGxrX3BhdGgpID0gQF87CisKKyAgICBpZiAoJGxrX3Bh dGggbmUgIiIgJiYgc3Vic3RyKCRsa19wYXRoLGxlbmd0aCgkbGtfcGF0aCktMSwxKSBuZSAiLyIp IHsKKwkkbGtfcGF0aCAuPSAiLyI7CisgICAgfQorICAgIGlmICggICAoLWYgIiR7bGtfcGF0aH1j aGVjayIpCisJJiYgKC1mICIke2xrX3BhdGh9bG9jYWwuY29uZmlnLmV4YW1wbGUiKQorCSYmICgt ZSAiJHtsa19wYXRofU1BSU5UQUlORVJTIikKKwkmJiAoLWYgIiR7bGtfcGF0aH1NYWtlZmlsZSIp CisJJiYgKC1mICIke2xrX3BhdGh9UkVBRE1FIikKKwkmJiAoLWYgIiR7bGtfcGF0aH1uZXciKQor CSYmICgtZCAiJHtsa19wYXRofUxJQ0VOU0VTIikKKwkmJiAoLWQgIiR7bGtfcGF0aH10ZXN0cyIp CisJJiYgKC1kICIke2xrX3BhdGh9Y29tbW9uIikKKwkmJiAoLWQgIiR7bGtfcGF0aH1zcmMiKQor CSYmICgtZCAiJHtsa19wYXRofXRvb2xzIikKKwkmJiAoLWQgIiR7bGtfcGF0aH1pbmNsdWRlIikK KwkmJiAoLWQgIiR7bGtfcGF0aH1tNCIpCisJJiYgKC1kICIke2xrX3BhdGh9bGliIikKKwkmJiAo LWQgIiR7bGtfcGF0aH1kb2MiKSkgeworCXJldHVybiAxOworICAgIH0KKyAgICByZXR1cm4gMDsK K30KKworc3ViIHBhcnNlX2VtYWlsIHsKKyAgICBteSAoJGZvcm1hdHRlZF9lbWFpbCkgPSBAXzsK KworICAgIG15ICRuYW1lID0gIiI7CisgICAgbXkgJGFkZHJlc3MgPSAiIjsKKworICAgIGlmICgk Zm9ybWF0dGVkX2VtYWlsID1+IC9eKFtePF0rKTwoLitcQC4qKT4uKiQvKSB7CisJJG5hbWUgPSAk MTsKKwkkYWRkcmVzcyA9ICQyOworICAgIH0gZWxzaWYgKCRmb3JtYXR0ZWRfZW1haWwgPX4gL15c cyo8KC4rXEBcUyopPi4qJC8pIHsKKwkkYWRkcmVzcyA9ICQxOworICAgIH0gZWxzaWYgKCRmb3Jt YXR0ZWRfZW1haWwgPX4gL14oLitcQFxTKikuKiQvKSB7CisJJGFkZHJlc3MgPSAkMTsKKyAgICB9 CisKKyAgICAkbmFtZSA9fiBzL15ccyt8XHMrJC8vZzsKKyAgICAkbmFtZSA9fiBzL15cInxcIiQv L2c7CisgICAgJGFkZHJlc3MgPX4gcy9eXHMrfFxzKyQvL2c7CisKKyAgICBpZiAoJG5hbWUgPX4g L1teXHcgXC1dL2kpIHsgIAkgIyNoYXMgIm11c3QgcXVvdGUiIGNoYXJzCisJJG5hbWUgPX4gcy8o PzwhXFwpIi9cXCIvZzsgICAgICAgIyNlc2NhcGUgcXVvdGVzCisJJG5hbWUgPSAiXCIkbmFtZVwi IjsKKyAgICB9CisKKyAgICByZXR1cm4gKCRuYW1lLCAkYWRkcmVzcyk7Cit9CisKK3N1YiBmb3Jt YXRfZW1haWwgeworICAgIG15ICgkbmFtZSwgJGFkZHJlc3MsICR1c2VuYW1lKSA9IEBfOworCisg ICAgbXkgJGZvcm1hdHRlZF9lbWFpbDsKKworICAgICRuYW1lID1+IHMvXlxzK3xccyskLy9nOwor ICAgICRuYW1lID1+IHMvXlwifFwiJC8vZzsKKyAgICAkYWRkcmVzcyA9fiBzL15ccyt8XHMrJC8v ZzsKKworICAgIGlmICgkbmFtZSA9fiAvW15cdyBcLV0vaSkgeyAgICAgICAgICAjI2hhcyAibXVz dCBxdW90ZSIgY2hhcnMKKwkkbmFtZSA9fiBzLyg/PCFcXCkiL1xcIi9nOyAgICAgICAjI2VzY2Fw ZSBxdW90ZXMKKwkkbmFtZSA9ICJcIiRuYW1lXCIiOworICAgIH0KKworICAgIGlmICgkdXNlbmFt ZSkgeworCWlmICgiJG5hbWUiIGVxICIiKSB7CisJICAgICRmb3JtYXR0ZWRfZW1haWwgPSAiJGFk ZHJlc3MiOworCX0gZWxzZSB7CisJICAgICRmb3JtYXR0ZWRfZW1haWwgPSAiJG5hbWUgPCRhZGRy ZXNzPiI7CisJfQorICAgIH0gZWxzZSB7CisJJGZvcm1hdHRlZF9lbWFpbCA9ICRhZGRyZXNzOwor ICAgIH0KKworICAgIHJldHVybiAkZm9ybWF0dGVkX2VtYWlsOworfQorCitzdWIgZmluZF9maXJz dF9zZWN0aW9uIHsKKyAgICBteSAkaW5kZXggPSAwOworCisgICAgd2hpbGUgKCRpbmRleCA8IEB0 eXBldmFsdWUpIHsKKwlteSAkdHYgPSAkdHlwZXZhbHVlWyRpbmRleF07CisJaWYgKCgkdHYgPX4g bS9eKFtBLVpdKTpccyooLiopLykpIHsKKwkgICAgbGFzdDsKKwl9CisJJGluZGV4Kys7CisgICAg fQorCisgICAgcmV0dXJuICRpbmRleDsKK30KKworc3ViIGZpbmRfc3RhcnRpbmdfaW5kZXggewor ICAgIG15ICgkaW5kZXgpID0gQF87CisKKyAgICB3aGlsZSAoJGluZGV4ID4gMCkgeworCW15ICR0 diA9ICR0eXBldmFsdWVbJGluZGV4XTsKKwlpZiAoISgkdHYgPX4gbS9eKFtBLVpdKTpccyooLiop LykpIHsKKwkgICAgbGFzdDsKKwl9CisJJGluZGV4LS07CisgICAgfQorCisgICAgcmV0dXJuICRp bmRleDsKK30KKworc3ViIGZpbmRfZW5kaW5nX2luZGV4IHsKKyAgICBteSAoJGluZGV4KSA9IEBf OworCisgICAgd2hpbGUgKCRpbmRleCA8IEB0eXBldmFsdWUpIHsKKwlteSAkdHYgPSAkdHlwZXZh bHVlWyRpbmRleF07CisJaWYgKCEoJHR2ID1+IG0vXihbQS1aXSk6XHMqKC4qKS8pKSB7CisJICAg IGxhc3Q7CisJfQorCSRpbmRleCsrOworICAgIH0KKworICAgIHJldHVybiAkaW5kZXg7Cit9CisK K3N1YiBnZXRfc3Vic3lzdGVtX25hbWUgeworICAgIG15ICgkaW5kZXgpID0gQF87CisKKyAgICBt eSAkc3RhcnQgPSBmaW5kX3N0YXJ0aW5nX2luZGV4KCRpbmRleCk7CisKKyAgICBteSAkc3Vic3lz dGVtID0gJHR5cGV2YWx1ZVskc3RhcnRdOworICAgIGlmICgkb3V0cHV0X3NlY3Rpb25fbWF4bGVu ICYmIGxlbmd0aCgkc3Vic3lzdGVtKSA+ICRvdXRwdXRfc2VjdGlvbl9tYXhsZW4pIHsKKwkkc3Vi c3lzdGVtID0gc3Vic3RyKCRzdWJzeXN0ZW0sIDAsICRvdXRwdXRfc2VjdGlvbl9tYXhsZW4gLSAz KTsKKwkkc3Vic3lzdGVtID1+IHMvXHMqJC8vOworCSRzdWJzeXN0ZW0gPSAkc3Vic3lzdGVtIC4g Ii4uLiI7CisgICAgfQorICAgIHJldHVybiAkc3Vic3lzdGVtOworfQorCitzdWIgZ2V0X21haW50 YWluZXJfcm9sZSB7CisgICAgbXkgKCRpbmRleCkgPSBAXzsKKworICAgIG15ICRpOworICAgIG15 ICRzdGFydCA9IGZpbmRfc3RhcnRpbmdfaW5kZXgoJGluZGV4KTsKKyAgICBteSAkZW5kID0gZmlu ZF9lbmRpbmdfaW5kZXgoJGluZGV4KTsKKworICAgIG15ICRyb2xlID0gInVua25vd24iOworICAg IG15ICRzdWJzeXN0ZW0gPSBnZXRfc3Vic3lzdGVtX25hbWUoJGluZGV4KTsKKworICAgIGZvciAo JGkgPSAkc3RhcnQgKyAxOyAkaSA8ICRlbmQ7ICRpKyspIHsKKwlteSAkdHYgPSAkdHlwZXZhbHVl WyRpXTsKKwlpZiAoJHR2ID1+IG0vXihbQS1aXSk6XHMqKC4qKS8pIHsKKwkgICAgbXkgJHB0eXBl ID0gJDE7CisJICAgIG15ICRwdmFsdWUgPSAkMjsKKwkgICAgaWYgKCRwdHlwZSBlcSAiUyIpIHsK KwkJJHJvbGUgPSAkcHZhbHVlOworCSAgICB9CisJfQorICAgIH0KKworICAgICRyb2xlID0gbGMo JHJvbGUpOworICAgIGlmICAgICAgKCRyb2xlIGVxICJzdXBwb3J0ZWQiKSB7CisJJHJvbGUgPSAi c3VwcG9ydGVyIjsKKyAgICB9IGVsc2lmICgkcm9sZSBlcSAibWFpbnRhaW5lZCIpIHsKKwkkcm9s ZSA9ICJtYWludGFpbmVyIjsKKyAgICB9IGVsc2lmICgkcm9sZSBlcSAib2RkIGZpeGVzIikgewor CSRyb2xlID0gIm9kZCBmaXhlciI7CisgICAgfSBlbHNpZiAoJHJvbGUgZXEgIm9ycGhhbiIpIHsK Kwkkcm9sZSA9ICJvcnBoYW4gbWluZGVyIjsKKyAgICB9IGVsc2lmICgkcm9sZSBlcSAib2Jzb2xl dGUiKSB7CisJJHJvbGUgPSAib2Jzb2xldGUgbWluZGVyIjsKKyAgICB9IGVsc2lmICgkcm9sZSBl cSAiYnVyaWVkIGFsaXZlIGluIHJlcG9ydGVycyIpIHsKKwkkcm9sZSA9ICJjaGllZiBwZW5ndWlu IjsKKyAgICB9CisKKyAgICByZXR1cm4gJHJvbGUgLiAiOiIgLiAkc3Vic3lzdGVtOworfQorCitz dWIgZ2V0X2xpc3Rfcm9sZSB7CisgICAgbXkgKCRpbmRleCkgPSBAXzsKKworICAgIG15ICRzdWJz eXN0ZW0gPSBnZXRfc3Vic3lzdGVtX25hbWUoJGluZGV4KTsKKworICAgIGlmICgkc3Vic3lzdGVt IGVxICJBTEwiKSB7CisJJHN1YnN5c3RlbSA9ICJTZW5kIFRvIE1lIjsKKyAgICB9CisKKyAgICBy ZXR1cm4gJHN1YnN5c3RlbTsKK30KKworc3ViIGFkZF9jYXRlZ29yaWVzIHsKKyAgICBteSAoJGlu ZGV4KSA9IEBfOworCisgICAgbXkgJGk7CisgICAgbXkgJHN0YXJ0ID0gZmluZF9zdGFydGluZ19p bmRleCgkaW5kZXgpOworICAgIG15ICRlbmQgPSBmaW5kX2VuZGluZ19pbmRleCgkaW5kZXgpOwor CisgICAgcHVzaChAc3Vic3lzdGVtLCAkdHlwZXZhbHVlWyRzdGFydF0pOworCisgICAgZm9yICgk aSA9ICRzdGFydCArIDE7ICRpIDwgJGVuZDsgJGkrKykgeworCW15ICR0diA9ICR0eXBldmFsdWVb JGldOworCWlmICgkdHYgPX4gbS9eKFtBLVpdKTpccyooLiopLykgeworCSAgICBteSAkcHR5cGUg PSAkMTsKKwkgICAgbXkgJHB2YWx1ZSA9ICQyOworCSAgICBpZiAoJHB0eXBlIGVxICJMIikgewor CQlteSAkbGlzdF9hZGRyZXNzID0gJHB2YWx1ZTsKKwkJbXkgJGxpc3RfYWRkaXRpb25hbCA9ICIi OworCQlteSAkbGlzdF9yb2xlID0gZ2V0X2xpc3Rfcm9sZSgkaSk7CisKKwkJaWYgKCRsaXN0X3Jv bGUgbmUgIiIpIHsKKwkJICAgICRsaXN0X3JvbGUgPSAiOiIgLiAkbGlzdF9yb2xlOworCQl9CisJ CWlmICgkbGlzdF9hZGRyZXNzID1+IG0vKFteXHNdKylccysoLiopJC8pIHsKKwkJICAgICRsaXN0 X2FkZHJlc3MgPSAkMTsKKwkJICAgICRsaXN0X2FkZGl0aW9uYWwgPSAkMjsKKwkJfQorCQlpZiAo JGxpc3RfYWRkaXRpb25hbCA9fiBtL3N1YnNjcmliZXJzLW9ubHkvKSB7CisJCSAgICBpZiAoJGVt YWlsX3N1YnNjcmliZXJfbGlzdCkgeworCQkJaWYgKCEkaGFzaF9saXN0X3Rve2xjKCRsaXN0X2Fk ZHJlc3MpfSkgeworCQkJICAgICRoYXNoX2xpc3RfdG97bGMoJGxpc3RfYWRkcmVzcyl9ID0gMTsK KwkJCSAgICBwdXNoKEBsaXN0X3RvLCBbJGxpc3RfYWRkcmVzcywKKwkJCQkJICAgICJzdWJzY3Jp YmVyIGxpc3Qke2xpc3Rfcm9sZX0iXSk7CisJCQl9CisJCSAgICB9CisJCX0gZWxzZSB7CisJCSAg ICBpZiAoJGVtYWlsX2xpc3QpIHsKKwkJCWlmICghJGhhc2hfbGlzdF90b3tsYygkbGlzdF9hZGRy ZXNzKX0pIHsKKwkJCSAgICBpZiAoJGxpc3RfYWRkaXRpb25hbCA9fiBtL21vZGVyYXRlZC8pIHsK KwkJCQlpZiAoJGVtYWlsX21vZGVyYXRlZF9saXN0KSB7CisJCQkJICAgICRoYXNoX2xpc3RfdG97 bGMoJGxpc3RfYWRkcmVzcyl9ID0gMTsKKwkJCQkgICAgcHVzaChAbGlzdF90bywgWyRsaXN0X2Fk ZHJlc3MsCisJCQkJCQkgICAgIm1vZGVyYXRlZCBsaXN0JHtsaXN0X3JvbGV9Il0pOworCQkJCX0K KwkJCSAgICB9IGVsc2UgeworCQkJCSRoYXNoX2xpc3RfdG97bGMoJGxpc3RfYWRkcmVzcyl9ID0g MTsKKwkJCQlwdXNoKEBsaXN0X3RvLCBbJGxpc3RfYWRkcmVzcywKKwkJCQkJCSJvcGVuIGxpc3Qk e2xpc3Rfcm9sZX0iXSk7CisJCQkgICAgfQorCQkJfQorCQkgICAgfQorCQl9CisJICAgIH0gZWxz aWYgKCRwdHlwZSBlcSAiTSIpIHsKKwkJaWYgKCRlbWFpbF9tYWludGFpbmVyKSB7CisJCSAgICBt eSAkcm9sZSA9IGdldF9tYWludGFpbmVyX3JvbGUoJGkpOworCQkgICAgcHVzaF9lbWFpbF9hZGRy ZXNzZXMoJHB2YWx1ZSwgJHJvbGUpOworCQl9CisJICAgIH0gZWxzaWYgKCRwdHlwZSBlcSAiUiIp IHsKKwkJaWYgKCRlbWFpbF9yZXZpZXdlcikgeworCQkgICAgbXkgJHN1YnN5c3RlbSA9IGdldF9z dWJzeXN0ZW1fbmFtZSgkaSk7CisJCSAgICBwdXNoX2VtYWlsX2FkZHJlc3NlcygkcHZhbHVlLCAi cmV2aWV3ZXI6JHN1YnN5c3RlbSIpOworCQl9CisJICAgIH0gZWxzaWYgKCRwdHlwZSBlcSAiVCIp IHsKKwkJcHVzaChAc2NtLCAkcHZhbHVlKTsKKwkgICAgfSBlbHNpZiAoJHB0eXBlIGVxICJXIikg eworCQlwdXNoKEB3ZWIsICRwdmFsdWUpOworCSAgICB9IGVsc2lmICgkcHR5cGUgZXEgIlMiKSB7 CisJCXB1c2goQHN0YXR1cywgJHB2YWx1ZSk7CisJICAgIH0KKwl9CisgICAgfQorfQorCitzdWIg ZW1haWxfaW51c2UgeworICAgIG15ICgkbmFtZSwgJGFkZHJlc3MpID0gQF87CisKKyAgICByZXR1 cm4gMSBpZiAoKCRuYW1lIGVxICIiKSAmJiAoJGFkZHJlc3MgZXEgIiIpKTsKKyAgICByZXR1cm4g MSBpZiAoKCRuYW1lIG5lICIiKSAmJiBleGlzdHMoJGVtYWlsX2hhc2hfbmFtZXtsYygkbmFtZSl9 KSk7CisgICAgcmV0dXJuIDEgaWYgKCgkYWRkcmVzcyBuZSAiIikgJiYgZXhpc3RzKCRlbWFpbF9o YXNoX2FkZHJlc3N7bGMoJGFkZHJlc3MpfSkpOworCisgICAgcmV0dXJuIDA7Cit9CisKK3N1YiBw dXNoX2VtYWlsX2FkZHJlc3MgeworICAgIG15ICgkbGluZSwgJHJvbGUpID0gQF87CisKKyAgICBt eSAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRsaW5lKTsKKworICAgIGlmICgkYWRk cmVzcyBlcSAiIikgeworCXJldHVybiAwOworICAgIH0KKworICAgIGlmICghJGVtYWlsX3JlbW92 ZV9kdXBsaWNhdGVzKSB7CisJcHVzaChAZW1haWxfdG8sIFtmb3JtYXRfZW1haWwoJG5hbWUsICRh ZGRyZXNzLCAkZW1haWxfdXNlbmFtZSksICRyb2xlXSk7CisgICAgfSBlbHNpZiAoIWVtYWlsX2lu dXNlKCRuYW1lLCAkYWRkcmVzcykpIHsKKwlwdXNoKEBlbWFpbF90bywgW2Zvcm1hdF9lbWFpbCgk bmFtZSwgJGFkZHJlc3MsICRlbWFpbF91c2VuYW1lKSwgJHJvbGVdKTsKKwkkZW1haWxfaGFzaF9u YW1le2xjKCRuYW1lKX0rKyBpZiAoJG5hbWUgbmUgIiIpOworCSRlbWFpbF9oYXNoX2FkZHJlc3N7 bGMoJGFkZHJlc3MpfSsrOworICAgIH0KKworICAgIHJldHVybiAxOworfQorCitzdWIgcHVzaF9l bWFpbF9hZGRyZXNzZXMgeworICAgIG15ICgkYWRkcmVzcywgJHJvbGUpID0gQF87CisKKyAgICBt eSBAYWRkcmVzc19saXN0ID0gKCk7CisKKyAgICBpZiAocmZjODIyX3ZhbGlkKCRhZGRyZXNzKSkg eworCXB1c2hfZW1haWxfYWRkcmVzcygkYWRkcmVzcywgJHJvbGUpOworICAgIH0gZWxzaWYgKEBh ZGRyZXNzX2xpc3QgPSByZmM4MjJfdmFsaWRsaXN0KCRhZGRyZXNzKSkgeworCW15ICRhcnJheV9j b3VudCA9IHNoaWZ0KEBhZGRyZXNzX2xpc3QpOworCXdoaWxlIChteSAkZW50cnkgPSBzaGlmdChA YWRkcmVzc19saXN0KSkgeworCSAgICBwdXNoX2VtYWlsX2FkZHJlc3MoJGVudHJ5LCAkcm9sZSk7 CisJfQorICAgIH0gZWxzZSB7CisJaWYgKCFwdXNoX2VtYWlsX2FkZHJlc3MoJGFkZHJlc3MsICRy b2xlKSkgeworCSAgICB3YXJuKCJJbnZhbGlkIE1BSU5UQUlORVJTIGFkZHJlc3M6ICciIC4gJGFk ZHJlc3MgLiAiJ1xuIik7CisJfQorICAgIH0KK30KKworc3ViIGFkZF9yb2xlIHsKKyAgICBteSAo JGxpbmUsICRyb2xlKSA9IEBfOworCisgICAgbXkgKCRuYW1lLCAkYWRkcmVzcykgPSBwYXJzZV9l bWFpbCgkbGluZSk7CisgICAgbXkgJGVtYWlsID0gZm9ybWF0X2VtYWlsKCRuYW1lLCAkYWRkcmVz cywgJGVtYWlsX3VzZW5hbWUpOworCisgICAgZm9yZWFjaCBteSAkZW50cnkgKEBlbWFpbF90bykg eworCWlmICgkZW1haWxfcmVtb3ZlX2R1cGxpY2F0ZXMpIHsKKwkgICAgbXkgKCRlbnRyeV9uYW1l LCAkZW50cnlfYWRkcmVzcykgPSBwYXJzZV9lbWFpbCgkZW50cnktPlswXSk7CisJICAgIGlmICgo JG5hbWUgZXEgJGVudHJ5X25hbWUgfHwgJGFkZHJlc3MgZXEgJGVudHJ5X2FkZHJlc3MpCisJCSYm ICgkcm9sZSBlcSAiIiB8fCAhKCRlbnRyeS0+WzFdID1+IG0vJHJvbGUvKSkKKwkgICAgKSB7CisJ CWlmICgkZW50cnktPlsxXSBlcSAiIikgeworCQkgICAgJGVudHJ5LT5bMV0gPSAiJHJvbGUiOwor CQl9IGVsc2UgeworCQkgICAgJGVudHJ5LT5bMV0gPSAiJGVudHJ5LT5bMV0sJHJvbGUiOworCQl9 CisJICAgIH0KKwl9IGVsc2UgeworCSAgICBpZiAoJGVtYWlsIGVxICRlbnRyeS0+WzBdCisJCSYm ICgkcm9sZSBlcSAiIiB8fCAhKCRlbnRyeS0+WzFdID1+IG0vJHJvbGUvKSkKKwkgICAgKSB7CisJ CWlmICgkZW50cnktPlsxXSBlcSAiIikgeworCQkgICAgJGVudHJ5LT5bMV0gPSAiJHJvbGUiOwor CQl9IGVsc2UgeworCQkgICAgJGVudHJ5LT5bMV0gPSAiJGVudHJ5LT5bMV0sJHJvbGUiOworCQl9 CisJICAgIH0KKwl9CisgICAgfQorfQorCitzdWIgd2hpY2ggeworICAgIG15ICgkYmluKSA9IEBf OworCisgICAgZm9yZWFjaCBteSAkcGF0aCAoc3BsaXQoLzovLCAkRU5We1BBVEh9KSkgeworCWlm ICgtZSAiJHBhdGgvJGJpbiIpIHsKKwkgICAgcmV0dXJuICIkcGF0aC8kYmluIjsKKwl9CisgICAg fQorCisgICAgcmV0dXJuICIiOworfQorCitzdWIgd2hpY2hfY29uZiB7CisgICAgbXkgKCRjb25m KSA9IEBfOworCisgICAgZm9yZWFjaCBteSAkcGF0aCAoc3BsaXQoLzovLCAiLjokRU5We0hPTUV9 Oi5zY3JpcHRzIikpIHsKKwlpZiAoLWUgIiRwYXRoLyRjb25mIikgeworCSAgICByZXR1cm4gIiRw YXRoLyRjb25mIjsKKwl9CisgICAgfQorCisgICAgcmV0dXJuICIiOworfQorCitzdWIgbWFpbG1h cF9lbWFpbCB7CisgICAgbXkgKCRsaW5lKSA9IEBfOworCisgICAgbXkgKCRuYW1lLCAkYWRkcmVz cykgPSBwYXJzZV9lbWFpbCgkbGluZSk7CisgICAgbXkgJGVtYWlsID0gZm9ybWF0X2VtYWlsKCRu YW1lLCAkYWRkcmVzcywgMSk7CisgICAgbXkgJHJlYWxfbmFtZSA9ICRuYW1lOworICAgIG15ICRy ZWFsX2FkZHJlc3MgPSAkYWRkcmVzczsKKworICAgIGlmIChleGlzdHMgJG1haWxtYXAtPntuYW1l c30tPnskZW1haWx9IHx8CisJZXhpc3RzICRtYWlsbWFwLT57YWRkcmVzc2VzfS0+eyRlbWFpbH0p IHsKKwlpZiAoZXhpc3RzICRtYWlsbWFwLT57bmFtZXN9LT57JGVtYWlsfSkgeworCSAgICAkcmVh bF9uYW1lID0gJG1haWxtYXAtPntuYW1lc30tPnskZW1haWx9OworCX0KKwlpZiAoZXhpc3RzICRt YWlsbWFwLT57YWRkcmVzc2VzfS0+eyRlbWFpbH0pIHsKKwkgICAgJHJlYWxfYWRkcmVzcyA9ICRt YWlsbWFwLT57YWRkcmVzc2VzfS0+eyRlbWFpbH07CisJfQorICAgIH0gZWxzZSB7CisJaWYgKGV4 aXN0cyAkbWFpbG1hcC0+e25hbWVzfS0+eyRhZGRyZXNzfSkgeworCSAgICAkcmVhbF9uYW1lID0g JG1haWxtYXAtPntuYW1lc30tPnskYWRkcmVzc307CisJfQorCWlmIChleGlzdHMgJG1haWxtYXAt PnthZGRyZXNzZXN9LT57JGFkZHJlc3N9KSB7CisJICAgICRyZWFsX2FkZHJlc3MgPSAkbWFpbG1h cC0+e2FkZHJlc3Nlc30tPnskYWRkcmVzc307CisJfQorICAgIH0KKyAgICByZXR1cm4gZm9ybWF0 X2VtYWlsKCRyZWFsX25hbWUsICRyZWFsX2FkZHJlc3MsIDEpOworfQorCitzdWIgbWFpbG1hcCB7 CisgICAgbXkgKEBhZGRyZXNzZXMpID0gQF87CisKKyAgICBteSBAbWFwcGVkX2VtYWlscyA9ICgp OworICAgIGZvcmVhY2ggbXkgJGxpbmUgKEBhZGRyZXNzZXMpIHsKKwlwdXNoKEBtYXBwZWRfZW1h aWxzLCBtYWlsbWFwX2VtYWlsKCRsaW5lKSk7CisgICAgfQorICAgIG1lcmdlX2J5X3JlYWxuYW1l KEBtYXBwZWRfZW1haWxzKSBpZiAoJGVtYWlsX3VzZV9tYWlsbWFwKTsKKyAgICByZXR1cm4gQG1h cHBlZF9lbWFpbHM7Cit9CisKK3N1YiBtZXJnZV9ieV9yZWFsbmFtZSB7CisgICAgbXkgJWFkZHJl c3NfbWFwOworICAgIG15IChAZW1haWxzKSA9IEBfOworCisgICAgZm9yZWFjaCBteSAkZW1haWwg KEBlbWFpbHMpIHsKKwlteSAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRlbWFpbCk7 CisJaWYgKGV4aXN0cyAkYWRkcmVzc19tYXB7JG5hbWV9KSB7CisJICAgICRhZGRyZXNzID0gJGFk ZHJlc3NfbWFweyRuYW1lfTsKKwkgICAgJGVtYWlsID0gZm9ybWF0X2VtYWlsKCRuYW1lLCAkYWRk cmVzcywgMSk7CisJfSBlbHNlIHsKKwkgICAgJGFkZHJlc3NfbWFweyRuYW1lfSA9ICRhZGRyZXNz OworCX0KKyAgICB9Cit9CisKK3N1YiBnaXRfZXhlY3V0ZV9jbWQgeworICAgIG15ICgkY21kKSA9 IEBfOworICAgIG15IEBsaW5lcyA9ICgpOworCisgICAgbXkgJG91dHB1dCA9IGAkY21kYDsKKyAg ICAkb3V0cHV0ID1+IHMvXlxzKi8vZ207CisgICAgQGxpbmVzID0gc3BsaXQoIlxuIiwgJG91dHB1 dCk7CisKKyAgICByZXR1cm4gQGxpbmVzOworfQorCitzdWIgaGdfZXhlY3V0ZV9jbWQgeworICAg IG15ICgkY21kKSA9IEBfOworICAgIG15IEBsaW5lcyA9ICgpOworCisgICAgbXkgJG91dHB1dCA9 IGAkY21kYDsKKyAgICBAbGluZXMgPSBzcGxpdCgiXG4iLCAkb3V0cHV0KTsKKworICAgIHJldHVy biBAbGluZXM7Cit9CisKK3N1YiBleHRyYWN0X2Zvcm1hdHRlZF9zaWduYXR1cmVzIHsKKyAgICBt eSAoQHNpZ25hdHVyZV9saW5lcykgPSBAXzsKKworICAgIG15IEB0eXBlID0gQHNpZ25hdHVyZV9s aW5lczsKKworICAgIHMvXHMqKC4qKTouKi8kMS8gZm9yIChAdHlwZSk7CisKKyAgICAjIGN1dCAt ZjItIC1kIjoiCisgICAgcy9ccyouKjpccyooLispXHMqLyQxLyBmb3IgKEBzaWduYXR1cmVfbGlu ZXMpOworCisjIyBSZWZvcm1hdCBlbWFpbCBhZGRyZXNzZXMgKHdpdGggbmFtZXMpIHRvIGF2b2lk IGJhZGx5IHdyaXR0ZW4gc2lnbmF0dXJlcworCisgICAgZm9yZWFjaCBteSAkc2lnbmVyIChAc2ln bmF0dXJlX2xpbmVzKSB7CisJJHNpZ25lciA9IGRlZHVwbGljYXRlX2VtYWlsKCRzaWduZXIpOwor ICAgIH0KKworICAgIHJldHVybiAoXEB0eXBlLCBcQHNpZ25hdHVyZV9saW5lcyk7Cit9CisKK3N1 YiB2Y3NfZmluZF9zaWduZXJzIHsKKyAgICBteSAoJGNtZCwgJGZpbGUpID0gQF87CisgICAgbXkg JGNvbW1pdHM7CisgICAgbXkgQGxpbmVzID0gKCk7CisgICAgbXkgQHNpZ25hdHVyZXMgPSAoKTsK KyAgICBteSBAYXV0aG9ycyA9ICgpOworICAgIG15IEBzdGF0cyA9ICgpOworCisgICAgQGxpbmVz ID0gJnskVkNTX2NtZHN7ImV4ZWN1dGVfY21kIn19KCRjbWQpOworCisgICAgbXkgJHBhdHRlcm4g PSAkVkNTX2NtZHN7ImNvbW1pdF9wYXR0ZXJuIn07CisgICAgbXkgJGF1dGhvcl9wYXR0ZXJuID0g JFZDU19jbWRzeyJhdXRob3JfcGF0dGVybiJ9OworICAgIG15ICRzdGF0X3BhdHRlcm4gPSAkVkNT X2NtZHN7InN0YXRfcGF0dGVybiJ9OworCisgICAgJHN0YXRfcGF0dGVybiA9fiBzLyhcJFx3Kykv JDEvZWVnOwkJI2ludGVycG9sYXRlICRzdGF0X3BhdHRlcm4KKworICAgICRjb21taXRzID0gZ3Jl cCgvJHBhdHRlcm4vLCBAbGluZXMpOwkjIG9mIGNvbW1pdHMKKworICAgIEBhdXRob3JzID0gZ3Jl cCgvJGF1dGhvcl9wYXR0ZXJuLywgQGxpbmVzKTsKKyAgICBAc2lnbmF0dXJlcyA9IGdyZXAoL15b IFx0XSoke3NpZ25hdHVyZV9wYXR0ZXJufS4qXEAuKiQvLCBAbGluZXMpOworICAgIEBzdGF0cyA9 IGdyZXAoLyRzdGF0X3BhdHRlcm4vLCBAbGluZXMpOworCisjICAgIHByaW50KCJzdGF0czogPEBz dGF0cz5cbiIpOworCisgICAgcmV0dXJuICgwLCBcQHNpZ25hdHVyZXMsIFxAYXV0aG9ycywgXEBz dGF0cykgaWYgIUBzaWduYXR1cmVzOworCisgICAgc2F2ZV9jb21taXRzX2J5X2F1dGhvcihAbGlu ZXMpIGlmICgkaW50ZXJhY3RpdmUpOworICAgIHNhdmVfY29tbWl0c19ieV9zaWduZXIoQGxpbmVz KSBpZiAoJGludGVyYWN0aXZlKTsKKworICAgIGlmICghJGVtYWlsX2dpdF9wZW5ndWluX2NoaWVm cykgeworCUBzaWduYXR1cmVzID0gZ3JlcCghLyR7cGVuZ3Vpbl9jaGllZnN9L2ksIEBzaWduYXR1 cmVzKTsKKyAgICB9CisKKyAgICBteSAoJGF1dGhvcl9yZWYsICRhdXRob3JzX3JlZikgPSBleHRy YWN0X2Zvcm1hdHRlZF9zaWduYXR1cmVzKEBhdXRob3JzKTsKKyAgICBteSAoJHR5cGVzX3JlZiwg JHNpZ25lcnNfcmVmKSA9IGV4dHJhY3RfZm9ybWF0dGVkX3NpZ25hdHVyZXMoQHNpZ25hdHVyZXMp OworCisgICAgcmV0dXJuICgkY29tbWl0cywgJHNpZ25lcnNfcmVmLCAkYXV0aG9yc19yZWYsIFxA c3RhdHMpOworfQorCitzdWIgdmNzX2ZpbmRfYXV0aG9yIHsKKyAgICBteSAoJGNtZCkgPSBAXzsK KyAgICBteSBAbGluZXMgPSAoKTsKKworICAgIEBsaW5lcyA9ICZ7JFZDU19jbWRzeyJleGVjdXRl X2NtZCJ9fSgkY21kKTsKKworICAgIGlmICghJGVtYWlsX2dpdF9wZW5ndWluX2NoaWVmcykgewor CUBsaW5lcyA9IGdyZXAoIS8ke3Blbmd1aW5fY2hpZWZzfS9pLCBAbGluZXMpOworICAgIH0KKwor ICAgIHJldHVybiBAbGluZXMgaWYgIUBsaW5lczsKKworICAgIG15IEBhdXRob3JzID0gKCk7Cisg ICAgZm9yZWFjaCBteSAkbGluZSAoQGxpbmVzKSB7CisJaWYgKCRsaW5lID1+IG0vJFZDU19jbWRz eyJhdXRob3JfcGF0dGVybiJ9LykgeworCSAgICBteSAkYXV0aG9yID0gJDE7CisJICAgIG15ICgk bmFtZSwgJGFkZHJlc3MpID0gcGFyc2VfZW1haWwoJGF1dGhvcik7CisJICAgICRhdXRob3IgPSBm b3JtYXRfZW1haWwoJG5hbWUsICRhZGRyZXNzLCAxKTsKKwkgICAgcHVzaChAYXV0aG9ycywgJGF1 dGhvcik7CisJfQorICAgIH0KKworICAgIHNhdmVfY29tbWl0c19ieV9hdXRob3IoQGxpbmVzKSBp ZiAoJGludGVyYWN0aXZlKTsKKyAgICBzYXZlX2NvbW1pdHNfYnlfc2lnbmVyKEBsaW5lcykgaWYg KCRpbnRlcmFjdGl2ZSk7CisKKyAgICByZXR1cm4gQGF1dGhvcnM7Cit9CisKK3N1YiB2Y3Nfc2F2 ZV9jb21taXRzIHsKKyAgICBteSAoJGNtZCkgPSBAXzsKKyAgICBteSBAbGluZXMgPSAoKTsKKyAg ICBteSBAY29tbWl0cyA9ICgpOworCisgICAgQGxpbmVzID0gJnskVkNTX2NtZHN7ImV4ZWN1dGVf Y21kIn19KCRjbWQpOworCisgICAgZm9yZWFjaCBteSAkbGluZSAoQGxpbmVzKSB7CisJaWYgKCRs aW5lID1+IG0vJFZDU19jbWRzeyJibGFtZV9jb21taXRfcGF0dGVybiJ9LykgeworCSAgICBwdXNo KEBjb21taXRzLCAkMSk7CisJfQorICAgIH0KKworICAgIHJldHVybiBAY29tbWl0czsKK30KKwor c3ViIHZjc19ibGFtZSB7CisgICAgbXkgKCRmaWxlKSA9IEBfOworICAgIG15ICRjbWQ7CisgICAg bXkgQGNvbW1pdHMgPSAoKTsKKworICAgIHJldHVybiBAY29tbWl0cyBpZiAoISgtZiAkZmlsZSkp OworCisgICAgaWYgKEByYW5nZSAmJiAkVkNTX2NtZHN7ImJsYW1lX3JhbmdlX2NtZCJ9IGVxICIi KSB7CisJbXkgQGFsbF9jb21taXRzID0gKCk7CisKKwkkY21kID0gJFZDU19jbWRzeyJibGFtZV9m aWxlX2NtZCJ9OworCSRjbWQgPX4gcy8oXCRcdyspLyQxL2VlZzsJCSNpbnRlcnBvbGF0ZSAkY21k CisJQGFsbF9jb21taXRzID0gdmNzX3NhdmVfY29tbWl0cygkY21kKTsKKworCWZvcmVhY2ggbXkg JGZpbGVfcmFuZ2VfZGlmZiAoQHJhbmdlKSB7CisJICAgIG5leHQgaWYgKCEoJGZpbGVfcmFuZ2Vf ZGlmZiA9fiBtLyguKyk6KC4rKTooLispLykpOworCSAgICBteSAkZGlmZl9maWxlID0gJDE7CisJ ICAgIG15ICRkaWZmX3N0YXJ0ID0gJDI7CisJICAgIG15ICRkaWZmX2xlbmd0aCA9ICQzOworCSAg ICBuZXh0IGlmICgiJGZpbGUiIG5lICIkZGlmZl9maWxlIik7CisJICAgIGZvciAobXkgJGkgPSAk ZGlmZl9zdGFydDsgJGkgPCAkZGlmZl9zdGFydCArICRkaWZmX2xlbmd0aDsgJGkrKykgeworCQlw dXNoKEBjb21taXRzLCAkYWxsX2NvbW1pdHNbJGldKTsKKwkgICAgfQorCX0KKyAgICB9IGVsc2lm IChAcmFuZ2UpIHsKKwlmb3JlYWNoIG15ICRmaWxlX3JhbmdlX2RpZmYgKEByYW5nZSkgeworCSAg ICBuZXh0IGlmICghKCRmaWxlX3JhbmdlX2RpZmYgPX4gbS8oLispOiguKyk6KC4rKS8pKTsKKwkg ICAgbXkgJGRpZmZfZmlsZSA9ICQxOworCSAgICBteSAkZGlmZl9zdGFydCA9ICQyOworCSAgICBt eSAkZGlmZl9sZW5ndGggPSAkMzsKKwkgICAgbmV4dCBpZiAoIiRmaWxlIiBuZSAiJGRpZmZfZmls ZSIpOworCSAgICAkY21kID0gJFZDU19jbWRzeyJibGFtZV9yYW5nZV9jbWQifTsKKwkgICAgJGNt ZCA9fiBzLyhcJFx3KykvJDEvZWVnOwkJI2ludGVycG9sYXRlICRjbWQKKwkgICAgcHVzaChAY29t bWl0cywgdmNzX3NhdmVfY29tbWl0cygkY21kKSk7CisJfQorICAgIH0gZWxzZSB7CisJJGNtZCA9 ICRWQ1NfY21kc3siYmxhbWVfZmlsZV9jbWQifTsKKwkkY21kID1+IHMvKFwkXHcrKS8kMS9lZWc7 CQkjaW50ZXJwb2xhdGUgJGNtZAorCUBjb21taXRzID0gdmNzX3NhdmVfY29tbWl0cygkY21kKTsK KyAgICB9CisKKyAgICBmb3JlYWNoIG15ICRjb21taXQgKEBjb21taXRzKSB7CisJJGNvbW1pdCA9 fiBzL15cXi8vZzsKKyAgICB9CisKKyAgICByZXR1cm4gQGNvbW1pdHM7Cit9CisKK215ICRwcmlu dGVkX25vdmNzID0gMDsKK3N1YiB2Y3NfZXhpc3RzIHsKKyAgICAlVkNTX2NtZHMgPSAlVkNTX2Nt ZHNfZ2l0OworICAgIHJldHVybiAxIGlmIGV2YWwgJFZDU19jbWRzeyJhdmFpbGFibGUifTsKKyAg ICAlVkNTX2NtZHMgPSAlVkNTX2NtZHNfaGc7CisgICAgcmV0dXJuIDIgaWYgZXZhbCAkVkNTX2Nt ZHN7ImF2YWlsYWJsZSJ9OworICAgICVWQ1NfY21kcyA9ICgpOworICAgIGlmICghJHByaW50ZWRf bm92Y3MgJiYgJGVtYWlsX2dpdCkgeworCXdhcm4oIiRQOiBObyBzdXBwb3J0ZWQgVkNTIGZvdW5k LiAgQWRkIC0tbm9naXQgdG8gb3B0aW9ucz9cbiIpOworCXdhcm4oIlVzaW5nIGEgZ2l0IHJlcG9z aXRvcnkgcHJvZHVjZXMgYmV0dGVyIHJlc3VsdHMuXG4iKTsKKwl3YXJuKCJUcnkgTGludXMgVG9y dmFsZHMnIGxhdGVzdCBnaXQgcmVwb3NpdG9yeSB1c2luZzpcbiIpOworCXdhcm4oImdpdCBjbG9u ZSBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2ZzL3hmcy94ZnN0ZXN0cy1kZXYuZ2l0XG4i KTsKKwkkcHJpbnRlZF9ub3ZjcyA9IDE7CisgICAgfQorICAgIHJldHVybiAwOworfQorCitzdWIg dmNzX2lzX2dpdCB7CisgICAgdmNzX2V4aXN0cygpOworICAgIHJldHVybiAkdmNzX3VzZWQgPT0g MTsKK30KKworc3ViIHZjc19pc19oZyB7CisgICAgcmV0dXJuICR2Y3NfdXNlZCA9PSAyOworfQor CitzdWIgdmNzX2FkZF9jb21taXRfc2lnbmVycyB7CisgICAgcmV0dXJuIGlmICghdmNzX2V4aXN0 cygpKTsKKworICAgIG15ICgkY29tbWl0LCAkZGVzYykgPSBAXzsKKyAgICBteSAkY29tbWl0X2Nv dW50ID0gMDsKKyAgICBteSAkY29tbWl0X2F1dGhvcnNfcmVmOworICAgIG15ICRjb21taXRfc2ln bmVyc19yZWY7CisgICAgbXkgJHN0YXRzX3JlZjsKKyAgICBteSBAY29tbWl0X2F1dGhvcnMgPSAo KTsKKyAgICBteSBAY29tbWl0X3NpZ25lcnMgPSAoKTsKKyAgICBteSAkY21kOworCisgICAgJGNt ZCA9ICRWQ1NfY21kc3siZmluZF9jb21taXRfc2lnbmVyc19jbWQifTsKKyAgICAkY21kID1+IHMv KFwkXHcrKS8kMS9lZWc7CSNzdWJzdGl0dXRlIHZhcmlhYmxlcyBpbiAkY21kCisKKyAgICAoJGNv bW1pdF9jb3VudCwgJGNvbW1pdF9zaWduZXJzX3JlZiwgJGNvbW1pdF9hdXRob3JzX3JlZiwgJHN0 YXRzX3JlZikgPSB2Y3NfZmluZF9zaWduZXJzKCRjbWQsICIiKTsKKyAgICBAY29tbWl0X2F1dGhv cnMgPSBAeyRjb21taXRfYXV0aG9yc19yZWZ9IGlmIGRlZmluZWQgJGNvbW1pdF9hdXRob3JzX3Jl ZjsKKyAgICBAY29tbWl0X3NpZ25lcnMgPSBAeyRjb21taXRfc2lnbmVyc19yZWZ9IGlmIGRlZmlu ZWQgJGNvbW1pdF9zaWduZXJzX3JlZjsKKworICAgIGZvcmVhY2ggbXkgJHNpZ25lciAoQGNvbW1p dF9zaWduZXJzKSB7CisJJHNpZ25lciA9IGRlZHVwbGljYXRlX2VtYWlsKCRzaWduZXIpOworICAg IH0KKworICAgIHZjc19hc3NpZ24oJGRlc2MsIDEsIEBjb21taXRfc2lnbmVycyk7Cit9CisKK3N1 YiBpbnRlcmFjdGl2ZV9nZXRfbWFpbnRhaW5lcnMgeworICAgIG15ICgkbGlzdF9yZWYpID0gQF87 CisgICAgbXkgQGxpc3QgPSBAJGxpc3RfcmVmOworCisgICAgdmNzX2V4aXN0cygpOworCisgICAg bXkgJXNlbGVjdGVkOworICAgIG15ICVhdXRob3JlZDsKKyAgICBteSAlc2lnbmVkOworICAgIG15 ICRjb3VudCA9IDA7CisgICAgbXkgJG1haW50YWluZWQgPSAwOworICAgIGZvcmVhY2ggbXkgJGVu dHJ5IChAbGlzdCkgeworCSRtYWludGFpbmVkID0gMSBpZiAoJGVudHJ5LT5bMV0gPX4gL14obWFp bnRhaW5lcnxzdXBwb3J0ZXIpL2kpOworCSRzZWxlY3RlZHskY291bnR9ID0gMTsKKwkkYXV0aG9y ZWR7JGNvdW50fSA9IDA7CisJJHNpZ25lZHskY291bnR9ID0gMDsKKwkkY291bnQrKzsKKyAgICB9 CisKKyAgICAjbWVudSBsb29wCisgICAgbXkgJGRvbmUgPSAwOworICAgIG15ICRwcmludF9vcHRp b25zID0gMDsKKyAgICBteSAkcmVkcmF3ID0gMTsKKyAgICB3aGlsZSAoISRkb25lKSB7CisJJGNv dW50ID0gMDsKKwlpZiAoJHJlZHJhdykgeworCSAgICBwcmludGYgU1RERVJSICJcbiUxcyAlMnMg JS02NXMiLAorCQkJICAiKiIsICIjIiwgImVtYWlsL2xpc3QgYW5kIHJvbGU6c3RhdHMiOworCSAg ICBpZiAoJGVtYWlsX2dpdCB8fAorCQkoJGVtYWlsX2dpdF9mYWxsYmFjayAmJiAhJG1haW50YWlu ZWQpIHx8CisJCSRlbWFpbF9naXRfYmxhbWUpIHsKKwkJcHJpbnQgU1RERVJSICJhdXRoIHNpZ24i OworCSAgICB9CisJICAgIHByaW50IFNUREVSUiAiXG4iOworCSAgICBmb3JlYWNoIG15ICRlbnRy eSAoQGxpc3QpIHsKKwkJbXkgJGVtYWlsID0gJGVudHJ5LT5bMF07CisJCW15ICRyb2xlID0gJGVu dHJ5LT5bMV07CisJCW15ICRzZWwgPSAiIjsKKwkJJHNlbCA9ICIqIiBpZiAoJHNlbGVjdGVkeyRj b3VudH0pOworCQlteSAkY29tbWl0X2F1dGhvciA9ICRjb21taXRfYXV0aG9yX2hhc2h7JGVtYWls fTsKKwkJbXkgJGNvbW1pdF9zaWduZXIgPSAkY29tbWl0X3NpZ25lcl9oYXNoeyRlbWFpbH07CisJ CW15ICRhdXRob3JlZCA9IDA7CisJCW15ICRzaWduZWQgPSAwOworCQkkYXV0aG9yZWQrKyBmb3Ig KEB7JGNvbW1pdF9hdXRob3J9KTsKKwkJJHNpZ25lZCsrIGZvciAoQHskY29tbWl0X3NpZ25lcn0p OworCQlwcmludGYgU1RERVJSICIlMXMgJTJkICUtNjVzIiwgJHNlbCwgJGNvdW50ICsgMSwgJGVt YWlsOworCQlwcmludGYgU1RERVJSICIlNGQgJTRkIiwgJGF1dGhvcmVkLCAkc2lnbmVkCisJCSAg ICBpZiAoJGF1dGhvcmVkID4gMCB8fCAkc2lnbmVkID4gMCk7CisJCXByaW50ZiBTVERFUlIgIlxu ICAgICAlc1xuIiwgJHJvbGU7CisJCWlmICgkYXV0aG9yZWR7JGNvdW50fSkgeworCQkgICAgbXkg JGNvbW1pdF9hdXRob3IgPSAkY29tbWl0X2F1dGhvcl9oYXNoeyRlbWFpbH07CisJCSAgICBmb3Jl YWNoIG15ICRyZWYgKEB7JGNvbW1pdF9hdXRob3J9KSB7CisJCQlwcmludCBTVERFUlIgIiAgICAg QXV0aG9yOiBAeyRyZWZ9WzFdXG4iOworCQkgICAgfQorCQl9CisJCWlmICgkc2lnbmVkeyRjb3Vu dH0pIHsKKwkJICAgIG15ICRjb21taXRfc2lnbmVyID0gJGNvbW1pdF9zaWduZXJfaGFzaHskZW1h aWx9OworCQkgICAgZm9yZWFjaCBteSAkcmVmIChAeyRjb21taXRfc2lnbmVyfSkgeworCQkJcHJp bnQgU1RERVJSICIgICAgIEB7JHJlZn1bMl06IEB7JHJlZn1bMV1cbiI7CisJCSAgICB9CisJCX0K KworCQkkY291bnQrKzsKKwkgICAgfQorCX0KKwlteSAkZGF0ZV9yZWYgPSBcJGVtYWlsX2dpdF9z aW5jZTsKKwkkZGF0ZV9yZWYgPSBcJGVtYWlsX2hnX3NpbmNlIGlmICh2Y3NfaXNfaGcoKSk7CisJ aWYgKCRwcmludF9vcHRpb25zKSB7CisJICAgICRwcmludF9vcHRpb25zID0gMDsKKwkgICAgaWYg KHZjc19leGlzdHMoKSkgeworCQlwcmludCBTVERFUlIgPDxFT1QKKworVmVyc2lvbiBDb250cm9s IG9wdGlvbnM6CitnICB1c2UgZ2l0IGhpc3RvcnkgICAgICBbJGVtYWlsX2dpdF0KK2dmIHVzZSBn aXQtZmFsbGJhY2sgICAgIFskZW1haWxfZ2l0X2ZhbGxiYWNrXQorYiAgdXNlIGdpdCBibGFtZSAg ICAgICAgWyRlbWFpbF9naXRfYmxhbWVdCiticyB1c2UgYmxhbWUgc2lnbmF0dXJlcyBbJGVtYWls X2dpdF9ibGFtZV9zaWduYXR1cmVzXQorYyMgbWluaW11bSBjb21taXRzICAgICAgWyRlbWFpbF9n aXRfbWluX3NpZ25hdHVyZXNdCislIyBtaW4gcGVyY2VudCAgICAgICAgICBbJGVtYWlsX2dpdF9t aW5fcGVyY2VudF0KK2QjIGhpc3RvcnkgdG8gdXNlICAgICAgIFskJGRhdGVfcmVmXQoreCMgbWF4 IG1haW50YWluZXJzICAgICAgWyRlbWFpbF9naXRfbWF4X21haW50YWluZXJzXQordCAgYWxsIHNp Z25hdHVyZSB0eXBlcyAgWyRlbWFpbF9naXRfYWxsX3NpZ25hdHVyZV90eXBlc10KK20gIHVzZSAu bWFpbG1hcCAgICAgICAgIFskZW1haWxfdXNlX21haWxtYXBdCitFT1QKKwkgICAgfQorCSAgICBw cmludCBTVERFUlIgPDxFT1QKKworQWRkaXRpb25hbCBvcHRpb25zOgorMCAgdG9nZ2xlIGFsbAor dG0gdG9nZ2xlIG1haW50YWluZXJzCit0ZyB0b2dnbGUgZ2l0IGVudHJpZXMKK3RsIHRvZ2dsZSBv cGVuIGxpc3QgZW50cmllcwordHMgdG9nZ2xlIHN1YnNjcmliZXIgbGlzdCBlbnRyaWVzCitmICBl bWFpbHMgaW4gZmlsZSAgICAgICBbJGVtYWlsX2ZpbGVfZW1haWxzXQorayAga2V5d29yZHMgaW4g ZmlsZSAgICAgWyRrZXl3b3Jkc10KK3IgIHJlbW92ZSBkdXBsaWNhdGVzICAgIFskZW1haWxfcmVt b3ZlX2R1cGxpY2F0ZXNdCitwIyBwYXR0ZXJuIG1hdGNoIGRlcHRoICBbJHBhdHRlcm5fZGVwdGhd CitFT1QKKwl9CisJcHJpbnQgU1RERVJSCisiXG4jKHRvZ2dsZSksIEEjKGF1dGhvciksIFMjKHNp Z25lZCkgKihhbGwpLCBeKG5vbmUpLCBPKG9wdGlvbnMpLCBZKGFwcHJvdmUpOiAiOworCisJbXkg JGlucHV0ID0gPFNURElOPjsKKwljaG9tcCgkaW5wdXQpOworCisJJHJlZHJhdyA9IDE7CisJbXkg JHJlcnVuID0gMDsKKwlteSBAd2lzaCA9IHNwbGl0KC9bLCBdKy8sICRpbnB1dCk7CisJZm9yZWFj aCBteSAkbnIgKEB3aXNoKSB7CisJICAgICRuciA9IGxjKCRucik7CisJICAgIG15ICRzZWwgPSBz dWJzdHIoJG5yLCAwLCAxKTsKKwkgICAgbXkgJHN0ciA9IHN1YnN0cigkbnIsIDEpOworCSAgICBt eSAkdmFsID0gMDsKKwkgICAgJHZhbCA9ICQxIGlmICRzdHIgPX4gL14oXGQrKSQvOworCisJICAg IGlmICgkc2VsIGVxICJ5IikgeworCQkkaW50ZXJhY3RpdmUgPSAwOworCQkkZG9uZSA9IDE7CisJ CSRvdXRwdXRfcm9sZXN0YXRzID0gMDsKKwkJJG91dHB1dF9yb2xlcyA9IDA7CisJCWxhc3Q7CisJ ICAgIH0gZWxzaWYgKCRuciA9fiAvXlxkKyQvICYmICRuciA+IDAgJiYgJG5yIDw9ICRjb3VudCkg eworCQkkc2VsZWN0ZWR7JG5yIC0gMX0gPSAhJHNlbGVjdGVkeyRuciAtIDF9OworCSAgICB9IGVs c2lmICgkc2VsIGVxICIqIiB8fCAkc2VsIGVxICdeJykgeworCQlteSAkdG9nZ2xlID0gMDsKKwkJ JHRvZ2dsZSA9IDEgaWYgKCRzZWwgZXEgJyonKTsKKwkJZm9yIChteSAkaSA9IDA7ICRpIDwgJGNv dW50OyAkaSsrKSB7CisJCSAgICAkc2VsZWN0ZWR7JGl9ID0gJHRvZ2dsZTsKKwkJfQorCSAgICB9 IGVsc2lmICgkc2VsIGVxICIwIikgeworCQlmb3IgKG15ICRpID0gMDsgJGkgPCAkY291bnQ7ICRp KyspIHsKKwkJICAgICRzZWxlY3RlZHskaX0gPSAhJHNlbGVjdGVkeyRpfTsKKwkJfQorCSAgICB9 IGVsc2lmICgkc2VsIGVxICJ0IikgeworCQlpZiAobGMoJHN0cikgZXEgIm0iKSB7CisJCSAgICBm b3IgKG15ICRpID0gMDsgJGkgPCAkY291bnQ7ICRpKyspIHsKKwkJCSRzZWxlY3RlZHskaX0gPSAh JHNlbGVjdGVkeyRpfQorCQkJICAgIGlmICgkbGlzdFskaV0tPlsxXSA9fiAvXihtYWludGFpbmVy fHN1cHBvcnRlcikvaSk7CisJCSAgICB9CisJCX0gZWxzaWYgKGxjKCRzdHIpIGVxICJnIikgewor CQkgICAgZm9yIChteSAkaSA9IDA7ICRpIDwgJGNvdW50OyAkaSsrKSB7CisJCQkkc2VsZWN0ZWR7 JGl9ID0gISRzZWxlY3RlZHskaX0KKwkJCSAgICBpZiAoJGxpc3RbJGldLT5bMV0gPX4gL14oYXV0 aG9yfGNvbW1pdHxzaWduZXIpL2kpOworCQkgICAgfQorCQl9IGVsc2lmIChsYygkc3RyKSBlcSAi bCIpIHsKKwkJICAgIGZvciAobXkgJGkgPSAwOyAkaSA8ICRjb3VudDsgJGkrKykgeworCQkJJHNl bGVjdGVkeyRpfSA9ICEkc2VsZWN0ZWR7JGl9CisJCQkgICAgaWYgKCRsaXN0WyRpXS0+WzFdID1+ IC9eKG9wZW4gbGlzdCkvaSk7CisJCSAgICB9CisJCX0gZWxzaWYgKGxjKCRzdHIpIGVxICJzIikg eworCQkgICAgZm9yIChteSAkaSA9IDA7ICRpIDwgJGNvdW50OyAkaSsrKSB7CisJCQkkc2VsZWN0 ZWR7JGl9ID0gISRzZWxlY3RlZHskaX0KKwkJCSAgICBpZiAoJGxpc3RbJGldLT5bMV0gPX4gL14o c3Vic2NyaWJlciBsaXN0KS9pKTsKKwkJICAgIH0KKwkJfQorCSAgICB9IGVsc2lmICgkc2VsIGVx ICJhIikgeworCQlpZiAoJHZhbCA+IDAgJiYgJHZhbCA8PSAkY291bnQpIHsKKwkJICAgICRhdXRo b3JlZHskdmFsIC0gMX0gPSAhJGF1dGhvcmVkeyR2YWwgLSAxfTsKKwkJfSBlbHNpZiAoJHN0ciBl cSAnKicgfHwgJHN0ciBlcSAnXicpIHsKKwkJICAgIG15ICR0b2dnbGUgPSAwOworCQkgICAgJHRv Z2dsZSA9IDEgaWYgKCRzdHIgZXEgJyonKTsKKwkJICAgIGZvciAobXkgJGkgPSAwOyAkaSA8ICRj b3VudDsgJGkrKykgeworCQkJJGF1dGhvcmVkeyRpfSA9ICR0b2dnbGU7CisJCSAgICB9CisJCX0K KwkgICAgfSBlbHNpZiAoJHNlbCBlcSAicyIpIHsKKwkJaWYgKCR2YWwgPiAwICYmICR2YWwgPD0g JGNvdW50KSB7CisJCSAgICAkc2lnbmVkeyR2YWwgLSAxfSA9ICEkc2lnbmVkeyR2YWwgLSAxfTsK KwkJfSBlbHNpZiAoJHN0ciBlcSAnKicgfHwgJHN0ciBlcSAnXicpIHsKKwkJICAgIG15ICR0b2dn bGUgPSAwOworCQkgICAgJHRvZ2dsZSA9IDEgaWYgKCRzdHIgZXEgJyonKTsKKwkJICAgIGZvciAo bXkgJGkgPSAwOyAkaSA8ICRjb3VudDsgJGkrKykgeworCQkJJHNpZ25lZHskaX0gPSAkdG9nZ2xl OworCQkgICAgfQorCQl9CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgIm8iKSB7CisJCSRwcmludF9v cHRpb25zID0gMTsKKwkJJHJlZHJhdyA9IDE7CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgImciKSB7 CisJCWlmICgkc3RyIGVxICJmIikgeworCQkgICAgYm9vbF9pbnZlcnQoXCRlbWFpbF9naXRfZmFs bGJhY2spOworCQl9IGVsc2UgeworCQkgICAgYm9vbF9pbnZlcnQoXCRlbWFpbF9naXQpOworCQl9 CisJCSRyZXJ1biA9IDE7CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgImIiKSB7CisJCWlmICgkc3Ry IGVxICJzIikgeworCQkgICAgYm9vbF9pbnZlcnQoXCRlbWFpbF9naXRfYmxhbWVfc2lnbmF0dXJl cyk7CisJCX0gZWxzZSB7CisJCSAgICBib29sX2ludmVydChcJGVtYWlsX2dpdF9ibGFtZSk7CisJ CX0KKwkJJHJlcnVuID0gMTsKKwkgICAgfSBlbHNpZiAoJHNlbCBlcSAiYyIpIHsKKwkJaWYgKCR2 YWwgPiAwKSB7CisJCSAgICAkZW1haWxfZ2l0X21pbl9zaWduYXR1cmVzID0gJHZhbDsKKwkJICAg ICRyZXJ1biA9IDE7CisJCX0KKwkgICAgfSBlbHNpZiAoJHNlbCBlcSAieCIpIHsKKwkJaWYgKCR2 YWwgPiAwKSB7CisJCSAgICAkZW1haWxfZ2l0X21heF9tYWludGFpbmVycyA9ICR2YWw7CisJCSAg ICAkcmVydW4gPSAxOworCQl9CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgIiUiKSB7CisJCWlmICgk c3RyIG5lICIiICYmICR2YWwgPj0gMCkgeworCQkgICAgJGVtYWlsX2dpdF9taW5fcGVyY2VudCA9 ICR2YWw7CisJCSAgICAkcmVydW4gPSAxOworCQl9CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgImQi KSB7CisJCWlmICh2Y3NfaXNfZ2l0KCkpIHsKKwkJICAgICRlbWFpbF9naXRfc2luY2UgPSAkc3Ry OworCQl9IGVsc2lmICh2Y3NfaXNfaGcoKSkgeworCQkgICAgJGVtYWlsX2hnX3NpbmNlID0gJHN0 cjsKKwkJfQorCQkkcmVydW4gPSAxOworCSAgICB9IGVsc2lmICgkc2VsIGVxICJ0IikgeworCQli b29sX2ludmVydChcJGVtYWlsX2dpdF9hbGxfc2lnbmF0dXJlX3R5cGVzKTsKKwkJJHJlcnVuID0g MTsKKwkgICAgfSBlbHNpZiAoJHNlbCBlcSAiZiIpIHsKKwkJYm9vbF9pbnZlcnQoXCRlbWFpbF9m aWxlX2VtYWlscyk7CisJCSRyZXJ1biA9IDE7CisJICAgIH0gZWxzaWYgKCRzZWwgZXEgInIiKSB7 CisJCWJvb2xfaW52ZXJ0KFwkZW1haWxfcmVtb3ZlX2R1cGxpY2F0ZXMpOworCQkkcmVydW4gPSAx OworCSAgICB9IGVsc2lmICgkc2VsIGVxICJtIikgeworCQlib29sX2ludmVydChcJGVtYWlsX3Vz ZV9tYWlsbWFwKTsKKwkJcmVhZF9tYWlsbWFwKCk7CisJCSRyZXJ1biA9IDE7CisJICAgIH0gZWxz aWYgKCRzZWwgZXEgImsiKSB7CisJCWJvb2xfaW52ZXJ0KFwka2V5d29yZHMpOworCQkkcmVydW4g PSAxOworCSAgICB9IGVsc2lmICgkc2VsIGVxICJwIikgeworCQlpZiAoJHN0ciBuZSAiIiAmJiAk dmFsID49IDApIHsKKwkJICAgICRwYXR0ZXJuX2RlcHRoID0gJHZhbDsKKwkJICAgICRyZXJ1biA9 IDE7CisJCX0KKwkgICAgfSBlbHNpZiAoJHNlbCBlcSAiaCIgfHwgJHNlbCBlcSAiPyIpIHsKKwkJ cHJpbnQgU1RERVJSIDw8RU9UCisKK0ludGVyYWN0aXZlIG1vZGUgYWxsb3dzIHlvdSB0byBzZWxl Y3QgdGhlIHZhcmlvdXMgbWFpbnRhaW5lcnMsIHN1Ym1pdHRlcnMsCitjb21taXQgc2lnbmVycyBh bmQgbWFpbGluZyBsaXN0cyB0aGF0IGNvdWxkIGJlIENDJ2Qgb24gYSBwYXRjaC4KKworQW55ICon ZCBlbnRyeSBpcyBzZWxlY3RlZC4KKworSWYgeW91IGhhdmUgZ2l0IG9yIGhnIGluc3RhbGxlZCwg eW91IGNhbiBjaG9vc2UgdG8gc3VtbWFyaXplIHRoZSBjb21taXQKK2hpc3Rvcnkgb2YgZmlsZXMg aW4gdGhlIHBhdGNoLiAgQWxzbywgZWFjaCBsaW5lIG9mIHRoZSBjdXJyZW50IGZpbGUgY2FuCiti ZSBtYXRjaGVkIHRvIGl0cyBjb21taXQgYXV0aG9yIGFuZCB0aGF0IGNvbW1pdHMgc2lnbmVycyB3 aXRoIGJsYW1lLgorCitWYXJpb3VzIGtub2JzIGV4aXN0IHRvIGNvbnRyb2wgdGhlIGxlbmd0aCBv ZiB0aW1lIGZvciBhY3RpdmUgY29tbWl0Cit0cmFja2luZywgdGhlIG1heGltdW0gbnVtYmVyIG9m IGNvbW1pdCBhdXRob3JzIGFuZCBzaWduZXJzIHRvIGFkZCwKK2FuZCBzdWNoLgorCitFbnRlciBz ZWxlY3Rpb25zIGF0IHRoZSBwcm9tcHQgdW50aWwgeW91IGFyZSBzYXRpc2ZpZWQgdGhhdCB0aGUg c2VsZWN0ZWQKK21haW50YWluZXJzIGFyZSBhcHByb3ByaWF0ZS4gIFlvdSBtYXkgZW50ZXIgbXVs dGlwbGUgc2VsZWN0aW9ucyBzZXBhcmF0ZWQKK2J5IGVpdGhlciBjb21tYXMgb3Igc3BhY2VzLgor CitFT1QKKwkgICAgfSBlbHNlIHsKKwkJcHJpbnQgU1RERVJSICJpbnZhbGlkIG9wdGlvbjogJyRu cidcbiI7CisJCSRyZWRyYXcgPSAwOworCSAgICB9CisJfQorCWlmICgkcmVydW4pIHsKKwkgICAg cHJpbnQgU1RERVJSICJnaXQtYmxhbWUgY2FuIGJlIHZlcnkgc2xvdywgcGxlYXNlIGhhdmUgcGF0 aWVuY2UuLi4iCisJCWlmICgkZW1haWxfZ2l0X2JsYW1lKTsKKwkgICAgZ290byAmZ2V0X21haW50 YWluZXJzOworCX0KKyAgICB9CisKKyAgICAjZHJvcCBub3Qgc2VsZWN0ZWQgZW50cmllcworICAg ICRjb3VudCA9IDA7CisgICAgbXkgQG5ld19lbWFpbHRvID0gKCk7CisgICAgZm9yZWFjaCBteSAk ZW50cnkgKEBsaXN0KSB7CisJaWYgKCRzZWxlY3RlZHskY291bnR9KSB7CisJICAgIHB1c2goQG5l d19lbWFpbHRvLCAkbGlzdFskY291bnRdKTsKKwl9CisJJGNvdW50Kys7CisgICAgfQorICAgIHJl dHVybiBAbmV3X2VtYWlsdG87Cit9CisKK3N1YiBib29sX2ludmVydCB7CisgICAgbXkgKCRib29s X3JlZikgPSBAXzsKKworICAgIGlmICgkJGJvb2xfcmVmKSB7CisJJCRib29sX3JlZiA9IDA7Cisg ICAgfSBlbHNlIHsKKwkkJGJvb2xfcmVmID0gMTsKKyAgICB9Cit9CisKK3N1YiBkZWR1cGxpY2F0 ZV9lbWFpbCB7CisgICAgbXkgKCRlbWFpbCkgPSBAXzsKKworICAgIG15ICRtYXRjaGVkID0gMDsK KyAgICBteSAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRlbWFpbCk7CisgICAgJGVt YWlsID0gZm9ybWF0X2VtYWlsKCRuYW1lLCAkYWRkcmVzcywgMSk7CisgICAgJGVtYWlsID0gbWFp bG1hcF9lbWFpbCgkZW1haWwpOworCisgICAgcmV0dXJuICRlbWFpbCBpZiAoISRlbWFpbF9yZW1v dmVfZHVwbGljYXRlcyk7CisKKyAgICAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRl bWFpbCk7CisKKyAgICBpZiAoJG5hbWUgbmUgIiIgJiYgJGRlZHVwbGljYXRlX25hbWVfaGFzaHts YygkbmFtZSl9KSB7CisJJG5hbWUgPSAkZGVkdXBsaWNhdGVfbmFtZV9oYXNoe2xjKCRuYW1lKX0t PlswXTsKKwkkYWRkcmVzcyA9ICRkZWR1cGxpY2F0ZV9uYW1lX2hhc2h7bGMoJG5hbWUpfS0+WzFd OworCSRtYXRjaGVkID0gMTsKKyAgICB9IGVsc2lmICgkZGVkdXBsaWNhdGVfYWRkcmVzc19oYXNo e2xjKCRhZGRyZXNzKX0pIHsKKwkkbmFtZSA9ICRkZWR1cGxpY2F0ZV9hZGRyZXNzX2hhc2h7bGMo JGFkZHJlc3MpfS0+WzBdOworCSRhZGRyZXNzID0gJGRlZHVwbGljYXRlX2FkZHJlc3NfaGFzaHts YygkYWRkcmVzcyl9LT5bMV07CisJJG1hdGNoZWQgPSAxOworICAgIH0KKyAgICBpZiAoISRtYXRj aGVkKSB7CisJJGRlZHVwbGljYXRlX25hbWVfaGFzaHtsYygkbmFtZSl9ID0gWyAkbmFtZSwgJGFk ZHJlc3MgXTsKKwkkZGVkdXBsaWNhdGVfYWRkcmVzc19oYXNoe2xjKCRhZGRyZXNzKX0gPSBbICRu YW1lLCAkYWRkcmVzcyBdOworICAgIH0KKyAgICAkZW1haWwgPSBmb3JtYXRfZW1haWwoJG5hbWUs ICRhZGRyZXNzLCAxKTsKKyAgICAkZW1haWwgPSBtYWlsbWFwX2VtYWlsKCRlbWFpbCk7CisgICAg cmV0dXJuICRlbWFpbDsKK30KKworc3ViIHNhdmVfY29tbWl0c19ieV9hdXRob3IgeworICAgIG15 IChAbGluZXMpID0gQF87CisKKyAgICBteSBAYXV0aG9ycyA9ICgpOworICAgIG15IEBjb21taXRz ID0gKCk7CisgICAgbXkgQHN1YmplY3RzID0gKCk7CisKKyAgICBmb3JlYWNoIG15ICRsaW5lIChA bGluZXMpIHsKKwlpZiAoJGxpbmUgPX4gbS8kVkNTX2NtZHN7ImF1dGhvcl9wYXR0ZXJuIn0vKSB7 CisJICAgIG15ICRhdXRob3IgPSAkMTsKKwkgICAgJGF1dGhvciA9IGRlZHVwbGljYXRlX2VtYWls KCRhdXRob3IpOworCSAgICBwdXNoKEBhdXRob3JzLCAkYXV0aG9yKTsKKwl9CisJcHVzaChAY29t bWl0cywgJDEpIGlmICgkbGluZSA9fiBtLyRWQ1NfY21kc3siY29tbWl0X3BhdHRlcm4ifS8pOwor CXB1c2goQHN1YmplY3RzLCAkMSkgaWYgKCRsaW5lID1+IG0vJFZDU19jbWRzeyJzdWJqZWN0X3Bh dHRlcm4ifS8pOworICAgIH0KKworICAgIGZvciAobXkgJGkgPSAwOyAkaSA8IEBhdXRob3JzOyAk aSsrKSB7CisJbXkgJGV4aXN0cyA9IDA7CisJZm9yZWFjaCBteSAkcmVmKEB7JGNvbW1pdF9hdXRo b3JfaGFzaHskYXV0aG9yc1skaV19fSkgeworCSAgICBpZiAoQHskcmVmfVswXSBlcSAkY29tbWl0 c1skaV0gJiYKKwkJQHskcmVmfVsxXSBlcSAkc3ViamVjdHNbJGldKSB7CisJCSRleGlzdHMgPSAx OworCQlsYXN0OworCSAgICB9CisJfQorCWlmICghJGV4aXN0cykgeworCSAgICBwdXNoKEB7JGNv bW1pdF9hdXRob3JfaGFzaHskYXV0aG9yc1skaV19fSwKKwkJIFsgKCRjb21taXRzWyRpXSwgJHN1 YmplY3RzWyRpXSkgXSk7CisJfQorICAgIH0KK30KKworc3ViIHNhdmVfY29tbWl0c19ieV9zaWdu ZXIgeworICAgIG15IChAbGluZXMpID0gQF87CisKKyAgICBteSAkY29tbWl0ID0gIiI7CisgICAg bXkgJHN1YmplY3QgPSAiIjsKKworICAgIGZvcmVhY2ggbXkgJGxpbmUgKEBsaW5lcykgeworCSRj b21taXQgPSAkMSBpZiAoJGxpbmUgPX4gbS8kVkNTX2NtZHN7ImNvbW1pdF9wYXR0ZXJuIn0vKTsK Kwkkc3ViamVjdCA9ICQxIGlmICgkbGluZSA9fiBtLyRWQ1NfY21kc3sic3ViamVjdF9wYXR0ZXJu In0vKTsKKwlpZiAoJGxpbmUgPX4gL15bIFx0XSoke3NpZ25hdHVyZV9wYXR0ZXJufS4qXEAuKiQv KSB7CisJICAgIG15IEBzaWduYXR1cmVzID0gKCRsaW5lKTsKKwkgICAgbXkgKCR0eXBlc19yZWYs ICRzaWduZXJzX3JlZikgPSBleHRyYWN0X2Zvcm1hdHRlZF9zaWduYXR1cmVzKEBzaWduYXR1cmVz KTsKKwkgICAgbXkgQHR5cGVzID0gQCR0eXBlc19yZWY7CisJICAgIG15IEBzaWduZXJzID0gQCRz aWduZXJzX3JlZjsKKworCSAgICBteSAkdHlwZSA9ICR0eXBlc1swXTsKKwkgICAgbXkgJHNpZ25l ciA9ICRzaWduZXJzWzBdOworCisJICAgICRzaWduZXIgPSBkZWR1cGxpY2F0ZV9lbWFpbCgkc2ln bmVyKTsKKworCSAgICBteSAkZXhpc3RzID0gMDsKKwkgICAgZm9yZWFjaCBteSAkcmVmKEB7JGNv bW1pdF9zaWduZXJfaGFzaHskc2lnbmVyfX0pIHsKKwkJaWYgKEB7JHJlZn1bMF0gZXEgJGNvbW1p dCAmJgorCQkgICAgQHskcmVmfVsxXSBlcSAkc3ViamVjdCAmJgorCQkgICAgQHskcmVmfVsyXSBl cSAkdHlwZSkgeworCQkgICAgJGV4aXN0cyA9IDE7CisJCSAgICBsYXN0OworCQl9CisJICAgIH0K KwkgICAgaWYgKCEkZXhpc3RzKSB7CisJCXB1c2goQHskY29tbWl0X3NpZ25lcl9oYXNoeyRzaWdu ZXJ9fSwKKwkJICAgICBbICgkY29tbWl0LCAkc3ViamVjdCwgJHR5cGUpIF0pOworCSAgICB9CisJ fQorICAgIH0KK30KKworc3ViIHZjc19hc3NpZ24geworICAgIG15ICgkcm9sZSwgJGRpdmlzb3Is IEBsaW5lcykgPSBAXzsKKworICAgIG15ICVoYXNoOworICAgIG15ICRjb3VudCA9IDA7CisKKyAg ICByZXR1cm4gaWYgKEBsaW5lcyA8PSAwKTsKKworICAgIGlmICgkZGl2aXNvciA8PSAwKSB7CisJ d2FybigiQmFkIGRpdmlzb3IgaW4gIiAuIChjYWxsZXIoMCkpWzNdIC4gIjogJGRpdmlzb3JcbiIp OworCSRkaXZpc29yID0gMTsKKyAgICB9CisKKyAgICBAbGluZXMgPSBtYWlsbWFwKEBsaW5lcyk7 CisKKyAgICByZXR1cm4gaWYgKEBsaW5lcyA8PSAwKTsKKworICAgIEBsaW5lcyA9IHNvcnQoQGxp bmVzKTsKKworICAgICMgdW5pcSAtYworICAgICRoYXNoeyRffSsrIGZvciBAbGluZXM7CisKKyAg ICAjIHNvcnQgLXJuCisgICAgZm9yZWFjaCBteSAkbGluZSAoc29ydCB7JGhhc2h7JGJ9IDw9PiAk aGFzaHskYX19IGtleXMgJWhhc2gpIHsKKwlteSAkc2lnbl9vZmZzID0gJGhhc2h7JGxpbmV9Owor CW15ICRwZXJjZW50ID0gJHNpZ25fb2ZmcyAqIDEwMCAvICRkaXZpc29yOworCisJJHBlcmNlbnQg PSAxMDAgaWYgKCRwZXJjZW50ID4gMTAwKTsKKwluZXh0IGlmIChpZ25vcmVfZW1haWxfYWRkcmVz cygkbGluZSkpOworCSRjb3VudCsrOworCWxhc3QgaWYgKCRzaWduX29mZnMgPCAkZW1haWxfZ2l0 X21pbl9zaWduYXR1cmVzIHx8CisJCSAkY291bnQgPiAkZW1haWxfZ2l0X21heF9tYWludGFpbmVy cyB8fAorCQkgJHBlcmNlbnQgPCAkZW1haWxfZ2l0X21pbl9wZXJjZW50KTsKKwlwdXNoX2VtYWls X2FkZHJlc3MoJGxpbmUsICcnKTsKKwlpZiAoJG91dHB1dF9yb2xlc3RhdHMpIHsKKwkgICAgbXkg JGZtdF9wZXJjZW50ID0gc3ByaW50ZigiJS4wZiIsICRwZXJjZW50KTsKKwkgICAgYWRkX3JvbGUo JGxpbmUsICIkcm9sZTokc2lnbl9vZmZzLyRkaXZpc29yPSRmbXRfcGVyY2VudCUiKTsKKwl9IGVs c2UgeworCSAgICBhZGRfcm9sZSgkbGluZSwgJHJvbGUpOworCX0KKyAgICB9Cit9CisKK3N1YiB2 Y3NfZmlsZV9zaWdub2ZmcyB7CisgICAgbXkgKCRmaWxlKSA9IEBfOworCisgICAgbXkgJGF1dGhv cnNfcmVmOworICAgIG15ICRzaWduZXJzX3JlZjsKKyAgICBteSAkc3RhdHNfcmVmOworICAgIG15 IEBhdXRob3JzID0gKCk7CisgICAgbXkgQHNpZ25lcnMgPSAoKTsKKyAgICBteSBAc3RhdHMgPSAo KTsKKyAgICBteSAkY29tbWl0czsKKworICAgICR2Y3NfdXNlZCA9IHZjc19leGlzdHMoKTsKKyAg ICByZXR1cm4gaWYgKCEkdmNzX3VzZWQpOworCisgICAgbXkgJGNtZCA9ICRWQ1NfY21kc3siZmlu ZF9zaWduZXJzX2NtZCJ9OworICAgICRjbWQgPX4gcy8oXCRcdyspLyQxL2VlZzsJCSMgaW50ZXJw b2xhdGUgJGNtZAorCisgICAgKCRjb21taXRzLCAkc2lnbmVyc19yZWYsICRhdXRob3JzX3JlZiwg JHN0YXRzX3JlZikgPSB2Y3NfZmluZF9zaWduZXJzKCRjbWQsICRmaWxlKTsKKworICAgIEBzaWdu ZXJzID0gQHskc2lnbmVyc19yZWZ9IGlmIGRlZmluZWQgJHNpZ25lcnNfcmVmOworICAgIEBhdXRo b3JzID0gQHskYXV0aG9yc19yZWZ9IGlmIGRlZmluZWQgJGF1dGhvcnNfcmVmOworICAgIEBzdGF0 cyA9IEB7JHN0YXRzX3JlZn0gaWYgZGVmaW5lZCAkc3RhdHNfcmVmOworCisjICAgIHByaW50KCJj b21taXRzOiA8JGNvbW1pdHM+XG5zaWduZXJzOjxAc2lnbmVycz5cbmF1dGhvcnM6IDxAYXV0aG9y cz5cbnN0YXRzOiA8QHN0YXRzPlxuIik7CisKKyAgICBmb3JlYWNoIG15ICRzaWduZXIgKEBzaWdu ZXJzKSB7CisJJHNpZ25lciA9IGRlZHVwbGljYXRlX2VtYWlsKCRzaWduZXIpOworICAgIH0KKwor ICAgIHZjc19hc3NpZ24oImNvbW1pdF9zaWduZXIiLCAkY29tbWl0cywgQHNpZ25lcnMpOworICAg IHZjc19hc3NpZ24oImF1dGhvcmVkIiwgJGNvbW1pdHMsIEBhdXRob3JzKTsKKyAgICBpZiAoJCNh dXRob3JzID09ICQjc3RhdHMpIHsKKwlteSAkc3RhdF9wYXR0ZXJuID0gJFZDU19jbWRzeyJzdGF0 X3BhdHRlcm4ifTsKKwkkc3RhdF9wYXR0ZXJuID1+IHMvKFwkXHcrKS8kMS9lZWc7CSNpbnRlcnBv bGF0ZSAkc3RhdF9wYXR0ZXJuCisKKwlteSAkYWRkZWQgPSAwOworCW15ICRkZWxldGVkID0gMDsK Kwlmb3IgKG15ICRpID0gMDsgJGkgPD0gJCNzdGF0czsgJGkrKykgeworCSAgICBpZiAoJHN0YXRz WyRpXSA9fiAvJHN0YXRfcGF0dGVybi8pIHsKKwkJJGFkZGVkICs9ICQxOworCQkkZGVsZXRlZCAr PSAkMjsKKwkgICAgfQorCX0KKwlteSBAdG1wX2F1dGhvcnMgPSB1bmlxKEBhdXRob3JzKTsKKwlm b3JlYWNoIG15ICRhdXRob3IgKEB0bXBfYXV0aG9ycykgeworCSAgICAkYXV0aG9yID0gZGVkdXBs aWNhdGVfZW1haWwoJGF1dGhvcik7CisJfQorCUB0bXBfYXV0aG9ycyA9IHVuaXEoQHRtcF9hdXRo b3JzKTsKKwlteSBAbGlzdF9hZGRlZCA9ICgpOworCW15IEBsaXN0X2RlbGV0ZWQgPSAoKTsKKwlm b3JlYWNoIG15ICRhdXRob3IgKEB0bXBfYXV0aG9ycykgeworCSAgICBteSAkYXV0aF9hZGRlZCA9 IDA7CisJICAgIG15ICRhdXRoX2RlbGV0ZWQgPSAwOworCSAgICBmb3IgKG15ICRpID0gMDsgJGkg PD0gJCNzdGF0czsgJGkrKykgeworCQlpZiAoJGF1dGhvciBlcSBkZWR1cGxpY2F0ZV9lbWFpbCgk YXV0aG9yc1skaV0pICYmCisJCSAgICAkc3RhdHNbJGldID1+IC8kc3RhdF9wYXR0ZXJuLykgewor CQkgICAgJGF1dGhfYWRkZWQgKz0gJDE7CisJCSAgICAkYXV0aF9kZWxldGVkICs9ICQyOworCQl9 CisJICAgIH0KKwkgICAgZm9yIChteSAkaSA9IDA7ICRpIDwgJGF1dGhfYWRkZWQ7ICRpKyspIHsK KwkJcHVzaChAbGlzdF9hZGRlZCwgJGF1dGhvcik7CisJICAgIH0KKwkgICAgZm9yIChteSAkaSA9 IDA7ICRpIDwgJGF1dGhfZGVsZXRlZDsgJGkrKykgeworCQlwdXNoKEBsaXN0X2RlbGV0ZWQsICRh dXRob3IpOworCSAgICB9CisJfQorCXZjc19hc3NpZ24oImFkZGVkX2xpbmVzIiwgJGFkZGVkLCBA bGlzdF9hZGRlZCk7CisJdmNzX2Fzc2lnbigicmVtb3ZlZF9saW5lcyIsICRkZWxldGVkLCBAbGlz dF9kZWxldGVkKTsKKyAgICB9Cit9CisKK3N1YiB2Y3NfZmlsZV9ibGFtZSB7CisgICAgbXkgKCRm aWxlKSA9IEBfOworCisgICAgbXkgQHNpZ25lcnMgPSAoKTsKKyAgICBteSBAYWxsX2NvbW1pdHMg PSAoKTsKKyAgICBteSBAY29tbWl0cyA9ICgpOworICAgIG15ICR0b3RhbF9jb21taXRzOworICAg IG15ICR0b3RhbF9saW5lczsKKworICAgICR2Y3NfdXNlZCA9IHZjc19leGlzdHMoKTsKKyAgICBy ZXR1cm4gaWYgKCEkdmNzX3VzZWQpOworCisgICAgQGFsbF9jb21taXRzID0gdmNzX2JsYW1lKCRm aWxlKTsKKyAgICBAY29tbWl0cyA9IHVuaXEoQGFsbF9jb21taXRzKTsKKyAgICAkdG90YWxfY29t bWl0cyA9IEBjb21taXRzOworICAgICR0b3RhbF9saW5lcyA9IEBhbGxfY29tbWl0czsKKworICAg IGlmICgkZW1haWxfZ2l0X2JsYW1lX3NpZ25hdHVyZXMpIHsKKwlpZiAodmNzX2lzX2hnKCkpIHsK KwkgICAgbXkgJGNvbW1pdF9jb3VudDsKKwkgICAgbXkgJGNvbW1pdF9hdXRob3JzX3JlZjsKKwkg ICAgbXkgJGNvbW1pdF9zaWduZXJzX3JlZjsKKwkgICAgbXkgJHN0YXRzX3JlZjsKKwkgICAgbXkg QGNvbW1pdF9hdXRob3JzID0gKCk7CisJICAgIG15IEBjb21taXRfc2lnbmVycyA9ICgpOworCSAg ICBteSAkY29tbWl0ID0gam9pbigiIC1yICIsIEBjb21taXRzKTsKKwkgICAgbXkgJGNtZDsKKwor CSAgICAkY21kID0gJFZDU19jbWRzeyJmaW5kX2NvbW1pdF9zaWduZXJzX2NtZCJ9OworCSAgICAk Y21kID1+IHMvKFwkXHcrKS8kMS9lZWc7CSNzdWJzdGl0dXRlIHZhcmlhYmxlcyBpbiAkY21kCisK KwkgICAgKCRjb21taXRfY291bnQsICRjb21taXRfc2lnbmVyc19yZWYsICRjb21taXRfYXV0aG9y c19yZWYsICRzdGF0c19yZWYpID0gdmNzX2ZpbmRfc2lnbmVycygkY21kLCAkZmlsZSk7CisJICAg IEBjb21taXRfYXV0aG9ycyA9IEB7JGNvbW1pdF9hdXRob3JzX3JlZn0gaWYgZGVmaW5lZCAkY29t bWl0X2F1dGhvcnNfcmVmOworCSAgICBAY29tbWl0X3NpZ25lcnMgPSBAeyRjb21taXRfc2lnbmVy c19yZWZ9IGlmIGRlZmluZWQgJGNvbW1pdF9zaWduZXJzX3JlZjsKKworCSAgICBwdXNoKEBzaWdu ZXJzLCBAY29tbWl0X3NpZ25lcnMpOworCX0gZWxzZSB7CisJICAgIGZvcmVhY2ggbXkgJGNvbW1p dCAoQGNvbW1pdHMpIHsKKwkJbXkgJGNvbW1pdF9jb3VudDsKKwkJbXkgJGNvbW1pdF9hdXRob3Jz X3JlZjsKKwkJbXkgJGNvbW1pdF9zaWduZXJzX3JlZjsKKwkJbXkgJHN0YXRzX3JlZjsKKwkJbXkg QGNvbW1pdF9hdXRob3JzID0gKCk7CisJCW15IEBjb21taXRfc2lnbmVycyA9ICgpOworCQlteSAk Y21kOworCisJCSRjbWQgPSAkVkNTX2NtZHN7ImZpbmRfY29tbWl0X3NpZ25lcnNfY21kIn07CisJ CSRjbWQgPX4gcy8oXCRcdyspLyQxL2VlZzsJI3N1YnN0aXR1dGUgdmFyaWFibGVzIGluICRjbWQK KworCQkoJGNvbW1pdF9jb3VudCwgJGNvbW1pdF9zaWduZXJzX3JlZiwgJGNvbW1pdF9hdXRob3Jz X3JlZiwgJHN0YXRzX3JlZikgPSB2Y3NfZmluZF9zaWduZXJzKCRjbWQsICRmaWxlKTsKKwkJQGNv bW1pdF9hdXRob3JzID0gQHskY29tbWl0X2F1dGhvcnNfcmVmfSBpZiBkZWZpbmVkICRjb21taXRf YXV0aG9yc19yZWY7CisJCUBjb21taXRfc2lnbmVycyA9IEB7JGNvbW1pdF9zaWduZXJzX3JlZn0g aWYgZGVmaW5lZCAkY29tbWl0X3NpZ25lcnNfcmVmOworCisJCXB1c2goQHNpZ25lcnMsIEBjb21t aXRfc2lnbmVycyk7CisJICAgIH0KKwl9CisgICAgfQorCisgICAgaWYgKCRmcm9tX2ZpbGVuYW1l KSB7CisJaWYgKCRvdXRwdXRfcm9sZXN0YXRzKSB7CisJICAgIG15IEBibGFtZV9zaWduZXJzOwor CSAgICBpZiAodmNzX2lzX2hnKCkpIHt7CQkjIERvdWJsZSBicmFjZSBmb3IgbGFzdCBleGl0CisJ CW15ICRjb21taXRfY291bnQ7CisJCW15IEBjb21taXRfc2lnbmVycyA9ICgpOworCQlAY29tbWl0 cyA9IHVuaXEoQGNvbW1pdHMpOworCQlAY29tbWl0cyA9IHNvcnQoQGNvbW1pdHMpOworCQlteSAk Y29tbWl0ID0gam9pbigiIC1yICIsIEBjb21taXRzKTsKKwkJbXkgJGNtZDsKKworCQkkY21kID0g JFZDU19jbWRzeyJmaW5kX2NvbW1pdF9hdXRob3JfY21kIn07CisJCSRjbWQgPX4gcy8oXCRcdysp LyQxL2VlZzsJI3N1YnN0aXR1dGUgdmFyaWFibGVzIGluICRjbWQKKworCQlteSBAbGluZXMgPSAo KTsKKworCQlAbGluZXMgPSAmeyRWQ1NfY21kc3siZXhlY3V0ZV9jbWQifX0oJGNtZCk7CisKKwkJ aWYgKCEkZW1haWxfZ2l0X3Blbmd1aW5fY2hpZWZzKSB7CisJCSAgICBAbGluZXMgPSBncmVwKCEv JHtwZW5ndWluX2NoaWVmc30vaSwgQGxpbmVzKTsKKwkJfQorCisJCWxhc3QgaWYgIUBsaW5lczsK KworCQlteSBAYXV0aG9ycyA9ICgpOworCQlmb3JlYWNoIG15ICRsaW5lIChAbGluZXMpIHsKKwkJ ICAgIGlmICgkbGluZSA9fiBtLyRWQ1NfY21kc3siYXV0aG9yX3BhdHRlcm4ifS8pIHsKKwkJCW15 ICRhdXRob3IgPSAkMTsKKwkJCSRhdXRob3IgPSBkZWR1cGxpY2F0ZV9lbWFpbCgkYXV0aG9yKTsK KwkJCXB1c2goQGF1dGhvcnMsICRhdXRob3IpOworCQkgICAgfQorCQl9CisKKwkJc2F2ZV9jb21t aXRzX2J5X2F1dGhvcihAbGluZXMpIGlmICgkaW50ZXJhY3RpdmUpOworCQlzYXZlX2NvbW1pdHNf Ynlfc2lnbmVyKEBsaW5lcykgaWYgKCRpbnRlcmFjdGl2ZSk7CisKKwkJcHVzaChAc2lnbmVycywg QGF1dGhvcnMpOworCSAgICB9fQorCSAgICBlbHNlIHsKKwkJZm9yZWFjaCBteSAkY29tbWl0IChA Y29tbWl0cykgeworCQkgICAgbXkgJGk7CisJCSAgICBteSAkY21kID0gJFZDU19jbWRzeyJmaW5k X2NvbW1pdF9hdXRob3JfY21kIn07CisJCSAgICAkY21kID1+IHMvKFwkXHcrKS8kMS9lZWc7CSNp bnRlcnBvbGF0ZSAkY21kCisJCSAgICBteSBAYXV0aG9yID0gdmNzX2ZpbmRfYXV0aG9yKCRjbWQp OworCQkgICAgbmV4dCBpZiAhQGF1dGhvcjsKKworCQkgICAgbXkgJGZvcm1hdHRlZF9hdXRob3Ig PSBkZWR1cGxpY2F0ZV9lbWFpbCgkYXV0aG9yWzBdKTsKKworCQkgICAgbXkgJGNvdW50ID0gZ3Jl cCgvJGNvbW1pdC8sIEBhbGxfY29tbWl0cyk7CisJCSAgICBmb3IgKCRpID0gMDsgJGkgPCAkY291 bnQgOyAkaSsrKSB7CisJCQlwdXNoKEBibGFtZV9zaWduZXJzLCAkZm9ybWF0dGVkX2F1dGhvcik7 CisJCSAgICB9CisJCX0KKwkgICAgfQorCSAgICBpZiAoQGJsYW1lX3NpZ25lcnMpIHsKKwkJdmNz X2Fzc2lnbigiYXV0aG9yZWQgbGluZXMiLCAkdG90YWxfbGluZXMsIEBibGFtZV9zaWduZXJzKTsK KwkgICAgfQorCX0KKwlmb3JlYWNoIG15ICRzaWduZXIgKEBzaWduZXJzKSB7CisJICAgICRzaWdu ZXIgPSBkZWR1cGxpY2F0ZV9lbWFpbCgkc2lnbmVyKTsKKwl9CisJdmNzX2Fzc2lnbigiY29tbWl0 cyIsICR0b3RhbF9jb21taXRzLCBAc2lnbmVycyk7CisgICAgfSBlbHNlIHsKKwlmb3JlYWNoIG15 ICRzaWduZXIgKEBzaWduZXJzKSB7CisJICAgICRzaWduZXIgPSBkZWR1cGxpY2F0ZV9lbWFpbCgk c2lnbmVyKTsKKwl9CisJdmNzX2Fzc2lnbigibW9kaWZpZWQgY29tbWl0cyIsICR0b3RhbF9jb21t aXRzLCBAc2lnbmVycyk7CisgICAgfQorfQorCitzdWIgdmNzX2ZpbGVfZXhpc3RzIHsKKyAgICBt eSAoJGZpbGUpID0gQF87CisKKyAgICBteSAkZXhpc3RzOworCisgICAgbXkgJHZjc191c2VkID0g dmNzX2V4aXN0cygpOworICAgIHJldHVybiAwIGlmICghJHZjc191c2VkKTsKKworICAgIG15ICRj bWQgPSAkVkNTX2NtZHN7ImZpbGVfZXhpc3RzX2NtZCJ9OworICAgICRjbWQgPX4gcy8oXCRcdysp LyQxL2VlZzsJCSMgaW50ZXJwb2xhdGUgJGNtZAorICAgICRjbWQgLj0gIiAyPiYxIjsKKyAgICAk ZXhpc3RzID0gJnskVkNTX2NtZHN7ImV4ZWN1dGVfY21kIn19KCRjbWQpOworCisgICAgcmV0dXJu IDAgaWYgKCQ/ICE9IDApOworCisgICAgcmV0dXJuICRleGlzdHM7Cit9CisKK3N1YiB2Y3NfbGlz dF9maWxlcyB7CisgICAgbXkgKCRmaWxlKSA9IEBfOworCisgICAgbXkgQGxzZmlsZXMgPSAoKTsK KworICAgIG15ICR2Y3NfdXNlZCA9IHZjc19leGlzdHMoKTsKKyAgICByZXR1cm4gMCBpZiAoISR2 Y3NfdXNlZCk7CisKKyAgICBteSAkY21kID0gJFZDU19jbWRzeyJsaXN0X2ZpbGVzX2NtZCJ9Owor ICAgICRjbWQgPX4gcy8oXCRcdyspLyQxL2VlZzsgICAjIGludGVycG9sYXRlICRjbWQKKyAgICBA bHNmaWxlcyA9ICZ7JFZDU19jbWRzeyJleGVjdXRlX2NtZCJ9fSgkY21kKTsKKworICAgIHJldHVy biAoKSBpZiAoJD8gIT0gMCk7CisKKyAgICByZXR1cm4gQGxzZmlsZXM7Cit9CisKK3N1YiB1bmlx IHsKKyAgICBteSAoQHBhcm1zKSA9IEBfOworCisgICAgbXkgJXNhdzsKKyAgICBAcGFybXMgPSBn cmVwKCEkc2F3eyRffSsrLCBAcGFybXMpOworICAgIHJldHVybiBAcGFybXM7Cit9CisKK3N1YiBz b3J0X2FuZF91bmlxIHsKKyAgICBteSAoQHBhcm1zKSA9IEBfOworCisgICAgbXkgJXNhdzsKKyAg ICBAcGFybXMgPSBzb3J0IEBwYXJtczsKKyAgICBAcGFybXMgPSBncmVwKCEkc2F3eyRffSsrLCBA cGFybXMpOworICAgIHJldHVybiBAcGFybXM7Cit9CisKK3N1YiBjbGVhbl9maWxlX2VtYWlscyB7 CisgICAgbXkgKEBmaWxlX2VtYWlscykgPSBAXzsKKyAgICBteSBAZm10X2VtYWlscyA9ICgpOwor CisgICAgZm9yZWFjaCBteSAkZW1haWwgKEBmaWxlX2VtYWlscykgeworCSRlbWFpbCA9fiBzL1tc KFw8XHtdezAsMX0oW0EtWmEtejAtOV9cLlwrLV0rXEBbQS1aYS16MC05XC4tXSspW1wpXD5cfV17 MCwxfS9cPCQxXD4vZzsKKwlteSAoJG5hbWUsICRhZGRyZXNzKSA9IHBhcnNlX2VtYWlsKCRlbWFp bCk7CisJaWYgKCRuYW1lIGVxICciWyxcLl0iJykgeworCSAgICAkbmFtZSA9ICIiOworCX0KKwor CW15IEBudyA9IHNwbGl0KC9bXkEtWmEtesOALcO/XCdcLFwuXCstXS8sICRuYW1lKTsKKwlpZiAo QG53ID4gMikgeworCSAgICBteSAkZmlyc3QgPSAkbndbQG53IC0gM107CisJICAgIG15ICRtaWRk bGUgPSAkbndbQG53IC0gMl07CisJICAgIG15ICRsYXN0ID0gJG53W0BudyAtIDFdOworCisJICAg IGlmICgoKGxlbmd0aCgkZmlyc3QpID09IDEgJiYgJGZpcnN0ID1+IG0vW0EtWmEtel0vKSB8fAor CQkgKGxlbmd0aCgkZmlyc3QpID09IDIgJiYgc3Vic3RyKCRmaXJzdCwgLTEpIGVxICIuIikpIHx8 CisJCShsZW5ndGgoJG1pZGRsZSkgPT0gMSB8fAorCQkgKGxlbmd0aCgkbWlkZGxlKSA9PSAyICYm IHN1YnN0cigkbWlkZGxlLCAtMSkgZXEgIi4iKSkpIHsKKwkJJG5hbWUgPSAiJGZpcnN0ICRtaWRk bGUgJGxhc3QiOworCSAgICB9IGVsc2UgeworCQkkbmFtZSA9ICIkbWlkZGxlICRsYXN0IjsKKwkg ICAgfQorCX0KKworCWlmIChzdWJzdHIoJG5hbWUsIC0xKSA9fiAvWyxcLl0vKSB7CisJICAgICRu YW1lID0gc3Vic3RyKCRuYW1lLCAwLCBsZW5ndGgoJG5hbWUpIC0gMSk7CisJfSBlbHNpZiAoc3Vi c3RyKCRuYW1lLCAtMikgPX4gL1ssXC5dIi8pIHsKKwkgICAgJG5hbWUgPSBzdWJzdHIoJG5hbWUs IDAsIGxlbmd0aCgkbmFtZSkgLSAyKSAuICciJzsKKwl9CisKKwlpZiAoc3Vic3RyKCRuYW1lLCAw LCAxKSA9fiAvWyxcLl0vKSB7CisJICAgICRuYW1lID0gc3Vic3RyKCRuYW1lLCAxLCBsZW5ndGgo JG5hbWUpIC0gMSk7CisJfSBlbHNpZiAoc3Vic3RyKCRuYW1lLCAwLCAyKSA9fiAvIlssXC5dLykg eworCSAgICAkbmFtZSA9ICciJyAuIHN1YnN0cigkbmFtZSwgMiwgbGVuZ3RoKCRuYW1lKSAtIDIp OworCX0KKworCW15ICRmbXRfZW1haWwgPSBmb3JtYXRfZW1haWwoJG5hbWUsICRhZGRyZXNzLCAk ZW1haWxfdXNlbmFtZSk7CisJcHVzaChAZm10X2VtYWlscywgJGZtdF9lbWFpbCk7CisgICAgfQor ICAgIHJldHVybiBAZm10X2VtYWlsczsKK30KKworc3ViIG1lcmdlX2VtYWlsIHsKKyAgICBteSBA bGluZXM7CisgICAgbXkgJXNhdzsKKworICAgIGZvciAoQF8pIHsKKwlteSAoJGFkZHJlc3MsICRy b2xlKSA9IEAkXzsKKwlpZiAoISRzYXd7JGFkZHJlc3N9KSB7CisJICAgIGlmICgkb3V0cHV0X3Jv bGVzKSB7CisJCXB1c2goQGxpbmVzLCAiJGFkZHJlc3MgKCRyb2xlKSIpOworCSAgICB9IGVsc2Ug eworCQlwdXNoKEBsaW5lcywgJGFkZHJlc3MpOworCSAgICB9CisJICAgICRzYXd7JGFkZHJlc3N9 ID0gMTsKKwl9CisgICAgfQorCisgICAgcmV0dXJuIEBsaW5lczsKK30KKworc3ViIG91dHB1dCB7 CisgICAgbXkgKEBwYXJtcykgPSBAXzsKKworICAgIGlmICgkb3V0cHV0X211bHRpbGluZSkgewor CWZvcmVhY2ggbXkgJGxpbmUgKEBwYXJtcykgeworCSAgICBwcmludCgiJHtsaW5lfVxuIik7CisJ fQorICAgIH0gZWxzZSB7CisJcHJpbnQoam9pbigkb3V0cHV0X3NlcGFyYXRvciwgQHBhcm1zKSk7 CisJcHJpbnQoIlxuIik7CisgICAgfQorfQorCitteSAkcmZjODIycmU7CisKK3N1YiBtYWtlX3Jm YzgyMnJlIHsKKyMgICBCYXNpYyBsZXhpY2FsIHRva2VucyBhcmUgc3BlY2lhbHMsIGRvbWFpbl9s aXRlcmFsLCBxdW90ZWRfc3RyaW5nLCBhdG9tLCBhbmQKKyMgICBjb21tZW50LiAgV2UgbXVzdCBh bGxvdyBmb3IgcmZjODIyX2x3c3AgKG9yIGNvbW1lbnRzKSBhZnRlciBlYWNoIG9mIHRoZXNlLgor IyAgIFRoaXMgcmVnZXhwIHdpbGwgb25seSB3b3JrIG9uIGFkZHJlc3NlcyB3aGljaCBoYXZlIGhh ZCBjb21tZW50cyBzdHJpcHBlZAorIyAgIGFuZCByZXBsYWNlZCB3aXRoIHJmYzgyMl9sd3NwLgor CisgICAgbXkgJHNwZWNpYWxzID0gJygpPD5ALDs6XFxcXCIuXFxbXFxdJzsKKyAgICBteSAkY29u dHJvbHMgPSAnXFwwMDAtXFwwMzdcXDE3Nyc7CisKKyAgICBteSAkZHRleHQgPSAiW15cXFtcXF1c XHJcXFxcXSI7CisgICAgbXkgJGRvbWFpbl9saXRlcmFsID0gIlxcWyg/OiRkdGV4dHxcXFxcLikq XFxdJHJmYzgyMl9sd3NwKiI7CisKKyAgICBteSAkcXVvdGVkX3N0cmluZyA9ICJcIig/OlteXFxc IlxcclxcXFxdfFxcXFwufCRyZmM4MjJfbHdzcCkqXCIkcmZjODIyX2x3c3AqIjsKKworIyAgIFVz ZSB6ZXJvLXdpZHRoIGFzc2VydGlvbiB0byBzcG90IHRoZSBsaW1pdCBvZiBhbiBhdG9tLiAgQSBz aW1wbGUKKyMgICAkcmZjODIyX2x3c3AqIGNhdXNlcyB0aGUgcmVnZXhwIGVuZ2luZSB0byBoYW5n IG9jY2FzaW9uYWxseS4KKyAgICBteSAkYXRvbSA9ICJbXiRzcGVjaWFscyAkY29udHJvbHNdKyg/ OiRyZmM4MjJfbHdzcCt8XFxafCg/PVtcXFtcIiRzcGVjaWFsc10pKSI7CisgICAgbXkgJHdvcmQg PSAiKD86JGF0b218JHF1b3RlZF9zdHJpbmcpIjsKKyAgICBteSAkbG9jYWxwYXJ0ID0gIiR3b3Jk KD86XFwuJHJmYzgyMl9sd3NwKiR3b3JkKSoiOworCisgICAgbXkgJHN1Yl9kb21haW4gPSAiKD86 JGF0b218JGRvbWFpbl9saXRlcmFsKSI7CisgICAgbXkgJGRvbWFpbiA9ICIkc3ViX2RvbWFpbig/ OlxcLiRyZmM4MjJfbHdzcCokc3ViX2RvbWFpbikqIjsKKworICAgIG15ICRhZGRyX3NwZWMgPSAi JGxvY2FscGFydFxAJHJmYzgyMl9sd3NwKiRkb21haW4iOworCisgICAgbXkgJHBocmFzZSA9ICIk d29yZCoiOworICAgIG15ICRyb3V0ZSA9ICIoPzpcQCRkb21haW4oPzosXEAkcmZjODIyX2x3c3Aq JGRvbWFpbikqOiRyZmM4MjJfbHdzcCopIjsKKyAgICBteSAkcm91dGVfYWRkciA9ICJcXDwkcmZj ODIyX2x3c3AqJHJvdXRlPyRhZGRyX3NwZWNcXD4kcmZjODIyX2x3c3AqIjsKKyAgICBteSAkbWFp bGJveCA9ICIoPzokYWRkcl9zcGVjfCRwaHJhc2Ukcm91dGVfYWRkcikiOworCisgICAgbXkgJGdy b3VwID0gIiRwaHJhc2U6JHJmYzgyMl9sd3NwKig/OiRtYWlsYm94KD86LFxccyokbWFpbGJveCkq KT87XFxzKiI7CisgICAgbXkgJGFkZHJlc3MgPSAiKD86JG1haWxib3h8JGdyb3VwKSI7CisKKyAg ICByZXR1cm4gIiRyZmM4MjJfbHdzcCokYWRkcmVzcyI7Cit9CisKK3N1YiByZmM4MjJfc3RyaXBf Y29tbWVudHMgeworICAgIG15ICRzID0gc2hpZnQ7CisjICAgUmVjdXJzaXZlbHkgcmVtb3ZlIGNv bW1lbnRzLCBhbmQgcmVwbGFjZSB3aXRoIGEgc2luZ2xlIHNwYWNlLiAgVGhlIHNpbXBsZXIKKyMg ICByZWdleHBzIGluIHRoZSBFbWFpbCBBZGRyZXNzaW5nIEZBUSBhcmUgaW1wZXJmZWN0IC0gdGhl eSB3aWxsIG1pc3MgZXNjYXBlZAorIyAgIGNoYXJzIGluIGF0b21zLCBmb3IgZXhhbXBsZS4KKwor ICAgIHdoaWxlICgkcyA9fiBzL14oKD86W14iXFxdfFxcLikqCisgICAgICAgICAgICAgICAgICAg ICg/OiIoPzpbXiJcXF18XFwuKSoiKD86W14iXFxdfFxcLikqKSopCisgICAgICAgICAgICAgICAg ICAgIFwoKD86W14oKVxcXXxcXC4pKlwpLyQxIC9vc3gpIHt9CisgICAgcmV0dXJuICRzOworfQor CisjICAgdmFsaWQ6IHJldHVybnMgdHJ1ZSBpZiB0aGUgcGFyYW1ldGVyIGlzIGFuIFJGQzgyMiB2 YWxpZCBhZGRyZXNzCisjCitzdWIgcmZjODIyX3ZhbGlkIHsKKyAgICBteSAkcyA9IHJmYzgyMl9z dHJpcF9jb21tZW50cyhzaGlmdCk7CisKKyAgICBpZiAoISRyZmM4MjJyZSkgeworICAgICAgICAk cmZjODIycmUgPSBtYWtlX3JmYzgyMnJlKCk7CisgICAgfQorCisgICAgcmV0dXJuICRzID1+IG0v XiRyZmM4MjJyZSQvc28gJiYgJHMgPX4gbS9eJHJmYzgyMl9jaGFyKiQvOworfQorCisjICAgdmFs aWRsaXN0OiBJbiBzY2FsYXIgY29udGV4dCwgcmV0dXJucyB0cnVlIGlmIHRoZSBwYXJhbWV0ZXIg aXMgYW4gUkZDODIyCisjICAgICAgICAgICAgICB2YWxpZCBsaXN0IG9mIGFkZHJlc3Nlcy4KKyMK KyMgICAgICAgICAgICAgIEluIGxpc3QgY29udGV4dCwgcmV0dXJucyBhbiBlbXB0eSBsaXN0IG9u IGZhaWx1cmUgKGFuIGludmFsaWQKKyMgICAgICAgICAgICAgIGFkZHJlc3Mgd2FzIGZvdW5kKTsg b3RoZXJ3aXNlIGEgbGlzdCB3aG9zZSBmaXJzdCBlbGVtZW50IGlzIHRoZQorIyAgICAgICAgICAg ICAgbnVtYmVyIG9mIGFkZHJlc3NlcyBmb3VuZCBhbmQgd2hvc2UgcmVtYWluaW5nIGVsZW1lbnRz IGFyZSB0aGUKKyMgICAgICAgICAgICAgIGFkZHJlc3Nlcy4gIFRoaXMgaXMgbmVlZGVkIHRvIGRp c2FtYmlndWF0ZSBmYWlsdXJlIChpbnZhbGlkKQorIyAgICAgICAgICAgICAgZnJvbSBzdWNjZXNz IHdpdGggbm8gYWRkcmVzc2VzIGZvdW5kLCBiZWNhdXNlIGFuIGVtcHR5IHN0cmluZyBpcworIyAg ICAgICAgICAgICAgYSB2YWxpZCBsaXN0LgorCitzdWIgcmZjODIyX3ZhbGlkbGlzdCB7CisgICAg bXkgJHMgPSByZmM4MjJfc3RyaXBfY29tbWVudHMoc2hpZnQpOworCisgICAgaWYgKCEkcmZjODIy cmUpIHsKKyAgICAgICAgJHJmYzgyMnJlID0gbWFrZV9yZmM4MjJyZSgpOworICAgIH0KKyAgICAj ICogbnVsbCBsaXN0IGl0ZW1zIGFyZSB2YWxpZCBhY2NvcmRpbmcgdG8gdGhlIFJGQworICAgICMg KiB0aGUgJzEnIGJ1c2luZXNzIGlzIHRvIGFpZCBpbiBkaXN0aW5ndWlzaGluZyBmYWlsdXJlIGZy b20gbm8gcmVzdWx0cworCisgICAgbXkgQHI7CisgICAgaWYgKCRzID1+IG0vXig/OiRyZmM4MjJy ZSk/KD86LCg/OiRyZmM4MjJyZSk/KSokL3NvICYmCisJJHMgPX4gbS9eJHJmYzgyMl9jaGFyKiQv KSB7CisgICAgICAgIHdoaWxlICgkcyA9fiBtLyg/Ol58LCRyZmM4MjJfbHdzcCopKCRyZmM4MjJy ZSkvZ29zKSB7CisgICAgICAgICAgICBwdXNoKEByLCAkMSk7CisgICAgICAgIH0KKyAgICAgICAg cmV0dXJuIHdhbnRhcnJheSA/IChzY2FsYXIoQHIpLCBAcikgOiAxOworICAgIH0KKyAgICByZXR1 cm4gd2FudGFycmF5ID8gKCkgOiAwOworfQotLSAKMi4zOS4yCgoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KT2NmczItZGV2ZWwgbWFpbGluZyBsaXN0Ck9j ZnMyLWRldmVsQG9zcy5vcmFjbGUuY29tCmh0dHBzOi8vb3NzLm9yYWNsZS5jb20vbWFpbG1hbi9s aXN0aW5mby9vY2ZzMi1kZXZlbA==