ZGlmZiAtLWdpdCBhL2RvYy9kcml2ZXIvY29kZXN0eWxlIGIvZG9jL2RyaXZlci9jb2Rlc3R5bGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzhhMDViNgotLS0gL2Rldi9udWxsCisrKyBiL2RvYy9kcml2ZXIvY29kZXN0eWxlCkBAIC0wLDAgKzEsMjQ3IEBACisgICAgVGhlIExQTXVkIGdhbWVkcml2ZXIgaXMgYnkgbmF0dXJlIHRoZSByZXN1bHQgb2YgdGhlIGNvb3BlcmF0aXZlIHdvcmsKKyAgICBvZiBtdWx0aXBsZSBwcm9ncmFtbWVycywgb2Z0ZW4gc2VwYXJhdGVkIGJ5IGxhcmdlIG9jZWFucyBhbmQgeWVhcnMKKyAgICBvZiB0aW1lLiBJbiBvcmRlciB0byBrZWVwIHRoZSBhcHBlYXJhbmNlIG9mIHRoZSBkcml2ZXIgc291cmNlIGNvbnNpc3RlbnQKKyAgICAoYW5kIHdpdGggdGhhdCBtYWludGFpbmFibGUpLCB0aGUgZm9sbG93aW5nIGd1aWRlbGluZXMgc2hvdWxkIGJlIGZvbGxvd2VkCisgICAgZm9yIGFsbCBjb2RlIGNvbnRyaWJ1dGlvbnMuCisKKyAgICBGb3IgYSBxdWljayBzdGFydCBpbiBob3cgZ29vZCBkcml2ZXIgc291cmNlIHNob3VsZCBsb29rIGxpa2UsIHRha2UKKyAgICBhIGxvb2sgYXQgY29tbS57YyxofSwgb2JqZWN0LntjLGh9IGFuZCBtYXBwaW5nLntjLmh9LgorCisgICAgVGhlIGd1aWRlbGluZXMgaGF2ZSBhIHN0cm9uZyBlbXBoYXNpcyBvbiBjb2RlIGxheW91dCBhbmQgY29tbWVudGluZywKKyAgICBzdGVtbWluZyBmcm9tIHRoZSBmYWN0IHRoYXQgcHJvcGVyIGxheW91dCBhbmQgY29tbWVudHMgZ2F2ZSB0aGUKKyAgICBpbmNlbnRpdmUgZm9yIExETXVkIGluIHRoZSBmaXJzdCBwbGFjZS4gUmlnaHQgbm93LCA1MCUgb2YgYWxsIGxpbmVzCisgICAgYXJlIGNvbW1lbnRzLCBhbmQgdGhhdCBoYXMgYmVlbiBwcm92ZW4gdG8gYmUgYSBHb29kIFRoaW5nLgorCisgICAgQW55IHJlYWRlciBvZiB0aGUgInJlYWwgcHJvZ3JhbW1lcnMgZG9uJ3Qgd3JpdGUgY29tbWVudHMiLXNjaG9vbAorICAgIG9mIHRob3VnaHQgaXMgYXNrZWQgdG8gdGFrZSBoaXMgb3IgaGVyIGluY29tcGV0ZW5jZSBlbHNld2hlcmUuCisKKworTGFuZ3VhZ2UKKy0tLS0tLS0tCisgICAgVGhlIGxhbmd1YWdlIGlzIElTTyBTdGFuZGFyZCBDIChhbHNvIGtub3duIGFzICdDODknIG9yICdBTlNJIEMnKS4KKyAgICBDb21tb24gY29tcGlsZXIgZXh0ZW5zaW9ucyBvciBmZWF0dXJlcyBmcm9tIHRoZSBuZXcgQzk5IHN0YW5kYXJkIGFyZQorICAgIHBlcm1pdHRlZCBpZiB0aGVpciBhZGRpdGlvbiBpcyB0cmFuc3BhcmVudCBmb3Igb3RoZXIgQzg5IGNvbXBpbGVycy4KKyAgICBGb3IgZXhhbXBsZTogdGhlICdpbmxpbmUnIGtleXdvcmQgcGVybWl0dGVkIHRocm91Z2ggdGhlIHVzZSBvZiB0aGUKKyAgICBJTkxJTkUgbWFjcm87IHNvIGFyZSB0aGUgTWV0cm93ZXJrcy1wcmFnbWFzIGFuZCBHTlUtYXR0cmlidXRlcy4gTm90CisgICAgcGVybWl0dGVkIGFyZSBHTlUncyBsb2NhbCBmdW5jdGlvbnMuCisKKyAgICBTeXN0ZW0vUGxhdGZvcm0gc3BlY2lmaWNzIGFyZSB0byBiZSBkZXRlY3RlZCBieSB0aGUgY29uZmlndXJlIHNjcmlwdAorICAgIGFuZCBwcm92aWRlZCB3aXRoIHRyYW5zcGFyZW50IGltcGxlbWVudGF0aW9ucyBpbiBwb3J0LntjLGh9IChvciBmb3IKKyAgICBtb2R1bGUtc3BlY2lmaWMgZGVwZW5kZW5jaWVzIGluIHRoZSByZXNwZWN0aXZlIG1vZHVsZXMpLgorCisgICAgQWRoZXJlbmNlIHRvIHRoZSBTdGFuZGFyZCBoYXMgdGhlIGZvbGxvd2luZyBpbXBsaWNhdGlvbnM6CisKKyAgICAgLSBBbGwgZnVuY3Rpb25zIG11c3QgYmUgZnVsbHkgcHJvdG90eXBlZC4KKyAgICAgLSBTdGFuZGFyZCB0eXBlcyBsaWtlIHNpemVfdCwgc3NpemVfdCBvciBwdHJkaWZmX3QgYXJlIHRvIGJlIHVzZWQKKyAgICAgICB3aGVyZWV2ZXIgcG9zc2libGUuCisgICAgIC0gVW5peGlzbXMgbGlrZQorICAgICAgICAgeworICAgICAgICAgICBhID0gbWFsbG9jKDIwKTsKKyAgICAgICAgICAgYiA9IG1hbGxvYygyMCk7CisgICAgICAgICAgIGMgPSBiLWE7CisgICAgICAgICB9CisgICAgICAgYXJlIG5vdCBsZWdhbCBhbmQgc2hvdWxkbid0IGJlIHVzZWQuCisgICAgIC0gRG9uJ3QgbWFrZSBhc3N1bXB0aW9ucyBhYm91dCB0aGUgc2l6ZSBvZiB0aGUgYmFzZSB0eXBlcyAoZS5nLgorICAgICAgIGEgY2hhciBtaWdodCBoYXZlIG1vcmUgdGhhbiA4IGJpdHMpLiBJZiBzdWNoIGFuIGFzc3VtcHRpb24KKyAgICAgICBpcyB1bmF2b2lkYWJsZSwgY29tbWVudCBpdCBjbGVhcmx5IGFuZCBpZiBwb3NzaWJsZSBhZGQgYSB0ZXN0CisgICAgICAgdG8gcmFpc2UgYSBjb21waWxlIG9yIHJ1bnRpbWUgZXJyb3IgaWYgdGhlIGFzc3VtcHRpb24gaXMgbm90IG1ldC4KKworCitTdHlsZQorLS0tLS0KKyAgICBBbGwgbW9kdWxlcyAoLmMtZmlsZXMpIGhhdmUgdG8gaGF2ZSB0aGVpciBpbnRlcmZhY2UgaW4gYW4gYWNjb21wYW5pbmcKKyAgICAuaC1maWxlLiBUaGUgaGVhZGVyIGZpbGUgbXVzdCBiZSBndWFyZGVkIGFnYWluc3QgcmVwZWF0ZWQgaW5jbHVzaW9uCisgICAgd2l0aCB0aGUgbm9ybWFsCisgICAgICAgICNpZm5kZWYgSEVBREVSTkFNRV9ICisgICAgICAgICNkZWZpbmUgSEVBREVSTkFNRV9IIDEKKyAgICAgICAgICAuLi4KKyAgICAgICAgI2VuZGlmIC8qIEhFQURFUk5BTUVfSCAqLworICAgIGNvbnN0cnVjdC4gVG8gdXNlIGEgbW9kdWxlLCBpdHMgaGVhZGVyZmlsZSBtdXN0IGJlIGluY2x1ZGVkIC0gbm8gcmFuZG9tCisgICAgJ2V4dGVybicgZGVjbGFyYXRpb25zLgorCisgICAgRXZlcnkgbW9kdWxlIG11c3QgaW5jbHVkZSAiZHJpdmVyLmgiIHdoaWNoIGluIHR1cm4gaW5jbHVkZXMgdGhlCisgICAgcG9ydGFiaWxpdHkgaGVhZGVycyBhbmQgcHJvdmlkZXMgY29tbW9uIGRlZmluZXMuCisKKyAgICBVc2UgdGhlIGRyaXZlci1wcm92aWRlZCB0eXBlcyBhbmQgbWFjcm9zIGxpa2UgQm9vbCBvciBwX2ludC4KKworICAgIENvZGUgc2hvdWxkIGJlIHdyaXR0ZW4gZGVmZW5zaXZlbHkgYW5kIHJlYWRhYmxlLiBUaGlzIGlzIG5vdCB0aGUgSU9DQ0MuCisKKyAgICBObyBtYWdpYyBudW1iZXJzIC0gdXNlICNkZWZpbmVzIHRvIGdpdmUgdGhlbSBuYW1lcy4KKworICAgIEFkZCBzYW5pdHkgY2hlY2tzIHdoZXJlIHVzZWZ1bC4gSWYgdGhlIGNoZWNrcyBhcmUgY29zdGx5LCBlbmNsb3NlCisgICAgdGhlbSBpbiBhICNpZmRlZiBERUJVRy4uLiNlbmRpZiBicmFja2V0LgorCisgICAgQ29tbWVudCBxdWVzdGlvbmFibGUgY29kZSBvciBvcHBvcnR1bml0aWVzIGZvciBwb3NzaWJsZSBleHRlbnNpb25zIHdpdGggYQorICAgICdUT0RPOiAuLi4nIGNvbW1lbnQuIEZvciBtdWx0aWxpbmUgY29tbWVudHMsIHVzZSAnVE9ETzo6JyBvbiB0aGUgc2Vjb25kCisgICAgYW5kIGZvbGxvd2luZyBsaW5lcyAodGhpcyBtYWtlcyByZWFkaW5nIGEgZ3JlcCBlYXNpZXIpLgorCisgICAgQ29tbWVudCB0ZW1wb3JhcnkgZGVidWcgY29kZSB3aXRoIGEgJ0RFQlVHOicgY29tbWVudC4gU2ltaWxhciwgZGVidWcKKyAgICBvdXRwdXQgc2hvdWxkIGFsd2F5cyBiZWdpbiB3aXRoICdERUJVRzonLgorCisgICAgVmFyaWFibGUgaWRlbnRpZmllcnMgc2hvdWxkIHN0YXJ0IHdpdGggYSBsb3dlcmNhc2UgbGV0dGVyLCBmdW5jdGlvbgorICAgIGlkZW50aWZpZXJzIG1heSBzdGFydCB3aXRoIHVwcGVyIG9yIGxvd2VyY2FzZSwgY29uc3RhbnQgaWRlbnRpZmllcnMKKyAgICBzaG91bGQgc3RhcnQgd2l0aCBhbiB1cHBlcmNhc2UgbGV0dGVyLiBNYWNybyBpZGVudGlmaWVycyBzaG91bGQgYmUKKyAgICBhbGwgVVBQRVJDQVNFLCBvdGhlciBpZGVudGlmaWVycyBtYXkgYmUgdW5kZXJfc2NvcmVkIG9yIFNrdWRseUNhcHMuCisgICAgSHVuZ2FyaWFuIG5vdGF0aW9uIGlzIGFjY2VwdGVkIG9ubHkgaW4gYSB2ZXJ5IGxpZ2h0IGZvcm06IHBGb28gZm9yCisgICAgcG9pbnRlcnMsIHBwRm9vIGZvciBwb2ludGVyIHRvIHBvaW50ZXJzLCBpRm9vIGZvciBpbnRlZ2VyIHR5cGVzLAorICAgIHNGb28gZm9yIHN0cmluZyBwb2ludGVycywgYUZvbyBmb3IgY29tcGxleCB0eXBlcyAtIHlvdSBnZXQgdGhlCisgICAgaWRlYS4gQnV0IG5vIGFscHpzRm9vIGFuZCBmcmllbmRzLgorCisgICAgZl94eHgoKSBmdW5jdGlvbiBuYW1lcyBhcmUgcmVzZXJ2ZWQgZm9yIGVmdW4gaW1wbGVtZW50YXRpb25zLgorICAgIHR5cGVkZWYnZCB0eXBlbmFtZXMgc2hvdWxkIGVuZCBpbiBfdCAoZS5nLiAnbWFwcGluZ190JyksIHN0cnVjdAorICAgIG5hbWVzIHNob3VsZCBlbmQgaW4gX3MgKGUuZy4gJ3N0cnVjdCBpbnN0cnNfcycpLgorCisgICAgSW5kZW50YXRpb24gaXMgNCBzcGFjZXMgcGVyIGxldmVsLiBObyB0YWIgY2hhcmFjdGVycyBhbnl3aGVyZSEKKworICAgIFRoZSBpbmRlbnRhdGlvbiBzdHlsZSBpcyBhIHZhcmlhbnQgb2YgdGhlICdBbGxtYW4gc3R5bGUnOgorCisgICAgICAgIGlmIChmb28pCisgICAgICAgIHsKKyAgICAgICAgICAgIC4uLmJvZHkuLi4KKyAgICAgICAgfSAvKiBpZiAoZm9vKSAqLworCisgICAgTm90ZSB0aGUgY29tbWVudCBhdCB0aGUgY2xvc2luZyBicmFjZSEKKworICAgIE9uZSBsaW5lIGJvZGllcyBtYXkgYmUgd3JpdHRlbiBhcworCisgICAgICAgIGlmIChmb28pIGJvZHk7CisKKyAgICBvcgorCisgICAgICAgIGlmIChmb28pCisgICAgICAgICAgICBib2R5OworCisgICAgX2lmXyBpdCBpbXByb3ZlcyB0aGUgcmVhZGFiaWxpdHkuCisKKyAgICBTaW1pbGFyLCB0aGUgdHlwaWNhbCBsYXlvdXQgb2YgYSBmdW5jdGlvbiBpczoKKworICAgICAgICBzdGF0aWMgaW50CisgICAgICAgIGZ1bmN0aW9uX25hbWUgKCBhcmcxICwgYXJnMikKKworICAgICAgICAvKiBUd2lkZGxlIDxhcmcxPiB3aXRoIDxhcmcyPiBhbmQgcmV0dXJuIHRoZSByZXN1bHQuCisgICAgICAgICAqLworCisgICAgICAgIHsKKyAgICAgICAgICAgIC4uLi4KKyAgICAgICAgfSAvKiBmdW5jdGlvbl9uYW1lKCkgKi8KKworICAgIElmIGFuIGV4cHJlc3Npb24gKGFyZ3VtZW50IGxpc3QsIC4uLikgZXh0ZW5kcyBvdmVyIHNldmVyYWwsIHRoZSBmaXJzdAorICAgIGxpdGVyYWwgZWxlbWVudCBvbiBhIGxpbmUgc2hvdWxkIGJlIGFuIG9wZXJhdG9yIG9yIHN5bnRhY3RpY2FsIG1hcmtlcjoKKworICAgICAgICBpZiAoY29uZGl0aW9uMQorICAgICAgICAgJiYgKCAgIGNvbmRpdGlvbjIKKyAgICAgICAgICAgICB8fCBjb25kaXRpb24zKQorICAgICAgICAgICApCisKKyAgICAgICAgcHJpbnRmKCAiLi4uIgorICAgICAgICAgICAgICAsIGFyZzEsIGFyZzIsIGFyZzMKKyAgICAgICAgICAgICAgKTsKKworICAgIEJlIGdlbmVyb3VzIHdpdGggd2hpdGVzcGFjZSAtIGJvdGggaG9yaXpvbnRhbCBhbmQgdmVydGljYWwuCisKKyAgICBbIFRoZSByZWFzb25pbmcgYmVoaW5kIHRoaXMgc3R5bGUgaXMgdG8gdXNlIHRoZSBsYW5ndWFnZSBlbGVtZW50cworICAgICAgdG8gY3JlYXRlIHN0cm9uZyB2aXN1YWwgc3RydWN0dXJlcyBmb3IgdGhlIGV5ZXMgdG8gZm9sbG93LiBCeSBkb2luZyBzbywKKyAgICAgIHRoZSBzdHJ1Y3R1cmUgb2YgdGhlIHByb2dyYW0gYmVjb21lcyBvYnZpb3VzIHdpdGhvdXQgbXVjaAorICAgICAgY29uc2Npb3VzIHRob3VnaHQuCisgICAgXQorCisKK0NvbW1lbnRpbmcKKy0tLS0tLS0tLS0KKyAgICBUaGUgY29tbWVudHMgYWxzbyBmb2xsb3cgdGhlIGlkZWEgb2YgZ2l2aW5nIHN0cm9uZyB2aXN1YWwgY2x1ZXMgb2YKKyAgICBob3cgdGhlIHByb2dyYW0gaXMgc3RydWN0dXJlZC4KKworICAgIEhvcml6b250YWwgbGluZXMgc2hvdWxkIGJlIGNyZWF0ZWQgYXMKKworICAgICAgICAvKi0tLS0tLS4uLi0tLS0tLS0qLworICAgICAgICAvKj09PT09PS4uLj09PT09PT0qLworICAgICAgICAvKiAtIC0gLS4uLiAtIC0gLSAqLworCisgICAgVGhlICctLS0nIGxpbmUgaXMgdGhlIG5vcm1hbCBzZXBhcmF0b3IgYmV0d2VlbiB0aGUgY29tcG9uZW50cyBvZiBhCisgICAgc291cmNlIGZpbGUgKGluY2x1ZGVzLCB2YXJpYWJsZSBkZWNsYXJhdGlvbnMsIG1hY3JvIGRlY2xhcmF0aW9ucywKKyAgICB0aGUgc2VwYXJhdGUgZnVuY3Rpb25zKS4gVGhlICc9PT0nIGxpbmUgY2FuIGJlIHVzZWQgdG8gc2VwYXJhdGUKKyAgICBsYXJnZXIgc2VjdGlvbnMgb2YgYSBzb3VyY2UgZmlsZSAoZS5nLiB0aGUgbG93bGV2ZWwgcm91dGluZXMgZnJvbQorICAgIHRoZSBlZnVuIGltcGxlbWVudGF0aW9ucykuICctIC0nIGxpbmVzLCB3aGljaCB1c2FsbHkgc3BhbiBsZXNzIHRoYW4KKyAgICB0aGUgd2hvbGUgbGluZSwgY2FuIGJlIHVzZWQgdG8gc3ViZGl2aWRlIGxhcmdlIGZ1bmN0aW9ucyAodGhvdWdoIHRoZW4KKyAgICBpdCdzIG9mdGVuIGJldHRlciB0byBzcGxpdCB0aGUgZnVuY3Rpb24gaW50byBzZXZlcmFsIHNtYWxsIG9uZXMpLgorCisgICAgQSAnKioqJyBsaW5lIGlzIHJlc2VydmVkIGZvciB0aGUgZW5kIG9mIGV2ZXJ5IHNvdXJjZSBmaWxlLgorCisgICAgQSAnLyogLS0tIFN1YnNlY3Rpb24gLS0tICovJyBpcyBhbHNvIGdvb2QgdG8gc2VwYXJhdGUgc3Vic2VjdGlvbnMuCisKKyAgICBWZXJ0aWNhbCBsaW5lcyBhcmUgdG8gYmUgY29uc3RydWN0ZWQgYXMKKworICAgICAgLyoKKyAgICAgICAqCisgICAgICAgKi8KKworICAgIE5vIGJveCBjb21tZW50cy4KKworICAgIEV2ZXJ5IGZ1bmN0aW9uIG11c3QgaGF2ZSBhIGhlYWQgY29tbWVudCBleHBsYWluaW5nIHRoZSBtZWFuaW5nCisgICAgb2YgdGhlIGFyZ3VtZW50cywgd2hhdCB0aGUgZnVuY3Rpb24gZG9lcywgYW5kIHRoZSBwb3NzaWJsZSByZXN1bHRzLgorICAgIEZvciBlZnVuIGltcGxlbWVudGF0aW9ucywgdGhpcyBjb21tZW50IHNob3VsZCBiZSBpZGVudGljYWwgdG8gdGhlCisgICAgbWFuIHBhZ2UuCisKKyAgICBXaXRoaW4gYSBmdW5jdGlvbiwgZXZlcnkgdmFyaWFibGUgc2hvdWxkIGJlIGNvbW1lbnRlZCBhcworCisgICAgICAgaW50IGZvbzsgIC8qIHNob3J0IGNvbW1lbnQgKi8KKyAgICAgICBpbnQgYmFyOworICAgICAgICAgLyogbG9uZyBjb21tZW50IHdoaWNoIGRvZXNuJ3QgZml0IG9uIG9uZSBsaW5lLgorICAgICAgICAgICovCisKKyAgICBUaGUgbWFqb3Igc3RlcHMgaW4gYSBmdW5jdGlvbiBzaG91bGQgYmUgcHJlY2VlZGVkIGJ5IGEgY29tbWVudAorICAgIGV4cGxhaW5pbmcgdGhlbS4gQWxzbywgd2hlcmV2ZXIgYSBjcml0aWNhbCBkZXNpZ24gZGVjaXNpb24gaGFzCisgICAgYmVlbiBtYWRlLCBhIGNvbW1lbnQgc2hvdWxkIGxpbmUgb3V0IHRoZSB3aGF0cyBhbmQgd2h5czoKKworICAgICAgICAvKiBEdXBsaWNhdGUgdGhlIHN0b3JlZCBhcmd1bWVudHMgZm9yIHRoZSBmdW5jdGlvbiBjYWxsLgorICAgICAgICAgKiAoSXQncyB0ZW1wdGluZyB0byB1c2UgdGhlIHN0b3JlZCBhcmd1bWVudHMgZGlyZWN0bHkKKyAgICAgICAgICogIGluIHRoZSBsYXN0IHBhc3M7IGhvd2V2ZXIgaXQncyBub3QgZ3VhcmFudGVlZCB0aGF0CisgICAgICAgICAqICB0aGUgbGFzdCBwYXNzIGFjdHVhbGx5IGNvbWVzIHRoaXMgZmFyLikKKyAgICAgICAgICovCisKKworICAgIEEgdHlwaWNhbCBmaWxlIGxheW91dCwgY29tbWVudHdpc2UsIGxvb2tzIGxpa2UgdGhpczoKKworICAgICAgICAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICAgICAgICAgKiBHYW1lZHJpdmVyIEJvdW5jaW5nIG1vZHVsZS4KKyAgICAgICAgICoKKyAgICAgICAgICogPHJlc2VydmVkIGZvciBmdXR1cmUgY29weXJpZ2h0IG5vdGljZT4KKyAgICAgICAgICotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgICAgICAgICogJ0JpZyBwaWN0dXJlJyBkZXNjcmlwdGlvbiBvZiB0aGUgbW9kdWxlIGFuZCBpdHMKKyAgICAgICAgICogcmVsYXRpb24gdG8gdGhlIG90aGVyIGdhbWVkcml2ZXIgcGFydHMuCisgICAgICAgICAqCisgICAgICAgICAqIFRyaWNreSBkZXNpZ24gZGlzY3Vzc2lvbnMgYWxzbyBiZWxvbmcgaW4gaGVyZS4KKyAgICAgICAgICotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAgICAgICAgICovCisKKyAgICAgICAgI2luY2x1ZGUgImRyaXZlci5oIgorICAgICAgICAjaW5jbHVkZSAidHlwZWRlZnMuaCIKKworICAgICAgICAjaW5jbHVkZSA8c3RkbGliLmg+CisKKyAgICAgICAgI2luY2x1ZGUgImJvdW5jZS5oIgorICAgICAgICAjaW5jbHVkZSAiYmFja2VuZC5oIgorCisgICAgICAgIC8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLworCisgICAgICAgIC8qIC0tLSBVc2VyIGluZm9ybWF0aW9uIC0tLSAqLworICAgICAgICBpbnRlcmFjdGl2ZV90ICphbGxfYm91bmNlcnNbTUFYX1BMQVlFUlNdOworCisgICAgICAgIC8qIC0tLSAgU3RhdGlzdGljcyAtLS0gKi8KKworICAgICAgICBwX2ludCBudW1iZXJfb2ZfY2FsbHM7CisKKyAgICAgICAgLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCisgICAgICAgIHZvaWQKKyAgICAgICAgYWRkX2JvdW5jZXIgKGludGVyYWN0aXZlX3QgKmJvdW5jZXIpCisKKyAgICAgICAgLyogVGhpcyBmdW5jdGlvbiBhZGRzIDxib3VuY2VyPiB0byB0aGUgYWxsX2JvdW5jZXJzW10uCisgICAgICAgICAqLworICAgICAgICB7CisgICAgICAgICAgICBpbnQgaTsgIC8qIHNlYXJjaCBpbmRleCAqLworCisgICAgICAgICAgICAuLi4uCisgICAgICAgIH0gLyogYWRkX2JvdW5jZXIoKSAqLworCisgICAgICAgIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCmRpZmYgLS1naXQgYS9kb2MvZHJpdmVyL2NvbW1hbmRsaW5lIGIvZG9jL2RyaXZlci9jb21tYW5kbGluZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZTE5N2U5Ci0tLSAvZGV2L251bGwKKysrIGIvZG9jL2RyaXZlci9jb21tYW5kbGluZQpAQCAtMCwwICsxLDYwIEBACitOQU1FCisJY29tbWFuZGxpbmUKKworREVTQ1JJUFRJT04KKwlUaGUgZHJpdmVyIHVuZGVyc3RhbmRzIHNldmVyYWwgY29tbWFuZCBsaW5lIG9wdGlvbnMgYW5kCisJYXJndW1lbnRzLgorCisJLWY8c3RyaW5nPjogV2hlbiB0aGUgbWFzdGVyIG9iamVjdCBpcyBsb2FkZWQgYW5kIGZ1bGx5CisJCSAgICBvcGVyYXRpb25hbCBhZnRlciBzdGFydHVwLCB0aGUgZnVuY3Rpb24gZmxhZygpCisJCSAgICB3aXRoIGFyZ3VtZW50IHN0cmluZyBpcyBhcHBsaWVkIHRvIHRoZSBtYXN0ZXIKKwkJICAgIG9iamVjdCBmb3IgZWFjaCBvY2N1cmVuY2Ugb2YgLWYgaW4gdGhlIGNvbW1hbmQgbGluZS4KKworCS1vCSAgOiBydW4gaW4gY29tcGF0IG1vZGUgKHRodXMgc29tZXRpbWVzIGFsc28gY2FsbGVkCisJCSAgICAtbyBtb2RlKSwgaW5zdGVhZCBvZiBuYXRpdmUgbW9kZS4gTm90ZTogdGhlIGZsYWcKKwkJICAgIGlzIG9ic29sZXRlIGJ5IG5vdywgdGhlIGRyaXZlciBtdXN0IGJlIGNvbXBpbGVkCisJCSAgICB3aXRoIHRoZSBhcHByb3ByaWF0ZSBkZWZpbml0aW9ucyBpbiB0aGUgY29uZmlnLmgKKwkJICAgIGluc3RlYWQuCisKKwktYwkgIDogdHJhY2UgY29tcGlsYXRpb25zLgorCisJLURzeW1ib2wgIDogR2xvYmFsbHkgcHJlLSNkZWZpbmUgc3ltYm9sIGZvciBwcmVwcm9jZXNzb3IuCisKKwktRAkgIDogd2l0aG91dCBzeW1ib2wsIHRoaXMgbG9ncyBzcGVjaWZpYyB0cmFjZSBtZXNzYWdlcworCQkgICAgdG8gL2xvZy9EX1RSQUNFIChpZiB0aGUgZHJpdmVyIHdhcyBjb21waWxlZCBmb3IgaXQpCisKKwktZQkgIDogVGhlIG51bWJlciBvZiBvY2N1cmVuY2VzIG9mIHRoZSAtZSBmbGFnIGlzCisJCSAgICBwYXNzZWQgYXMgYXJndW1lbnQgdG8gdGhlIGVwaWxvZygpIGZ1bmN0aW9uCisJCSAgICBpbiB0aGUgbWFzdGVyIGF0IHN0YXJ0dXAgdGltZS4KKworCS1OCSAgOiBEb24ndCBzdGFydCB0aGUgZXJxIGRlbW9uLgorCisJLU08bWFzdGVyPjogcHJvdmlkZSBhIGRpZmZlcmVudCBuYW1lIGZvciB0aGUgbWFzdGVyIG9iamVjdC4KKworCS1tPGRpcj4JICA6IHByb3ZpZGUgYSBkaWZmZXJlbnQgbXVkbGliIGRpcmVjdG9yeS4KKworCS1ydTxzaXplPiA6IHNldCB0aGUgc2l6ZSBvZiB0aGUgcmVzZXJ2ZWQgdXNlciBtZW1vcnkuCisJLXJtPHNpemU+IDogc2V0IHRoZSBzaXplIG9mIHRoZSByZXNlcnZlZCBtYXN0ZXIgbWVtb3J5LgorCS1yczxzaXplPiA6IHNldCB0aGUgc2l6ZSBvZiB0aGUgcmVzZXJ2ZWQgc3lzdGVtIG1lbW9yeS4KKworCS1FPGNvc3Q+ICA6IHNldCB0aGUgbWF4aW11bSBhbGxvd2VkIGV2YWx1YXRpb24gY29zdC4KKworCS0tbWF4X21hbGxvY2VkIDogc2V0IG1heGltdW0gc2l6ZSBvZiBtYWxsb2NhYmxlIG1lbW9yeSBjaHVua3MuCisJLS1tYXhfc21hbGxfbWFsbG9jZWQgOiBzZXQgbWF4LiBzaXplIG9mIG1hbGxvY2FibGUgbWVtb3J5IGNodW5rcy4KKworCS11PHBvcnQ+IDogc2V0IHRoZSBVRFAgcG9ydCBudW1iZXIgZm9yIElNUCBjb21tdW5pY2F0aW9uLgorCisJLXQJIDogZGlzYWJsZSBoZWFydF9iZWF0IGFuZCByZXNldC4KKworCS1kCSA6IHJ1biB3aXRoIGRlYnVnLgorCisJLXM8dGltZT4gOiBTZXQgdGhlIHRpbWUgYmV0d2VlbiBzd2Fwb3V0IGF0dGVtcHRzLiAtMSBtZWFucworCQkgICBkb24ndCBzd2FwLgorCisJLXkJIDogSWYgdGhlIGRyaXZlciBoYXMgYmVlbiBjb21waWxlZCB3aXRoIFlZREVCVUcsCisJCSAgIHRoaXMgd2lsbCBlbmFibGUgZGVidWcgb3V0cHV0IGZvciB0aGUgTFBDIGNvbXBpbGVyLgorCisJPG51bWJlcj4gOiB0aGUgVENQIHBvcnQgbnVtYmVyIHRvIHVzZSBmb3IgdXNlciBjb25uZWN0aW9ucy4KKworU0VFIEFMU08KKwlmbGFnKE0pLCBlcGlsb2coTSksIG5hdGl2ZShDKSwgaW1wKEMpCmRpZmYgLS1naXQgYS9kb2MvZHJpdmVyL2NvcHlyaWdodC1pc3N1ZSBiL2RvYy9kcml2ZXIvY29weXJpZ2h0LWlzc3VlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjlmMDg2YTUKLS0tIC9kZXYvbnVsbAorKysgYi9kb2MvZHJpdmVyL2NvcHlyaWdodC1pc3N1ZQpAQCAtMCwwICsxLDI1MiBAQAorVGhlIHF1ZXN0aW9uIG9mIHRoZSBDb3B5cmlnaHQgYW5kIFRlcm1zIG9mIFVzZSBmb3IgdGhlIGRyaXZlciBpcyBhbiBvbGQKK29uZS4gSGVyZSBpcyB3aGF0IEkgY291bGQgc2FsdmFnZSBmcm9tIHRoZSBhbXlsYWFyLXVzZXJzIG1haWxpbmcgbGlzdC4KK0ltcG9ydGFudCBpcyBKYWNvYidzIG1haWwgSSByZWNlaXZlZCBpbiAxOTk5IHdoaWNoIGVzc2VudGlhbGx5IGNhc3RzCit0aGUgY3VycmVudCBjb3B5cmlnaHQgdGVybXMgaW4gc3RvbmUuCisKKyAgLS0gTGFycyAobm90IC9MYXJzKQorCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCitEYXRlOiBTYXQsIDEzIE5vdiAxOTkzIDAzOjExOjI5ICswMTAwIChNRVQpCitGcm9tOiBhbXlsYWFyQG1lb2x5b24uaGFuc2UuZGUgKEpvZXJuIFJlbm5lY2tlKQorU3ViamVjdDogTFBtdWQgQ29weXJpZ2h0CitUbzogYnVzZXlAdXgxLmNzby51aXVjLmVkdSAoYnVzZXkgYW5kcmV3KSwgbGFyc0BjZC5jaGFsbWVycy5zZSwKKyAgICAgICAgY3JvZXNAc3dpLnBzeS51dmEubmwsIGd1c2FyQHVuaXdhLnV3YS5PWi5BVSwgZHVlbmluZ0BpYnIuY3MudHUtYnMuZGUsCisgICAgICAgIGphY29iQGNkLmNoYWxtZXJzLnNlLCByX2JlaHJlbkBpbmZvcm1hdGlrLnVuaS1rbC5kZSwKKyAgICAgICAgbXVkQGFsaWprdTA1LmVkdnoudW5pLWxpbnouYWMuYXQsIGFsY2FtYW5AY3MudHUtYmVybGluLmRlCisKK01vdGl2YXRpb24gb2YgdGhpcyBsZXR0ZXI6CitUaGVyZSBzZWVtcyB0byBiZSBhIHBvdGVudGlhbCBmb3IgbXVkcyB0aGF0IHJ1biBvbiBkZWRpY2F0ZWQgbWFjaGluZXMKK3RoYXQgY2hhcmdlIGZlZXMgZnJvbSBwbGF5ZXIgdG8gbWFrZSB0aGUgbXVkIGVjb25vbWljYWxseSBmZWFzaWJsZS4KK1RoZSBDb3B5cmlnaHQgZmlsZSBzYXlzIHRoYXQgTFBtdWQgY2FuIGZyZWVseSB1c2VkIGlmZiBpdCBpcyBub3QgZm9yCittb25ldGFyeSBnYWluLiBOb3cgdGhlIGRlYmF0ZSB3aGF0IGNvbnN0aXR1dGVzIG1vbmV0YXJ5IGdhaW4gYW5kIGlmCithbiBpbmRpdmlkdWFsIGxpY2Vuc2UgaXMgYW4gbGljZW5zZSB0byBicmVhayB0aGUgY29weXJpZ2h0LAoraXMgYW4gaW50ZXJwcmV0YXRpb24gb2YgdGhlIGxpY2Vuc2UgaW4gQ29weXJpZ2h0IG9yIGdpdmVzIHJpZ2h0cworaW5kZXBlbmRlbnQgdGhlIHJlc3RyaWN0aW9ucyBpbiBDb3B5cmlnaHQgaGFzIGJlY29tZSBhIG5vcm1hbCBmbGFtZQord2FyIGluIHRoZSByZWMuZ2FtZXMubXVkLiogZ3JvdXBzLiBUaGF0IGlzIHRvIHNheSwgb25lIG9mIHRoZSB3b3JzdAordGhpbmthYmxlLgorCitUbyBhbGxvdyBtdWRzIHRvIGNoYXJnZSBmZWVzIHRvIGNvdmVyIGNvc3RzLCB3aXRob3V0IGdvaW5nIHRocm91Z2gKK3N1Y2ggZGViYXRlcyBldmVyeSB0aW1lLCBJIHN1Z2dlc3QgdG8gYW1lbmQgdGhlIENvcHlyaWdodCBmaWxlCit3aXRoIHRlcm1zIHVuZGVyIHdpdGNoIHN1Y2ggYSBtdWQgaXMgY29uc2lkZXJlZCB0byBjb21wbHkgdG8gdGhlCisnbm8gbW9uZXRhcnkgZ2FpbiBjbGF1c2UnIC4KKworRXhwbGFuYXRpb24gb2YgdGhlIHJlY2lwaWVudCBsaXN0IGFuZCBzb21lIGluZGl2aWR1YWwgbWVzc2FnZXM6CisKK0J1c2V5IEFuZHJldzogd2FudHMgdG8gc2V0IHVwIGEgbXVkIHRoYXQgY2hhcmdlcyBmZWVzIHRvIGNvdmVyIGNvc3RzLgorICBJZiB0aGUgYmVsb3cgcnVsZXMgd29uJ3QgbWFrZSBpdCBpbnRvIHRoZSBDb3B5cmlnaHQsIHlvdSBjYW4gcmVnYXJkIHRoaXMKKyAgYXMgYSBsaWNlbnNlIC0gb2YgY291cnNlIG9ubHkgZm9yIHRoZSBjb2RlIHdyaXR0ZW4gYnkgbWUuCitMYXJzIFBlbnNqfDogb3JpZ2luYWwgYXV0aG9yLgorICBQbGVhc2UgZm9yd2FyZCB0aGlzIGxldHRlciB0byBvdGhlciBhdXRob3JzIHRoYXQgaGF2ZSBjb250cmlidXRlZCB0byAzLjEuMgorICB3aG8gaGF2ZSBhIHNheSBpbiB0aGUgY29weXJpZ2h0LgorRmVsaXggQS4gQ3JvZXM6IHdyb3RlIHRoZSBub24tY29ycnVwdGluZyBpbmRlbnRhdGlvbiBjb2RlIGZvciBlZC4KK1NlYW4gQSBSZWl0aDogd3JvdGUgTXVkLXNwcmludGYoKSAuCitMYXJzIER1ZW5pbmc6IHdyb3RlIHRoZSBBbWlnYSBwb3J0LgorUmVpbWVyIEJlaHJlbmRzOiB3cm90ZSBtZXJnZXNvcnQgYmFzZWQgc29ydF9hcnJheSgpIC4KK0hlcnA6IHdyb3RlIGdldF9vYmplY3RfYWN0aW9ucygpIC4KK0phY29iIEhhbGxlbjogaXMgb25lIG9mIHRoZSBwZW9wbGUgaW52b2x2ZWQgd2l0aCB0aGUgQ0QgZHJpdmVyOyB0aGUgZW1haWwKKyBhZGRyZXNzIHdhcyBpbiB0aGUgbmV3cyByZWNlbnRseS4uLgorICBQbGVhc2UgZm9yd2FyZCB0aGlzIGxldHRlciB0byB0aGUgcGVyc29uIGhvbGRpbmcgdGhlIGNvcHlyaWdodCBmb3IgdGhlCisgIFVEUCBjb25uZWN0aXZpdHkodW5sZXNzIGl0J3MgeW91cnNlbGYgOi0pIC4KK0FsZXhhbmRlciBXZWlkdDoKKyAgUGxlYXNlIHRyeSB0byBmb3J3YXJkIHRoaXMgbGV0dGVyIHRvIG15IGJyb3RoZXIuLi4KKworSSBob3BlIHRvIGZpbmFsbHkgZ2V0IHRlcm1zIHdoaWNoIGFsbCBhdXRvcnMgY2FuIGFncmVlIG9uIHRoYXQgY2FuIGJlIGluY2x1ZGVkCitpbnRvIHRoZSBDb3B5cmlnaHQgZmlsZS4gSSBzdWdnZXN0IGdyb3VwIHJlcGxpZXMsIHNvIHRoYXQgd2UgY2FuIGdldCBzb21lCitraW5kIG9mIGRpc2N1c3Npb24gZ29pbmcgKHVubGVzcyB0aGVyZSBpcyBpbW1lZGlhdGUgYXBwcm92YWwgZnJvbSBhbGwKK2F1dGhvcnMgOi0pIC4gV2hlbiB5b3UgaGF2ZSBvYmplY3Rpb25zLCBwbGVhc2UgdHJ5IHRvIHBvaW50IG91dCB3aGF0IGlzCit3cm9uZyB3aXRoIHRoZXNlIHRlcm1zLiBFdmVuIGJldHRlciB3b3VsZCBpdCBiZSBpZiB5b3UgaGFkIGEgc29sdXRpb24KK3RvIHRoZSBwcm9ibGVtLgorCisgICAgICAgIEpvZXJuIFJlbm5lY2tlIChBbXlsYWFyKQorCitQcm9wb3NlZCBUZXJtczoKKzEuIEEgTFBtdWQgbWF5IGNoYXJnZSBmZWVzIGZyb20gcGxheWVycyB0byBjb3ZlciBydW5uaW5nIGFuZCBtYWNoaW5lIGNvc3RzLgorMi4gUnVubmluZyBjb3N0cyBpbiB0aGVzZSB0ZXJtcyBhcmUgdGhlIGNvc3QgZm9yIHRoZSBuZXR3b3JrIGNvbm5lY3Rpb24sCisgICBlbGVjdHJpYyBwb3dlciB0byBvcGVyYXRlIHRoZSBob3N0IG1hY2hpbmUsIHdlYXIgb2YgYmFja3VwIG1lZGlhLAorICAgcmVwYWlyIGNvc3RzIGZvciB0aGUgaG9zdCBtYWNoaW5lLCBhbmQgY29zdCBmb3IgYSBiYW5rIGFjY291bnQuCisgICBGb3IgdGhlIGNvc3RzIG9mIGEgYmFuayBhY2NvdW50IHRvIGJlIGNvbnNpZGVyZWQgcnVubnVuZyBjb3N0cywKKyAgIHRoZXkgbXVzdCBub3QgaGFiZSBiZWVuIGNvbnNpZGVyZWQgYWNjb3JkaW5nIHRvIDguICwgYW5kIHRoZQorICAgaW5zdGl0dXRlIGhhcyB0byBiZSBjaG9vc2VuIHdpdGggYXQgbGVhc3QgdXN1YWwgY29uc2lkZXJhdGlvbiBvbgorICAgdGVybXMgYW5kIGNvc3RzIG9mIHRoZSBhY2NvdW50IGFuZCB0aGF0IHRoZXJlIG11c3QgYmUgbm8gYWZmaWxpYXRvbgorICAgd2l0aCB0aGUgaW5zdGl0dXRlLgorMy4gTW9uZXkgdG8gY292ZXIgcnVubmluZyBjb3N0cyBmb3IgYSBtYXhpbXVtIG9mIDE4IG1vbnRoIG1heSBiZSBhY2N1bXVsYXRlZAorICAgaW4gYWR2YW5jZSBmcm9tIGZlZXMgdG8gc21vb3RoZSBmbHVjdGF0aW9uIGFuZCB0byBlbnN1cmUgc3RhYmlsaXR5IG9mCisgICB0aGUgbXVkLiBUaGUgc3BhcmUgbW9uZXkgaGFzIHRvIGJlIGtlcHQgc2VwYXJhdGUgZnJvbSBwZXJzb25hbCBtb25leQorICAgYW5kIHNob3VsZCBiZSBpbnZlc3RlZCBpbiB0cnVzdGVlIGludmVzdG1lbnQgaWYgbGlxdWlkaXR5IGFsbG93cy4KKyAgIElmIHRoZSBtdWQgaXMgcGVybWFuZW50bHkgcHV0IGRvd24sIHRoaXMgbW9uZXkgaGFzIHRvIGJlIHJlZm91bmRlZCB0byB0aGUKKyAgIHBsYXllcmVzLgorNC4gTWFjaGluZSBjb3N0cyBhcmUgY29zdHMgZm9yIGJ1eWluZywgaW5zdGFsbGF0aW9uIGFuZCB1cGdyYWRlIG9mIHRoZSBob3N0CisgICBtYWNoaW5lLiBUaGUgY29zdHMgaGF2ZSB0byBhcHBlYXIgb24gYSBib25hIGZpZGUgcHVyY2hhc2UgLyBzZXJ2aWNlCisgICBjb250cmFjdCB3aXRoIGEgcGVyc29uL2luc3RpdHV0aW9uIHRoYXQgaXMgbm90IGFmZmlsaWF0ZWQgd2l0aCB0aGUKKyAgIHBlcnNvbiB3aG8gc2V0cyB1cCB0aGUgbXVkLgorICAgV2hlbiB0aGUgaG9zdCBtYWNoaW5lIGlzIHB1dCBvdXQgb2YgdXNlLCBvciBwYXJ0cyBvZiBpdCBhcmUgcmVtb3ZlZCBmb3IKKyAgIG90aGVyIHRoYW4gdGVjaG5pY2FsIHJlYXNvbnMsIGFyZSBwYXJ0cyBhcmUgbm9yIHJlLWluc2VydGVkIGFmdGVyIHRoZQorICAgdGVjaG5pY2FsIHJlc29ucyBmb3IgcmVtb3ZhbCBhbmQgbm90IHJlLWluc2VydGluZyBoYXZlIGJlY29tZSB2b2lkLAorICAgdGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhlIG1hY2hpbmUgdGhhdCBoYXMgcHV0IG91dCBvZiB1c2UvdGhlIHJlbW92ZWQKKyAgIHBhcnRzIGlzIHRvIGJlIHN1YnRyYWN0ZWQgZnJvbSB0aGUgbWFjaGluZSBjb3N0cy4KKyAgIElmIHRodXMgbW9yZSBtb25leSBoYXMgYmVlbiBwYWlkIGZvciBtYWNoaW5lIGNvc3RzIHRoYW4gdGhlcmUgYXJlCisgICBjdXJyZW50bHksIHRoZSBzdXJwbHVzIGFtb3VudCBoYXMgdG8gYmUgcmVmb3VuZGVkIHRvIHRoZSBtdWQgcGxheWVycy4KKzUuIFRoZSBtYWNoaW5lIGNvc3Qgc2hhcmUgaW4gdGhlIGZlZSBtYXkgbm90IGJlIG1vcmUgdGhhbiAxLzI0MDB0aAorICAgb2YgdGhlIG1hY2hpbmUgY29zdHMgcGVyIG1vbnRoLiBJZiB0aGUgbXVkIGhhcyBsZXNzIHRoYW4gMTAwIHBsYXllcnMsCisgICBpdCBtYXkgYmUgdXAgdG8gbWFjaGluZSBjb3N0cyAvIDI0IC8gbnVtYmVyIG9mIHBsYXllcnMsIGJ1dCBub3QgbW9yZSB0aGFuCisgICAxLzEyMHRoIG9mIHRoZSBtYWNoaW5lIGNvc3RzIHBlciBtb250aC4KKzYuIFdoZW4gbW9uZXkgaGFzIHRvIGJlIHBheWVkIGJhY2sgdG8gdGhlIG11ZCBwbGF5ZXJzLCBvbmx5IHRob3NlIHRoYXQKKyAgIGhhdmUgcGF5ZWQgYXQgbGVhc3Qgb25jZSBhIGZlZSB3aXRoaW4gdGhlIGxhc3QgMjQgbW9udGggYXJlIHRvIGJlCisgICBjb25zaWRlcmVkLiBGb3IgdGhlc2UgcGxheWVycywgdGhlIG1vbmV5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSByYXRpbworICAgb2YgdGhlIGFsbCBmZWUgc2hhcmVzIGV2ZXIgcGF5ZWQgdG8gY292ZXIgbWFjaGluZSBjb3N0cy4KKzcuIEFsbCBwbGF5ZXJzIHBheSBlcXVhbCBmZWVzLgorOC4gQmFua2luZyBjb3N0cyB0aGF0IGhhdmUgdG8gYmUgcGFpZCBieSB0aGUgbXVkIGFkbWluaXN0cmF0aW9uIGFuZCBhcmUKKyAgIGltbWVkaWF0ZWx5IGNvbm5lY3RlZCB0byBpbmNvbWluZyBtb25leSB0cmFuc2FjdGlvbnMgY2FuIGJlIHN1YnRyYWN0ZWQKKyAgIGZyb20gdGhlIHRyYW5zZmVycmVkIGFtb3VudCBiZWZvcmUgY291bnRpbmcgaXQgYXMgcGF5bWVudCBvZiBmZWVzLAorICAgcHJvdmlkZWQgdGhhdCB0aGUgaW5zdGl0dXRlIHdhcyBjaG9vc2VuIHdpdGggYXQgbGVhc3QgdXN1YWwKKyAgIGNvbnNpZGVyYXRpb24gb24gdGVybXMgYW5kIGNvc3RzIG9mIHRoZSBhY2NvdW50LCBhbmQgdGhhdCB0aGVyZSBpcworICAgbm8gYWZmaWxpYXRvbiB3aXRoIHRoZSBpbnN0aXR1dGUuCis5LiBUaGUgYW1vdW50IG9mIHZvbHVudGFyeSBkb25hdGlvbnMgaXMgdW5saW1pdGVkLiBBIGRvbmF0aW9uIGlzIG5vdAorICAgY29uc2lkZXJlZCB2b2x1bnRhcnkgaWYgaXQgaXMgY29ubmVjdGVkIHdpdGggc3BlY2lhbCBmZWF0dXJlcyBvcgorICAgZmF2b3VycyBpbiB0aGUgbXVkIG90aGVyIHRoYW4gYW4gaG91bmFyYXJ5IG1lbnRpb25pbmcgb2YgdGhlIGRvbm9yLAorICAgb3IgaWYgdGhlIGRvbm9yIGlzIG1hZGUgdG8gYmVsaWV2ZSB0aGF0IHN1Y2ggYSBjb25uZWN0aW9uIGV4aXN0cy4KKyAgIFJlYXNvbmFibGUgbWVhc3VyZXMgaGF2ZSB0byBiZSB0YWtlbiB0aGF0IHRoZXJlIGlzIG5vCisgICBtaXN1bmRlcnN0YW5kaW5nIG9uIHRoaXMgcG9pbnQuCisKK0NvbW1lbnRzOgorMy4gWW91IG1heSBub3QgdXNlIHRoZSBtb25leSBvZiB0aGUgbXVkIHRvIGJyaWRnZSBwZXJzb25hbCBpbmxpcXVpZGl0eS4KKyAgIERvbid0IGdhbWJsZSB3aXRoIG90aGVyIHBlcnNvbnMgbW9uZXksIGUuZy4gaW52ZXN0aW5nIGl0IGluIGp1bmsgYm9uZHMuCis1LiBGZWVzIHNob3VsZCBub3QgYmUgYXJiaXRyYXJpbHkgcmFpc2VkIHNvIHRoYXQgcGxheWVycyBjYW4gYmUgZHJpdmVuCisgICBvdXQuIEkgY29uc2lkZXJlZCBhIGZpeGVkIG1pbmltYWwgZGlzdHJpYnV0ZW4gb2YgdGhlIGNvc3RzIHRvIGJlCisgICB0aGUgYmVzdCBtZWFucyB0byBjb2RpZnkgdGhpcy4KKyAgIEFic29sdXRlIGZpZ3VyZXMgYXJlIGJvdW5kIHRvIGJlY29tZSB2b2lkIGJ5IGluZmxhdGlvbi4KKzYuIFRoZSAyNCBtb250aCBwZXJpb2QgaXMgaW50cm9kdWNlZCB0byBhbGxvdyB0byBlcmVhc2UgcmVjb3JkcyBvZgorICAgY2xpZW50cyBhZnRlciB0d28geWVhcnMsIGFuZCB0byBrZWVwIG92ZXJoZWFkIGFmZm9yZGFibGUuCis3LiBXZSBkb24ndCB3YW50IGZhdm91cml0ZXMgdG8gZ2V0IGEgZnJlZSBsaWZ0LCBhbmQgb3RoZXJzIGdydWRnaW5nbHkKKyAgIHBheWluZyBleHRyYS4gSWYgeW91IHRoaW5rIHNvbWVib2R5IG5lZWRzIGZyZWUgYWNjZXNzLCBmaW5kIHNvbWVvbmUKKyAgIHdobyBwYXlzIGZvciBpdCwgb3IgbWFrZSBhIGZvdW5kIHBheWVkIGZyb20gdm9sdW50YXJ5IGRvbmF0aW9ucy4KKworLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorRGF0ZTogRnJpLCAxOSBOb3YgMTk5MyAxNzoxMDo0NCArMDEwMCAoTUVUKQorRnJvbTogTGFycyBQZW5zanwgPGxhcnNAY2QuY2hhbG1lcnMuc2U+CitTdWJqZWN0OiBSZTogTFBtdWQgQ29weXJpZ2h0CitUbzogYW15bGFhckBtZW9seW9uLmhhbnNlLmRlIChKb2VybiBSZW5uZWNrZSkKK0NjOiBidXNleUB1eDEuY3NvLnVpdWMuZWR1LCBsYXJzQGNkLmNoYWxtZXJzLnNlLCBjcm9lc0Bzd2kucHN5LnV2YS5ubCwKKyAgICAgICAgZ3VzYXJAdW5pd2EudXdhLk9aLkFVLCBkdWVuaW5nQGlici5jcy50dS1icy5kZSwgamFjb2JAY2QuY2hhbG1lcnMuc2UsCisgICAgICAgIHJfYmVocmVuQGluZm9ybWF0aWsudW5pLWtsLmRlLCBtdWRAYWxpamt1MDUuZWR2ei51bmktbGluei5hYy5hdCwKKyAgICAgICAgYWxjYW1hbkBjcy50dS1iZXJsaW4uZGUKKworSSBhZ3JlZSB0aGF0IGZpeCBvZiB0aGUgY29weXJpZ2h0IGlzIG5lZWRlZC4gSSB3b3VsZCBwcmVmZXIgdG8gdXNlIHRoZQorR251IENvcHlsZWZ0LCBhcyBJIGRvbid0IGNhcmUgYW55IGxvbmdlciBpZiBhbnlvbmUgbWFrZXMgbW9uZXkgZnJvbSBpdC4gVGhlCitpbXBvcnRhbnQgdGhpbmcgaXMgdGhhdCBpdCBpcyBmcmVlLCB3aGljaCBtZWFucyBub29uZSB3aWxsIGJlIGFibGUgdG8gbWFrZQorbXVjaCBtb25leSBhbnl3YXkuCisKK0FueSB0aG91Z2h0cyBhYm91dCBpdCA/CisKKy9MYXJzCisKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KK0RhdGU6IEZyaSwgMTkgTm92IDE5OTMgMjA6MTQ6MTAgKzAxMDAgKE1FVCkKK0Zyb206IEphY29iIEhhbGxlbiA8amFjb2JAY2QuY2hhbG1lcnMuc2U+CitTdWJqZWN0OiBSZTogTFBtdWQgQ29weXJpZ2h0CitUbzogYW15bGFhckBtZW9seW9uLmhhbnNlLmRlIChKb2VybiBSZW5uZWNrZSkKK0NjOiBidXNleUB1eDEuY3NvLnVpdWMuZWR1LCBsYXJzQGNkLmNoYWxtZXJzLnNlLCBjcm9lc0Bzd2kucHN5LnV2YS5ubCwKKyAgICAgICAgZ3VzYXJAdW5pd2EudXdhLk9aLkFVLCBkdWVuaW5nQGlici5jcy50dS1icy5kZSwgamFjb2JAY2QuY2hhbG1lcnMuc2UsCisgICAgICAgIHJfYmVocmVuQGluZm9ybWF0aWsudW5pLWtsLmRlLCBtdWRAYWxpamt1MDUuZWR2ei51bmktbGluei5hYy5hdCwKKyAgICAgICAgYWxjYW1hbkBjcy50dS1iZXJsaW4uZGUKKworPiBKYWNvYiBIYWxsZW46IGlzIG9uZSBvZiB0aGUgcGVvcGxlIGludm9sdmVkIHdpdGggdGhlIENEIGRyaXZlcjsgdGhlIGVtYWlsCis+ICBhZGRyZXNzIHdhcyBpbiB0aGUgbmV3cyByZWNlbnRseS4uLgorPiAgIFBsZWFzZSBmb3J3YXJkIHRoaXMgbGV0dGVyIHRvIHRoZSBwZXJzb24gaG9sZGluZyB0aGUgY29weXJpZ2h0IGZvciB0aGUKKz4gICBVRFAgY29ubmVjdGl2aXR5KHVubGVzcyBpdCdzIHlvdXJzZWxmIDotKSAuCisKK0kgcmVwcmVzZW50IGV2ZXJ5b25lIGludm9sdmVkIGluIHRoZSBDRCBkcml2ZXIuIFRoZSBVRFAgc3R1ZmYgaXMgdG8gYmUKK2NvbnNpZGVyZWQgcHVibGljIGRvbWFpbi4gQWxsIG90aGVyIHBhcnRzIGFyZSBjb3ZlcmVkIGJ5IHRoZSBub24tcHJvZml0IGNsYXVzZS4KK0NvZGUgb3JpZ2luYXRpb24gZnJvbSBtZSwgSm9oYW4gQW5kZXJzc29uIChDb21tYW5kZXIpLCBSb25ueSBXaWtoIChNcnByKSwKK0xlbm5hcnQgQXVndXN0c3NvbiAoTWFydmluKSBpcyBjb3ZlcmVkIGJ5IGl0LiBXZSBoYXZlIG5vIGludGVudGlvbiBvZgorYWxsb3dpbmcgcGVvcGxlIHRvIGNoYXJnZSBtb25leSBmb3IgdGhlIHVzYWdlIG9mIG91ciBkcml2ZXIsIG9yIGJvcnJvd2VkCitwaWVjZXMgdGhlcmVvZi4KK1dlIGNvbnNpZGVyIHRoZSBhY2NlcHRhbmNlIG9mIHZvbG9udGFyeSBkb25hdGlvbnMgYXMgZmFpciBwcmFjdGljZSwgYW5kIHdlCitjYW4gYWNjZXB0IHRoZSBjaGFyZ2luZyBmb3IgdGhlIHVzZSBvZiBleHRyYSBlcXVpcG1lbnQgbmVlZGVkIHRvIGFsbG93CitwZW9wbGUgdG8gYWNjZXNzIHRoZSBtdWQsIGFzIGxvbmcgYXMgdGhlcmUgaXMgYSByZWFzb25hYmxlIHdheSB0byBhY2Nlc3MgdGhlCittdWQgd2l0aG91dCBiZWluZyBjaGFyZ2VkLiAoUHJvdmlkaW5nIG1vZGVtIGFjY2VzcyBhdCBhIGNvc3Qgd2hpbGUgYWxsb3dpbmcKK2ZyZWUgYWNjZXNzIG92ZXIgdGhlIGludGVybmV0IGlzIGFuIGV4YW1wbGUgb2Ygc3VjaCBhIHNldHVwLikKKworTXkgcGVyc29uYWwgdmlldyBpcyB0aGF0IGFuIGVsYWJvcmF0ZSBzZXR1cCBvZiB0ZXJtcyBsaWtlIHRoZSBvbmUgaW4gdGhlCitvcmlnaW5hbCBsZXR0ZXIgaXMgdW5yZWFzb25hYmxlLiBJdCBpcyBkZXNpZ25lZCBmb3IgYSB2ZXJ5IHNwZWNpZmljIHNldCBvZgorY2lyY3Vtc3RhbmNlcy4gSXQgaXMgaW1wb3NzaWJsZSB0byBjaGVjayBhbmQgaXQgaXMgdmVyeSBidXJlYXVjcmF0aWMuCitJdCBkb2VzIG5vdCBoYXZlIG15IHN1cHBvcnQuCisKK0phY29iIEhhbGxlbgorCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCitEYXRlOiBTYXQsIDIwIE5vdiAxOTkzIDIzOjM1OjEyICswMTAwIChNRVQpCitGcm9tOiBNdWx0aSBVc2VyIER1bmdlb24gPG11ZEBhbGlqa3UwNS5lZHZ6LnVuaS1saW56LmFjLmF0PgorU3ViamVjdDogUmU6IExQbXVkIENvcHlyaWdodAorVG86IGxhcnNAY2QuY2hhbG1lcnMuc2UgKExhcnMgUGVuc2p8KQorQ2M6IGJ1c2V5QHV4MS5jc28udWl1Yy5lZHUsIGNyb2VzQHN3aS5wc3kudXZhLm5sLCBndXNhckB1bml3YS51d2EuT1ouQVUsCisgICAgICAgIGR1ZW5pbmdAaWJyLmNzLnR1LWJzLmRlLCBqYWNvYkBjZC5jaGFsbWVycy5zZSwKKyAgICAgICAgcl9iZWhyZW5AaW5mb3JtYXRpay51bmkta2wuZGUsIGFsY2FtYW5AY3MudHUtYmVybGluLmRlCisKK0xhcnM+IGltcG9ydGFudCB0aGluZyBpcyB0aGF0IGl0IGlzIGZyZWUsIHdoaWNoIG1lYW5zIG5vb25lIHdpbGwgYmUgYWJsZSB0byBtYWtlCitMYXJzPiBtdWNoIG1vbmV5IGFueXdheS4KKworWW91IGFyZSBzcGVha2luZyBhYm91dCB0aGUgR0QsY29ycmVjdCA/IE5vcm1hbGx5LCBtYW55IGEgc2l0ZSB1c2VzIGFuIHVubW9kaWZpZWQKK0dEIGJhc2VkIHVwb24gd2hpY2ggaXMgYSBtb3JlIG9yIGxlc3MgaGVhdmlseSBvciBub3QgaGVhdmlseSBNdWRsaWIuIEJhc2VkIHVwb24KK3RoaXMgTXVkbGliIGlzIHRoZSB3b3JrIG9mIHRoZSBgd2l6YXJkcycgLi4uIFNvcnJ5IGZvciByZXBlYXRpbmcga25vd24gc3R1ZmYuCisKK1RoaXMgbWFrZXMgbW9zdCBNdWRzIGRpZmZlciBmcm9tIGVhY2ggb3RoZXIuIFNvLCB0aGUgZmFjdCB0aGF0IHRoZSBHRCBpdHNlbGYKK2lzIGZyZWUsIGRvZXNuJ3QgaW1wbHkgdGhhdCB5b3Ugd29uJ3QgbWFrZSBtb25leS4KKworQW5vdGhlciBwb2ludCB0byBhcmd1ZTogbWFpbnRhaW5pZyBhIE11ZCB0YWtlcyB0aW1lIC4uIGEgTE9UIG9mIHRpbWUuIFVzdWFsbHksCitkb2luZyBzbyBpcyBub3QgZnVuIGF0IGFsbC4gSSBleHBlcmllbmNlZCB0aGF0IHRoZSBtb3JlIHBsYXllcnMgeW91IGhhdmUsIHRoZQorbGVzcyBmdW4gaXQgaXMgZm9yZSB0aGUgYWRtaW5zdHJhdG9ycy4gWW91IHNwZW5kIGEgbG90IG9mIHRpbWUgY29kaW5nLAorc2VhcmNoaW5nIGFuZCBmaXhpbmcgYnVncyAuLi4gYW5kIEkgdGhpbmssIHRoaXMgY2FuIGJlIHJlZ2FyZGVkIGFzIGEKK3NlcnZpY2UgZm9yIHBsYXllcnMgKC4uLiBhbmQgcGxheWVycyByZWFsbHkgY2FuIGJlIGEgcGFpbiBzb21ldGltZXMgLi4uKQorV291bGQgaXQgYmUgbGVnYWwgdG8gY2hhcmdlIG1vbmV5IGZvciB0aGF0ID8KKworQW5vdGhlciB0aG91Z2h0OiBJbnRlcm5ldCBNdWRzLiBUaGV5IHJ1biBvbiBpbnRlcm5ldCwgdXN1YWxseSBvbiBjb21wdXRlcnMKK293bmVkIGJ5IGEgc2Nob29sIG9yIHVuaXZlcnNpdHksIHNvbWUgd2l0aCwgc29tZSB3aXRob3V0IHRoZSBrbm93bGVkZ2Ugb2YKK3RoZSBzaXRlIGFkbWluc3RyYXRvcnMuIFdvdWxkIGl0IGJlIGxlZ2FsIHRvIGNoYXJnZSBtb25leSB3aGVuIHlvdSBydW4KK2EgTXVkIG9uIGVxdWlwbWVudCBub3Qgb3duZWQgYnkgeW91cnNlbGYgPyBBbmQsIGV2ZW4gaWYgeW91IG93biB0aGUgY29tcHV0ZXIsCitkbyB5b3UgcGF5IGZvciB0aGUgaW50ZXJuZXQgbGluayA/IElmIG5vdCwgSSBmZWFyIHlvdSBtdXN0IG5vdCBjaGFyZ2UgbW9uZXkKK2ZvciBhIE11ZCB3aXRob3V0IHNwZWFraW5nIHdpdGggdGhlIG5ldHdvcmsgYWRtaW5zdHJhdG9yIHNpbmNlIHlvdSBhcmUgdXNpbmcKK3RoZSBuZXR3b3JrIGNvbXBvbmVudHMgKHJvdXRlci9icmlkZ2VzLCBldmVuIGNhYmxlcyA6LT4gLi4uKSBmb3IgZnJlZS4KKworSG93IGRpZmZpY3VsdCBpcyBjaGFyZ2luZyBtb25leSBpbiBFdXJvcGVhbiBNdWRzID8gTm90IHRoYXQgSSBwbGFuCit0byBkbyBzbyBmb3IgSE0gKGl0J3MgY2xvc2VkIGZvciBwbGF5ZXJzIGN1cnJlbnRseSBhbnl3YXkpLCBidXQgaXNuJ3QgdGhlcmUgYQorYmlnIGRpZmZlcmVuY2UgYWNjb3JkaW5nIHRvIHRoZSAiYWNjb3VudGluZyBtZWNoYW5pc20iICh1Z2gsIGJhZCBlbmdsaXNoIDotKQordGhhdCBpcyB1c2VkIGluIHRoZSBTdGF0ZXMgPyBJIGhlYXJkIHRoYXQgaXQgaXMgbXVjaCBtb3JlIGVhc3kgdG8gbWFrZQorZmluYW5jaWFsIHRyYW5zYWN0aW9ucyB3aXRoaW4gdGhlIFN0YXRlcy4gU28sIEkgc3VzcGVjdCB0aGUgIk11ZCBtb25leSBjaGFyZ2luZyIKK2Rpc2N1c3Npb24gYXJyaXZlcyBmcm9tIHRoZSBVUyA6LSkKKworR3JlZXRpbmdzLCBIZXJwIChtdWRAbXVkLnVuaS1saW56LmFjLmF0KQorCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KK0Zyb20gamFjb2JAY2QuY2hhbG1lcnMuc2UgU3VuIE9jdCAyNCAxNzowMjo1MyAxOTk5CitOZXdzZ3JvdXBzOiByZWMuZ2FtZXMubXVkLmFkbWluCitTdWJqZWN0OiBSZTogTmV3c2dyb3VwcworRnJvbTogamFjb2JAY2QuY2hhbG1lcnMuc2UgKEphY29iIEhhbGxlbikKK0RhdGU6IDI0IE9jdCAxOTk5IDE2OjAyOjUzIEdNVAorCitJbiBhcnRpY2xlIDwzODBmODE3ZC4zNTkxNjUyOEBuZXdzLmVhcnRobGluay5uZXQ+LAorTGFycyBEdWVuaW5nIDxsYXJzQGJlYXJuaXAuY29tPiB3cm90ZToKKz5PbiBUaHUsIDIxIE9jdCAxOTk5IDEyOjExOjM2IC0wNzAwLCBJbHlhCis+PGlseWFAc3BhbS5mcmVlLmdhbWVjb21tYW5kb3MuY29tPiB3cm90ZToKKz4KKz4+SGV5IExhcnMsIHdoYXQgaG9wZSBpcyB0aGVyZSwgaWYgYW55LCBvZiBnZXR0aW5nCis+PnNvbWV0aGluZyBnb2luZyBpbiB0aGUgTFAgd29ybGQsIHVzaW5nIExEbXVkIG9yCis+PndoYXRldmVyLCAgdGhhdCBjYW4gYmUgdXNlZCBjb21tZXJjaWFsbHk/Cis+Cis+VW5mb3J0dW5hdGVseSBvbmx5IHNsaW0gaG9wZTogdGhlIHBhcnRzIHdyaXR0ZW4gYnkgdGhlIEdlbmVzaXMgZm9sa3MKKz5hcmUgZGVmaW5pdGVseSBub24tY29tbWVyY2lhbDsgYnV0IHJld3JpdGluZyBpcyBkaWZmaWN1bHQgYmVjYXVzZQorPm5vYm9keSByZW1lbWJlcnMgX3doaWNoXyBwYXJ0cyBhcmUgY29uY2VybmVkIChhbmQgbWFpbGVkIHJlcXVlc3RzCis+aGF2ZW4ndCBiZWVuIGFuc3dlcmVkKS4gQW5kIEkgaGF2ZW4ndCBhc2tlZCB0aGUgb3RoZXIgY29udHJpYnV0b3JzCis+eWV0LCBlaXRoZXIuCisKK0kgaGF2ZSBhIHByZXR0eSBnb29kIGlkZWEgb2Ygd2hvIHdyb3RlIHdoYXQgcGFydHMgb2YgdGhlIGVhcmx5IHZlcnNpb24gMworZ2FtZWRyaXZlcnMuIEFsbCBpbiBhbGwgdGhlcmUgaGF2ZSBiZWVuIGFib3V0IDMwIHBlb3BsZSBpbnZvbHZlZC4gVW5sZXNzCit5b3UgcmVjb2RlIHRoZSBlbnRpcmUgZ2FtZWRyaXZlciBmcm9tIHNjcmF0Y2gsIG9yIGJ1aWxkIGZyb20gYXNzZW1ibGVkIHBpZWNlcword2l0aCBrbm93biBjb3B5cmlnaHQgcmVzdHJpY3Rpb25zLCB0aGVyZSBpcyBubyB3YXkgeW91IGNhbiBjb21lIHVwIHdpdGgKK3NvbWV0aGluZyB0aGF0IGRvZXMgbm90IGluZnJpbmdlIG9uIHRoZSByaWdodHMgb2Ygc29tZW9uZSB3aG8gd2lsbCBub3QKK2FsbG93IGNvbW1lY2lhbCB1c2UuCisKK0phY29iIEhhbGzpbgorCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKwpkaWZmIC0tZ2l0IGEvZG9jL2RyaXZlci9kZWJ1Z21hbGxvYyBiL2RvYy9kcml2ZXIvZGVidWdtYWxsb2MKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGY3OGJhZQotLS0gL2Rldi9udWxsCisrKyBiL2RvYy9kcml2ZXIvZGVidWdtYWxsb2MKQEAgLTAsMCArMSwxNyBAQAorTkFNRQorICAgICAgICBkZWJ1Z21hbGxvYworCitERVNDUklQVElPTgorICAgICAgICBUaGlzIGNvbW1hbmQgaXMgaGFyZGNvZGVkIGludG8gdGhlIGRyaXZlci4KKworICAgICAgICBUb2dnbGVzIHRoZSBkZWJ1ZyBtb2RlIGZvciB0aGUgbWVtb3J5IG1hbmFnbWVudC4KKyAgICAgICAgSWYgdGhlIE9fSVNfV0laQVJEIGZsYWcgaXMgdXNlZCBpbiB0aGUgbXVkbGliIChpLmUuIGlmCisgICAgICAgIHNldF9pc193aXphcmQoKSB3YXMgY2FsbGVkKSwgdGhpcyBjb21tYW5kIGlzIGFsbG93ZWQgb25seSBmb3IKKyAgICAgICAgdXNlcnMgdGhhdCBoYXZlIHRoaXMgZmxhZyBzZXQuCisKK0hJU1RPUlkKKyAgICAgICAgRGVhY3RpdmF0ZWQgaW4gMy4yLjcgYnkgZGVmYXVsdCwgaXQgd2FzIGVmZmVjdGxlc3MgYmVmb3JlIGFueXdheS4KKworU0VFIEFMU08KKyAgICAgICAgbWFsbG9jKEQpLCBzdGF0dXMoRCksIG1lbW9yeShDKSwgb2JqZWN0cyhDKSwgZGVidWdfaW5mbyhFKSwKKyAgICAgICAgc2V0X2lzX3dpemFyZChFKQpkaWZmIC0tZ2l0IGEvZG9jL2RyaXZlci9kcml2ZXIgYi9kb2MvZHJpdmVyL2RyaXZlcgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40MDQzMGU4Ci0tLSAvZGV2L251bGwKKysrIGIvZG9jL2RyaXZlci9kcml2ZXIKQEAgLTAsMCArMSwxNSBAQAorTkFNRQorICAgICAgICBkcml2ZXIKKworREVTQ1JJUFRJT04KKyAgICAgICAgVGhpcyBkaXJlY3RvcnkgY29udGFpbnMgZGVzY3JpcHRpb25zIG9mIG1pc2NlbGxhbmVvdXMKKyAgICAgICAgaW50ZXJuYWxzIG9mIEFteWxhYXIncyB2ZXJzaW9uIG9mIHRoZSBMUEMgcGFyc2VyL2ludGVycHJldGVyLAorICAgICAgICB0aGF0IG1pZ2h0IGJlIHVzZWZ1bCB0byBrbm93LgorCisgICAgICAgIE9uZSB0aGluZyBkZXNjcmliZWQgaGVyZSBhcmUgdGhlIHNwZWNpYWwgaGFyZGNvZGVkIGNvbW1hbmRzCisgICAgICAgIG9mIHRoZSBpbnRlcnByZXRlciBmb3IgcXVlcnlpbmcgdGhlIHN0YXR1cyBvZiB0aGUgbWVtb3J5CisgICAgICAgIG1hbmFnZW1lbnQuCisKK1NFRSBBTFNPCisgICAgICAgIGVmdW4oRSksIGFwcGxpZWQoQSksIGNvbmNlcHRzKEMpLCBtYXN0ZXIoTSksIGxwYyhMUEMpLAorICAgICAgICBtYWxsb2MoRCksIHN0YXR1cyhEKQpkaWZmIC0tZ2l0IGEvZG9jL2RyaXZlci9kdW1wYWxsb2JqIGIvZG9jL2RyaXZlci9kdW1wYWxsb2JqCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI0Yjg4NGEKLS0tIC9kZXYvbnVsbAorKysgYi9kb2MvZHJpdmVyL2R1bXBhbGxvYmoKQEAgLTAsMCArMSw0OSBAQAorTkFNRQorICAgICAgICBkdW1wYWxsb2JqCisKK0RFU0NSSVBUSU9OCisgICAgICAgIFdyaXRlIGEgbGlzdCBvZiBhbGwgbG9hZGVkIG9yIGNsb25lZCBvYmplY3RzIGludG8gdGhlIGZpbGUKKyAgICAgICAgT0JKX0RVTVAsIGFuZCBhIGxpc3Qgb2YgYWxsIGRlc3RydWN0ZWQgb2JqZWN0cyBpbnRvIHRoZQorICAgICAgICBmaWxlIERFU1RfT0JKX0RVTVAuIEJvdGggZmlsZXMgYXJlIGxvY2F0ZWQgaW4gdGhlIHJvb3QgZGlyZWN0b3J5IG9mCisgICAgICAgIHRoZSBtdWRsaWIuCisKKyAgICAgICAgV2FybmluZzogdGhlc2UgZmlsZXMgY2FuIGJlIHZlcnkgbGFyZ2UsIGFuZCBpZiB0aGUgZHJpdmVyIGlzIGxvdworICAgICAgICBvbiBtZW1vcnkgdGhlcmUgaXMgYSBjZXJ0YWluIGNyYXNoIHByb2JhYmlsaXR5LgorCisgICAgICAgIElmIHRoZSBPX0lTX1dJWkFSRCBmbGFnIGlzIHVzZWQgaW4gdGhlIG11ZGxpYiAoaS5lLiBpZgorICAgICAgICBzZXRfaXNfd2l6YXJkKCkgd2FzIGNhbGxlZCksIHRoaXMgY29tbWFuZCBpcyBhbGxvd2VkIG9ubHkgZm9yCisgICAgICAgIHVzZXJzIHRoYXQgaGF2ZSB0aGlzIGZsYWcgc2V0LgorCisgICAgICAgIEZvciBldmVyeSBsaXZlIG9iamVjdCwgYSBsaW5lIGlzIHdyaXR0ZW4gaW50byB0aGUgZmlsZSB3aXRoIHRoZQorICAgICAgICBmb2xsb3dpbmcgaW5mb3JtYXRpb24gaW4gdGhlIGdpdmVuIG9yZGVyOgorICAgICAgICAgIC0gb2JqZWN0IG5hbWUKKyAgICAgICAgICAtIHNpemUgaW4gbWVtb3J5LCBzaGFyZWQgZGF0YSBjb3VudGVkIG9ubHkgb25jZQorICAgICAgICAgIC0gc2l6ZSBpbiBtZW1vcnkgaWYgZGF0YSB3b3VsZG4ndCBiZSBzaGFyZWQKKyAgICAgICAgICAtIG51bWJlciBvZiByZWZlcmVuY2VzCisgICAgICAgICAgLSAnSEInIGlmIHRoZSBvYmplY3QgaGFzIGEgaGVhcnRiZWF0LCBub3RoaW5nIGlmIG5vdC4KKyAgICAgICAgICAtIHRoZSBuYW1lIG9mIHRoZSBlbnZpcm9ubWVudCwgb3IgJy0tJyBpZiB0aGUgb2JqZWN0IGhhcyBubworICAgICAgICAgICAgZW52aXJvbm1lbnQKKyAgICAgICAgICAtIGluIHBhcmVudGhlc2VzIHRoZSBudW1iZXIgb2YgZXhlY3V0aW9uIHRpY2tzIHNwZW50IGluIHRoaXMKKyAgICAgICAgICAgIG9iamVjdAorICAgICAgICAgIC0gdGhlIHN3YXAgc3RhdHVzOgorICAgICAgICAgICAgIG5vdGhpbmcgaWYgbm90IHN3YXBwZWQsCisgICAgICAgICAgICAgJ1BST0cgU1dBUFBFRCcgaWYgb25seSB0aGUgcHJvZ3JhbSBpcyBzd2FwcGVkCisgICAgICAgICAgICAgJ1ZBUiBTV0FQUEVEJyBpZiBvbmx5IHRoZSB2YXJpYWJlcyBhcmUgc3dhcHBlZAorICAgICAgICAgICAgICdTV0FQUEVEJyBpZiBib3RoIHByb2dyYW0gYW5kIHZhcmlhYmxlcyBhcmUgc3dhcHBlZAorICAgICAgICAgIC0gdGhlIHRpbWUgdGhlIG9iamVjdCB3YXMgY3JlYXRlZAorCisgICAgICAgIEZvciBldmVyeSBkZXN0cnVjdGVkIG9iamVjdCwgYSBsaW5lIGlzIHdyaXR0ZW4gaW50byB0aGUgZmlsZSB3aXRoIHRoZQorICAgICAgICBmb2xsb3dpbmcgaW5mb3JtYXRpb24gaW4gdGhlIGdpdmVuIG9yZGVyOgorICAgICAgICAgIC0gb2JqZWN0IG5hbWUKKyAgICAgICAgICAtIG51bWJlciBvZiByZWZlcmVuY2VzCisgICAgICAgICAgLSAnTkVXJyBpZiB0aGUgb2JqZWN0IHdhcyBkZXN0cnVjdGVkIGluIHRoaXMgZXhlY3V0aW9uZworICAgICAgICAgICAgdGhyZWFkLCBub3RoaW5nIGlmIGl0IGlzIG9sZGVyIGFscmVhZHkuCisKKworSElTVE9SWQorICAgICAgICBMRE11ZCAzLjIuOSBhZGRlZCB0aGUgREVTVF9PQkpfRFVNUC4KKyAgICAgICAgTERNdWQgMy4yLjEwIGFkZGVkIHRoZSBvYmplY3QgY3JlYXRpb24gdGltZSB0byBPQkpfRFVNUC4KKworU0VFIEFMU08KKyAgICAgICAgbWFsbG9jKEQpLCBzdGF0dXMoRCksIG1lbW9yeShDKSwgb2JqZWN0cyhDKSwgZGVidWdfaW5mbyhFKSwKKyAgICAgICAgc2V0X2lzX3dpemFyZChFKQpkaWZmIC0tZ2l0IGEvZG9jL2RyaXZlci9pbnZvY2F0aW9uIGIvZG9jL2RyaXZlci9pbnZvY2F0aW9uCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU3NjBiNDYKLS0tIC9kZXYvbnVsbAorKysgYi9kb2MvZHJpdmVyL2ludm9jYXRpb24KQEAgLTAsMCArMSwzMzUgQEAKK05BTUUKKyAgICBkcml2ZXIvaW52b2NhdGlvbgorCitQVVJQT1NFCisgICAgRGVzY3JpcHRpb24gb2YgdGhlIGludm9jYXRpb24gb2YgdGhlIGdhbWVkcml2ZXIsIGVzcGVjaWFsbHkgb2YgdGhlIGNvbW1hbmQKKyAgICBhcmd1bWVudHMuIFRoaXMgZG9jdW1lbnQgZGVzY3JpYmVzIHRoZSBjb21tYW5kbGluZSB2ZXJzaW9uIG9mIHRoZSBkcml2ZXIKKyAgICBvbmx5OyBub24tY29tbWFuZGxpbmUgdmVyc2lvbnMgYXJlIHBsYXRmb3JtIHNwZWNpZmljIGFuZCBkZXNjcmliZWQgaW4KKyAgICB0aGUgcmVsYXRlZCBkb2N1bWVudGF0aW9uLgorCitERVNDUklQVElPTgorICAgIFRoZSBkcml2ZXIgaXMgaW52b2tlZCBmcm9tIHRoZSBjb21tYW5kbGluZSBhcyBvdGhlciBub3JtYWwgcHJvZ3JhbXMuCisgICAgTmVpdGhlciB0aGUgY3VycmVudCBkaXJlY3Rvcnkgbm9yIHRoZSBkaXJlY3RvcnkgdGhlIGV4ZWN1dGFibGUgaXMgaW4gbmVlZAorICAgIHRvIGJlIGluIGFueSBzcGVjaWFsIHJlbGF0aW9uIHRoZSBkaXJlY3Rvcnkgb2YgdGhlIG11ZGxpYi4gT25jZSB0aGUgZHJpdmVyCisgICAgaXMgcnVubmluZywgaXQgZW1pdHMgdHdvIHN0cmVhbXMgb2Ygb3V0cHV0czoKKworICAgICAgLSBkcml2ZXItcmVsYXRlZCBtZXNzYWdlcyBvbiBzdGRlcnI7IHRoaXMgdW5mb3J0dW5hdGVseSBpbmNsdWRlcworICAgICAgICBMUEMgY29tcGlsZXIgZGlhZ25vc3RpY3MKKyAgICAgIC0gTFBDIHJ1bnRpbWUtcmVsYXRlZCBtZXNzYWdlcyBpbiB0aGUgbG9nZmlsZSA8bXVkbGliPi88aG9zdD4ucGFyc2UubG9nCisgICAgICAgICh0aGUgbmFtZSBjYW4gYmUgY2hhbmdlZCkuCisKKyAgICBJdCBpcyBwb3NzaWJsZSB0byBzdGFydCB0aGUgZHJpdmVyIHdpdGhvdXQgYW55IGNvbW1hbmRsaW5lIGFyZ3VtZW50cyBhcworICAgIHN1aXRhYmxlIGRlZmF1bHRzIGFyZSBzcGVjaWZpZWQgYXQgY29tcGlsZSB0aW1lLiBUaGUgaW52b2NhdGlvbiBzeW50YXgKKyAgICBpczoKKworICAgICAgICBkcml2ZXIgW29wdGlvbnNdIFs8cG9ydG51bWJlcj5dLi4uCisKKyAgICA8cG9ydG51bWJlcj4gdGhlIG51bWJlciBvZiB0aGUgcG9ydCB0aGUgZHJpdmVyIHNoYWxsIHVzZSB0byBhY2NlcHQKKyAgICBjb25uZWN0aW9ucy4gVGhlIG1heGltdW0gbnVtYmVyIG9mIHBvcnRzIGlzIGRldGVybWluZWQgYnkgTUFYTlVNUE9SVFMKKyAgICBpbiB0aGUgc291cmNlIGZpbGUgY29uZmlnLmguCisKKyAgICBUaGUgb3B0aW9ucyBtb2RpZnkgdGhlIGJlaGF2aW91ciBvZiB0aGUgZ2FtZWRyaXZlci4gU29tZSBvZiB0aGVtIGFyZSBvbmx5CisgICAgYXZhaWxhYmxlIGlmIGEgY2VydGFpbiBjb21waWxlLXRpbWUgb3B0aW9uIHdhcyBlbmFibGVkICh0eXBpY2FsbHkgaW4KKyAgICB0aGUgc291cmNlIGZpbGUgY29uZmlnLmgpLiBUaGUgZm9sbG93aW5nIG9wdGlvbnMgYXJlIHJlY29nbml6ZWQ6CisKKyAgICAgIC1QfC0taW5oZXJpdCA8ZmQtbnVtYmVyPgorICAgICAgICBJbmhlcml0IGZpbGVkZXNjcmlwdG9yIDxmZC1udW1iZXI+IGZyb20gdGhlIHBhcmVudCBwcm9jZXNzCisgICAgICAgIGFzIHNvY2tldCB0byBsaXN0ZW4gZm9yIGNvbm5lY3Rpb25zLgorICAgICAgICBPbmx5IGF2YWlsYWJsZSBpZiBjb21waWxlZCB3aXRoIE1BWE5VTVBPUlRTLgorCisgICAgICAtdXwtLXVkcCA8cG9ydG51bWJlcj4KKyAgICAgICAgU3BlY2lmeSB0aGUgPHBvcnRudW1iZXI+IGZvciB0aGUgVURQIHBvcnQsIG92ZXJyaWRpbmcgdGhlIGNvbXBpbGVkLWluCisgICAgICAgIGRlZmF1bHQuCisgICAgICAgIE9ubHkgYXZhaWxhYmxlIGlmIGNvbXBpbGVkIHdpdGggQ0FUQ0hfVURQX1BPUlQuCisKKyAgICAgIC1EfC0tZGVmaW5lIDxtYWNybz5bPTx0ZXh0Pl0KKyAgICAgICAgQWRkIDxtYWNybz4gKG9wdGlvbmFsbHkgdG8gYmUgZXhwYW5kZWQgdG8gPHRleHQ+KSB0byB0aGUgbGlzdCBvZgorICAgICAgICBwcmVkZWZpbmVkIG1hY3JvcyBrbm93biBieSB0aGUgTFBDIGNvbXBpbGVyLgorCisgICAgICAtRXwtLWV2YWwtY29zdCA8dGlja3M+CisgICAgICAgIFNldCB0aGUgbnVtYmVyIG9mIDx0aWNrcz4gYXZhaWxhYmxlIGZvciBvbmUgZXZhbHVhdGlvbiB0aHJlYWQuCisgICAgICAgIElmIDAsIGV4ZWN1dGlvbiBpcyB1bmxpbWl0ZWQuCisKKyAgICAgIC1NfC0tbWFzdGVyIDxmaWxlbmFtZT4KKyAgICAgICAgVXNlIDxmaWxlbmFtZT4gZm9yIHRoZSBtYXN0ZXIgb2JqZWN0LgorCisgICAgICAtbXwtLW11ZGxpYiA8cGF0aG5hbWU+CisgICAgICAgIFVzZSA8cGF0aG5hbWU+IGFzIHRoZSB0b3AgZGlyZWN0b3J5IG9mIHRoZSBtdWRsaWIuCisKKyAgICAgIC0tZGVidWctZmlsZSA8ZmlsZW5hbWU+CisgICAgICAgIExvZyBhbGwgZGVidWcgb3V0cHV0IGluIDxmaWxlbmFtZT4gaW5zdGVhZCBvZgorICAgICAgICA8bXVkbGliPi88aG9zdD4uZGVidWcubG9nIC4KKworICAgICAgLS1ob3N0bmFtZSA8bmFtZT4KKyAgICAgICAgVXNlIDxuYW1lPiBhcyBob3N0bmFtZSBpbnN0ZWFkIG9mIHdoYXQgdGhlIHN5c3RlbSBzYXlzLgorCisgICAgICAtLWhvc3RhZGRyIDxhZGRyPgorICAgICAgICBVc2UgPGFkZHI+IGFzIGFkZHJlc3Mgb2YgdGhpcyBtYWNoaW5lLCBpbnN0ZWFkIG9mIHdoYXQgdGhlCisgICAgICAgIHN5c3RlbSBzYXlzLiAgSW4gcGFydGljdWxhciB0aGlzIGFkZHJlc3Mgd2lsbCBiZSB1c2VkIHRvIG9wZW4KKyAgICAgICAgdGhlIGRyaXZlciBwb3J0cy4KKworICAgICAgLS1uby1jb21wYXQKKyAgICAgIC0tY29tcGF0CisgICAgICAgIFNlbGVjdCB0aGUgbW9kZSAocGxhaW4gb3IgY29tcGF0KSBvZiB0aGUgZHJpdmVyLgorICAgICAgICBUaGlzIGNob2ljZSBkb2VzIG5vdCBhZmZlY3QgdGhlIGRlZmF1bHQgbmFtZSBvZiB0aGUgbWFzdGVyIG9iamVjdC4KKworICAgICAgLWR8LS1kZWJ1ZworICAgICAgICBHZW5lcmF0ZSBkZWJ1ZyBvdXRwdXQ7IHJlcGVhdCB0aGUgYXJndW1lbnQgZm9yIGV2ZW4gbW9yZSBvdXRwdXQ6CisgICAgICAgICAgPj0gMTogbG9nIHJlc2V0cywgY2xlYW4gdXBzLCBzd2FwcywgcmVjZXB0aW9uIG9mIHVyZ2VuZCBkYXRhLAorICAgICAgICAgICAgICAgICAgIHRlbG5ldCBuZWdvdGlhdGlvbiBzdGF0ZXMuCisgICAgICAgICAgICAgICAgY2hlY2tfYV9sb3Rfb2ZfcmVmY291bnRzKCkgb24gc3RhcnR1cCB3aGVuIHN3YXBwaW5nIG9mCisgICAgICAgICAgICAgICAgICAgdmFyaWFibGVzIGlzIGRpc2FibGVkLgorICAgICAgICAgID49IDI6IGxvZyBhbGwgYWRkX21lc3NhZ2UoKXMsIG5hbWUgbG9va3VwIGZhaWx1cmVzLCBuZXcgcGxheWVycy4KKyAgICAgICAgICA+PSAzOiBwcm9ncmVzcyBvZiBnYXJiYWdlIGNvbGxlY3Rpb24KKyAgICAgICAgICA+PSA0OiBldmVuIG1vcmUganVuayBmcm9tIGdhcmJhZ2UgY29sbGVjdGlvbgorCisgICAgICAtY3wtLWxpc3QtY29tcGlsZXMKKyAgICAgICAgTGlzdCB0aGUgbmFtZSBvZiBldmVyeSBjb21waWxlZCBmaWxlIG9uIHN0ZGVyci4KKworICAgICAgLWV8LS1uby1wcmVsb2FkCisgICAgICAgIFBhc3MgYSBub24temVybyBhcmd1bWVudCAodGhlIG51bWJlciBvZiBvY2N1cmVuY2VzIG9mIHRoaXMgb3B0aW9uKQorICAgICAgICB0byBtYXN0ZXItPnByZWxvYWQoKSwgd2hpY2ggdXN1YWxseSBpbmhpYml0cyBhbGwgcHJlbG9hZHMgb2YgY2FzdGxlcworICAgICAgICBhbmQgb3RoZXIgb2JqZWN0cy4KKworICAgICAgLS1lcnEgPGZpbGVuYW1lPgorICAgICAgLS1lcnEgIjxmaWxlbmFtZT4gPGVycSBhcmdzPiIKKyAgICAgICAgVXNlIDxmaWxlbmFtZT4gaW5zdGVhZCBvZiAnZXJxJyBhcyB0aGUgYmFzZW5hbWUgb2YgdGhlIEVSUSBleGVjdXRhYmxlLgorICAgICAgICBJZiB0aGUgbmFtZSBzdGFydHMgd2l0aCBhICcvJywgaXQgaXMgdGFrZSB0byBiZSBhbiBhYnNvbHV0ZSBwYXRobmFtZSwKKyAgICAgICAgb3RoZXJ3aXNlIGl0IGlzIGludGVycHJldGVkIHJlbGF0aXZlIHRvIDxiaW5kaXI+LiBJZiBub3Qgc3BlY2lmaWVkLAorICAgICAgICAnZXJxJyBpcyB1c2VkIGFzIHRoZSBleGVjdXRhYmxlIG5hbWUuCisKKyAgICAgICAgQnkgZW5jbG9zaW5nIHRoZSBhcmd1bWVudCB2YWx1ZSBpbiBxdW90ZXMsIGl0IGlzIHBvc3NpYmxlIHRvIHBhc3MKKyAgICAgICAgYXJndW1lbnRzIChlLmcuIC0tZXhlY2RpcikgdG8gdGhlIGVycS4gVGhlc2UgYXJndW1lbnRzIGhvd2V2ZXIgbXVzdAorICAgICAgICBub3QgY29udGFpbiBlbWJlZGRlZCBzcGFjZXMuCisKKyAgICAgIC1OfC0tbm8tZXJxCisgICAgICAgIERvbid0IHN0YXJ0IHRoZSBlcnEgZGVtb24gKGlmIGl0IHdvdWxkIGJlIHN0YXJ0ZWQgYXQgYWxsKS4KKworICAgICAgLS1hbGFybS10aW1lIDxzZWNvbmRzPgorICAgICAgICBTZXQgdGhlIGdyYW51bGFyaXR5IG9mIGNhbGxfb3V0KCkgYW5kIGhlYXJ0YmVhdCB0aW1pbmcuIE1pbmltdW0KKyAgICAgICAgdmFsdWUgaXMgMS4KKworICAgICAgLS1oZWFydC1pbnRlcnZhbCA8c2Vjb25kcz4KKyAgICAgICAgU2V0IHRoZSBpbnRlcnZhbCBiZXR3ZWVuIHR3byBoZWFydGJlYXRzLiBNaW5pbXVtIHZhbHVlIGlzIDEuCisKKyAgICAgIC0tc3luYy1oZWFydAorICAgICAgICBBbGwgaGVhcnRiZWF0cyBvY2N1ciBhdCB0aGUgc2FtZSB0aW1lIChtb2R1bG8gZ3JhbnVsYXJpdHkpLgorICAgICAgCisgICAgICAtLWFzeW5jLWhlYXJ0CisgICAgICAgIEhlYXJ0YmVhdHMgb2NjdXIgd2hlbiB0aGV5IGFyZSBkdWUgKG1vZHVsbyBncmFudWxhcml0eSkuCisKKyAgICAgIC10fC0tbm8taGVhcnQKKyAgICAgICAgRGlzYWJsZSBoZWFydGJlYXRzIGFuZCBjYWxsX291dHMuCisKKyAgICAgIC1mfC0tZnVuY2FsbCA8d29yZD4KKyAgICAgICAgVGhlIGxmdW4gbWFzdGVyLT5mbGFnKCkgaXMgY2FsbGVkIHdpdGggPHdvcmQ+IGFzIGFyZ3VtZW50IGJlZm9yZSB0aGUKKyAgICAgICAgZ2FtZWRyaXZlciBhY2NlcHRzIG5ldHdvcmQgY29ubmVjdGlvbnMuCisKKyAgICAgIC0tcmVnZXhwIHBjcmUgfCB0cmFkaXRpb25hbAorICAgICAgICBTZWxlY3QgdGhlIGRlZmF1bHQgcmVnZXhwIHBhY2thZ2UuCisKKyAgICAgIC0tbWF4LWFycmF5IDxzaXplPgorICAgICAgICBUaGUgbWF4aW11bSBudW1iZXIgb2YgZWxlbWVudHMgYW4gYXJyYXkgY2FuIGhvbGQuCisgICAgICAgIFNldCB0byAwLCBhcnJheXMgb2YgYW55IHNpemUgYXJlIGFsbG93ZWQuCisKKyAgICAgIC0tbWF4LW1hcHBpbmcgPHNpemU+CisgICAgICAgIFRoZSBtYXhpbXVtIG51bWJlciBvZiBlbGVtZW50cyBhIG1hcHBpbmcgY2FuIGhvbGQuCisgICAgICAgIFNldCB0byAwLCBtYXBwaW5ncyBvZiBhbnkgc2l6ZSBhcmUgYWxsb3dlZC4KKworICAgICAgLS1tYXgtbWFwcGluZy1rZXlzIDxzaXplPgorICAgICAgICBUaGUgbWF4aW11bSBudW1iZXIgb2YgZW50cmllcyBhIG1hcHBpbmcgY2FuIGhvbGQuCisgICAgICAgIFNldCB0byAwLCBtYXBwaW5ncyBvZiBhbnkgc2l6ZSBhcmUgYWxsb3dlZC4KKworICAgICAgLS1tYXgtY2FsbG91dHMgPHNpemU+CisgICAgICAgIFRoZSBtYXhpbXVtIG51bWJlciBvZiBjYWxsb3V0cyBhdCBvbmUgdGltZS4KKyAgICAgICAgU2V0IHRvIDAsIGFueSBudW1iZXIgaXMgYWxsb3dlZC4KKworICAgICAgLS1tYXgtYnl0ZXMgPHNpemU+CisgICAgICAgIFRoZSBtYXhpbXVtIG51bWJlciBvZiBieXRlcyBvbmUgcmVhZF9ieXRlcygpL3dyaXRlX2J5dGVzKCkgY2FsbAorICAgICAgICBjYW4gaGFuZGxlLgorICAgICAgICBTZXQgdG8gMCwgcmVhZHMgYW5kIHdyaXRlcyBvZiBhbnkgc2l6ZSBhcmUgYWxsb3dlZC4KKworICAgICAgLS1tYXgtZmlsZSA8c2l6ZT4KKyAgICAgICAgVGhlIG1heGltdW0gbnVtYmVyIG9mIGJ5dGVzIG9uZSByZWFkX2ZpbGUoKS93cml0ZV9maWxlKCkgY2FsbAorICAgICAgICBjYW4gaGFuZGxlLgorICAgICAgICBTZXQgdG8gMCwgcmVhZHMgYW5kIHdyaXRlcyBvZiBhbnkgc2l6ZSBhcmUgYWxsb3dlZC4KKworICAgICAgLS1tYXgtdGhyZWFkLXBlbmRpbmcgPHNpemU+XG4iCisgICAgICAgIFRoZSBtYXhpbXVtIG51bWJlciBvZiBieXRlcyB0byBiZSBrZXB0IHBlbmRpbmcgYnkgdGhlIHNvY2tldCB3cml0ZQorICAgICAgICB0aHJlYWQuCisgICAgICAgIFNldCB0byAwLCBhbiB1bmxpbWl0ZWQgYW1vdW50IG9mIGRhdGEgY2FuIGJlIGtlcHQgcGVuZGluZy4KKworICAgICAgICBUaGlzIG9wdGlvbiBpcyBpZ25vcmVkIGlmIHB0aHJlYWRzIGFyZSBub3QgdXNlZC4KKworICAgICAgLS1jbGVhbnVwLXRpbWUgPHRpbWU+CisgICAgICAgIFRoZSBpZGxlIHRpbWUgaW4gc2Vjb25kcyBmb3IgYW4gb2JqZWN0IGJlZm9yZSB0aGUgZHJpdmVyIHRyaWVzIHRvCisgICAgICAgIGNsZWFuIGl0IHVwLiBJdCBzaG91bGQgYmUgc3Vic3RhbnRpYWxseSBsb25nZXIgdGhhbiB0aGUgcmVzZXQgdGltZS4KKyAgICAgICAgQSB0aW1lIDw9IDAgZGlzYWJsZXMgdGhlIGNsZWFudXAgbWVjaGFuaXNtLgorCisgICAgICAtLXJlc2V0LXRpbWUgPHRpbWU+CisgICAgICAgIFRoZSB0aW1lIGluIHNlY29uZHMgYmVmb3JlIGFuIG9iamVjdCBpcyByZXNldC4gQSB0aW1lIDw9IDAgZGlzYWJsZXMKKyAgICAgICAgdGhlIHJlc2V0IG1lY2hhbmlzbS4KKworICAgICAgLXMgPHRpbWU+ICB8IC0tc3dhcC10aW1lIDx0aW1lPgorICAgICAgLXMgdjx0aW1lPiB8IC0tc3dhcC12YXJpYWJsZXMgPHRpbWU+CisgICAgICAgIFRpbWUgaW4gc2Vjb25kcyBiZWZvcmUgYW4gb2JqZWN0IChvciBpdHMgdmFyaWFibGVzKSBhcmUgc3dhcHBlZCBvdXQuCisgICAgICAgIEEgdGltZSBsZXNzIG9yIGVxdWFsIDAgZGlzYWJsZXMgc3dhcHBpbmcuCisKKyAgICAgIC1zIGY8bmFtZT4gfCAtLXN3YXAtZmlsZSA8bmFtZT4KKyAgICAgICAgU3dhcCBpbnRvIGZpbGUgPG5hbWU+IGluc3RlYWQgb2YgPG11ZGxpYj4vTFBfU1dBUC48aG9zdD4gLgorCisgICAgICAtcyBjICAgICAgIHwgLS1zd2FwLWNvbXBhY3QKKyAgICAgICAgUmV1c2UgZnJlZSBzcGFjZSBpbiB0aGUgc3dhcCBmaWxlIGltbWVkaWF0ZWx5LgorICAgICAgICBHaXZpbmcgdGhpcyBvcHRpb24gcmVzdWx0cyBpbiBzbWFsbGVyLCBidXQgYWxzbyBtb3JlIGZyYWdtZW50ZWQKKyAgICAgICAgc3dhcGZpbGVzLCBhbmQgdGhlIHN3YXAgcGVyZm9ybWFuY2UgbWF5IGRlZ3JhZGUuCisKKyAgICAgIC0tbWF4LW1hbGxvYyA8c2l6ZT4KKyAgICAgICAgUmVzdHJpY3QgdG90YWwgbWVtb3J5IGFsbG9jYXRpb25zIHRvIDxzaXplPiBieXRlcy4KKyAgICAgICAgQSA8c2l6ZT4gb2YgMCBvciAndW5saW1pdGVkJyByZW1vdmVzIGFueSByZXN0cmljdGlvbi5cbiIKKworICAgICAgLS1taW4tbWFsbG9jIDxzaXplPgorICAgICAgLS1taW4tc21hbGwtbWFsbG9jIDxzaXplPgorICAgICAgICBEZXRlcm1pbmUgdGhlIHNpemVzIGZvciB0aGUgZXhwbGljaXRlIGluaXRpYWwgbGFyZ2UgcmVzcC4gc21hbGwgY2h1bmsKKyAgICAgICAgYWxsb2NhdGlvbi4gQSBzaXplIG9mIDAgZGlzYWJsZXMgdGhlIGV4cGxpY2l0ZSBpbml0aWFsIGFsbG9jYXRpb25zLgorCisgICAgICAtciB1PHNpemU+IHwgLS1yZXNlcnZlLXVzZXIgPHNpemU+CisgICAgICAtciBtPHNpemU+IHwgLS1yZXNlcnZlLW1hc3RlciA8c2l6ZT4KKyAgICAgIC1yIHM8c2l6ZT4gfCAtLXJlc2VydmUtc3lzdGVtIDxzaXplPgorICAgICAgICBSZXNlcnZlIDxzaXplPiBhbW91bnQgb2YgbWVtb3J5IGZvciB1c2VyL21hc3Rlci9zeXN0ZW0gYWxsb2NhdGlvbnMgdG8KKyAgICAgICAgYmUgaGVsZCB1bnRpbCBtYWluIG1lbW9yeSBydW5zIG91dC4KKworICAgICAgLS1maWxlbmFtZS1zcGFjZXMKKyAgICAgIC0tbm8tZmlsZW5hbWUtc3BhY2VzCisgICAgICAgIEFsbG93L2Rpc2FsbG93IHRoZSB1c2Ugb2Ygc3BhY2VzIGluIGZpbGVuYW1lcy4KKworICAgICAgLS1zdHJpY3QtZXVpZHMKKyAgICAgIC0tbm8tc3RyaWN0LWV1aWRzCisgICAgICAgIEVuYWJsZS9kaXNhYmxlIHRoZSBlbmZvcmNlZCB1c2Ugb2YgZXVpZHMuCisKKyAgICAgIC0tc2hhcmUtdmFyaWFibGVzCisgICAgICAtLWluaXQtdmFyaWFibGVzCisgICAgICAgIFNlbGVjdCBob3cgY2xvbmVzIGluaXRpYWxpemUgdGhlaXIgdmFyaWFibGVzOgorICAgICAgICAgIC0gYnkgc2hhcmluZyB0aGUgY3VycmVudCB2YWx1ZXMgb2YgdGhlaXIgYmx1ZXByaW50CisgICAgICAgICAgLSBieSBpbml0aWFsaXppbmcgdGhlbSBhZnJlc2ggKHVzaW5nIF9fSU5JVCgpKS4KKworICAgICAgLS1waWRmaWxlIDxmaWxlbmFtZT5cbiIKKyAgICAgICAgV3JpdGUgdGhlIHBpZCBvZiB0aGUgZHJpdmVyIHByb2Nlc3MgaW50byA8ZmlsZW5hbWU+LlxuIgorCisgICAgICAtLXRscy1rZXkgPHBhdGhuYW1lPgorICAgICAgICAgIFVzZSA8cGF0aG5hbWU+IGFzIHRoZSB4NTA5IGtleWZpbGUsIGRlZmF1bHQgaXMgJ2tleS5wZW0nLgorICAgICAgICAgIElmIHJlbGF0aXZlLCA8cGF0aG5hbWU+IGlzIGludGVycHJldGVkIHJlbGF0aXZlIHRvIDxtdWRsaWI+LgorCisgICAgICAtLXRscy1jZXJ0IDxwYXRobmFtZT4KKyAgICAgICAgIFVzZSA8cGF0aG5hbWU+IGFzIHRoZSB4NTA5IGNlcnRmaWxlLCBkZWZhdWx0IGlzICdjZXJ0LnBlbScuCisgICAgICAgICBJZiByZWxhdGl2ZSwgPHBhdGhuYW1lPiBpcyBpbnRlcnByZXRlZCByZWxhdGl2ZSB0byA8bXVkbGliPi4KKworICAgICAgLS10bHMtdHJ1c3RmaWxlIDxwYXRobmFtZT4KKyAgICAgICAgVXNlIDxwYXRobmFtZT4gYXMgdGhlIGZpbGVuYW1lIGhvbGRpbmcgeW91ciB0cnVzdGVkIFBFTSBjZXJ0aWZpY2F0ZXMuCisgICAgICAgIElmIHJlbGF0aXZlLCA8cGF0aG5hbWU+IGlzIGludGVycHJldGVkIHJlbGF0aXZlIHRvIDxtdWRsaWI+LgorCisgICAgICAtLXRscy10cnVzdGRpcmVjdG9yeSA8cGF0aG5hbWU+CisgICAgICAgIFVzZSA8cGF0aG5hbWU+IGFzIHRoZSBkaXJlY3Rvcnkgd2hlcmUgeW91ciB0cnVzdGVkCisgICAgICAgIFBFTSBjZXJ0aWZpY2F0ZXMgcmVzaWRlLCBkZWZhdWx0IGlzICcvZXRjL3NzbC9jZXJ0cycuCisgICAgICAgIElmIHJlbGF0aXZlLCA8cGF0aG5hbWU+IGlzIGludGVycHJldGVkIHJlbGF0aXZlIHRvIDxtdWRsaWI+LgorCisgICAgICAtLXdpemxpc3QtZmlsZSA8ZmlsZW5hbWU+CisgICAgICAtLW5vLXdpemxpc3QtZmlsZQorICAgICAgICBSZWFkIGFuZCBzYXZlIHRoZSB3aXpsaXN0IGluIHRoZSBuYW1lZCBmaWxlIChhbHdheXMgaW50ZXJwcmV0ZWQKKyAgICAgICAgcmVsYXRpdmUgdGhlIG11ZGxpYik7IHJlc3AuIGRvbid0IHJlYWQgb3Igc2F2ZSB0aGUgd2l6bGlzdC4KKworICAgICAgLS1nY29sbGVjdC1vdXRmZCA8ZmlsZW5hbWU+fDxudW0+CisgICAgICAgIEdhcmJhZ2UgY29sbGVjdG9yIG91dHB1dCAobGlrZSBhIGxvZyBvZiBhbGwgcmVjbGFpbWVkIG1lbW9yeSBibG9ja3MpCisgICAgICAgIGlzIHNlbnQgdG8gPGZpbGVuYW1lPiAob3IgaW5oZXJpdGVkIGZkIDxudW0+KSBpbnN0ZWFkIG9mIHN0ZGVyci4KKyAgICAgICAgT25seSBhdmFpbGFibGUgaWYgY29tcGlsZWQgd2l0aCBNQUxMT0Nfc21hbGxvYy4KKworICAgICAgLS15fC0teXlkZWJ1ZworICAgICAgICBFbmFibGUgZGVidWdnaW5nIG9mIHRoZSBMUEMgY29tcGlsZXIuCisgICAgICAgIE9ubHkgYXZhaWxhYmxlIGlmIGNvbXBpbGVkIHdpdGggWVlERUJVRy4KKworICAgICAgLS1yYW5kb20tc2VlZCA8bnVtPgorICAgICAgICBTZWVkIHZhbHVlIGZvciB0aGUgcmFuZG9tIG51bWJlciBnZW5lcmF0b3IuIElmIG5vdCBnaXZlbiwgdGhlCisgICAgICAgIGRyaXZlciBjaG9vc2VzIGEgc2VlZCB2YWx1ZSBvbiBpdHMgb3duLgorICAgICAgICBUaGlzIG9wdGlvbiBpcyBmb3IgZGVidWdnaW5nLgorCisgICAgICAtLWNoZWNrLXN0YXRlIDxsdmw+CisgICAgICAgIFBlcmZvcm0gYSByZWd1bGFyIHNpbXBsaXN0aWMgY2hlY2sgb2YgdGhlIHZpcnR1YWwgbWFjaGluZSBhY2NvcmRpbmcKKyAgICAgICAgdG8gPGx2bD46CisgICAgICAgICAgPSAwOiBubyBjaGVjaworICAgICAgICAgID0gMTogb25jZSBwZXIgYmFja2VuZCBsb29wCisgICAgICAgICAgPSAyOiBhdCB2YXJpb3VzIHBvaW50cyBpbiB0aGUgYmFja2VuZCBsb29wCisgICAgICAgIE9ubHkgYXZhaWxhYmxlIGlmIGNvbXBpbGVkIHdpdGggREVCVUcuCisKKyAgICAgIC0tY2hlY2stcmVmY291bnRzCisgICAgICAgIEV2ZXJ5IGJhY2tlbmQgY3ljbGUsIGFsbCByZWZjb3VudHMgaW4gdGhlIHN5c3RlbSBhcmUgY2hlY2tlZC4KKyAgICAgICAgU0xPVyEgT25seSBhdmFpbGFibGUgaWYgY29tcGlsZWQgd2l0aCBERUJVRy4KKworICAgICAgLS1nb2JibGUtZGVzY3JpcHRvcnMgPG51bT4KKyAgICAgICAgPG51bT4gKG1vcmUpIGZpbGVkZXNjcmlwdG9ycyBhcmUgdXNlZCB1cC4gWW91J2xsIGtub3cgd2hlbiB5b3UgbmVlZCBpdC4KKyAgICAgICAgT25seSBhdmFpbGFibGUgaWYgY29tcGlsZWQgd2l0aCBERUJVRy4KKworICAgICAgLS1jaGVjay1zdHJpbmdzCisgICAgICAgIEV2ZXJ5IGJhY2tlbmQgY3ljbGUsIGFsbCBzaGFyZWQgc3RyaW5ncyBpbiB0aGUgc3lzdGVtIGFyZSBjaGVja2VkLgorICAgICAgICBTTE9XISBPbmx5IGF2YWlsYWJsZSBpZiBjb21waWxlZCB3aXRoIERFQlVHIGFuZCBDSEVDS19TVFJJTkdTLgorCisgICAgICAtVnwtLXZlcnNpb24KKyAgICAgICAgUHJpbnQgdGhlIHZlcnNpb24gb2YgdGhlIGRyaXZlciBhbmQgZXhpdC4KKworICAgICAgLS1vcHRpb25zCisgICAgICAgIFByaW50IHRoZSB2ZXJzaW9uIGFuZCBjb21waWxhdGlvbiBvcHRpb25zIG9mIHRoZSBkcml2ZXIgYW5kIGV4aXQuCisKKyAgICAgIC1ofC0/fC0taGVscAorICAgICAgICBEaXNwbGF5IGEgY29tbWFuZCBoZWxwIGFuZCBleGl0LgorCisgICAgICAtLWxvbmdoZWxwCisgICAgICAgIERpc3BsYXkgYSBsb25nIGNvbW1hbmQgaGVscCBhbmQgZXhpdC4KKworICAgICAgLS1hcmdzIDxmaWxlbmFtZT4KKyAgICAgICAgVGhlIGRyaXZlciByZWFkcyBhbmQgcGFyc2VzIHRoZSBnaXZlbiBmaWxlIGFuZCB0cmVhdHMgaXRzIGNvbnRlbnRzCisgICAgICAgIGFzIGlmIGdpdmVuIG9uIHRoZSBjb21tYW5kbGluZSByaWdodCB3aGVyZSB0aGUgLS1hcmdzIG9wdGlvbgorICAgICAgICBvY2N1cmVkLiBUaGUgZmlsZSBpdHNlbGYgY2FuIGFnYWluIGNvbnRhaW4gLS1hcmdzIG9wdGlvbnMuCisKKworREVTQ1JJUFRJT04gLS0gQXJndW1lbnQgUGFyc2VyCisgICAgVGhlIHBhcnNlciBhbmFseXNlcyB0aGUgY29tbWFuZGxpbmUgYXJndW1lbnRzIGdpdmVuIHdpdGggdGhlIGRyaXZlcgorICAgIGludm9jYXRpb24gYW5kIGRpc3Rpbmd1aXNoZXMgJ29wdGlvbnMnLCB3aGljaCBzdGFydCB3aXRoIGEgJy0nLCBmcm9tCisgICAgcHJvcGVyIGFyZ3VtZW50cy4gT3B0aW9ucyBhcmUgZnVydGhlciBkaXN0aW5ndWlzaGVkIGJ5IHRoZWlyIG5hbWUgYW5kCisgICAgbWF5IHRha2UgYW4gYWRkaXRpb25hbCB2YWx1ZS4gSW4gZ2VuZXJhbCwgb3B0aW9ucyBhbmQgYXJndW1lbnRzIGNhbiBiZQorICAgIGdpdmVpbiBpbiBhbnkgb3JkZXIuCisKKyAgICBPcHRpb25zIGFyZSByZWNvZ25pemVkIGluIHR3byBmb3Jtcy4gSW4gdGhlIHNob3J0IGZvcm0gdGhlIG9wdGlvbiBtdXN0CisgICAgYmUgZ2l2ZW4gYXMgYSBzaW5nbGUgJy0nIGZvbGxvd2VkIGJ5IGEgc2luZ2xlIGxldHRlci4gSW4gdGhlIGxvbmcgZm9ybSwKKyAgICBvcHRpb25zIHN0YXJ0IHdpdGggJy0tJyBmb2xsb3dlZCBieSBhIHN0cmluZyBvZiBhcmJpdHJhcnkgbGVuZ3RoLiBUaGUKKyAgICBzaG9ydCBvcHRpb25zIGFyZSBjYXNlIHNlbnNpdGl2ZSwgdGhlIGxvbmcgb3B0aW9ucyBhcmVuJ3QuCisgICAgTW9zdCBvcHRpb25zIGNhbiBiZSBzcGVjaWZpZWQgaW4gYm90aCB0aGUgc2hvcnQgYW5kIGxvbmcgZm9ybSwgYnV0IHRoYXQKKyAgICBpcyBub3QgbWFuZGF0b3J5LiBFeGFtcGxlczogJy1yJyBhbmQgJy0tcmVjdXJzaXZlJy4KKworICAgIElmIGFuIG9wdGlvbiB0YWtlcyBhIHZhbHVlLCBpdCBtdXN0IGZvbGxvdyB0aGUgb3B0aW9uIGltbWVkaWF0ZWx5IGFmdGVyCisgICAgYSBzZXBhcmF0aW5nIHNwYWNlIG9yICc9Jy4gQWRkaXRpb25hbGx5LCB0aGUgdmFsdWUgZm9yIGEgc2hvcnQgb3B0aW9uCisgICAgbWF5IGZvbGxvdyB0aGUgb3B0aW9uIHdpdGhvdXQgc2VwYXJhdG9yLiBFeGFtcGxlcyBhcmU6ICctZk1ha2VmaWxlJywKKyAgICAnLWYgTWFrZWZpbGUnLCAnLS1maWxlPU1ha2VmaWxlJyBhbmQgJy0tZmlsZSBNYWtlZmlsZScuCisKKyAgICBTaG9ydCBvcHRpb25zIG1heSBiZSBjb2xsYXRlZCBpbnRvIG9uZSBhcmd1bWVudCwgZS5nLiAnLXJ0bCcsIGJ1dAorICAgIG9mIHRoZXNlIG9ubHkgdGhlIGxhc3QgbWF5IHRha2UgYSB2YWx1ZS4KKworICAgIFRoZSBvcHRpb24gJy0tJyBtYXJrcyB0aGUgZW5kIG9mIG9wdGlvbnMuIEFsbCBmb2xsb3dpbmcgY29tbWFuZCBhcmd1bWVudHMKKyAgICBhcmUgY29uc2lkZXJlZCBwcm9wZXIgYXJndW1lbnRzIGV2ZW4gaWYgdGhleSBzdGFydCB3aXRoIGEgJy0nIG9yICctLScuCisKKyAgICBUaGUgYXJndW1lbnRzIGFyZSB1c3VhbGx5IHRha2VuIGZyb20gdGhlIGNvbW1hbmRsaW5lOyBidXQgdGhlIHBhcnNlcgorICAgIGlzIGFsc28gYWJsZSB0byByZWFkIHRoZW0gZnJvbSBhIHRleHRmaWxlcywgd2hpY2ggY2FuIGJlIG5lc3RlZC4gVGhlCisgICAgY29udGVudCBvZiB0aGUgdGV4dGZpbGVzIGlzIGJyb2tlbiBkb3duIGludG8gd29yZHMgZGVsaW1pdGVkIGJ5IHdoaXRlc3BhY2UsCisgICAgd2hpY2ggYXJlIHRoZW4gdHJlYXRlZCBhcyBnaXZlbiBvbiB0aGUgY29tbWFuZGxpbmUgYXQgdGhlIHBsYWNlIHdoZXJlCisgICAgdGhlIGluc3RydWN0aW9uIHRvIHJlYWQgdGhlIHRleHRmaWxlIHN0b29kLgorCisgICAgVGhlIGZpbGUgcGFyc2VyIHJlY29nbml6ZXMgc2ltcGxlIGRvdWJsZS1xdW90ZWQgc3RyaW5ncywgd2hpY2ggbXVzdCBiZQorICAgIGNvbnRhaW5lZCBvbiBhIHNpbmdsZSBsaW5lLiBBZGRpdGlvbmFsbHksIHRoZSAnIycgY2hhcmFjdGVyIGdpdmVuIGJ5CisgICAgaXRzZWxmIGlzIGEgY29tbWVudCBtYXJrZXIgLSBldmVydGhpbmcgYWZ0ZXIgdGhlICcjJyB1bnRpbCB0aGUgZW5kCisgICAgb2YgdGhlIGN1cnJlbnQgbGluZSBpcyBpZ25vcmVkLgorCitISVNUT1JZCisgICAgTERNdWQgMy4yLjkgYWRkZWQgdGhlIC0tbWF4LXRocmVhZC1wZW5kaW5nLCAtLWhvc3RuYW1lLAorICAgICAgLS1ob3N0YWRkciwgLS1hcmdzIGFuZCAtLXJhbmRvbS1zZWVkIG9wdGlvbnMuCisgICAgTERNdWQgMy4yLjEwIGFkZGVkIHRoZSAtLWZpbGVuYW1lLXNwYWNlcyBvcHRpb25zLgorICAgIExETXVkIDMuMy4zNzggYWRkZWQgLS1zaGFyZS12YXJpYWJsZXMsIC0taW5pdC12YXJpYWJsZXMuCisgICAgTERNdWQgMy4zLjQ3NS8zLjIuMTEgYWRkZWQgLS10bHMta2V5LCAtLXRscy1jZXJ0LgorICAgIExETXVkIDMuMy42NzIvMy4yLjExIGFkZGVkIC0tdGxzLXRydXN0ZmlsZSwgLS10bHMtdHJ1c3RkaXJlY3RvcnkuCisgICAgTERNdWQgMy4zLjY3NyBhZGRlZCAtLW1heC1tYXBwaW5nLWtleXMuCmRpZmYgLS1naXQgYS9kb2MvZHJpdmVyL21hbGxvYyBiL2RvYy9kcml2ZXIvbWFsbG9jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdmYjI3MjIKLS0tIC9kZXYvbnVsbAorKysgYi9kb2MvZHJpdmVyL21hbGxvYwpAQCAtMCwwICsxLDEyIEBACitOQU1FCisgICAgICAgIG1hbGxvYworCitERVNDUklQVElPTgorICAgICAgICBUaGlzIGNvbW1hbmQgaXMgaGFyZGNvZGVkIGludG8gdGhlIGRyaXZlcidzIGlucHV0IHBhcnNlci4KKyAgICAgICAgSXQgc2hvd3MgdGhlIHN0YXRpc3RpY3Mgb2YgdGhlIG1lbW9yeSBtYW5hZ2VtZW50IG1vZHVsZS4KKworSElTVE9SWQorICAgICAgICBTaW5jZSAzLjIuNywgJ3N0YXR1cyBtYWxsb2MnIGhhcyB0aGUgc2FtZSBlZmZlY3QuCisKK1NFRSBBTFNPCisgICAgICAgIHN0YXR1cyhEKSwgbWVtb3J5KEMpLCBkZWJ1Z19pbmZvKEUpCmRpZmYgLS1naXQgYS9kb2MvZHJpdmVyL29wY2R1bXAgYi9kb2MvZHJpdmVyL29wY2R1bXAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjc1ZWE2OAotLS0gL2Rldi9udWxsCisrKyBiL2RvYy9kcml2ZXIvb3BjZHVtcApAQCAtMCwwICsxLDEzIEBACitOQU1FCisgICAgICAgIG9wY2R1bXAKKworREVTQ1JJUFRJT04KKyAgICAgICAgSWYgdGhlIGRyaXZlciB3YXMgY29tcGlsZWQgdG8gZG8gb3Bjb2RlIHByb2ZpbGluZywgdGhpcyBjb21tYW5kCisgICAgICAgIHdpbGwgc2F2ZSB0aGUgY29sbGVjdGVkIHByb2ZpbGluZyBpbmZvcm1hdGlvbiBpbnRvIHRoZSBmaWxlIC9PUENfRFVNUC4KKyAgICAgICAgSWYgdGhlIE9fSVNfV0laQVJEIGZsYWcgaXMgdXNlZCBpbiB0aGUgbXVkbGliIChpLmUuIGlmCisgICAgICAgIHNldF9pc193aXphcmQoKSB3YXMgY2FsbGVkKSwgdGhpcyBjb21tYW5kIGlzIGFsbG93ZWQgb25seSBmb3IKKyAgICAgICAgdXNlcnMgdGhhdCBoYXZlIHRoaXMgZmxhZyBzZXQuCisKK1NFRSBBTFNPCisgICAgICAgIG1hbGxvYyhEKSwgc3RhdHVzKEQpLCBtZW1vcnkoQyksIG9iamVjdHMoQyksIGRlYnVnX2luZm8oRSksCisgICAgICAgIHNldF9pc193aXphcmQoRSkKZGlmZiAtLWdpdCBhL2RvYy9kcml2ZXIvcHJlZGVmaW5lZCBiL2RvYy9kcml2ZXIvcHJlZGVmaW5lZApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xN2E3ZWIwCi0tLSAvZGV2L251bGwKKysrIGIvZG9jL2RyaXZlci9wcmVkZWZpbmVkCkBAIC0wLDAgKzEsMTMwIEBACitOQU1FCisgICAgcHJlZGVmaW5lZCAtIHByZWRlZmluZWQgI2RlZmluZXMgYnkgdGhlIHBhcnNlcgorCitERVNDUklQVElPTgorICAgIFNldmVyYWwgcHJlcHJvY2Vzc29yIG1hY3JvcyBhcmUgcHJlI2RlZmluZWQgYnkgdGhlIHBhcnNlciwKKyAgICB0byBwcm92aWRlIGluZm9ybWF0aW9uIGFib3V0IHBhcnNlciB2ZXJzaW9uLCBjb21waWxlIHRpbWUKKyAgICBvcHRpb25zIGFuZCBwYXJzZXIgaW52b2NhdGlvbiBvcHRpb25zOgorCisgICAgICBMUEMzICAgICAgICAgICAgOiBhbHdheXMgZGVmaW5lZC4KKyAgICAgIF9fTERNVURfXyAgICAgICA6IGFsd2F5cyBkZWZpbmVkLgorICAgICAgX19FVUlEU19fICAgICAgIDogYWx3YXlzIChmb3IgY29tcGF0aWJpbGl0eSkuCisgICAgICBDT01QQVRfRkxBRyAgICAgOiBkZWZpbmVkIGlmIHRoZSBkcml2ZXIgcnVucyBpbiBjb21wYXQgbW9kZS4KKyAgICAgIF9fQ09NUEFUX01PREVfXyA6IGRpdHRvCisgICAgICBfX1NUUklDVF9FVUlEU19fOiBkZWZpbmVkIGlmIHN0cmljdCBldWlkIHVzYWdlIGlzIGVuZm9yY2VkLgorICAgICAgX19GSUxFTkFNRV9TUEFDRVNfXzogZGVmaW5lZCBpZiBmaWxlbmFtZXMgbWF5IGNvbnRhaW4gc3BhY2VzLgorCisgICAgICBfX01BU1RFUl9PQkpFQ1RfXyA6IHRoZSBuYW1lIG9mIHRoZSBtYXN0ZXIgb2JqZWN0IChpbiBjb21wYXQgbW9kZQorICAgICAgICAgICAgICAgICAgICAgICAgICB3aXRob3V0IGxlYWRpbmcgJy8nKS4KKyAgICAgIF9fRklMRV9fICAgICAgICAgIDogdGhlIG5hbWUgb2YgdGhlIGNvbXBpbGVkIGZpbGUgKGluIGNvbXBhdCBtb2RlCisgICAgICAgICAgICAgICAgICAgICAgICAgIHdpdGhvdXQgbGVhZGluZyAnLycpLgorICAgICAgX19MSU5FX18gICAgICAgICAgOiB0aGUgY3VycmVudCBsaW5lIG51bWJlci4KKyAgICAgIF9fRlVOQ1RJT05fXyAgICAgIDogdGhlIGN1cnJlbnQgZnVuY3Rpb24gbmFtZS4KKyAgICAgIF9fRElSX18gICAgICAgICAgIDogdGhlIGRpcmVjdG9yeSBwYXRoIG9mIHRoZSBjb21waWxlZCBmaWxlIChpbgorICAgICAgICAgICAgICAgICAgICAgICAgICBjb21wYXQgbW9kZSB3aXRob3V0IGxlYWRpbmcgJy8nKS4KKyAgICAgIF9fUEFUSF9fKG4pICAgICAgIDogdGhlIGRpcmVjdG9yeSBwYXRoIG9mIHRoZSBjb21waWxlZCBmaWxlIHdpdGhvdXQKKyAgICAgICAgICAgICAgICAgICAgICAgICAgdGhlIDxuPiB0cmFpbGluZyBlbGVtZW50cyAoaW4gY29tcGF0IG1vZGUgd2l0aG91dAorICAgICAgICAgICAgICAgICAgICAgICAgICBsZWFkaW5nICcvJykuCisgICAgICBfX1ZFUlNJT05fXyAgICAgICA6IHRoZSB2ZXJzaW9uIHN0cmluZyBvZiB0aGUgZHJpdmVyLgorICAgICAgX19WRVJTSU9OX01BSk9SX18gOiB0aGUgbWFqb3IgdmVyc2lvbiBudW1iZXIgb2YgdGhlIGRyaXZlci4KKyAgICAgIF9fVkVSU0lPTl9NSU5PUl9fIDogdGhlIG1pbm9yIHZlcnNpb24gbnVtYmVyIG9mIHRoZSBkcml2ZXIuCisgICAgICBfX1ZFUlNJT05fTUlDUk9fXyA6IHRoZSBtaWNybyB2ZXJzaW9uIG51bWJlciBvZiB0aGUgZHJpdmVyLgorICAgICAgX19WRVJTSU9OX1BBVENIX18gOiB0aGUgcGF0Y2hsZXZlbCBvZiB0aGUgZHJpdmVyOyBhIDAgaGVyZSBtZWFucworICAgICAgICAgICAgICAgICAgICAgICAgICAnbm8gcGF0Y2hsZXZlbCcuCisgICAgICBfX1ZFUlNJT05fQ09NTUlUSURfXyA6IHRoZSBjb21taXQgSUQgb2YgdGhlIHNvdXJjZSBvZiB0aGUgZHJpdmVyIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoYXR0ZW50aW9uOiBpdCBtaWdodCBiZSA8dW5rbm93bj4sIGlmIHRoZSBkcml2ZXIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHdhcyBub3QgY29tcGlsZWQgZnJvbSBhIGdpdCByZXBvc2l0b3J5KQorICAgICAgX19WRVJTSU9OX0xPQ0FMX18gOiB0aGUgKG9wdGlvbmFsKSBMT0NBTF9MRVZFTCwgdGhlIHVzZXIgaGFzIGRlZmluZWQuCisKKworICAgICAgX19ET01BSU5fTkFNRV9fICAgIDogdGhlIGRvbWFpbiB0aGUgaG9zdCBpcyBwYXJ0IG9mLgorICAgICAgX19IT1NUX0lQX05VTUJFUl9fIDogdGhlIGhvc3RzIElQIG51bWJlciAoYXMgYSBzdHJpbmcpLgorICAgICAgX19IT1NUX05BTUVfXyAgICAgIDogdGhlIGZ1bGwgaG9zdG5hbWUuCisgICAgICBfX01BWF9SRUNVUlNJT05fXyAgOiB0aGUgbWF4IGNvdW50IG9mIG5lc3RlZCBmdW5jdGlvbiBjYWxscworICAgICAgICAgICAgICAgICAgICAgICAgICAgKHRoaXMgaXMgY29uZmlnLmg6TUFYX1VTRVJfVFJBQ0UpLgorICAgICAgX19NQVhfRVZBTF9DT1NUX18gIDogdGhlIG1heCBldmFsdWF0aW9uIGNvc3QuCisgICAgICBfX1JFU0VUX1RJTUVfXyAgICAgOiBkZWZhdWx0IGludGVydmFsIHRpbWUgYmV0d2VlbiBvYmplY3QgcmVzZXRzLgorICAgICAgX19DTEVBTlVQX1RJTUVfXyAgIDogZGVmYXVsdCBpbnRlcnZhbCB0aW1lIGJldHdlZW4gb2JqZWN0IGNsZWFudXBzLgorICAgICAgX19BTEFSTV9USU1FX18gICAgIDogdGhlIGNvbmZpZ3VyZWQgdGltaW5nIGdyYW51bGFyaXR5LgorICAgICAgX19IRUFSVF9CRUFUX0lOVEVSVkFMX186IHRoZSBjb25maWd1cmVkIGhlYXJ0YmVhdCB0aW1lLgorICAgICAgX19TWU5DSFJPTk9VU19IRUFSVF9CRUFUX186IGRlZmluZWQgaWYgc3luY2hyb25vdXMgaGVhcnRiZWF0cyBhcmUKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGVuYWJsZWQuCisgICAgICBfX01BWF9DT01NQU5EX0xFTkdUSF9fOiB0aGUgbWF4aW11bSBsZW5ndGggYSBjb21tYW5kIGNhbiBoYXZlLgorICAgICAgX19FRlVOX0RFRklORURfXyhuYW1lKSA6IGlmIHRoZSBlZnVuICduYW1lJyBleGlzdHMsIHRoaXMKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtYWNybyBldmFsdWF0ZXMgdG8gIiAxICIsIGVsc2UgdG8gIiAwICIuCisgICAgICBfX0RSSVZFUl9MT0dfXyAgICAgOiB0aGUgbmFtZSBvZiB0aGUgZGVmYXVsdCBkZWJ1Zy5sb2cgZmlsZSAod2l0aGluCisgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGUgbXVkbGliKTsgdW5kZWZpbmVkIGlmIGEgZGlmZmVyZW50IG5hbWUKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGhhcyBiZWVuIHNwZWNpZmllZCBvbiB0aGUgY29tbWFuZGxpbmUuCisgICAgICBfX1dJWkxJU1RfXyAgICAgICAgOiB0aGUgbmFtZSBvZiB0aGUgKG11ZGxpYikgZmlsZSBmcm9tIHdoZXJlIHRoZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgZHJpdmVyIHJlYWQgdGhlIGluaXRpYWwgV0laTElTVCBpbmZvcm1hdGlvbi4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgIEl0IGlzIHVuZGVmaW5lZCBpZiB0aGUgZHJpdmVyIHdhcyBjb25maWd1cmVkCisgICAgICAgICAgICAgICAgICAgICAgICAgICB0byBub3QgcmVhZCB0aGUgaW5mb3JtYXRpb24uCisgICAgICBfX01BWF9NQUxMT0NfXyAgICAgOiB0aGUgaW50ZXJuYWwgdXBwZXIgbGltaXQgZm9yIHRvdGFsIG1lbW9yeQorICAgICAgICAgICAgICAgICAgICAgICAgICAgdXNhZ2UuCisgICAgICBfX0lOVF9NQVhfXyAgICAgICAgOiB0aGUgbGFyZ2VzdCBpbnRlZ2VyIG51bWJlcgorICAgICAgX19JTlRfTUlOX18gICAgICAgIDogdGhlIHNtYWxsZXN0IGludGVnZXIgbnVtYmVyCisgICAgICBfX0ZMT0FUX01BWF9fICAgICAgOiB0aGUgbGFyZ2VzdCAocG9zaXRpdmUpIGZsb2F0IG51bWJlcgorICAgICAgX19GTE9BVF9NSU5fXyAgICAgIDogdGhlIHNtYWxsZXN0IChwb3NpdGl2ZSkgZmxvYXQgbnVtYmVyCisKKyAgICAgIF9fTFBDX05PU0FWRV9fICAgICA6IGFsd2F5cyBkZWZpbmVkCisgICAgICBfX0xQQ19TVFJVQ1RTX18gICAgOiBkZWZpbmVkIHdoZW4gc3RydWN0IHN1cHBvcnQgaXMgZW5hYmxlZC4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgIE9uY2Ugc3RydWN0cyBhcmUgZnVsbHkgc3VwcG9ydGVkLCB0aGlzIG1hY3JvCisgICAgICAgICAgICAgICAgICAgICAgICAgICB3aWxsIGFsd2F5cyBiZSBkZWZpbmVkLgorICAgICAgX19MUENfSU5MSU5FX0NMT1NVUkVTX186IGRlZmluZWQgd2hlbiB0aGUgJ3JlYWwnIGlubGluZSBjbG9zdXJlcworICAgICAgICAgICAgICAgICAgICAgICAgICAgYXJlIGVuYWJsZWQuCisgICAgICBfX0xQQ19BUlJBWV9DQUxMU19fOiBjYWxsX290aGVyKClzIG9uIGFycmF5cyBvZiBvYmplY3RzIGVuYWJsZWQuCisgICAgICBfX0JPT1RfVElNRV9fICAgICAgOiB0aGUgdGltZSgpIHRoZSBkcml2ZXIgd2FzIHN0YXJ0ZWQuCisKKyAgICBJZiB0aGUgRVJRIGlzIHN1cHBvcnRlZCwgdGhlIGZvbGxvd2luZyBtYWNyb3MgYXJlIGRlZmluZWQ6CisKKyAgICAgIF9fRVJRX01BWF9TRU5EX18gIDogdGhlIG1heCBzaXplIG9mIHRoZSBzZW5kIGJ1ZmZlcgorICAgICAgX19FUlFfTUFYX1JFUExZX18gOiB0aGUgbWF4IHNpemUgb2YgdGhlIHJlcGx5IGJ1ZmZlcgorCisgICAgVGhlIGZvbGxvd2luZyBtYWNyb3MgYXJlIGRlZmluZWQgaWYgdGhlaXIgYXNzb2NpYXRlZCBwYWNrYWdlCisgICAgaGFzIGJlZW4gY29tcGlsZWQgaW50byB0aGUgZHJpdmVyOgorCisgICAgICBfX0lETkFfXyA6ICAgICAgc3VwcG9ydCBmb3IgSUROQQorICAgICAgX19JUFY2X18gOiAgICAgIHN1cHBvcnQgZm9yIElQIHYuNgorICAgICAgX19NWVNRTF9fIDogICAgIHN1cHBvcnQgZm9yIG15U1FMCisgICAgICBfX1BHU1FMX18gOiAgICAgc3VwcG9ydCBmb3IgUG9zdGdyZVNRTAorICAgICAgX19TUUxJVEVfXyA6ICAgIHN1cHBvcnQgZm9yIFNRTGl0ZSAzLgorICAgICAgX19YTUxfRE9NX18gOiAgIHN1cHBvcnQgZm9yIFhNTCBwYXJzaW5nLgorICAgICAgX19KU09OX18gOiAgICAgIHN1cHBvcnQgZm9yIEpTT04gcGFyc2luZy9zZXJpYWxpemluZy4KKyAgICAgIF9fTUNDUF9fOiAgICAgICBzdXBwb3J0IGZvciBNQ0NQIGh0dHA6Ly93d3cucmFuZG9tbHkub3JnL3Byb2plY3RzL01DQ1AKKyAgICAgIF9fQUxJU1RTX186ICAgICBzdXBwb3J0IGZvciBhbGlzdHMKKyAgICAgIF9fUENSRV9fOiAgICAgICBzdXBwb3J0IGZvciBQQ1JFCisgICAgICBfX1RMU19fOiAgICAgICAgc3VwcG9ydCBmb3IgVExTIChpbnRlcm5hbCkKKyAgICAgIF9fR05VVExTX186ICAgICBpZiBfX1RMU19fOiBUTFMgc3VwcG9ydCBwcm92aWRlZCBieSBHbnVUTFMuCisgICAgICBfX09QRU5TU0xfXzogICAgaWYgX19UTFNfXzogVExTIHN1cHBvcnQgcHJvdmlkZWQgYnkgT3BlblNTTC4KKyAgICAgIF9fR0NSWVBUX186ICAgICBjcnlwdG9ncmFwaGljIHJvdXRpbmVzIHByb3ZpZGVkIGJ5IGxpYmdjcnlwdC4KKyAgICAgIF9fREVQUkVDQVRFRF9fOiBzdXBwb3J0IGZvciBvYnNvbGV0ZSBhbmQgZGVwcmVjYXRlZCBlZnVucy4KKworCitISVNUT1JZCisgICAgMy4yLjEgYWRkZWQgX19ET01BSU5fTkFNRV9fLCBfX0hPU1RfSVBfTlVNQkVSX18sIF9fSE9TVF9OQU1FX18sCisgICAgICAgIF9fTUFYX1JFQ1VSU0lPTl9fLCBfX0VGVU5fREVGSU5FRF9fKCkuCisgICAgMy4yLjUgYWRkZWQgX19DT01QQVRfTU9ERV9fLCBfX05BVElWRV9NT0RFX18sIF9fRVVJRFNfXywKKyAgICAgICAgX19FUlFfTUFYX1NFTkRfXyBhbmQgX19FUlFfTUFYX1JFUExZX18uCisgICAgMy4yLjYgYWRkZWQgX19NQVhfRVZBTF9DT1NUX18uCisgICAgMy4yLjcgYWRkZWQgX19TVFJJQ1RfRVVJRFNfXyBhbmQgbWFkZSBfX0VVSURTX18gc3RhbmRhcmQuCisgICAgMy4yLjggYWRkZWQgX19JUFY2X18sIF9fTFBDX05PU0FWRV9fLCBfX0RJUl9fLCBfX1BBVEhfXygpLgorICAgIDMuMi45IGFkZGVkIF9fTERNVURfXywgX19NWVNRTF9fLCBfX0RFUFJFQ0FURURfXywgX19WRVJTSU9OX01BSk9SX18sCisgICAgICAgICBfX1ZFUlNJT05fTUlOT1JfXywgX19WRVJTSU9OX01JQ1JPX18sIF9fVkVSU0lPTl9QQVRDSF9fLAorICAgICAgICAgX19JTlRfTUFYX18sIF9fSU5UX01JTl9fLCBfX0ZMT0FUX01JTl9fLCBfX0ZMT0FUX01BWF9fLAorICAgICAgICBfX0NBVENIX0VWQUxfQ09TVF9fLCBfX01BU1RFUl9FVkFMX0NPU1RfXywgX19SRVNFVF9USU1FX18sCisgICAgICAgIF9fQ0xFQU5VUF9USU1FX18sIF9fRFJJVkVSX0xPR19fLCBhbmQgX19XSVpMSVNUX18uCisgICAgMy4yLjEwIGFkZGVkIF9fTUFYX01BTExPQ19fLCBfX01TRE9TX0ZTX18sIF9fTFBDX0FSUkFZX0NBTExTX18KKyAgICAgICAgYW5kIF9fRklMRU5BTUVfU1BBQ0VTX18uCisgICAgMy4zIG1hZGUgX19MUENfTk9TQVZFX18gYWx3YXlzIGRlZmluZWQgYW5kIGFkZGVkIF9fQUxJU1RTX18sCisgICAgICAgIF9fTUNDUF9fLCBfX0xQQ19TVFJVQ1RTX18sIF9fTFBDX0lOTElORV9DTE9TVVJFU19fLCBfX1BHU1FMX18sCisgICAgICAgIF9fUFRIUkVBRFNfXywgX19UTFNfXywgX19CT09UX1RJTUVfXywgX19BTEFSTV9USU1FX18sCisgICAgICAgIF9fSEVBUlRfQkVBVF9JTlRFUlZBTF9fLCBfX1NZTkNIUk9OT1VTX0hFQVJUX0JFQVRfXywgYW5kIF9fUENSRV9fLgorICAgIDMuMy43MTMgYWRkZWQgX19JRE5BX18sIF9fU1FMSVRFX18uCisgICAgMy4zLjcxNCBhZGRlZCBfX09QRU5TU0xfXywgX19HTlVUTFNfXy4KKyAgICAzLjMuNzE4IGFkZGVkIF9fWE1MX0RPTV9fLgorICAgIDMuMy43MTkgcmVtb3ZlZCBfX1BUSFJFQURTX18sIEFNSUdBLCBNU0RPU19GUywgX19CRU9TX18gIAorCQkgICAgYW5kIGFkZGVkIF9fR0NSWVBUX18uCisgICAgMy4zLjcyMSBhZGRlZCBfX0ZVTkNUSU9OX18uCisKK1NFRSBBTFNPCisgICAgcHJhZ21hKExQQyksIHByZXByb2Nlc3NvcihMUEMpCmRpZmYgLS1naXQgYS9kb2MvZHJpdmVyL3Nob3dzbWFsbG5ld21hbGxvY2VkIGIvZG9jL2RyaXZlci9zaG93c21hbGxuZXdtYWxsb2NlZApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xN2UyMjUyCi0tLSAvZGV2L251bGwKKysrIGIvZG9jL2RyaXZlci9zaG93c21hbGxuZXdtYWxsb2NlZApAQCAtMCwwICsxLDE3IEBACitOQU1FCisgICAgICAgIHNob3dzbWFsbG5ld21hbGxvY2VkCisKK0RFU0NSSVBUSU9OCisgICAgICAgIFRoaXMgY29tbWFuZCBpcyBoYXJkY29kZWQgaW50byB0aGUgZHJpdmVyLgorCisgICAgICAgIFNob3dzIGEgbGlzdCBvZiByZWNlbnRseSBhbGxvY2F0ZWQgc21hbGwgbWVtb3J5IGJsb2Nrcy4KKyAgICAgICAgSWYgdGhlIE9fSVNfV0laQVJEIGZsYWcgaXMgdXNlZCBpbiB0aGUgbXVkbGliIChpLmUuIGlmCisgICAgICAgIHNldF9pc193aXphcmQoKSB3YXMgY2FsbGVkKSwgdGhpcyBjb21tYW5kIGlzIGFsbG93ZWQgb25seSBmb3IKKyAgICAgICAgdXNlcnMgdGhhdCBoYXZlIHRoaXMgZmxhZyBzZXQuCisKK0hJU1RPUlkKKyAgICAgICAgRGVhY3RpdmF0ZWQgaW4gMy4yLjcgYnkgZGVmYXVsdC4KKworU0VFIEFMU08KKyAgICAgICAgbWFsbG9jKEQpLCBzdGF0dXMoRCksIG1lbW9yeShDKSwgb2JqZWN0cyhDKSwgZGVidWdfaW5mbyhFKSwKKyAgICAgICAgc2V0X2lzX3dpemFyZChFKQpkaWZmIC0tZ2l0IGEvZG9jL2RyaXZlci9zdGF0dXMgYi9kb2MvZHJpdmVyL3N0YXR1cwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43OTc1OWRkCi0tLSAvZGV2L251bGwKKysrIGIvZG9jL2RyaXZlci9zdGF0dXMKQEAgLTAsMCArMSwxOCBAQAorTkFNRQorICAgICAgICBzdGF0dXMKKyAgICAgICAgc3RhdHVzIHRhYmxlcworICAgICAgICBzdGF0dXMgc3dhcAorICAgICAgICBzdGF0dXMgbWFsbG9jCisKK0RFU0NSSVBUSU9OCisgICAgICAgIFRoaXMgY29tbWFuZCBpcyBoYXJkY29kZWQgaW50byB0aGUgZHJpdmVycyBpbnB1dCByb3V0aW5lLgorICAgICAgICBJdCBkaXNwbGF5cyBpbmZvcm1hdGlvbiBhYm91dCB0aGUgcnVuIHN0YXR1cyBvZiB0aGUgc3lzdGVtLgorICAgICAgICBJZiB0aGUgT19JU19XSVpBUkQgZmxhZyBpcyB1c2VkIGluIHRoZSBtdWRsaWIgKGkuZS4gaWYKKyAgICAgICAgc2V0X2lzX3dpemFyZCgpIHdhcyBjYWxsZWQpLCB0aGlzIGNvbW1hbmQgaXMgYWxsb3dlZCBvbmx5IGZvcgorICAgICAgICB1c2VycyB0aGF0IGhhdmUgdGhpcyBmbGFnIHNldC4KKworSElTVE9SWQorICAgICAgICAzLjIuNyBhZGRlZCB0aGUgJ3N0YXR1cyBtYWxsb2MnIHZhcmlhbnQuCisKK1NFRSBBTFNPCisgICAgICAgIG1hbGxvYyhEKSwgbWVtb3J5KEMpLCBvYmplY3RzKEMpLCBkZWJ1Z19pbmZvKEUpLCBzZXRfaXNfd2l6YXJkKEUpCg==