Newsgroups: php.internals Path: news.php.net Xref: news.php.net php.internals:38377 Return-Path: Mailing-List: contact internals-help@lists.php.net; run by ezmlm Delivered-To: mailing list internals@lists.php.net Received: (qmail 23960 invoked from network); 19 Jun 2008 10:32:07 -0000 Received: from unknown (HELO lists.php.net) (127.0.0.1) by localhost with SMTP; 19 Jun 2008 10:32:07 -0000 Authentication-Results: pb1.pair.com smtp.mail=dmitry@zend.com; spf=pass; sender-id=pass Authentication-Results: pb1.pair.com header.from=dmitry@zend.com; sender-id=pass Received-SPF: pass (pb1.pair.com: domain zend.com designates 212.25.124.162 as permitted sender) X-PHP-List-Original-Sender: dmitry@zend.com X-Host-Fingerprint: 212.25.124.162 mail.zend.com Windows 2000 SP4, XP SP1 Received: from [212.25.124.162] ([212.25.124.162:32055] helo=mx1.zend.com) by pb1.pair.com (ecelerity 2.1.1.9-wez r(12769M)) with ESMTP id C8/62-10717-5A53A584 for ; Thu, 19 Jun 2008 06:32:06 -0400 Received: from ws.home ([10.1.1.1]) by mx1.zend.com with Microsoft SMTPSVC(6.0.3790.3959); Thu, 19 Jun 2008 13:32:11 +0300 Message-ID: <485A35A0.9050602@zend.com> Date: Thu, 19 Jun 2008 14:32:00 +0400 User-Agent: Thunderbird 2.0.0.14 (X11/20080501) MIME-Version: 1.0 To: Christian Seiler CC: php-dev List , Andi Gutmans , Stanislav Malyshev References: <4856A547.3080801@gmx.net> In-Reply-To: <4856A547.3080801@gmx.net> X-Enigmail-Version: 0.95.6 Content-Type: multipart/mixed; boundary="------------060008040609030900030108" X-OriginalArrivalTime: 19 Jun 2008 10:32:11.0924 (UTC) FILETIME=[BBE08540:01C8D1F7] Subject: Re: [PHP-DEV] [PATCH] [RFC] Closures and lambda functions in PHP From: dmitry@zend.com (Dmitry Stogov) --------------060008040609030900030108 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit Hi Christian, I took a look into your patch and found it too difficult. So I implemented another patch (attached) which is based on your ideas. From user's level of view it does exactly the same except for "lexical" variables definition. I don't use any new reserver word because every new reserved word is going to break some user code. I use the special syntax for lambda function definition instead, which looks much clear for me. The following code creates a lambda function with arguments $x, $y and lexical variables $a, $b, $c. $a = function($x, $y | $a, $b $c) {}; The patch shouldn't affect opcode caches and other extensions as it doesn't change any structures. It uses the op_array->static_variables for lexical variables. The patch also fixes several small issues and adds some missing functionality which didn't allow preg_replace_callback() (and may be others) to work with lambda functions. Now the following example works fine. foo($x[0].':'.$s); }; } } $x = new X; $x = $x->bar("bye\n"); $s = 'abc'; preg_replace_callback('/[abc]/', $x, $s); ?> It prints: a:1:bye b:2:1:bye c:3:2:1:bye Of course the patch doesn't break any existent tests. Please review. Thanks. Dmitry. Christian Seiler wrote: > Hi, > > As a followup to the discussion in January, I'd like post a revised > patch to > this list that implements closures and anonymous functions in PHP. > > INTRODUCTION > ------------ > > Closures and lambda functions can make programming much easier in > several ways: > > 1. Lambda functions allow the quick definition of throw-away functions > that are not used elsewhere. Imaging for example a piece of code that > needs to call preg_replace_callback(). Currently, there are three > possibilities to acchieve this: > > a. Define the callback function elsewhere. This distributes code that > belongs together throughout the file and decreases readability. > > b. Define the callback function in-place (but with a name). In that > case > one has to use function_exists() to make sure the function is only > defined once. Example code: > > function replace_spaces ($text) { > if (!function_exists ('replace_spaces_helper')) { > function replace_spaces_helper ($matches) { > return str_replace ($matches[1], ' ', ' ').' '; > } > } > return preg_replace_callback ('/( +) /', > 'replace_spaces_helper', > $text); > } > ?> > > Here, the additional if() around the function definition makes the > source code difficult to read. > > c. Use the present create_function() in order to create a function at > runtime. This approach has several disadvantages: First of all, > syntax > highlighting does not work because a string is passed to the > function. > It also compiles the function at run time and not at compile > time so > opcode caches can't cache the function. > > 2. Closures provide a very useful tool in order to make lambda > functions even > more useful. Just imagine you want to replace 'hello' through > 'goodbye' in > all elements of an array. PHP provides the array_map() function which > accepts a callback. If you don't wan't to hard-code 'hello' and > 'goodbye' > into your sourcecode, you have only four choices: > > a. Use create_function(). But then you may only pass literal values > (strings, integers, floats) into the function, objects at best as > clones (if var_export() allows for it) and resources not at all. > And > you have to worry about escaping everything correctly. > Especially when > handling user input this can lead to all sorts of security issues. > > b. Write a function that uses global variables. This is ugly, > non-reentrant and bad style. > > c. Create an entire class, instantiate it and pass the member function > as a callback. This is perhaps the cleanest solution for this > problem > with current PHP but just think about it: Creating an entire > class for > this extremely simple purpose and nothing else seems overkill. > > d. Don't use array_map() but simply do it manually (foreach). In this > simple case it may not be that much of an issue (because one simply > wants to iterate over an array) but there are cases where doing > something manually that a function with a callback as parameter > does > for you is quite tedious. > > [Yes, I know that str_replace also accepts arrays as a third > parameter so > this example may be a bit useless. But imagine you want to do a more > complex operation than simple search and replace.] > > PROPOSED PATCH > -------------- > > I now propose a patch that implements compile-time lambda functions and > closures for PHP while keeping the patch as simple as possible. The > patch is > based on a previous patch on mine which was based on ideas discussed here > end of December / start of January. > > Userland perspective > -------------------- > > 1. The patch adds the following syntax as a valid expression: > > function & (parameters) { body } > > (The & is optional and indicates - just as with normal functions - that the > anonymous function returns a reference instead of a value) > > Example usage: > > $lambda = function () { echo "Hello World!\n"; }; > > The variable $lambda then contains a callable resource that may be called > through different means: > > $lambda (); > call_user_func ($lambda); > call_user_func_array ($lambda, array ()); > > This allows for simple lambda functions, for example: > > function replace_spaces ($text) { > $replacement = function ($matches) { > return str_replace ($matches[1], ' ', ' ').' '; > }; > return preg_replace_callback ('/( +) /', $replacement, $text); > } > > 2. The patch implements closures by defining an additional keyword > 'lexical' > that allows an lambda function (and *only* an lambda function) to import > a variable from the "parent scope" to the lambda function scope. Example: > > function replace_in_array ($search, $replacement, $array) { > $map = function ($text) { > lexical $search, $replacement; > if (strpos ($text, $search) > 50) { > return str_replace ($search, $replacement, $text); > } else { > return $text; > } > }; > return array_map ($map, array); > } > > The variables $search and $replacement are variables in the scope of the > function replace_in_array() and the lexical keyword imports these variables > into the scope of the closure. The variables are imported as a reference, > so any change in the closure will result in a change in the variable of the > function itself. > > 3. If a closure is defined inside an object, the closure has full access > to the current object through $this (without the need to use 'lexical' to > import it seperately) and all private and protected methods of that class. > This also applies to nested closures. Essentially, closures inside > methods are > added as public methods to the class that contains the original method. > > 4. Closures may live longer as the methods that declared them. It is > perfectly > possible to have something like this: > > function getAdder($x) { > return function ($y) { > lexical $x; > return $x + $y; > }; > } > > Zend internal perspective > ------------------------- > > The patch basically changes the following in the Zend engine: > > When the compiler reaches a lambda function, it creates a unique name > for that > function ("\0__compiled_lambda_FILENAME_N" where FILENAME is the name of > the > file currently processed and N is a per-file counter). The use of the > filename > in the function name ensures compability with opcode caches. The lambda > function is then immediately added to the function table (either the global > function table or that of the current class if declared inside a class > method). > Instead of a normal ZEND_DECLARE_FUNCTION opcode the new > ZEND_DECLARE_LAMBDA_FUNC is used as an opcode at this point. The op_array > of the new function is initialized with is_lambda = 1 and is_closure = 0. > > When parsing a 'lexical' declaration inside an anonymous function the > parser > saves the name of the variable that is to be imported in an array stored > as a member of the op_array structure (lexical_names). > > The opcode handler for ZEND_DECLARE_LAMBDA_FUNC does the following: > First of > all it creates a new op_array and copies the entire memory structure of the > lambda function into it (the opcodes themselves are not copied since they > are only referenced in the op_array structure). Then it sets is_closure = 1 > on the new op_array, and for each lexical variable name that the compiler > added to the original op_array it creates a reference to that variable from > the current scope into a HashTable member in the new op_array. It also > saves > the current object pointer ($this) as a member of the op_array in order to > allow for the closure to access $this. Finally it registers the new > op_array > as a resource and returns that resource. > > The opcode handler of the 'lexical' construct simply fetches the variable > from that HashTable and imports it into local scope of the inner function > (just like with 'global' only with a different hash table). > > Some hooks were added that allow the 'lambda function' resource to be > called. > Also, there are several checks in place that make sure the lambda function > is not called directly, i.e. if someone explicitely tries to use the > internal > function name instead of using the resource return value of the > declaration. > > The patch > --------- > > The patch is available here: > > > Please note that I did NOT include the contents of zend_language_scanner.c > in the patch since that can easily be regenerated and just takes up > enormous > amounts of space. > > The patch itself applies against the 5.3 branch of PHP. > > If I understand the discussion regarding PHP6 on this list correctly, some > people are currently undergoing the task of removing the unicode_semantics > switch and if (UG(unicode)). As soon as this task is finished I will also > provide a patch for CVS HEAD (it doesn't make much sense adopting the patch > now and then having to change it again completely afterwards). > > BC BREAKS > --------- > > * Introduction of a new keyword 'lexical'. Since it is very improbable > that > someone should use it as a function, method, class or property name, I > think this is an acceptable break. > > Other that that, I can find no BC breaks of my patch. > > CAVEATS / POSSIBLE WTFS > ----------------------- > > * On writing $func = function () { }; there is a semicolon necessary. > If left > out it will produce a compile error. Since any attempt to remove that > necessity would unecessarily bloat the grammar, I suggest we simply keep > it the way it is. Also, Lukas Kahwe Smith pointed out that a single > trailing semicolon after a closing brace already exists: do { } while > (); > > * The fact that 'lexical' creates references may cause certain WTFs: > > for ($i = 0; $i < 10; $i++) { > $arr[$i] = function () { lexical $i; return $i; }; > } > > This will not work as expected since $i is a reference and thus all > created closures would reference the same variable. In order to get this > right one has to do: > > for ($i = 0; $i < 10; $i++) { > $loopIndex = $i; > $arr[$i] = function () { lexical $loopIndex; return $loopIndex; }; > unset ($loopIndex); > } > > This can be a WTF for people that don't expect lexical to create an > actual reference, especially since other languages such as JavaScript > don't do it. On the other hand, global and static both DO create > references so that behaviour is consistent with current PHP. > > But complex constructions such as this will probably not be used by > beginners so maintaining a good documentation should solve this. > > * The fact that 'lexical' is needed at all may cause WTFs. Other languages > such as JavaScript implicitely have the entire scope visible to child > functions. But since PHP does the same thing with global variables, I > find a keyword like 'lexical' much more consistent than importing the > entire scope (and always importing the entire scope costs unnecessary > performance). > > FINAL THOUGHTS > -------------- > > My now proposed patch addresses the two main problems of my previous patch: > Support for closures in objects (with access to $this) and opcode > caches. My > patch applies against PHP_5_3 and does not break any tests. It adds a > valuable > new language feature which I'd like to see in PHP. > > Regards, > Christian > --------------060008040609030900030108 Content-Type: text/plain; name="lambda.diff.txt" Content-Transfer-Encoding: base64 Content-Disposition: inline; filename="lambda.diff.txt" SW5kZXg6IFplbmQvemVuZF9BUEkuYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBmaWxlOiAvcmVwb3Np dG9yeS9aZW5kRW5naW5lMi96ZW5kX0FQSS5jLHYKcmV0cmlldmluZyByZXZpc2lvbiAxLjI5 Ni4yLjI3LjIuMzQuMi4zOApkaWZmIC11IC1wIC1kIC1yMS4yOTYuMi4yNy4yLjM0LjIuMzgg emVuZF9BUEkuYwotLS0gWmVuZC96ZW5kX0FQSS5jCTUgSnVuIDIwMDggMTg6NTM6MDYgLTAw MDAJMS4yOTYuMi4yNy4yLjM0LjIuMzgKKysrIFplbmQvemVuZF9BUEkuYwkxOSBKdW4gMjAw OCAxMDowNDozNyAtMDAwMApAQCAtMjYxNSw2ICsyNjE1LDI4IEBAIFpFTkRfQVBJIHplbmRf Ym9vbCB6ZW5kX2lzX2NhbGxhYmxlX2V4KHoKIAkJCX0KIAkJCXJldHVybiAwOwogCisJCWNh c2UgSVNfUkVTT1VSQ0U6CisJCQl7CisJCQkJemVuZF9jbG9zdXJlICpjbG9zdXJlID0gKHpl bmRfY2xvc3VyZSopIHplbmRfZmV0Y2hfcmVzb3VyY2UoJmNhbGxhYmxlIFRTUk1MU19DQywg LTEsIE5VTEwsIE5VTEwsIDEsIGxlX2xhbWJkYV9mdW5jKTsKKworCQkJCWlmIChjbG9zdXJl KSB7CisJCQkJCSpmcHRyX3B0ciA9ICh6ZW5kX2Z1bmN0aW9uKikmY2xvc3VyZS0+b3BfYXJy YXk7CisJCQkJCWlmIChjbG9zdXJlLT5UaGlzKSB7CisJCQkJCQkqem9ial9wdHJfcHRyID0g JmNsb3N1cmUtPlRoaXM7CisJCQkJCQkqY2VfcHRyID0gWl9PQkpDRV9QKGNsb3N1cmUtPlRo aXMpOworCQkJCQl9IGVsc2UgeworCQkJCQkJKnpvYmpfcHRyX3B0ciA9IE5VTEw7CisJCQkJ CQkqY2VfcHRyID0gY2xvc3VyZS0+b3BfYXJyYXkuc2NvcGU7CisJCQkJCX0KKwkJCQkJaWYg KGNhbGxhYmxlX25hbWUpIHsKKwkJCQkJCSpjYWxsYWJsZV9uYW1lX2xlbiA9IHN0cmxlbihj bG9zdXJlLT5vcF9hcnJheS5mdW5jdGlvbl9uYW1lKTsKKwkJCQkJCSpjYWxsYWJsZV9uYW1l ID0gZXN0cm5kdXAoY2xvc3VyZS0+b3BfYXJyYXkuZnVuY3Rpb25fbmFtZSwgKmNhbGxhYmxl X25hbWVfbGVuKTsKKwkJCQkJfQkJCQkJCQkJCQorCQkJCQlyZXR1cm4gMTsKKwkJCQl9CisJ CQl9CisJCQkvKiBicmVhayBtaXNzaW5nIGludGVudGlvbmFsbHkgKi8KKwogCQlkZWZhdWx0 OgogCQkJaWYgKGNhbGxhYmxlX25hbWUpIHsKIAkJCQl6dmFsIGV4cHJfY29weTsKSW5kZXg6 IFplbmQvemVuZF9jb21waWxlLmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpSQ1MgZmlsZTogL3JlcG9zaXRv cnkvWmVuZEVuZ2luZTIvemVuZF9jb21waWxlLmMsdgpyZXRyaWV2aW5nIHJldmlzaW9uIDEu NjQ3LjIuMjcuMi40MS4yLjY4CmRpZmYgLXUgLXAgLWQgLXIxLjY0Ny4yLjI3LjIuNDEuMi42 OCB6ZW5kX2NvbXBpbGUuYwotLS0gWmVuZC96ZW5kX2NvbXBpbGUuYwkxNSBKdW4gMjAwOCAx ODoyNzozNyAtMDAwMAkxLjY0Ny4yLjI3LjIuNDEuMi42OAorKysgWmVuZC96ZW5kX2NvbXBp bGUuYwkxOSBKdW4gMjAwOCAxMDowNDozNyAtMDAwMApAQCAtMTM3NSw2ICsxMzc1LDI5IEBA IHZvaWQgemVuZF9kb19iZWdpbl9mdW5jdGlvbl9kZWNsYXJhdGlvbigKIAlDRyhsYWJlbHMp ID0gTlVMTDsKIH0KIAordm9pZCB6ZW5kX2RvX2JlZ2luX2xhbWJkYV9mdW5jdGlvbl9kZWNs YXJhdGlvbih6bm9kZSAqcmVzdWx0LCB6bm9kZSAqZnVuY3Rpb25fdG9rZW4sIGludCByZXR1 cm5fcmVmZXJlbmNlIFRTUk1MU19EQykKK3sKKwl6bm9kZSAgICAgICAgICBmdW5jdGlvbl9u YW1lOworCXplbmRfb3BfYXJyYXkgKmN1cnJlbnRfb3BfYXJyYXkgPSBDRyhhY3RpdmVfb3Bf YXJyYXkpOworCWludCAgICAgICAgICAgIGN1cnJlbnRfb3BfbnVtYmVyID0gZ2V0X25leHRf b3BfbnVtYmVyKENHKGFjdGl2ZV9vcF9hcnJheSkpOworCXplbmRfb3AgICAgICAgKmN1cnJl bnRfb3A7CisKKwlmdW5jdGlvbl9uYW1lLm9wX3R5cGUgPSBJU19DT05TVDsKKwlaVkFMX1NU UklOR0woJmZ1bmN0aW9uX25hbWUudS5jb25zdGFudCwgImxhbWJkYSIsIHNpemVvZigibGFt YmRhIiktMSwgMSk7CisKKwl6ZW5kX2RvX2JlZ2luX2Z1bmN0aW9uX2RlY2xhcmF0aW9uKGZ1 bmN0aW9uX3Rva2VuLCAmZnVuY3Rpb25fbmFtZSwgMCwgcmV0dXJuX3JlZmVyZW5jZSwgTlVM TCBUU1JNTFNfQ0MpOworCisJcmVzdWx0LT5vcF90eXBlID0gSVNfVE1QX1ZBUjsKKwlyZXN1 bHQtPnUudmFyID0gZ2V0X3RlbXBvcmFyeV92YXJpYWJsZShjdXJyZW50X29wX2FycmF5KTs7 CisKKwljdXJyZW50X29wID0gJmN1cnJlbnRfb3BfYXJyYXktPm9wY29kZXNbY3VycmVudF9v cF9udW1iZXJdOworCWN1cnJlbnRfb3AtPm9wY29kZSA9IFpFTkRfREVDTEFSRV9MQU1CREFf RlVOQ1RJT047CisJenZhbF9kdG9yKCZjdXJyZW50X29wLT5vcDIudS5jb25zdGFudCk7CisJ WlZBTF9MT05HKCZjdXJyZW50X29wLT5vcDIudS5jb25zdGFudCwgemVuZF9oYXNoX2Z1bmMo Wl9TVFJWQUwoY3VycmVudF9vcC0+b3AxLnUuY29uc3RhbnQpLCBaX1NUUkxFTihjdXJyZW50 X29wLT5vcDEudS5jb25zdGFudCkpKTsKKwljdXJyZW50X29wLT5yZXN1bHQgPSAqcmVzdWx0 OworfQorCisKIHZvaWQgemVuZF9kb19oYW5kbGVfZXhjZXB0aW9uKFRTUk1MU19EKQogewog CXplbmRfb3AgKm9wbGluZSA9IGdldF9uZXh0X29wKENHKGFjdGl2ZV9vcF9hcnJheSkgVFNS TUxTX0NDKTsKQEAgLTQxNDksNiArNDE3MiwyMSBAQCB2b2lkIHplbmRfZG9fZmV0Y2hfc3Rh dGljX3ZhcmlhYmxlKHpub2RlCiAvKgl6dmFsX2R0b3IoJnZhcm5hbWUtPnUuY29uc3RhbnQp OyAqLwogfQogCit2b2lkIHplbmRfZG9fZmV0Y2hfbGV4aWNhbF92YXJpYWJsZSh6bm9kZSAq dmFybmFtZSBUU1JNTFNfREMpCit7CisJem5vZGUgdmFsdWU7CisKKwkvKiBFbXB0eSBjb25z dGFudCBoYXMgYSBzcGVjaWFsIG1lYW5pbmcgb2YgbGV4aWNhbCB2YXJpYWJsZS4KKwkgKiBJ dCBpcyBzdWJzdGl0dXRlZCBieSByZWFsIHZhbHVlIGluIFpFTkRfREVDTEFSRV9MQU1CREFf RlVOQ1RJT04gKi8KKwl2YWx1ZS5vcF90eXBlID0gSVNfQ09OU1Q7CisJWlZBTF9FTVBUWV9T VFJJTkcoJnZhbHVlLnUuY29uc3RhbnQpOworCVpfVFlQRSh2YWx1ZS51LmNvbnN0YW50KSA9 IElTX0NPTlNUQU5UOworCVpfU0VUX1JFRkNPVU5UX1AoJnZhbHVlLnUuY29uc3RhbnQsIDEp OworCVpfVU5TRVRfSVNSRUZfUCgmdmFsdWUudS5jb25zdGFudCk7CisJCisJemVuZF9kb19m ZXRjaF9zdGF0aWNfdmFyaWFibGUodmFybmFtZSwgJnZhbHVlLCBaRU5EX0ZFVENIX1NUQVRJ QyBUU1JNTFNfQ0MpOworfQorCiB2b2lkIHplbmRfZG9fZmV0Y2hfZ2xvYmFsX3ZhcmlhYmxl KHpub2RlICp2YXJuYW1lLCB6bm9kZSAqc3RhdGljX2Fzc2lnbm1lbnQsIGludCBmZXRjaF90 eXBlIFRTUk1MU19EQykKIHsKIAl6ZW5kX29wICpvcGxpbmU7CkluZGV4OiBaZW5kL3plbmRf Y29tcGlsZS5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KUkNTIGZpbGU6IC9yZXBvc2l0b3J5L1plbmRFbmdp bmUyL3plbmRfY29tcGlsZS5oLHYKcmV0cmlldmluZyByZXZpc2lvbiAxLjMxNi4yLjguMi4x Mi4yLjI1CmRpZmYgLXUgLXAgLWQgLXIxLjMxNi4yLjguMi4xMi4yLjI1IHplbmRfY29tcGls ZS5oCi0tLSBaZW5kL3plbmRfY29tcGlsZS5oCTExIEp1biAyMDA4IDEzOjE4OjM5IC0wMDAw CTEuMzE2LjIuOC4yLjEyLjIuMjUKKysrIFplbmQvemVuZF9jb21waWxlLmgJMTkgSnVuIDIw MDggMTA6MDQ6MzcgLTAwMDAKQEAgLTQyOSw2ICs0MjksMTQgQEAgdm9pZCB6ZW5kX2RvX2Vu ZF9mdW5jdGlvbl9jYWxsKHpub2RlICpmdQogdm9pZCB6ZW5kX2RvX3JldHVybih6bm9kZSAq ZXhwciwgaW50IGRvX2VuZF92cGFyc2UgVFNSTUxTX0RDKTsKIHZvaWQgemVuZF9kb19oYW5k bGVfZXhjZXB0aW9uKFRTUk1MU19EKTsKIAordHlwZWRlZiBzdHJ1Y3QgX3plbmRfY2xvc3Vy ZSB7CisJemVuZF9vcF9hcnJheSAgICAgb3BfYXJyYXk7CisJenZhbCAgICAgICAgICAgICAq VGhpczsKK30gemVuZF9jbG9zdXJlOworCit2b2lkIHplbmRfZG9fYmVnaW5fbGFtYmRhX2Z1 bmN0aW9uX2RlY2xhcmF0aW9uKHpub2RlICpyZXN1bHQsIHpub2RlICpmdW5jdGlvbl90b2tl biwgaW50IHJldHVybl9yZWZlcmVuY2UgVFNSTUxTX0RDKTsKK3ZvaWQgemVuZF9kb19mZXRj aF9sZXhpY2FsX3ZhcmlhYmxlKHpub2RlICp2YXJuYW1lIFRTUk1MU19EQyk7CisKIHZvaWQg emVuZF9kb190cnkoem5vZGUgKnRyeV90b2tlbiBUU1JNTFNfREMpOwogdm9pZCB6ZW5kX2Rv X2JlZ2luX2NhdGNoKHpub2RlICp0cnlfdG9rZW4sIHpub2RlICpjYXRjaF9jbGFzcywgem5v ZGUgKmNhdGNoX3Zhciwgem5vZGUgKmZpcnN0X2NhdGNoIFRTUk1MU19EQyk7CiB2b2lkIHpl bmRfZG9fZW5kX2NhdGNoKHpub2RlICp0cnlfdG9rZW4gVFNSTUxTX0RDKTsKSW5kZXg6IFpl bmQvemVuZF9leGVjdXRlLmMKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpSQ1MgZmlsZTogL3JlcG9zaXRvcnkv WmVuZEVuZ2luZTIvemVuZF9leGVjdXRlLmMsdgpyZXRyaWV2aW5nIHJldmlzaW9uIDEuNzE2 LjIuMTIuMi4yNC4yLjMwCmRpZmYgLXUgLXAgLWQgLXIxLjcxNi4yLjEyLjIuMjQuMi4zMCB6 ZW5kX2V4ZWN1dGUuYwotLS0gWmVuZC96ZW5kX2V4ZWN1dGUuYwkxMSBKdW4gMjAwOCAxMzox ODozOSAtMDAwMAkxLjcxNi4yLjEyLjIuMjQuMi4zMAorKysgWmVuZC96ZW5kX2V4ZWN1dGUu YwkxOSBKdW4gMjAwOCAxMDowNDozOCAtMDAwMApAQCAtMTI1OSw2ICsxMjU5LDI3IEBAIHN0 YXRpYyBpbmxpbmUgemVuZF9icmtfY29udF9lbGVtZW50KiB6ZW4KIAlyZXR1cm4gam1wX3Rv OwogfQogCitzdGF0aWMgaW50IHp2YWxfY29weV9zdGF0aWNfdmFyKHp2YWwgKipwLCBpbnQg bnVtX2FyZ3MsIHZhX2xpc3QgYXJncywgemVuZF9oYXNoX2tleSAqa2V5KQoreworCUhhc2hU YWJsZSAqdGFyZ2V0ID0gdmFfYXJnKGFyZ3MsIEhhc2hUYWJsZSopOworCisJaWYgKFpfVFlQ RV9QUChwKSA9PSBJU19DT05TVEFOVCAmJiBaX1NUUkxFTl9QUChwKSA9PSAwKSB7CisJCVRT Uk1MU19GRVRDSCgpOworCisJCWlmICghRUcoYWN0aXZlX3N5bWJvbF90YWJsZSkpIHsKKwkJ CXplbmRfcmVidWlsZF9zeW1ib2xfdGFibGUoVFNSTUxTX0MpOworCQl9CisJCWlmICh6ZW5k X2hhc2hfcXVpY2tfZmluZChFRyhhY3RpdmVfc3ltYm9sX3RhYmxlKSwga2V5LT5hcktleSwg a2V5LT5uS2V5TGVuZ3RoLCBrZXktPmgsICh2b2lkICoqKSAmcCkgPT0gRkFJTFVSRSkgewor CQkJcmV0dXJuIFpFTkRfSEFTSF9BUFBMWV9LRUVQOworCQl9CisJCVNFUEFSQVRFX1pWQUxf VE9fTUFLRV9JU19SRUYocCk7CisJfQorCWlmICh6ZW5kX2hhc2hfcXVpY2tfYWRkKHRhcmdl dCwga2V5LT5hcktleSwga2V5LT5uS2V5TGVuZ3RoLCBrZXktPmgsIHAsIHNpemVvZih6dmFs KiksIE5VTEwpID09IFNVQ0NFU1MpIHsKKwkJWl9BRERSRUZfUFAocCk7CisJfQorCXJldHVy biBaRU5EX0hBU0hfQVBQTFlfS0VFUDsKK30KKwogI2lmIFpFTkRfSU5URU5TSVZFX0RFQlVH R0lORwogCiAjZGVmaW5lIENIRUNLX1NZTUJPTF9UQUJMRVMoKQkJCQkJCQkJCQkJCQkJXApJ bmRleDogWmVuZC96ZW5kX2V4ZWN1dGVfQVBJLmMKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpSQ1MgZmlsZTog L3JlcG9zaXRvcnkvWmVuZEVuZ2luZTIvemVuZF9leGVjdXRlX0FQSS5jLHYKcmV0cmlldmlu ZyByZXZpc2lvbiAxLjMzMS4yLjIwLjIuMjQuMi40MgpkaWZmIC11IC1wIC1kIC1yMS4zMzEu Mi4yMC4yLjI0LjIuNDIgemVuZF9leGVjdXRlX0FQSS5jCi0tLSBaZW5kL3plbmRfZXhlY3V0 ZV9BUEkuYwk1IEp1biAyMDA4IDE4OjUwOjI5IC0wMDAwCTEuMzMxLjIuMjAuMi4yNC4yLjQy CisrKyBaZW5kL3plbmRfZXhlY3V0ZV9BUEkuYwkxOSBKdW4gMjAwOCAxMDowNDozOCAtMDAw MApAQCAtNzM5LDYgKzczOSwyMSBAQCBpbnQgemVuZF9jYWxsX2Z1bmN0aW9uKHplbmRfZmNh bGxfaW5mbyAqCiAJCQlTRVBBUkFURV9aVkFMX0lGX05PVF9SRUYodG1wX29iamVjdF9wdHIp OwogCQkJZmNpLT5vYmplY3RfcHAgPSB0bXBfb2JqZWN0X3B0cjsKIAkJCVpfU0VUX0lTUkVG X1BQKGZjaS0+b2JqZWN0X3BwKTsKKwkJfSBlbHNlIGlmIChaX1RZUEVfUChmY2ktPmZ1bmN0 aW9uX25hbWUpID09IElTX1JFU09VUkNFKSB7CisJCQl6ZW5kX2Nsb3N1cmUgKmNsb3N1cmUg PSAoemVuZF9jbG9zdXJlKikgemVuZF9mZXRjaF9yZXNvdXJjZSgmZmNpLT5mdW5jdGlvbl9u YW1lIFRTUk1MU19DQywgLTEsIE5VTEwsIE5VTEwsIDEsIGxlX2xhbWJkYV9mdW5jKTsKKwor CQkJaWYgKCFjbG9zdXJlKSB7CisJCQkJcmV0dXJuIEZBSUxVUkU7CisJCQl9CisJCQlFWChm dW5jdGlvbl9zdGF0ZSkuZnVuY3Rpb24gPSAoemVuZF9mdW5jdGlvbiopJmNsb3N1cmUtPm9w X2FycmF5OworCQkJaWYgKGNsb3N1cmUtPlRoaXMpIHsKKwkJCQlmY2ktPm9iamVjdF9wcCA9 ICZjbG9zdXJlLT5UaGlzOworCQkJCWNhbGxpbmdfc2NvcGUgPSBaX09CSkNFX1AoY2xvc3Vy ZS0+VGhpcyk7CisJCQl9IGVsc2UgeworCQkJCWZjaS0+b2JqZWN0X3BwID0gTlVMTDsKKwkJ CQljYWxsaW5nX3Njb3BlID0gY2xvc3VyZS0+b3BfYXJyYXkuc2NvcGU7CisJCQl9CisJCQln b3RvIGluaXRfZmNpX2NhY2hlOwogCQl9CiAKIAkJaWYgKGZjaS0+b2JqZWN0X3BwICYmICEq ZmNpLT5vYmplY3RfcHApIHsKQEAgLTkzNSw2ICs5NTAsOCBAQCBpbnQgemVuZF9jYWxsX2Z1 bmN0aW9uKHplbmRfZmNhbGxfaW5mbyAqCiAJCQkJcmV0dXJuIEZBSUxVUkU7CiAJCQl9CiAJ CX0KKworaW5pdF9mY2lfY2FjaGU6CiAJCWlmIChmY2lfY2FjaGUgJiYKIAkJCShFWChmdW5j dGlvbl9zdGF0ZSkuZnVuY3Rpb24tPnR5cGUgIT0gWkVORF9JTlRFUk5BTF9GVU5DVElPTiB8 fAogCQkJKCh6ZW5kX2ludGVybmFsX2Z1bmN0aW9uKilFWChmdW5jdGlvbl9zdGF0ZSkuZnVu Y3Rpb24pLT5oYW5kbGVyICE9IHplbmRfc3RkX2NhbGxfdXNlcl9jYWxsKQpJbmRleDogWmVu ZC96ZW5kX2xhbmd1YWdlX3BhcnNlci55Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KUkNTIGZpbGU6IC9yZXBv c2l0b3J5L1plbmRFbmdpbmUyL3plbmRfbGFuZ3VhZ2VfcGFyc2VyLnksdgpyZXRyaWV2aW5n IHJldmlzaW9uIDEuMTYwLjIuNC4yLjguMi4yMQpkaWZmIC11IC1wIC1kIC1yMS4xNjAuMi40 LjIuOC4yLjIxIHplbmRfbGFuZ3VhZ2VfcGFyc2VyLnkKLS0tIFplbmQvemVuZF9sYW5ndWFn ZV9wYXJzZXIueQk4IEp1biAyMDA4IDA5OjM4OjQ3IC0wMDAwCTEuMTYwLjIuNC4yLjguMi4y MQorKysgWmVuZC96ZW5kX2xhbmd1YWdlX3BhcnNlci55CTE5IEp1biAyMDA4IDEwOjA0OjM4 IC0wMDAwCkBAIC0zMDIsNyArMzAyLDcgQEAgaXNfcmVmZXJlbmNlOgogCiAKIHVudGlja2Vk X2Z1bmN0aW9uX2RlY2xhcmF0aW9uX3N0YXRlbWVudDoKLQkJVF9GVU5DVElPTiB7ICQxLnUu b3BsaW5lX251bSA9IENHKHplbmRfbGluZW5vKTsgfSBpc19yZWZlcmVuY2UgVF9TVFJJTkcg eyB6ZW5kX2RvX2JlZ2luX2Z1bmN0aW9uX2RlY2xhcmF0aW9uKCYkMSwgJiQ0LCAwLCAkMy5v cF90eXBlLCBOVUxMIFRTUk1MU19DQyk7IH0KKwkJZnVuY3Rpb24gaXNfcmVmZXJlbmNlIFRf U1RSSU5HIHsgemVuZF9kb19iZWdpbl9mdW5jdGlvbl9kZWNsYXJhdGlvbigmJDEsICYkMywg MCwgJDIub3BfdHlwZSwgTlVMTCBUU1JNTFNfQ0MpOyB9CiAJCQknKCcgcGFyYW1ldGVyX2xp c3QgJyknICd7JyBpbm5lcl9zdGF0ZW1lbnRfbGlzdCAnfScgeyB6ZW5kX2RvX2VuZF9mdW5j dGlvbl9kZWNsYXJhdGlvbigmJDEgVFNSTUxTX0NDKTsgfQogOwogCkBAIC01MTAsOCArNTEw LDggQEAgY2xhc3Nfc3RhdGVtZW50X2xpc3Q6CiBjbGFzc19zdGF0ZW1lbnQ6CiAJCXZhcmlh YmxlX21vZGlmaWVycyB7IENHKGFjY2Vzc190eXBlKSA9IFpfTFZBTCgkMS51LmNvbnN0YW50 KTsgfSBjbGFzc192YXJpYWJsZV9kZWNsYXJhdGlvbiAnOycKIAl8CWNsYXNzX2NvbnN0YW50 X2RlY2xhcmF0aW9uICc7JwotCXwJbWV0aG9kX21vZGlmaWVycyBUX0ZVTkNUSU9OIHsgJDIu dS5vcGxpbmVfbnVtID0gQ0coemVuZF9saW5lbm8pOyB9IGlzX3JlZmVyZW5jZSBUX1NUUklO RyB7IHplbmRfZG9fYmVnaW5fZnVuY3Rpb25fZGVjbGFyYXRpb24oJiQyLCAmJDUsIDEsICQ0 Lm9wX3R5cGUsICYkMSBUU1JNTFNfQ0MpOyB9ICcoJwotCQkJcGFyYW1ldGVyX2xpc3QgJykn IG1ldGhvZF9ib2R5IHsgemVuZF9kb19hYnN0cmFjdF9tZXRob2QoJiQ1LCAmJDEsICYkMTAg VFNSTUxTX0NDKTsgemVuZF9kb19lbmRfZnVuY3Rpb25fZGVjbGFyYXRpb24oJiQyIFRTUk1M U19DQyk7IH0KKwl8CW1ldGhvZF9tb2RpZmllcnMgZnVuY3Rpb24gaXNfcmVmZXJlbmNlIFRf U1RSSU5HIHsgemVuZF9kb19iZWdpbl9mdW5jdGlvbl9kZWNsYXJhdGlvbigmJDIsICYkNCwg MSwgJDMub3BfdHlwZSwgJiQxIFRTUk1MU19DQyk7IH0gJygnCisJCQlwYXJhbWV0ZXJfbGlz dCAnKScgbWV0aG9kX2JvZHkgeyB6ZW5kX2RvX2Fic3RyYWN0X21ldGhvZCgmJDQsICYkMSwg JiQ5IFRTUk1MU19DQyk7IHplbmRfZG9fZW5kX2Z1bmN0aW9uX2RlY2xhcmF0aW9uKCYkMiBU U1JNTFNfQ0MpOyB9CiA7CiAKIApAQCAtNjQzLDYgKzY0MywyMiBAQCBleHByX3dpdGhvdXRf dmFyaWFibGU6CiAJfAlUX0FSUkFZICcoJyBhcnJheV9wYWlyX2xpc3QgJyknIHsgJCQgPSAk MzsgfQogCXwJJ2AnIGVuY2Fwc19saXN0ICdgJyB7IHplbmRfZG9fc2hlbGxfZXhlYygmJCQs ICYkMiBUU1JNTFNfQ0MpOyB9CiAJfAlUX1BSSU5UIGV4cHIgIHsgemVuZF9kb19wcmludCgm JCQsICYkMiBUU1JNTFNfQ0MpOyB9CisJfAlmdW5jdGlvbiBpc19yZWZlcmVuY2UgJygnIHsg emVuZF9kb19iZWdpbl9sYW1iZGFfZnVuY3Rpb25fZGVjbGFyYXRpb24oJiQkLCAmJDEsICQy Lm9wX3R5cGUgVFNSTUxTX0NDKTsgfQorCQkJcGFyYW1ldGVyX2xpc3QgbGV4aWNhbF92YXJz ICcpJyAneycgaW5uZXJfc3RhdGVtZW50X2xpc3QgJ30nIHsgIHplbmRfZG9fZW5kX2Z1bmN0 aW9uX2RlY2xhcmF0aW9uKCYkMSBUU1JNTFNfQ0MpOyAkJCA9ICQ0OyB9Cis7CisKK2Z1bmN0 aW9uOgorCVRfRlVOQ1RJT04geyAkJC51Lm9wbGluZV9udW0gPSBDRyh6ZW5kX2xpbmVubyk7 IH0KKzsKKworbGV4aWNhbF92YXJzOgorCQkvKiBlbXB0cnkgKi8KKwl8CSd8JyBsZXhpY2Fs X3Zhcl9saXN0Cis7CisKK2xleGljYWxfdmFyX2xpc3Q6CisJCWxleGljYWxfdmFyX2xpc3Qg JywnIFRfVkFSSUFCTEUJCXsgemVuZF9kb19mZXRjaF9sZXhpY2FsX3ZhcmlhYmxlKCYkMyBU U1JNTFNfQ0MpOyB9CisJfAlUX1ZBUklBQkxFCQkJCQkJCXsgemVuZF9kb19mZXRjaF9sZXhp Y2FsX3ZhcmlhYmxlKCYkMSBUU1JNTFNfQ0MpOyB9CiA7CiAKIGZ1bmN0aW9uX2NhbGw6Cklu ZGV4OiBaZW5kL3plbmRfbGlzdC5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KUkNTIGZpbGU6IC9yZXBvc2l0 b3J5L1plbmRFbmdpbmUyL3plbmRfbGlzdC5jLHYKcmV0cmlldmluZyByZXZpc2lvbiAxLjY2 LjIuMS4yLjEuMi4xCmRpZmYgLXUgLXAgLWQgLXIxLjY2LjIuMS4yLjEuMi4xIHplbmRfbGlz dC5jCi0tLSBaZW5kL3plbmRfbGlzdC5jCTMxIERlYyAyMDA3IDA3OjE3OjA0IC0wMDAwCTEu NjYuMi4xLjIuMS4yLjEKKysrIFplbmQvemVuZF9saXN0LmMJMTkgSnVuIDIwMDggMTA6MDQ6 MzggLTAwMDAKQEAgLTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlICJ6ZW5kX2dsb2JhbHMuaCIK IAogWkVORF9BUEkgaW50IGxlX2luZGV4X3B0cjsKK1pFTkRfQVBJIGludCBsZV9sYW1iZGFf ZnVuYzsKIAogLyogdHJ1ZSBnbG9iYWwgKi8KIHN0YXRpYyBIYXNoVGFibGUgbGlzdF9kZXN0 cnVjdG9yczsKQEAgLTMzMyw2ICszMzQsMTggQEAgWkVORF9BUEkgaW50IHplbmRfZmV0Y2hf bGlzdF9kdG9yX2lkKGNoYQogCXJldHVybiAwOwogfQogCisKK3N0YXRpYyB2b2lkIHplbmRf bGFtYmRhX2Z1bmNfcmVzb3VyY2VfZHRvcih6ZW5kX3JzcmNfbGlzdF9lbnRyeSAqcnNyYyBU U1JNTFNfREMpCit7CisJemVuZF9jbG9zdXJlICpjbG9zdXJlID0gKHplbmRfY2xvc3VyZSAq KXJzcmMtPnB0cjsKKwlkZXN0cm95X3plbmRfZnVuY3Rpb24oJmNsb3N1cmUtPm9wX2FycmF5 IFRTUk1MU19DQyk7CisJaWYgKGNsb3N1cmUtPlRoaXMpIHsKKwkJenZhbF9wdHJfZHRvcigm Y2xvc3VyZS0+VGhpcyk7CisJfQorCWVmcmVlKGNsb3N1cmUpOworfQorCisKIGludCB6ZW5k X2luaXRfcnNyY19saXN0X2R0b3JzKHZvaWQpCiB7CiAJaW50IHJldHZhbDsKQEAgLTM0MCw2 ICszNTMsOCBAQCBpbnQgemVuZF9pbml0X3JzcmNfbGlzdF9kdG9ycyh2b2lkKQogCXJldHZh bCA9IHplbmRfaGFzaF9pbml0KCZsaXN0X2Rlc3RydWN0b3JzLCA1MCwgTlVMTCwgTlVMTCwg MSk7CiAJbGlzdF9kZXN0cnVjdG9ycy5uTmV4dEZyZWVFbGVtZW50PTE7CS8qIHdlIGRvbid0 IHdhbnQgcmVzb3VyY2UgdHlwZSAwICovCiAKKwlsZV9sYW1iZGFfZnVuYyA9IHplbmRfcmVn aXN0ZXJfbGlzdF9kZXN0cnVjdG9yc19leCh6ZW5kX2xhbWJkYV9mdW5jX3Jlc291cmNlX2R0 b3IsIE5VTEwsICJsYW1iZGEgZnVuY3Rpb24iLCAwKTsKKwogCXJldHVybiByZXR2YWw7CiB9 CiAKQEAgLTM2NCw3ICszNzksNiBAQCBjaGFyICp6ZW5kX3JzcmNfbGlzdF9nZXRfcnNyY190 eXBlKGludCByCiAJCXJldHVybiBOVUxMOwogCX0KIH0KLQogLyoKICAqIExvY2FsIHZhcmlh YmxlczoKICAqIHRhYi13aWR0aDogNApJbmRleDogWmVuZC96ZW5kX2xpc3QuaAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09ClJDUyBmaWxlOiAvcmVwb3NpdG9yeS9aZW5kRW5naW5lMi96ZW5kX2xpc3QuaCx2 CnJldHJpZXZpbmcgcmV2aXNpb24gMS40OC4yLjEuMi4xLjIuMQpkaWZmIC11IC1wIC1kIC1y MS40OC4yLjEuMi4xLjIuMSB6ZW5kX2xpc3QuaAotLS0gWmVuZC96ZW5kX2xpc3QuaAkzMSBE ZWMgMjAwNyAwNzoxNzowNCAtMDAwMAkxLjQ4LjIuMS4yLjEuMi4xCisrKyBaZW5kL3plbmRf bGlzdC5oCTE5IEp1biAyMDA4IDEwOjA0OjM4IC0wMDAwCkBAIC04Niw2ICs4Niw3IEBAIFpF TkRfQVBJIGNoYXIgKnplbmRfcnNyY19saXN0X2dldF9yc3JjX3QKIFpFTkRfQVBJIGludCB6 ZW5kX2ZldGNoX2xpc3RfZHRvcl9pZChjaGFyICp0eXBlX25hbWUpOwogCiBleHRlcm4gWkVO RF9BUEkgaW50IGxlX2luZGV4X3B0cjsgIC8qIGxpc3QgZW50cnkgdHlwZSBmb3IgaW5kZXgg cG9pbnRlcnMgKi8KK2V4dGVybiBaRU5EX0FQSSBpbnQgbGVfbGFtYmRhX2Z1bmM7ICAvKiBs aXN0IGVudHJ5IHR5cGUgZm9yIGxhbWJkYSBmdW5jdGlvbnMgKi8KIAogI2RlZmluZSBaRU5E X1ZFUklGWV9SRVNPVVJDRShyc3JjKQkJXAogCWlmICghcnNyYykgewkJCQkJCVwKSW5kZXg6 IFplbmQvemVuZF92bV9kZWYuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBmaWxlOiAvcmVwb3NpdG9y eS9aZW5kRW5naW5lMi96ZW5kX3ZtX2RlZi5oLHYKcmV0cmlldmluZyByZXZpc2lvbiAxLjU5 LjIuMjkuMi40OC4yLjU4CmRpZmYgLXUgLXAgLWQgLXIxLjU5LjIuMjkuMi40OC4yLjU4IHpl bmRfdm1fZGVmLmgKLS0tIFplbmQvemVuZF92bV9kZWYuaAkxMSBKdW4gMjAwOCAxMzoxODoz OSAtMDAwMAkxLjU5LjIuMjkuMi40OC4yLjU4CisrKyBaZW5kL3plbmRfdm1fZGVmLmgJMTkg SnVuIDIwMDggMTA6MDQ6MzggLTAwMDAKQEAgLTIwMjgsNiArMjAyOCwyMCBAQCBaRU5EX1ZN X0hBTkRMRVIoNTksIFpFTkRfSU5JVF9GQ0FMTF9CWV9OCiAJCX0KIAl9IGVsc2UgewogCQlm dW5jdGlvbl9uYW1lID0gR0VUX09QMl9aVkFMX1BUUihCUF9WQVJfUik7CisJCXplbmRfY2xv c3VyZSAqY2xvc3VyZTsKKworCQlpZiAoWl9UWVBFX1AoZnVuY3Rpb25fbmFtZSkgPT0gSVNf UkVTT1VSQ0UgJiYKKwkJICAgIChjbG9zdXJlID0gKHplbmRfY2xvc3VyZSopIHplbmRfZmV0 Y2hfcmVzb3VyY2UgKCZmdW5jdGlvbl9uYW1lIFRTUk1MU19DQywgLTEsIE5VTEwsIE5VTEws IDEsIGxlX2xhbWJkYV9mdW5jKSkgIT0gTlVMTCkgeworCQkJRVgoZmJjKSA9ICh6ZW5kX2Z1 bmN0aW9uKikmY2xvc3VyZS0+b3BfYXJyYXk7CisJCQlpZiAoKEVYKG9iamVjdCkgPSBjbG9z dXJlLT5UaGlzKSAhPSBOVUxMKSB7CisJCQkJWl9BRERSRUZfUChFWChvYmplY3QpKTsKKwkJ CQlFWChjYWxsZWRfc2NvcGUpID0gWl9PQkpDRV9QKEVYKG9iamVjdCkpOworCQkJfSBlbHNl IHsKKwkJCQlFWChjYWxsZWRfc2NvcGUpID0gY2xvc3VyZS0+b3BfYXJyYXkuc2NvcGU7CisJ CQl9CisJCQlGUkVFX09QMigpOworCQkJWkVORF9WTV9ORVhUX09QQ09ERSgpOworCQl9CiAK IAkJaWYgKFpfVFlQRV9QKGZ1bmN0aW9uX25hbWUpICE9IElTX1NUUklORykgewogCQkJemVu ZF9lcnJvcl9ub3JldHVybihFX0VSUk9SLCAiRnVuY3Rpb24gbmFtZSBtdXN0IGJlIGEgc3Ry aW5nIik7CkBAIC00MzI3LDQgKzQzNDEsNDIgQEAgWkVORF9WTV9IQU5ETEVSKDE0MywgWkVO RF9ERUNMQVJFX0NPTlNULAogCVpFTkRfVk1fTkVYVF9PUENPREUoKTsKIH0KIAorWkVORF9W TV9IQU5ETEVSKDE1MywgWkVORF9ERUNMQVJFX0xBTUJEQV9GVU5DVElPTiwgQ09OU1QsIENP TlNUKQoreworCXplbmRfb3AgKm9wbGluZSA9IEVYKG9wbGluZSk7CisJemVuZF9vcF9hcnJh eSAqb3BfYXJyYXk7CisJemVuZF9jbG9zdXJlICAqY2xvc3VyZTsKKworCWlmICh6ZW5kX2hh c2hfcXVpY2tfZmluZChFRyhmdW5jdGlvbl90YWJsZSksIFpfU1RSVkFMKG9wbGluZS0+b3Ax LnUuY29uc3RhbnQpLCBaX1NUUkxFTihvcGxpbmUtPm9wMS51LmNvbnN0YW50KSwgWl9MVkFM KG9wbGluZS0+b3AyLnUuY29uc3RhbnQpLCAodm9pZCAqKSAmb3BfYXJyYXkpID09IEZBSUxV UkUgfHwKKwkgICAgb3BfYXJyYXktPnR5cGUgIT0gWkVORF9VU0VSX0ZVTkNUSU9OKSB7CisJ CXplbmRfZXJyb3Jfbm9yZXR1cm4oRV9FUlJPUiwgIkJhc2UgbGFtYmRhIGZ1bmN0aW9uIGZv ciBjbG9zdXJlIG5vdCBmb3VuZCIpOworCX0KKwkKKwljbG9zdXJlID0gZW1hbGxvYyhzaXpl b2YoemVuZF9jbG9zdXJlKSk7CisJY2xvc3VyZS0+b3BfYXJyYXkgPSAqb3BfYXJyYXk7CisK KwlpZiAoY2xvc3VyZS0+b3BfYXJyYXkuc3RhdGljX3ZhcmlhYmxlcykgeworCQlIYXNoVGFi bGUgKnN0YXRpY192YXJpYWJsZXMgPSBjbG9zdXJlLT5vcF9hcnJheS5zdGF0aWNfdmFyaWFi bGVzOworCQorCQlBTExPQ19IQVNIVEFCTEUoY2xvc3VyZS0+b3BfYXJyYXkuc3RhdGljX3Zh cmlhYmxlcyk7CisJCXplbmRfaGFzaF9pbml0KGNsb3N1cmUtPm9wX2FycmF5LnN0YXRpY192 YXJpYWJsZXMsIHplbmRfaGFzaF9udW1fZWxlbWVudHMoc3RhdGljX3ZhcmlhYmxlcyksIE5V TEwsIFpWQUxfUFRSX0RUT1IsIDApOworCQl6ZW5kX2hhc2hfYXBwbHlfd2l0aF9hcmd1bWVu dHMoc3RhdGljX3ZhcmlhYmxlcywgKGFwcGx5X2Z1bmNfYXJnc190KXp2YWxfY29weV9zdGF0 aWNfdmFyLCAxLCBjbG9zdXJlLT5vcF9hcnJheS5zdGF0aWNfdmFyaWFibGVzKTsKKwl9CisK KwlpZiAoKGNsb3N1cmUtPm9wX2FycmF5LnNjb3BlID0gRUcoc2NvcGUpKSAhPSBOVUxMKSB7 CisJCWNsb3N1cmUtPm9wX2FycmF5LmZuX2ZsYWdzIHw9IFpFTkRfQUNDX1BVQkxJQzsKKwkJ aWYgKChjbG9zdXJlLT5UaGlzID0gRUcoVGhpcykpICE9IE5VTEwpIHsKKwkJCVpfQUREUkVG X1AoY2xvc3VyZS0+VGhpcyk7CisJCX0gZWxzZSB7CisJCQljbG9zdXJlLT5vcF9hcnJheS5m bl9mbGFncyB8PSBaRU5EX0FDQ19TVEFUSUM7CisJCX0KKwl9IGVsc2UgeworCQljbG9zdXJl LT5UaGlzID0gTlVMTDsKKwl9CisJKCpjbG9zdXJlLT5vcF9hcnJheS5yZWZjb3VudCkrKzsK KworCVpFTkRfUkVHSVNURVJfUkVTT1VSQ0UoJkVYX1Qob3BsaW5lLT5yZXN1bHQudS52YXIp LnRtcF92YXIsIGNsb3N1cmUsIGxlX2xhbWJkYV9mdW5jKTsKKwlaRU5EX1ZNX05FWFRfT1BD T0RFKCk7Cit9CisKIFpFTkRfVk1fRVhQT1JUX0hFTFBFUih6ZW5kX2RvX2ZjYWxsLCB6ZW5k X2RvX2ZjYWxsX2NvbW1vbl9oZWxwZXIpCkluZGV4OiBaZW5kL3plbmRfdm1fZXhlY3V0ZS5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KUkNTIGZpbGU6IC9yZXBvc2l0b3J5L1plbmRFbmdpbmUyL3plbmRf dm1fZXhlY3V0ZS5oLHYKcmV0cmlldmluZyByZXZpc2lvbiAxLjYyLjIuMzAuMi40OS4yLjU4 CmRpZmYgLXUgLXAgLWQgLXIxLjYyLjIuMzAuMi40OS4yLjU4IHplbmRfdm1fZXhlY3V0ZS5o Ci0tLSBaZW5kL3plbmRfdm1fZXhlY3V0ZS5oCTExIEp1biAyMDA4IDEzOjE4OjM5IC0wMDAw CTEuNjIuMi4zMC4yLjQ5LjIuNTgKKysrIFplbmQvemVuZF92bV9leGVjdXRlLmgJMTkgSnVu IDIwMDggMTA6MDQ6NDAgLTAwMDAKQEAgLTc0Niw2ICs3NDYsMjAgQEAgc3RhdGljIGludCBa RU5EX0ZBU1RDQUxMICBaRU5EX0lOSVRfRkNBTAogCQl9CiAJfSBlbHNlIHsKIAkJZnVuY3Rp b25fbmFtZSA9ICZvcGxpbmUtPm9wMi51LmNvbnN0YW50OworCQl6ZW5kX2Nsb3N1cmUgKmNs b3N1cmU7CisKKwkJaWYgKFpfVFlQRV9QKGZ1bmN0aW9uX25hbWUpID09IElTX1JFU09VUkNF ICYmCisJCSAgICAoY2xvc3VyZSA9ICh6ZW5kX2Nsb3N1cmUqKSB6ZW5kX2ZldGNoX3Jlc291 cmNlICgmZnVuY3Rpb25fbmFtZSBUU1JNTFNfQ0MsIC0xLCBOVUxMLCBOVUxMLCAxLCBsZV9s YW1iZGFfZnVuYykpICE9IE5VTEwpIHsKKwkJCUVYKGZiYykgPSAoemVuZF9mdW5jdGlvbiop JmNsb3N1cmUtPm9wX2FycmF5OworCQkJaWYgKChFWChvYmplY3QpID0gY2xvc3VyZS0+VGhp cykgIT0gTlVMTCkgeworCQkJCVpfQUREUkVGX1AoRVgob2JqZWN0KSk7CisJCQkJRVgoY2Fs bGVkX3Njb3BlKSA9IFpfT0JKQ0VfUChFWChvYmplY3QpKTsKKwkJCX0gZWxzZSB7CisJCQkJ RVgoY2FsbGVkX3Njb3BlKSA9IGNsb3N1cmUtPm9wX2FycmF5LnNjb3BlOworCQkJfQorCisJ CQlaRU5EX1ZNX05FWFRfT1BDT0RFKCk7CisJCX0KIAogCQlpZiAoWl9UWVBFX1AoZnVuY3Rp b25fbmFtZSkgIT0gSVNfU1RSSU5HKSB7CiAJCQl6ZW5kX2Vycm9yX25vcmV0dXJuKEVfRVJS T1IsICJGdW5jdGlvbiBuYW1lIG11c3QgYmUgYSBzdHJpbmciKTsKQEAgLTkzNCw2ICs5NDgs MjAgQEAgc3RhdGljIGludCBaRU5EX0ZBU1RDQUxMICBaRU5EX0lOSVRfRkNBTAogCQl9CiAJ fSBlbHNlIHsKIAkJZnVuY3Rpb25fbmFtZSA9IF9nZXRfenZhbF9wdHJfdG1wKCZvcGxpbmUt Pm9wMiwgRVgoVHMpLCAmZnJlZV9vcDIgVFNSTUxTX0NDKTsKKwkJemVuZF9jbG9zdXJlICpj bG9zdXJlOworCisJCWlmIChaX1RZUEVfUChmdW5jdGlvbl9uYW1lKSA9PSBJU19SRVNPVVJD RSAmJgorCQkgICAgKGNsb3N1cmUgPSAoemVuZF9jbG9zdXJlKikgemVuZF9mZXRjaF9yZXNv dXJjZSAoJmZ1bmN0aW9uX25hbWUgVFNSTUxTX0NDLCAtMSwgTlVMTCwgTlVMTCwgMSwgbGVf bGFtYmRhX2Z1bmMpKSAhPSBOVUxMKSB7CisJCQlFWChmYmMpID0gKHplbmRfZnVuY3Rpb24q KSZjbG9zdXJlLT5vcF9hcnJheTsKKwkJCWlmICgoRVgob2JqZWN0KSA9IGNsb3N1cmUtPlRo aXMpICE9IE5VTEwpIHsKKwkJCQlaX0FERFJFRl9QKEVYKG9iamVjdCkpOworCQkJCUVYKGNh bGxlZF9zY29wZSkgPSBaX09CSkNFX1AoRVgob2JqZWN0KSk7CisJCQl9IGVsc2UgeworCQkJ CUVYKGNhbGxlZF9zY29wZSkgPSBjbG9zdXJlLT5vcF9hcnJheS5zY29wZTsKKwkJCX0KKwkJ CXp2YWxfZHRvcihmcmVlX29wMi52YXIpOworCQkJWkVORF9WTV9ORVhUX09QQ09ERSgpOwor CQl9CiAKIAkJaWYgKFpfVFlQRV9QKGZ1bmN0aW9uX25hbWUpICE9IElTX1NUUklORykgewog CQkJemVuZF9lcnJvcl9ub3JldHVybihFX0VSUk9SLCAiRnVuY3Rpb24gbmFtZSBtdXN0IGJl IGEgc3RyaW5nIik7CkBAIC0xMDMwLDYgKzEwNTgsMjAgQEAgc3RhdGljIGludCBaRU5EX0ZB U1RDQUxMICBaRU5EX0lOSVRfRkNBTAogCQl9CiAJfSBlbHNlIHsKIAkJZnVuY3Rpb25fbmFt ZSA9IF9nZXRfenZhbF9wdHJfdmFyKCZvcGxpbmUtPm9wMiwgRVgoVHMpLCAmZnJlZV9vcDIg VFNSTUxTX0NDKTsKKwkJemVuZF9jbG9zdXJlICpjbG9zdXJlOworCisJCWlmIChaX1RZUEVf UChmdW5jdGlvbl9uYW1lKSA9PSBJU19SRVNPVVJDRSAmJgorCQkgICAgKGNsb3N1cmUgPSAo emVuZF9jbG9zdXJlKikgemVuZF9mZXRjaF9yZXNvdXJjZSAoJmZ1bmN0aW9uX25hbWUgVFNS TUxTX0NDLCAtMSwgTlVMTCwgTlVMTCwgMSwgbGVfbGFtYmRhX2Z1bmMpKSAhPSBOVUxMKSB7 CisJCQlFWChmYmMpID0gKHplbmRfZnVuY3Rpb24qKSZjbG9zdXJlLT5vcF9hcnJheTsKKwkJ CWlmICgoRVgob2JqZWN0KSA9IGNsb3N1cmUtPlRoaXMpICE9IE5VTEwpIHsKKwkJCQlaX0FE RFJFRl9QKEVYKG9iamVjdCkpOworCQkJCUVYKGNhbGxlZF9zY29wZSkgPSBaX09CSkNFX1Ao RVgob2JqZWN0KSk7CisJCQl9IGVsc2UgeworCQkJCUVYKGNhbGxlZF9zY29wZSkgPSBjbG9z dXJlLT5vcF9hcnJheS5zY29wZTsKKwkJCX0KKwkJCWlmIChmcmVlX29wMi52YXIpIHt6dmFs X3B0cl9kdG9yKCZmcmVlX29wMi52YXIpO307CisJCQlaRU5EX1ZNX05FWFRfT1BDT0RFKCk7 CisJCX0KIAogCQlpZiAoWl9UWVBFX1AoZnVuY3Rpb25fbmFtZSkgIT0gSVNfU1RSSU5HKSB7 CiAJCQl6ZW5kX2Vycm9yX25vcmV0dXJuKEVfRVJST1IsICJGdW5jdGlvbiBuYW1lIG11c3Qg YmUgYSBzdHJpbmciKTsKQEAgLTExNTQsNiArMTE5NiwyMCBAQCBzdGF0aWMgaW50IFpFTkRf RkFTVENBTEwgIFpFTkRfSU5JVF9GQ0FMCiAJCX0KIAl9IGVsc2UgewogCQlmdW5jdGlvbl9u YW1lID0gX2dldF96dmFsX3B0cl9jdigmb3BsaW5lLT5vcDIsIEVYKFRzKSwgQlBfVkFSX1Ig VFNSTUxTX0NDKTsKKwkJemVuZF9jbG9zdXJlICpjbG9zdXJlOworCisJCWlmIChaX1RZUEVf UChmdW5jdGlvbl9uYW1lKSA9PSBJU19SRVNPVVJDRSAmJgorCQkgICAgKGNsb3N1cmUgPSAo emVuZF9jbG9zdXJlKikgemVuZF9mZXRjaF9yZXNvdXJjZSAoJmZ1bmN0aW9uX25hbWUgVFNS TUxTX0NDLCAtMSwgTlVMTCwgTlVMTCwgMSwgbGVfbGFtYmRhX2Z1bmMpKSAhPSBOVUxMKSB7 CisJCQlFWChmYmMpID0gKHplbmRfZnVuY3Rpb24qKSZjbG9zdXJlLT5vcF9hcnJheTsKKwkJ CWlmICgoRVgob2JqZWN0KSA9IGNsb3N1cmUtPlRoaXMpICE9IE5VTEwpIHsKKwkJCQlaX0FE RFJFRl9QKEVYKG9iamVjdCkpOworCQkJCUVYKGNhbGxlZF9zY29wZSkgPSBaX09CSkNFX1Ao RVgob2JqZWN0KSk7CisJCQl9IGVsc2UgeworCQkJCUVYKGNhbGxlZF9zY29wZSkgPSBjbG9z dXJlLT5vcF9hcnJheS5zY29wZTsKKwkJCX0KKworCQkJWkVORF9WTV9ORVhUX09QQ09ERSgp OworCQl9CiAKIAkJaWYgKFpfVFlQRV9QKGZ1bmN0aW9uX25hbWUpICE9IElTX1NUUklORykg ewogCQkJemVuZF9lcnJvcl9ub3JldHVybihFX0VSUk9SLCAiRnVuY3Rpb24gbmFtZSBtdXN0 IGJlIGEgc3RyaW5nIik7CkBAIC0yODc1LDYgKzI5MzEsNDQgQEAgc3RhdGljIGludCBaRU5E X0ZBU1RDQUxMICBaRU5EX0RFQ0xBUkVfQwogCVpFTkRfVk1fTkVYVF9PUENPREUoKTsKIH0K IAorc3RhdGljIGludCBaRU5EX0ZBU1RDQUxMICBaRU5EX0RFQ0xBUkVfTEFNQkRBX0ZVTkNU SU9OX1NQRUNfQ09OU1RfQ09OU1RfSEFORExFUihaRU5EX09QQ09ERV9IQU5ETEVSX0FSR1Mp Cit7CisJemVuZF9vcCAqb3BsaW5lID0gRVgob3BsaW5lKTsKKwl6ZW5kX29wX2FycmF5ICpv cF9hcnJheTsKKwl6ZW5kX2Nsb3N1cmUgICpjbG9zdXJlOworCisJaWYgKHplbmRfaGFzaF9x dWlja19maW5kKEVHKGZ1bmN0aW9uX3RhYmxlKSwgWl9TVFJWQUwob3BsaW5lLT5vcDEudS5j b25zdGFudCksIFpfU1RSTEVOKG9wbGluZS0+b3AxLnUuY29uc3RhbnQpLCBaX0xWQUwob3Bs aW5lLT5vcDIudS5jb25zdGFudCksICh2b2lkICopICZvcF9hcnJheSkgPT0gRkFJTFVSRSB8 fAorCSAgICBvcF9hcnJheS0+dHlwZSAhPSBaRU5EX1VTRVJfRlVOQ1RJT04pIHsKKwkJemVu ZF9lcnJvcl9ub3JldHVybihFX0VSUk9SLCAiQmFzZSBsYW1iZGEgZnVuY3Rpb24gZm9yIGNs b3N1cmUgbm90IGZvdW5kIik7CisJfQorCisJY2xvc3VyZSA9IGVtYWxsb2Moc2l6ZW9mKHpl bmRfY2xvc3VyZSkpOworCWNsb3N1cmUtPm9wX2FycmF5ID0gKm9wX2FycmF5OworCisJaWYg KGNsb3N1cmUtPm9wX2FycmF5LnN0YXRpY192YXJpYWJsZXMpIHsKKwkJSGFzaFRhYmxlICpz dGF0aWNfdmFyaWFibGVzID0gY2xvc3VyZS0+b3BfYXJyYXkuc3RhdGljX3ZhcmlhYmxlczsK KworCQlBTExPQ19IQVNIVEFCTEUoY2xvc3VyZS0+b3BfYXJyYXkuc3RhdGljX3ZhcmlhYmxl cyk7CisJCXplbmRfaGFzaF9pbml0KGNsb3N1cmUtPm9wX2FycmF5LnN0YXRpY192YXJpYWJs ZXMsIHplbmRfaGFzaF9udW1fZWxlbWVudHMoc3RhdGljX3ZhcmlhYmxlcyksIE5VTEwsIFpW QUxfUFRSX0RUT1IsIDApOworCQl6ZW5kX2hhc2hfYXBwbHlfd2l0aF9hcmd1bWVudHMoc3Rh dGljX3ZhcmlhYmxlcywgKGFwcGx5X2Z1bmNfYXJnc190KXp2YWxfY29weV9zdGF0aWNfdmFy LCAxLCBjbG9zdXJlLT5vcF9hcnJheS5zdGF0aWNfdmFyaWFibGVzKTsKKwl9CisKKwlpZiAo KGNsb3N1cmUtPm9wX2FycmF5LnNjb3BlID0gRUcoc2NvcGUpKSAhPSBOVUxMKSB7CisJCWNs b3N1cmUtPm9wX2FycmF5LmZuX2ZsYWdzIHw9IFpFTkRfQUNDX1BVQkxJQzsKKwkJaWYgKChj bG9zdXJlLT5UaGlzID0gRUcoVGhpcykpICE9IE5VTEwpIHsKKwkJCVpfQUREUkVGX1AoY2xv c3VyZS0+VGhpcyk7CisJCX0gZWxzZSB7CisJCQljbG9zdXJlLT5vcF9hcnJheS5mbl9mbGFn cyB8PSBaRU5EX0FDQ19TVEFUSUM7CisJCX0KKwl9IGVsc2UgeworCQljbG9zdXJlLT5UaGlz ID0gTlVMTDsKKwl9CisJKCpjbG9zdXJlLT5vcF9hcnJheS5yZWZjb3VudCkrKzsKKworCVpF TkRfUkVHSVNURVJfUkVTT1VSQ0UoJkVYX1Qob3BsaW5lLT5yZXN1bHQudS52YXIpLnRtcF92 YXIsIGNsb3N1cmUsIGxlX2xhbWJkYV9mdW5jKTsKKwlaRU5EX1ZNX05FWFRfT1BDT0RFKCk7 Cit9CisKIHN0YXRpYyBpbnQgWkVORF9GQVNUQ0FMTCAgWkVORF9BRERfU1BFQ19DT05TVF9U TVBfSEFORExFUihaRU5EX09QQ09ERV9IQU5ETEVSX0FSR1MpCiB7CiAJemVuZF9vcCAqb3Bs aW5lID0gRVgob3BsaW5lKTsKQEAgLTMzNTA4LDYgKzMzNjAyLDMxIEBAIHZvaWQgemVuZF9p bml0X29wY29kZXNfaGFuZGxlcnModm9pZCkKICAgCVpFTkRfSk1QX1NFVF9TUEVDX0NWX0hB TkRMRVIsCiAgIAlaRU5EX0pNUF9TRVRfU1BFQ19DVl9IQU5ETEVSLAogICAJWkVORF9KTVBf U0VUX1NQRUNfQ1ZfSEFORExFUiwKKyAgCVpFTkRfREVDTEFSRV9MQU1CREFfRlVOQ1RJT05f U1BFQ19DT05TVF9DT05TVF9IQU5ETEVSLAorICAJWkVORF9OVUxMX0hBTkRMRVIsCisgIAla RU5EX05VTExfSEFORExFUiwKKyAgCVpFTkRfTlVMTF9IQU5ETEVSLAorICAJWkVORF9OVUxM X0hBTkRMRVIsCisgIAlaRU5EX05VTExfSEFORExFUiwKKyAgCVpFTkRfTlVMTF9IQU5ETEVS LAorICAJWkVORF9OVUxMX0hBTkRMRVIsCisgIAlaRU5EX05VTExfSEFORExFUiwKKyAgCVpF TkRfTlVMTF9IQU5ETEVSLAorICAJWkVORF9OVUxMX0hBTkRMRVIsCisgIAlaRU5EX05VTExf SEFORExFUiwKKyAgCVpFTkRfTlVMTF9IQU5ETEVSLAorICAJWkVORF9OVUxMX0hBTkRMRVIs CisgIAlaRU5EX05VTExfSEFORExFUiwKKyAgCVpFTkRfTlVMTF9IQU5ETEVSLAorICAJWkVO RF9OVUxMX0hBTkRMRVIsCisgIAlaRU5EX05VTExfSEFORExFUiwKKyAgCVpFTkRfTlVMTF9I QU5ETEVSLAorICAJWkVORF9OVUxMX0hBTkRMRVIsCisgIAlaRU5EX05VTExfSEFORExFUiwK KyAgCVpFTkRfTlVMTF9IQU5ETEVSLAorICAJWkVORF9OVUxMX0hBTkRMRVIsCisgIAlaRU5E X05VTExfSEFORExFUiwKKyAgCVpFTkRfTlVMTF9IQU5ETEVSLAogICAJWkVORF9OVUxMX0hB TkRMRVIKICAgfTsKICAgemVuZF9vcGNvZGVfaGFuZGxlcnMgPSAob3Bjb2RlX2hhbmRsZXJf dCopbGFiZWxzOwpJbmRleDogWmVuZC96ZW5kX3ZtX29wY29kZXMuaAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 ClJDUyBmaWxlOiAvcmVwb3NpdG9yeS9aZW5kRW5naW5lMi96ZW5kX3ZtX29wY29kZXMuaCx2 CnJldHJpZXZpbmcgcmV2aXNpb24gMS40Mi4yLjE3LjIuMS4yLjYKZGlmZiAtdSAtcCAtZCAt cjEuNDIuMi4xNy4yLjEuMi42IHplbmRfdm1fb3Bjb2Rlcy5oCi0tLSBaZW5kL3plbmRfdm1f b3Bjb2Rlcy5oCTI4IE1hciAyMDA4IDE0OjM1OjAxIC0wMDAwCTEuNDIuMi4xNy4yLjEuMi42 CisrKyBaZW5kL3plbmRfdm1fb3Bjb2Rlcy5oCTE5IEp1biAyMDA4IDEwOjA0OjQwIC0wMDAw CkBAIC0xNTIsMyArMTUyLDQgQEAKICNkZWZpbmUgWkVORF9IQU5ETEVfRVhDRVBUSU9OICAg ICAgICAgICAgICAgIDE0OQogI2RlZmluZSBaRU5EX1VTRVJfT1BDT0RFICAgICAgICAgICAg ICAgICAgICAgMTUwCiAjZGVmaW5lIFpFTkRfSk1QX1NFVCAgICAgICAgICAgICAgICAgICAg ICAgICAxNTIKKyNkZWZpbmUgWkVORF9ERUNMQVJFX0xBTUJEQV9GVU5DVElPTiAgICAgICAg IDE1MwpJbmRleDogZXh0L3BjcmUvcGhwX3BjcmUuYwo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBmaWxl OiAvcmVwb3NpdG9yeS9waHAtc3JjL2V4dC9wY3JlL3BocF9wY3JlLmMsdgpyZXRyaWV2aW5n IHJldmlzaW9uIDEuMTY4LjIuOS4yLjIxLjIuMTUKZGlmZiAtdSAtcCAtZCAtcjEuMTY4LjIu OS4yLjIxLjIuMTUgcGhwX3BjcmUuYwotLS0gZXh0L3BjcmUvcGhwX3BjcmUuYwkxIEp1biAy MDA4IDE4OjQ3OjIwIC0wMDAwCTEuMTY4LjIuOS4yLjIxLjIuMTUKKysrIGV4dC9wY3JlL3Bo cF9wY3JlLmMJMTkgSnVuIDIwMDggMTA6MDQ6NDAgLTAwMDAKQEAgLTEzMTIsNyArMTMxMiw3 IEBAIHN0YXRpYyB2b2lkIHByZWdfcmVwbGFjZV9pbXBsKElOVEVSTkFMX0YKIAl9CiAKIAlT RVBBUkFURV9aVkFMKHJlcGxhY2UpOwotCWlmIChaX1RZUEVfUFAocmVwbGFjZSkgIT0gSVNf QVJSQVkpCisJaWYgKFpfVFlQRV9QUChyZXBsYWNlKSAhPSBJU19BUlJBWSAmJiBaX1RZUEVf UFAocmVwbGFjZSkgIT0gSVNfUkVTT1VSQ0UpCiAJCWNvbnZlcnRfdG9fc3RyaW5nX2V4KHJl cGxhY2UpOwogCWlmIChpc19jYWxsYWJsZV9yZXBsYWNlKSB7CiAJCWlmICghemVuZF9pc19j YWxsYWJsZSgqcmVwbGFjZSwgMCwgJmNhbGxiYWNrX25hbWUpKSB7Cg== --------------060008040609030900030108--