LlwiIFlvdSBjYW4gdmlldyB0aGlzIGZpbGUgd2l0aDoKLlwiIG5yb2ZmIC1tYW4gY3VybC4xCi5cIiBXcml0dGVuIGJ5IERhbmllbCBTdGVuYmVyZwouXCIKLlRIIGN1cmwgMSAiMTIgTWFyY2ggMjAwMSIgIkN1cmwgNy43IiAiQ3VybCBNYW51YWwiCi5TSCBOQU1FCmN1cmwgXC0gZ2V0IGEgVVJMIHdpdGggRlRQLCBURUxORVQsIExEQVAsIEdPUEhFUiwgRElDVCwgRklMRSwgSFRUUCBvcgpIVFRQUyBzeW50YXguCi5TSCBTWU5PUFNJUwouQiBjdXJsIFtvcHRpb25zXQouSSBbVVJMLi4uXQouU0ggREVTQ1JJUFRJT04KLkIgY3VybAppcyBhIGNsaWVudCB0byBnZXQgZG9jdW1lbnRzL2ZpbGVzIGZyb20gb3Igc2VuZCBkb2N1bWVudHMgdG8gYSBzZXJ2ZXIsIHVzaW5nCmFueSBvZiB0aGUgc3VwcG9ydGVkIHByb3RvY29scyAoSFRUUCwgSFRUUFMsIEZUUCwgR09QSEVSLCBESUNULCBURUxORVQsIExEQVAKb3IgRklMRSkuIFRoZSBjb21tYW5kIGlzIGRlc2lnbmVkIHRvIHdvcmsgd2l0aG91dCB1c2VyIGludGVyYWN0aW9uIG9yIGFueSBraW5kCm9mIGludGVyYWN0aXZpdHkuCgpjdXJsIG9mZmVycyBhIGJ1c2xvYWQgb2YgdXNlZnVsIHRyaWNrcyBsaWtlIHByb3h5IHN1cHBvcnQsIHVzZXIKYXV0aGVudGljYXRpb24sIGZ0cCB1cGxvYWQsIEhUVFAgcG9zdCwgU1NMIChodHRwczopIGNvbm5lY3Rpb25zLCBjb29raWVzLCBmaWxlCnRyYW5zZmVyIHJlc3VtZSBhbmQgbW9yZS4KLlNIIFVSTApUaGUgVVJMIHN5bnRheCBpcyBwcm90b2NvbCBkZXBlbmRlbnQuIFlvdSdsbCBmaW5kIGEgZGV0YWlsZWQgZGVzY3JpcHRpb24gaW4KUkZDIDIzOTYuCgpZb3UgY2FuIHNwZWNpZnkgbXVsdGlwbGUgVVJMcyBvciBwYXJ0cyBvZiBVUkxzIGJ5IHdyaXRpbmcgcGFydCBzZXRzIHdpdGhpbgpicmFjZXMgYXMgaW46CgogaHR0cDovL3NpdGUue29uZSx0d28sdGhyZWV9LmNvbQoKb3IgeW91IGNhbiBnZXQgc2VxdWVuY2VzIG9mIGFscGhhbnVtZXJpYyBzZXJpZXMgYnkgdXNpbmcgW10gYXMgaW46CgogZnRwOi8vZnRwLm51bWVyaWNhbHMuY29tL2ZpbGVbMS0xMDBdLnR4dAogZnRwOi8vZnRwLm51bWVyaWNhbHMuY29tL2ZpbGVbMDAxLTEwMF0udHh0ICAgICh3aXRoIGxlYWRpbmcgemVyb3MpCiBmdHA6Ly9mdHAubGV0dGVycy5jb20vZmlsZVthLXpdLnR4dAoKSXQgaXMgcG9zc2libGUgdG8gc3BlY2lmeSB1cCB0byA5IHNldHMgb3Igc2VyaWVzIGZvciBhIFVSTCwgYnV0IG5vIG5lc3RpbmcgaXMKc3VwcG9ydGVkIGF0IHRoZSBtb21lbnQ6CgogaHR0cDovL3d3dy5hbnkub3JnL2FyY2hpdmVbMTk5Ni0xOTk5XS92b2x1bWVbMS00XXBhcnR7YSxiLGMsaW5kZXh9Lmh0bWwKClN0YXJ0aW5nIHdpdGggY3VybCA3LjYsIHlvdSBjYW4gc3BlY2lmeSBhbnkgYW1vdW50IG9mIFVSTHMgb24gdGhlIGNvbW1hbmQKbGluZS4gVGhleSB3aWxsIGJlIGZldGNoZWQgaW4gYSBzZXF1ZW50aWFsIG1hbm5lciBpbiB0aGUgc3BlY2lmaWVkIG9yZGVyLgoKU3RhcnRpbmcgd2l0aCBjdXJsIDcuNywgY3VybCB3aWxsIGF0dGVtcHQgdG8gcmUtdXNlIGNvbm5lY3Rpb25zIGZvciBtdWx0aXBsZQpmaWxlIHRyYW5zZmVycywgc28gdGhhdCBnZXR0aW5nIG1hbnkgZmlsZXMgZnJvbSB0aGUgc2FtZSBzZXJ2ZXIgd2lsbCBub3QgZG8KbXVsdGlwbGUgY29ubmVjdHMvaGFuZHNoYWtlcy4gVGhpcyBpbXByb3ZlcyBzcGVlZC4gT2YgY291cnNlIHRoaXMgaXMgb25seSBkb25lCm9uIGZpbGVzIHNwZWNpZmllZCBvbiBhIHNpbmdsZSBjb21tYW5kIGxpbmUgYW5kIGNhbm5vdCBiZSB1c2VkIGJldHdlZW4Kc2VwYXJhdGUgY3VybCBpbnZva2VzLgouU0ggT1BUSU9OUwouSVAgIi1hLy0tYXBwZW5kIgooRlRQKQpXaGVuIHVzZWQgaW4gYSBmdHAgdXBsb2FkLCB0aGlzIHdpbGwgdGVsbCBjdXJsIHRvIGFwcGVuZCB0byB0aGUgdGFyZ2V0CmZpbGUgaW5zdGVhZCBvZiBvdmVyd3JpdGluZyBpdC4gSWYgdGhlIGZpbGUgZG9lc24ndCBleGlzdCwgaXQgd2lsbApiZSBjcmVhdGVkLgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCB0d2ljZSwgdGhlIHNlY29uZCBvbmUgd2lsbCBkaXNhYmxlIGFwcGVuZCBtb2RlIGFnYWluLgouSVAgIi1BLy0tdXNlci1hZ2VudCA8YWdlbnQgc3RyaW5nPiIKKEhUVFApClNwZWNpZnkgdGhlIFVzZXItQWdlbnQgc3RyaW5nIHRvIHNlbmQgdG8gdGhlIEhUVFAgc2VydmVyLiBTb21lIGJhZGx5IGRvbmUgQ0dJcwpmYWlsIGlmIGl0cyBub3Qgc2V0IHRvICJNb3ppbGxhLzQuMCIuICBUbyBlbmNvZGUgYmxhbmtzIGluIHRoZSBzdHJpbmcsCnN1cnJvdW5kIHRoZSBzdHJpbmcgd2l0aCBzaW5nbGUgcXVvdGUgbWFya3MuICBUaGlzIGNhbiBhbHNvIGJlIHNldCB3aXRoIHRoZQotSC8tLWhlYWRlciBmbGFnIG9mIGNvdXJzZS4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgbW9yZSB0aGFuIG9uY2UsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHRoZSBvbmUgdG8gYmUKdXNlZC4KLklQICItYi8tLWNvb2tpZSA8bmFtZT1kYXRhPiIKKEhUVFApClBhc3MgdGhlIGRhdGEgdG8gdGhlIEhUVFAgc2VydmVyIGFzIGEgY29va2llLiBJdCBpcyBzdXBwb3NlZGx5IHRoZQpkYXRhIHByZXZpb3VzbHkgcmVjZWl2ZWQgZnJvbSB0aGUgc2VydmVyIGluIGEgIlNldC1Db29raWU6IiBsaW5lLgpUaGUgZGF0YSBzaG91bGQgYmUgaW4gdGhlIGZvcm1hdCAiTkFNRTE9VkFMVUUxOyBOQU1FMj1WQUxVRTIiLgoKSWYgbm8gJz0nIGxldHRlciBpcyB1c2VkIGluIHRoZSBsaW5lLCBpdCBpcyB0cmVhdGVkIGFzIGEgZmlsZW5hbWUgdG8gdXNlIHRvCnJlYWQgcHJldmlvdXNseSBzdG9yZWQgY29va2llIGxpbmVzIGZyb20sIHdoaWNoIHNob3VsZCBiZSB1c2VkIGluIHRoaXMgc2Vzc2lvbgppZiB0aGV5IG1hdGNoLiBVc2luZyB0aGlzIG1ldGhvZCBhbHNvIGFjdGl2YXRlcyB0aGUgImNvb2tpZSBwYXJzZXIiIHdoaWNoCndpbGwgbWFrZSBjdXJsIHJlY29yZCBpbmNvbWluZyBjb29raWVzIHRvbywgd2hpY2ggbWF5IGJlIGhhbmR5IGlmIHlvdSdyZSB1c2luZwp0aGlzIGluIGNvbWJpbmF0aW9uIHdpdGggdGhlIC1MLy0tbG9jYXRpb24gb3B0aW9uLiBUaGUgZmlsZSBmb3JtYXQgb2YgdGhlIGZpbGUKdG8gcmVhZCBjb29raWVzIGZyb20gc2hvdWxkIGJlIHBsYWluIEhUVFAgaGVhZGVycyBvciB0aGUgbmV0c2NhcGUgY29va2llIGZpbGUKZm9ybWF0LgoKLkIgTk9URQp0aGF0IHRoZSBmaWxlIHNwZWNpZmllZCB3aXRoIC1iLy0tY29va2llIGlzIG9ubHkgdXNlZCBhcyBpbnB1dC4gTm8gY29va2llcwp3aWxsIGJlIHN0b3JlZCBpbiB0aGUgZmlsZS4gVG8gc3RvcmUgY29va2llcywgc2F2ZSB0aGUgSFRUUCBoZWFkZXJzIHRvIGEgZmlsZQp1c2luZyAtRC8tLWR1bXAtaGVhZGVyIQoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCBtb3JlIHRoYW4gb25jZSwgdGhlIGxhc3Qgb25lIHdpbGwgYmUgdGhlIG9uZSB0byBiZQp1c2VkLgouSVAgIi1CLy0tdXNlLWFzY2lpIgpVc2UgQVNDSUkgdHJhbnNmZXIgd2hlbiBnZXR0aW5nIGFuIEZUUCBmaWxlIG9yIExEQVAgaW5mby4gRm9yIEZUUCwgdGhpcyBjYW4KYWxzbyBiZSBlbmZvcmNlZCBieSB1c2luZyBhbiBVUkwgdGhhdCBlbmRzIHdpdGggIjt0eXBlPUEiLiBUaGlzIG9wdGlvbiBjYXVzZXMKZGF0YSBzZW50IHRvIHN0ZG91dCB0byBiZSBpbiB0ZXh0IG1vZGUgZm9yIHdpbjMyIHN5c3RlbXMuCgpJZiB0aGlzIG9wdGlvbiBpcyB1c2VkIHR3aWNlLCB0aGUgc2Vjb25kIG9uZSB3aWxsIGRpc2FibGUgQVNDSUkgdXNhZ2UuCi5JUCAiLWMvLS1jb250aW51ZSIKLkIgRGVwcmVjYXRlZC4gVXNlICctQyAtJyBpbnN0ZWFkLgpDb250aW51ZS9SZXN1bWUgYSBwcmV2aW91cyBmaWxlIHRyYW5zZmVyLiBUaGlzIGluc3RydWN0cyBjdXJsIHRvCmNvbnRpbnVlIGFwcGVuZGluZyBkYXRhIG9uIHRoZSBmaWxlIHdoZXJlIGl0IHdhcyBwcmV2aW91c2x5IGxlZnQsCnBvc3NpYmx5IGJlY2F1c2Ugb2YgYSBicm9rZW4gY29ubmVjdGlvbiB0byB0aGUgc2VydmVyLiBUaGVyZSBtdXN0IGJlCmEgbmFtZWQgcGh5c2ljYWwgZmlsZSB0byBhcHBlbmQgdG8gZm9yIHRoaXMgdG8gd29yay4KTm90ZTogVXBsb2FkIHJlc3VtZSBpcyBkZXBlbmluZyBvbiBhIGNvbW1hbmQgbmFtZWQgU0laRSBub3QgYWx3YXlzCnByZXNlbnQgaW4gYWxsIGZ0cCBzZXJ2ZXJzISBVcGxvYWQgcmVzdW1lIGlzIGZvciBGVFAgb25seS4KSFRUUCByZXN1bWUgaXMgb25seSBwb3NzaWJsZSB3aXRoIEhUVFAvMS4xIG9yIGxhdGVyIHNlcnZlcnMuCi5JUCAiLUMvLS1jb250aW51ZS1hdCA8b2Zmc2V0PiIKQ29udGludWUvUmVzdW1lIGEgcHJldmlvdXMgZmlsZSB0cmFuc2ZlciBhdCB0aGUgZ2l2ZW4gb2Zmc2V0LiBUaGUKZ2l2ZW4gb2Zmc2V0IGlzIHRoZSBleGFjdCBudW1iZXIgb2YgYnl0ZXMgdGhhdCB3aWxsIGJlIHNraXBwZWQKY291bnRlZCBmcm9tIHRoZSBiZWdpbm5pbmcgb2YgdGhlIHNvdXJjZSBmaWxlIGJlZm9yZSBpdCBpcyB0cmFuc2ZlcmVkCnRvIHRoZSBkZXN0aW5hdGlvbi4KSWYgdXNlZCB3aXRoIHVwbG9hZHMsIHRoZSBmdHAgc2VydmVyIGNvbW1hbmQgU0laRSB3aWxsIG5vdCBiZSB1c2VkIGJ5CmN1cmwuIFVwbG9hZCByZXN1bWUgaXMgZm9yIEZUUCBvbmx5LgpIVFRQIHJlc3VtZSBpcyBvbmx5IHBvc3NpYmxlIHdpdGggSFRUUC8xLjEgb3IgbGF0ZXIgc2VydmVycy4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCi5JUCAiLWQvLS1kYXRhIDxkYXRhPiIKKEhUVFApIFNlbmRzIHRoZSBzcGVjaWZpZWQgZGF0YSBpbiBhIFBPU1QgcmVxdWVzdCB0byB0aGUgSFRUUCBzZXJ2ZXIuIE5vdGUKdGhhdCB0aGUgZGF0YSBpcyBzZW50IGV4YWN0bHkgYXMgc3BlY2lmaWVkIHdpdGggbm8gZXh0cmEgcHJvY2Vzc2luZyAod2l0aCBhbGwKbmV3bGluZXMgY3V0IG9mZikuICBUaGUgZGF0YSBpcyBleHBlY3RlZCB0byBiZSAidXJsLWVuY29kZWQiLiBUaGlzIHdpbGwgY2F1c2UKY3VybCB0byBwYXNzIHRoZSBkYXRhIHRvIHRoZSBzZXJ2ZXIgdXNpbmcgdGhlIGNvbnRlbnQtdHlwZQphcHBsaWNhdGlvbi94LXd3dy1mb3JtLXVybGVuY29kZWQuIENvbXBhcmUgdG8gLUYuIElmIG1vcmUgdGhhbiBvbmUgLWQvLS1kYXRhCm9wdGlvbiBpcyB1c2VkIG9uIHRoZSBzYW1lIGNvbW1hbmQgbGluZSwgdGhlIGRhdGEgcGllY2VzIHNwZWNpZmllZCB3aWxsIGJlCm1lcmdlZCB0b2dldGhlciB3aXRoIGEgc2VwYXJhdGluZyAmLWxldHRlci4gVGh1cywgdXNpbmcgJy1kIG5hbWU9ZGFuaWVsIC1kCnNraWxsPWxvdXN5JyB3b3VsZCBnZW5lcmF0ZSBhIHBvc3QgY2h1bmsgdGhhdCBsb29rcyBsaWtlCiduYW1lPWRhbmllbCZza2lsbD1sb3VzeScuCgpJZiB5b3Ugc3RhcnQgdGhlIGRhdGEgd2l0aCB0aGUgbGV0dGVyIEAsIHRoZSByZXN0IHNob3VsZCBiZSBhIGZpbGUgbmFtZSB0bwpyZWFkIHRoZSBkYXRhIGZyb20sIG9yIC0gaWYgeW91IHdhbnQgY3VybCB0byByZWFkIHRoZSBkYXRhIGZyb20gc3RkaW4uICBUaGUKY29udGVudHMgb2YgdGhlIGZpbGUgbXVzdCBhbHJlYWR5IGJlIHVybC1lbmNvZGVkLiBNdWx0aXBsZSBmaWxlcyBjYW4gYWxzbyBiZQpzcGVjaWZpZWQuCgpUbyBwb3N0IGRhdGEgcHVyZWx5IGJpbmFyeSwgeW91IHNob3VsZCBpbnN0ZWFkIHVzZSB0aGUgLS1kYXRhLWJpbmFyeSBvcHRpb24uCgotZC8tLWRhdGEgaXMgdGhlIHNhbWUgYXMgLS1kYXRhLWFzY2lpLgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCBzZXJ2ZXJhbCB0aW1lcywgdGhlIG9uZXMgZm9sbG93aW5nIHRoZSBmaXJzdCB3aWxsCmFwcGVuZCBkYXRhLgouSVAgIi0tZGF0YS1hc2NpaSA8ZGF0YT4iCihIVFRQKSBUaGlzIGlzIGFuIGFsaWFzIGZvciB0aGUgLWQvLS1kYXRhIG9wdGlvbi4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBvbmVzIGZvbGxvd2luZyB0aGUgZmlyc3Qgd2lsbAphcHBlbmQgZGF0YS4KLklQICItLWRhdGEtYmluYXJ5IDxkYXRhPiIKKEhUVFApIFRoaXMgcG9zdHMgZGF0YSBpbiBhIHNpbWlsYXIgbWFubmVyIGFzIC0tZGF0YS1hc2NpaSBkb2VzLCBhbHRob3VnaCB3aGVuCnVzaW5nIHRoaXMgb3B0aW9uIHRoZSBlbnRpcmUgY29udGV4dCBvZiB0aGUgcG9zdGVkIGRhdGEgaXMga2VwdCBhcy1pcy4gSWYgeW91CndhbnQgdG8gcG9zdCBhIGJpbmFyeSBmaWxlIHdpdGhvdXQgdGhlIHN0cmlwLW5ld2xpbmVzIGZlYXR1cmUgb2YgdGhlCi0tZGF0YS1hc2NpaSBvcHRpb24sIHRoaXMgaXMgZm9yIHlvdS4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCgpJZiB0aGlzIG9wdGlvbiBpcyB1c2VkIHNlcnZlcmFsIHRpbWVzLCB0aGUgb25lcyBmb2xsb3dpbmcgdGhlIGZpcnN0IHdpbGwKYXBwZW5kIGRhdGEuCi5JUCAiLUQvLS1kdW1wLWhlYWRlciA8ZmlsZT4iCihIVFRQL0ZUUCkKV3JpdGUgdGhlIEhUVFAgaGVhZGVycyB0byB0aGlzIGZpbGUuIFdyaXRlIHRoZSBGVFAgZmlsZSBpbmZvIHRvIHRoaXMKZmlsZSBpZiAtSS8tLWhlYWQgaXMgdXNlZC4KClRoaXMgb3B0aW9uIGlzIGhhbmR5IHRvIHVzZSB3aGVuIHlvdSB3YW50IHRvIHN0b3JlIHRoZSBjb29raWVzIHRoYXQgYSBIVFRQCnNpdGUgc2VuZHMgdG8geW91LiBUaGUgY29va2llcyBjb3VsZCB0aGVuIGJlIHJlYWQgaW4gYSBzZWNvbmQgY3VybCBpbnZva2UgYnkKdXNpbmcgdGhlIC1iLy0tY29va2llIG9wdGlvbiEKCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCi5JUCAiLWUvLS1yZWZlcmVyIDxVUkw+IgooSFRUUCkgU2VuZHMgdGhlICJSZWZlcmVyIFBhZ2UiIGluZm9ybWF0aW9uIHRvIHRoZSBIVFRQIHNlcnZlci4gVGhpcyBjYW4gYWxzbwpiZSBzZXQgd2l0aCB0aGUgLUgvLS1oZWFkZXIgZmxhZyBvZiBjb3Vyc2UuICBXaGVuIHVzZWQgd2l0aAouSSAtTC8tLWxvY2F0aW9uIAp5b3UgY2FuIGFwcGVuZCAiO2F1dG8iIHRvIHRoZSByZWZlcmVyIFVSTCB0byBtYWtlIGN1cmwgYXV0b21hdGljYWxseSBzZXQgdGhlCnByZXZpb3VzIFVSTCB3aGVuIGl0IGZvbGxvd3MgYSBMb2NhdGlvbjogaGVhZGVyLiBUaGUgIjthdXRvIiBzdHJpbmcgY2FuIGJlCnVzZWQgYWxvbmUsIGV2ZW4gaWYgeW91IGRvbid0IHNldCBhbiBpbml0aWFsIHJlZmVyZXIuCgpJZiB0aGlzIG9wdGlvbiBpcyB1c2VkIHNlcnZlcmFsIHRpbWVzLCB0aGUgbGFzdCBvbmUgd2lsbCBiZSB1c2VkLgouSVAgIi1FLy0tY2VydCA8Y2VydGlmaWNhdGVbOnBhc3N3b3JkXT4iCihIVFRQUykKVGVsbHMgY3VybCB0byB1c2UgdGhlIHNwZWNpZmllZCBjZXJ0aWZpY2F0ZSBmaWxlIHdoZW4gZ2V0dGluZyBhIGZpbGUKd2l0aCBIVFRQUy4gVGhlIGNlcnRpZmljYXRlIG11c3QgYmUgaW4gUEVNIGZvcm1hdC4KSWYgdGhlIG9wdGlvbmFsIHBhc3N3b3JkIGlzbid0IHNwZWNpZmllZCwgaXQgd2lsbCBiZSBxdWVyaWVkIGZvciBvbgp0aGUgdGVybWluYWwuIE5vdGUgdGhhdCB0aGlzIGNlcnRpZmljYXRlIGlzIHRoZSBwcml2YXRlIGtleSBhbmQgdGhlIHByaXZhdGUKY2VydGlmaWNhdGUgY29uY2F0ZW5hdGVkIQoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCBzZXJ2ZXJhbCB0aW1lcywgdGhlIGxhc3Qgb25lIHdpbGwgYmUgdXNlZC4KLklQICItLWNhY2VydCA8Q0EgY2VydGlmaWNhdGU+IgooSFRUUFMpIFRlbGxzIGN1cmwgdG8gdXNlIHRoZSBzcGVjaWZpZWQgY2VydGlmaWNhdGUgZmlsZSB0byB2ZXJpZnkgdGhlCnBlZXIuIFRoZSBjZXJ0aWZpY2F0ZSBtdXN0IGJlIGluIFBFTSBmb3JtYXQuCgpJZiB0aGlzIG9wdGlvbiBpcyB1c2VkIHNlcnZlcmFsIHRpbWVzLCB0aGUgbGFzdCBvbmUgd2lsbCBiZSB1c2VkLgouSVAgIi1mLy0tZmFpbCIKKEhUVFApCkZhaWwgc2lsZW50bHkgKG5vIG91dHB1dCBhdCBhbGwpIG9uIHNlcnZlciBlcnJvcnMuIFRoaXMgaXMgbW9zdGx5IGRvbmUKbGlrZSB0aGlzIHRvIGJldHRlciBlbmFibGUgc2NyaXB0cyBldGMgdG8gYmV0dGVyIGRlYWwgd2l0aCBmYWlsZWQKYXR0ZW1wdHMuIEluIG5vcm1hbCBjYXNlcyB3aGVuIGEgSFRUUCBzZXJ2ZXIgZmFpbHMgdG8gZGVsaXZlciBhCmRvY3VtZW50LCBpdCByZXR1cm5zIGEgSFRNTCBkb2N1bWVudCBzdGF0aW5nIHNvICh3aGljaCBvZnRlbiBhbHNvCmRlc2NyaWJlcyB3aHkgYW5kIG1vcmUpLiBUaGlzIGZsYWcgd2lsbCBwcmV2ZW50IGN1cmwgZnJvbQpvdXRwdXR0aW5nIHRoYXQgYW5kIGZhaWwgc2lsZW50bHkgaW5zdGVhZC4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgdHdpY2UsIHRoZSBzZWNvbmQgd2lsbCBhZ2FpbiBkaXNhYmxlIHNpbGVudCBmYWlsdXJlLgouSVAgIi1GLy0tZm9ybSA8bmFtZT1jb250ZW50PiIKKEhUVFApIFRoaXMgbGV0cyBjdXJsIGVtdWxhdGUgYSBmaWxsZWQgaW4gZm9ybSBpbiB3aGljaCBhIHVzZXIgaGFzIHByZXNzZWQgdGhlCnN1Ym1pdCBidXR0b24uIFRoaXMgY2F1c2VzIGN1cmwgdG8gUE9TVCBkYXRhIHVzaW5nIHRoZSBjb250ZW50LXR5cGUKbXVsdGlwYXJ0L2Zvcm0tZGF0YSBhY2NvcmRpbmcgdG8gUkZDMTg2Ny4gVGhpcyBlbmFibGVzIHVwbG9hZGluZyBvZiBiaW5hcnkKZmlsZXMgZXRjLiBUbyBmb3JjZSB0aGUgJ2NvbnRlbnQnIHBhcnQgdG8gYmUgYmUgYSBmaWxlLCBwcmVmaXggdGhlIGZpbGUgbmFtZQp3aXRoIGFuIEAgc2lnbi4gVG8ganVzdCBnZXQgdGhlIGNvbnRlbnQgcGFydCBmcm9tIGEgZmlsZSwgcHJlZml4IHRoZSBmaWxlIG5hbWUKd2l0aCB0aGUgbGV0dGVyIDwuIFRoZSBkaWZmZXJlbmNlIGJldHdlZW4gQCBhbmQgPCBpcyB0aGVuIHRoYXQgQCBtYWtlcyBhIGZpbGUKZ2V0IGF0dGFjaGVkIGluIHRoZSBwb3N0IGFzIGEgZmlsZSB1cGxvYWQsIHdoaWxlIHRoZSA8IG1ha2VzIGEgdGV4dCBmaWVsZCBhbmQKanVzdCBnZXQgdGhlIGNvbnRlbnRzIGZvciB0aGF0IHRleHQgZmllbGQgZnJvbSBhIGZpbGUuCgpFeGFtcGxlLCB0byBzZW5kIHlvdXIgcGFzc3dvcmQgZmlsZSB0byB0aGUgc2VydmVyLCB3aGVyZQoncGFzc3dvcmQnIGlzIHRoZSBuYW1lIG9mIHRoZSBmb3JtLWZpZWxkIHRvIHdoaWNoIC9ldGMvcGFzc3dkIHdpbGwgYmUgdGhlCmlucHV0OgoKLkIgY3VybAotRiBwYXNzd29yZD1AL2V0Yy9wYXNzd2Qgd3d3Lm15cGFzc3dvcmRzLmNvbQoKVG8gcmVhZCB0aGUgZmlsZSdzIGNvbnRlbnQgZnJvbSBzdGRpbiBpbnN0ZWQgb2YgYSBmaWxlLCB1c2UgLSB3aGVyZSB0aGUgZmlsZQpuYW1lIHNob3VsZCd2ZSBiZWVuLiBUaGlzIGdvZXMgZm9yIGJvdGggQCBhbmQgPCBjb25zdHJ1Y3RzLgoKVGhpcyBvcHRpb24gY2FuIGJlIHVzZWQgbXVsdGlwbGUgdGltZXMuCi5JUCAiLWcvLS1nbG9ib2ZmIgpUaGlzIG9wdGlvbiBzd2l0Y2hlcyBvZmYgdGhlICJVUkwgZ2xvYmJpbmcgcGFyc2VyIi4gV2hlbiB5b3Ugc2V0IHRoaXMgb3B0aW9uLAp5b3UgY2FuIHNwZWNpZnkgVVJMcyB0aGF0IGNvbnRhaW4gdGhlIGxldHRlcnMge31bXSB3aXRob3V0IGhhdmluZyB0aGVtIGJlaW5nCmludGVycHJldGVkIGJ5IGN1cmwgaXRzZWxmLiBOb3RlIHRoYXQgdGhlc2UgbGV0dGVycyBhcmUgbm90IG5vcm1hbCBsZWdhbCBVUkwKY29udGVudHMgYnV0IHRoZXkgc2hvdWxkIGJlIGVuY29kZWQgYWNjb3JkaW5nIHRvIHRoZSBVUkkgc3RhbmRhcmQuIChPcHRpb24KYWRkZWQgaW4gY3VybCA3LjYpCi5JUCAiLWgvLS1oZWxwIgpVc2FnZSBoZWxwLgouSVAgIi1ILy0taGVhZGVyIDxoZWFkZXI+IgooSFRUUCkgRXh0cmEgaGVhZGVyIHRvIHVzZSB3aGVuIGdldHRpbmcgYSB3ZWIgcGFnZS4gWW91IG1heSBzcGVjaWZ5IGFueSBudW1iZXIKb2YgZXh0cmEgaGVhZGVycy4gTm90ZSB0aGF0IGlmIHlvdSBzaG91bGQgYWRkIGEgY3VzdG9tIGhlYWRlciB0aGF0IGhhcyB0aGUKc2FtZSBuYW1lIGFzIG9uZSBvZiB0aGUgaW50ZXJuYWwgb25lcyBjdXJsIHdvdWxkIHVzZSwgeW91ciBleHRlcm5hbGx5IHNldApoZWFkZXIgd2lsbCBiZSB1c2VkIGluc3RlYWQgb2YgdGhlIGludGVybmFsIG9uZS4gVGhpcyBhbGxvd3MgeW91IHRvIG1ha2UgZXZlbgp0cmlja2llciBzdHVmZiB0aGFuIGN1cmwgd291bGQgbm9ybWFsbHkgZG8uIFlvdSBzaG91bGQgbm90IHJlcGxhY2UgaW50ZXJuYWxseQpzZXQgaGVhZGVycyB3aXRob3V0IGtub3dpbmcgcGVyZmVjdGx5IHdlbGwgd2hhdCB5b3UncmUgZG9pbmcuIFJlcGxhY2luZyBhbgppbnRlcm5hbCBoZWFkZXIgd2l0aCBvbmUgd2l0aG91dCBjb250ZW50IG9uIHRoZSByaWdodCBzaWRlIG9mIHRoZSBjb2xvbiB3aWxsCnByZXZlbnQgdGhhdCBoZWFkZXIgZnJvbSBhcHBlYXJpbmcuCgpUaGlzIG9wdGlvbiBjYW4gYmUgdXNlZCBtdWx0aXBsZSB0aW1lcy4KLklQICItaS8tLWluY2x1ZGUiCihIVFRQKQpJbmNsdWRlIHRoZSBIVFRQLWhlYWRlciBpbiB0aGUgb3V0cHV0LiBUaGUgSFRUUC1oZWFkZXIgaW5jbHVkZXMgdGhpbmdzCmxpa2Ugc2VydmVyLW5hbWUsIGRhdGUgb2YgdGhlIGRvY3VtZW50LCBIVFRQLXZlcnNpb24gYW5kIG1vcmUuLi4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgdHdpY2UsIHRoZSBzZWNvbmQgd2lsbCBhZ2FpbiBkaXNhYmxlIGhlYWRlciBpbmNsdWRlLgouSVAgIi0taW50ZXJmYWNlIDxuYW1lPiIKUGVyZm9ybSBhbiBvcGVyYXRpb24gdXNpbmcgYSBzcGVjaWZpZWQgaW50ZXJmYWNlLiBZb3UgY2FuIGVudGVyIGludGVyZmFjZQpuYW1lLCBJUCBhZGRyZXNzIG9yIGhvc3QgbmFtZS4gQW4gZXhhbXBsZSBjb3VsZCBsb29rIGxpa2U6CgouQiAiY3VybCAtLWludGVyZmFjZSBldGgwOjEgaHR0cDovL3d3dy5uZXRzY2FwZS5jb20vIgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCBzZXJ2ZXJhbCB0aW1lcywgdGhlIGxhc3Qgb25lIHdpbGwgYmUgdXNlZC4KLklQICItSS8tLWhlYWQiCihIVFRQL0ZUUCkKRmV0Y2ggdGhlIEhUVFAtaGVhZGVyIG9ubHkhIEhUVFAtc2VydmVycyBmZWF0dXJlIHRoZSBjb21tYW5kIEhFQUQKd2hpY2ggdGhpcyB1c2VzIHRvIGdldCBub3RoaW5nIGJ1dCB0aGUgaGVhZGVyIG9mIGEgZG9jdW1lbnQuIFdoZW4gdXNlZApvbiBhIEZUUCBmaWxlLCBjdXJsIGRpc3BsYXlzIHRoZSBmaWxlIHNpemUgb25seS4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgdHdpY2UsIHRoZSBzZWNvbmQgd2lsbCBhZ2FpbiBkaXNhYmxlIGhlYWRlciBvbmx5LgouSVAgIi0ta3JiNCA8bGV2ZWw+IgooRlRQKSBFbmFibGUga2VyYmVyb3M0IGF1dGhlbnRpY2F0aW9uIGFuZCB1c2UuIFRoZSBsZXZlbCBtdXN0IGJlIGVudGVyZWQgYW5kCnNob3VsZCBiZSBvbmUgb2YgJ2NsZWFyJywgJ3NhZmUnLCAnY29uZmlkZW50aWFsJyBvciAncHJpdmF0ZScuIFNob3VsZCB5b3UgdXNlCmEgbGV2ZWwgdGhhdCBpcyBub3Qgb25lIG9mIHRoZXNlLCAncHJpdmF0ZScgd2lsbCBpbnN0ZWFkIGJlIHVzZWQuCgpJZiB0aGlzIG9wdGlvbiBpcyB1c2VkIHNlcnZlcmFsIHRpbWVzLCB0aGUgbGFzdCBvbmUgd2lsbCBiZSB1c2VkLgouSVAgIi1LLy0tY29uZmlnIDxjb25maWcgZmlsZT4iClNwZWNpZnkgd2hpY2ggY29uZmlnIGZpbGUgdG8gcmVhZCBjdXJsIGFyZ3VtZW50cyBmcm9tLiBUaGUgY29uZmlnIGZpbGUgaXMgYQp0ZXh0IGZpbGUgaW4gd2hpY2ggY29tbWFuZCBsaW5lIGFyZ3VtZW50cyBjYW4gYmUgd3JpdHRlbiB3aGljaCB0aGVuIHdpbGwgYmUKdXNlZCBhcyBpZiB0aGV5IHdlcmUgd3JpdHRlbiBvbiB0aGUgYWN0dWFsIGNvbW1hbmQgbGluZS4gT3B0aW9ucyBhbmQgdGhlaXIKcGFyYW1ldGVycyBtdXN0IGJlIHNwZWNpZmllZCBvbiB0aGUgc2FtZSBjb25maWcgZmlsZSBsaW5lLiBJZiB0aGUgcGFyYW1ldGVyIGlzCnRvIGNvbnRhaW4gd2hpdGUgc3BhY2VzLCB0aGUgcGFyYW1ldGVyIG11c3QgYmUgaW5jbG9zZWQgd2l0aGluIHF1b3Rlcy4gIElmIHRoZQpmaXJzdCBjb2x1bW4gb2YgYSBjb25maWcgbGluZSBpcyBhICcjJyBjaGFyYWN0ZXIsIHRoZSByZXN0IG9mIHRoZSBsaW5lIHdpbGwgYmUKdHJlYXRlZCBhcyBhIGNvbW1lbnQuCgpTcGVjaWZ5IHRoZSBmaWxlbmFtZSBhcyAnLScgdG8gbWFrZSBjdXJsIHJlYWQgdGhlIGZpbGUgZnJvbSBzdGRpbi4KClRoaXMgb3B0aW9uIGNhbiBiZSB1c2VkIG11bHRpcGxlIHRpbWVzLgouSVAgIi1sLy0tbGlzdC1vbmx5IgooRlRQKQpXaGVuIGxpc3RpbmcgYW4gRlRQIGRpcmVjdG9yeSwgdGhpcyBzd2l0Y2ggZm9yY2VzIGEgbmFtZS1vbmx5IHZpZXcuCkVzcGVjaWFsbHkgdXNlZnVsIGlmIHlvdSB3YW50IHRvIG1hY2hpbmUtcGFyc2UgdGhlIGNvbnRlbnRzIG9mIGFuIEZUUApkaXJlY3Rvcnkgc2luY2UgdGhlIG5vcm1hbCBkaXJlY3RvcnkgdmlldyBkb2Vzbid0IHVzZSBhIHN0YW5kYXJkIGxvb2sKb3IgZm9ybWF0LgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCB0d2ljZSwgdGhlIHNlY29uZCB3aWxsIGFnYWluIGRpc2FibGUgbGlzdCBvbmx5LgouSVAgIi1MLy0tbG9jYXRpb24iCihIVFRQL0hUVFBTKSBJZiB0aGUgc2VydmVyIHJlcG9ydHMgdGhhdCB0aGUgcmVxdWVzdGVkIHBhZ2UgaGFzIGEgZGlmZmVyZW50CmxvY2F0aW9uIChpbmRpY2F0ZWQgd2l0aCB0aGUgaGVhZGVyIGxpbmUgTG9jYXRpb246KSB0aGlzIGZsYWcgd2lsbCBsZXQgY3VybAphdHRlbXB0IHRvIHJlYXR0ZW1wdCB0aGUgZ2V0IG9uIHRoZSBuZXcgcGxhY2UuIElmIHVzZWQgdG9nZXRoZXIgd2l0aCAtaSBvciAtSSwKaGVhZGVycyBmcm9tIGFsbCByZXF1ZXN0ZWQgcGFnZXMgd2lsbCBiZSBzaG93bi4gSWYgdGhpcyBmbGFnIGlzIHVzZWQgd2hlbgptYWtpbmcgYSBIVFRQIFBPU1QsIGN1cmwgd2lsbCBhdXRvbWF0aWNhbGx5IHN3aXRjaCB0byBHRVQgYWZ0ZXIgdGhlIGluaXRpYWwKUE9TVCBoYXMgYmVlbiBkb25lLgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCB0d2ljZSwgdGhlIHNlY29uZCB3aWxsIGFnYWluIGRpc2FibGUgbG9jYXRpb24gZm9sbG93aW5nLgouSVAgIi1tLy0tbWF4LXRpbWUgPHNlY29uZHM+IgpNYXhpbXVtIHRpbWUgaW4gc2Vjb25kcyB0aGF0IHlvdSBhbGxvdyB0aGUgd2hvbGUgb3BlcmF0aW9uIHRvIHRha2UuICBUaGlzIGlzCnVzZWZ1bCBmb3IgcHJldmVudGluZyB5b3VyIGJhdGNoIGpvYnMgZnJvbSBoYW5naW5nIGZvciBob3VycyBkdWUgdG8gc2xvdwpuZXR3b3JrcyBvciBsaW5rcyBnb2luZyBkb3duLiAgVGhpcyBkb2Vzbid0IHdvcmsgZnVsbHkgaW4gd2luMzIgc3lzdGVtcy4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCi5JUCAiLU0vLS1tYW51YWwiCk1hbnVhbC4gRGlzcGxheSB0aGUgaHVnZSBoZWxwIHRleHQuCi5JUCAiLW4vLS1uZXRyYyIKTWFrZXMgY3VybCBzY2FuIHRoZQouSSAubmV0cmMKZmlsZSBpbiB0aGUgdXNlcidzIGhvbWUgZGlyZWN0b3J5IGZvciBsb2dpbiBuYW1lIGFuZCBwYXNzd29yZC4gVGhpcyBpcwp0eXBpY2FsbHkgdXNlZCBmb3IgZnRwIG9uIHVuaXguIElmIHVzZWQgd2l0aCBodHRwLCBjdXJsIHdpbGwgZW5hYmxlIHVzZXIKYXV0aGVudGljYXRpb24uIFNlZQouQlIgbmV0cmMoNCkKZm9yIGRldGFpbHMgb24gdGhlIGZpbGUgZm9ybWF0LiBDdXJsIHdpbGwgbm90IGNvbXBsYWluIGlmIHRoYXQgZmlsZQpoYXNuJ3QgdGhlIHJpZ2h0IHBlcm1pc3Npb25zIChpdCBzaG91bGQgbm90IGJlIHdvcmxkIG5vciBncm91cApyZWFkYWJsZSkuIFRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZSAiSE9NRSIgaXMgdXNlZCB0byBmaW5kIHRoZSBob21lCmRpcmVjdG9yeS4KCkEgcXVpY2sgYW5kIHZlcnkgc2ltcGxlIGV4YW1wbGUgb2YgaG93IHRvIHNldHVwIGEKLkkgLm5ldHJjCnRvIGFsbG93IGN1cmwgdG8gZnRwIHRvIHRoZSBtYWNoaW5lIGhvc3QuZG9tYWluLmNvbSB3aXRoIHVzZXIgbmFtZQonbXlzZWxmJyBhbmQgcGFzc3dvcmQgJ3NlY3JldCcgc2hvdWxkIGxvb2sgc2ltaWxhciB0bzoKCi5CICJtYWNoaW5lIGhvc3QuZG9tYWluLmNvbSBsb2dpbiBteXNlbGYgcGFzc3dvcmQgc2VjcmV0IgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCB0d2ljZSwgdGhlIHNlY29uZCB3aWxsIGFnYWluIGRpc2FibGUgbmV0cmMgdXNhZ2UuCi5JUCAiLU4vLS1uby1idWZmZXIiCkRpc2FibGVzIHRoZSBidWZmZXJpbmcgb2YgdGhlIG91dHB1dCBzdHJlYW0uIEluIG5vcm1hbCB3b3JrIHNpdHVhdGlvbnMsIGN1cmwKd2lsbCB1c2UgYSBzdGFuZGFyZCBidWZmZXJlZCBvdXRwdXQgc3RyZWFtIHRoYXQgd2lsbCBoYXZlIHRoZSBlZmZlY3QgdGhhdCBpdAp3aWxsIG91dHB1dCB0aGUgZGF0YSBpbiBjaHVua3MsIG5vdCBuZWNlc3NhcmlseSBleGFjdGx5IHdoZW4gdGhlIGRhdGEgYXJyaXZlcy4KVXNpbmcgdGhpcyBvcHRpb24gd2lsbCBkaXNhYmxlIHRoYXQgYnVmZmVyaW5nLgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCB0d2ljZSwgdGhlIHNlY29uZCB3aWxsIGFnYWluIHN3aXRjaCBvbiBidWZmZXJpbmcuCi5JUCAiLW8vLS1vdXRwdXQgPGZpbGU+IgpXcml0ZSBvdXRwdXQgdG8gPGZpbGU+IGluc3RlYWQgb2Ygc3Rkb3V0LiBJZiB5b3UgYXJlIHVzaW5nIHt9IG9yIFtdIHRvIGZldGNoCm11bHRpcGxlIGRvY3VtZW50cywgeW91IGNhbiB1c2UgJyMnIGZvbGxvd2VkIGJ5IGEgbnVtYmVyIGluIHRoZSA8ZmlsZT4Kc3BlY2lmaWVyLiBUaGF0IHZhcmlhYmxlIHdpbGwgYmUgcmVwbGFjZWQgd2l0aCB0aGUgY3VycmVudCBzdHJpbmcgZm9yIHRoZSBVUkwKYmVpbmcgZmV0Y2hlZC4gTGlrZSBpbjoKCiAgY3VybCBodHRwOi8ve29uZSx0d299LnNpdGUuY29tIC1vICJmaWxlXyMxLnR4dCIKCm9yIHVzZSBzZXZlcmFsIHZhcmlhYmxlcyBsaWtlOgoKICBjdXJsIGh0dHA6Ly97c2l0ZSxob3N0fS5ob3N0WzEtNV0uY29tIC1vICIjMV8jMiIKCllvdSBtYXkgdXNlIHRoaXMgb3B0aW9uIGFzIG1hbnkgdGltZXMgYXMgeW91IGhhdmUgbnVtYmVyIG9mIFVSTHMuCi5JUCAiLU8vLS1yZW1vdGUtbmFtZSIKV3JpdGUgb3V0cHV0IHRvIGEgbG9jYWwgZmlsZSBuYW1lZCBsaWtlIHRoZSByZW1vdGUgZmlsZSB3ZSBnZXQuIChPbmx5CnRoZSBmaWxlIHBhcnQgb2YgdGhlIHJlbW90ZSBmaWxlIGlzIHVzZWQsIHRoZSBwYXRoIGlzIGN1dCBvZmYuKQoKWW91IG1heSB1c2UgdGhpcyBvcHRpb24gYXMgbWFueSB0aW1lcyBhcyB5b3UgaGF2ZSBudW1iZXIgb2YgVVJMcy4KLklQICItcC8tLXByb3h5dHVubmVsIgpXaGVuIGFuIEhUVFAgcHJveHkgaXMgdXNlZCwgdGhpcyBvcHRpb24gd2lsbCBjYXVzZSBub24tSFRUUCBwcm90b2NvbHMgdG8KYXR0ZW1wdCB0byB0dW5uZWwgdGhyb3VnaCB0aGUgcHJveHkgaW5zdGVhZCBvZiBtZXJlbHkgdXNpbmcgaXQgdG8gZG8gSFRUUC1saWtlCm9wZXJhdGlvbnMuIFRoZSB0dW5uZWwgYXBwcm9hY2ggaXMgbWFkZSB3aXRoIHRoZSBIVFRQIHByb3h5IENPTk5FQ1QgcmVxdWVzdAphbmQgcmVxdWlyZXMgdGhhdCB0aGUgcHJveHkgYWxsb3dzIGRpcmVjdCBjb25uZWN0IHRvIHRoZSByZW1vdGUgcG9ydCBudW1iZXIKY3VybCB3YW50cyB0byB0dW5uZWwgdGhyb3VnaCB0by4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgdHdpY2UsIHRoZSBzZWNvbmQgd2lsbCBhZ2FpbiBkaXNhYmxlIHByb3h5IHR1bm5lbC4KLklQICItUC8tLWZ0cHBvcnQgPGFkZHJlc3M+IgooRlRQKQpSZXZlcnNlcyB0aGUgaW5pdGlhdG9yL2xpc3RlbmVyIHJvbGVzIHdoZW4gY29ubmVjdGluZyB3aXRoIGZ0cC4gVGhpcwpzd2l0Y2ggbWFrZXMgQ3VybCB1c2UgdGhlIFBPUlQgY29tbWFuZCBpbnN0ZWFkIG9mIFBBU1YuIEluCnByYWN0aWNlLCBQT1JUIHRlbGxzIHRoZSBzZXJ2ZXIgdG8gY29ubmVjdCB0byB0aGUgY2xpZW50J3Mgc3BlY2lmaWVkCmFkZHJlc3MgYW5kIHBvcnQsIHdoaWxlIFBBU1YgYXNrcyB0aGUgc2VydmVyIGZvciBhbiBpcCBhZGRyZXNzIGFuZApwb3J0IHRvIGNvbm5lY3QgdG8uIDxhZGRyZXNzPiBzaG91bGQgYmUgb25lIG9mOgouUlMKLlRQIDEyCi5CIGludGVyZmFjZQppLmUgImV0aDAiIHRvIHNwZWNpZnkgd2hpY2ggaW50ZXJmYWNlJ3MgSVAgYWRkcmVzcyB5b3Ugd2FudCB0byB1c2UgIChVbml4IG9ubHkpCi5UUAouQiAiSVAgYWRkcmVzcyIKaS5lICIxOTIuMTY4LjEwLjEiIHRvIHNwZWNpZnkgZXhhY3QgSVAgbnVtYmVyCi5UUAouQiAiaG9zdCBuYW1lIgppLmUgIm15Lmhvc3QuZG9tYWluIiB0byBzcGVjaWZ5IG1hY2hpbmUKLlRQCi5CICItIgooYW55IHNpbmdsZS1sZXR0ZXIgc3RyaW5nKSB0byBtYWtlIGl0IHBpY2sgdGhlIG1hY2hpbmUncyBkZWZhdWx0Ci5SRQoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCBzZXJ2ZXJhbCB0aW1lcywgdGhlIGxhc3Qgb25lIHdpbGwgYmUgdXNlZC4KLklQICItcSIKSWYgdXNlZCBhcyB0aGUgZmlyc3QgcGFyYW1ldGVyIG9uIHRoZSBjb21tYW5kIGxpbmUsIHRoZQouSSAkSE9NRS8uY3VybHJjCmZpbGUgd2lsbCBub3QgYmUgcmVhZCBhbmQgdXNlZCBhcyBhIGNvbmZpZyBmaWxlLgouSVAgIi1RLy0tcXVvdGUgPGNvbWFuZD4iCihGVFApIFNlbmQgYW4gYXJiaXRyYXJ5IGNvbW1hbmQgdG8gdGhlIHJlbW90ZSBGVFAgc2VydmVyLCBieSB1c2luZyB0aGUgUVVPVEUKY29tbWFuZCBvZiB0aGUgc2VydmVyLiBOb3QgYWxsIHNlcnZlcnMgc3VwcG9ydCB0aGlzIGNvbW1hbmQsIGFuZCB0aGUgc2V0IG9mClFVT1RFIGNvbW1hbmRzIGFyZSBzZXJ2ZXIgc3BlY2lmaWMhIFF1b3RlIGNvbW1hbmRzIGFyZSBzZW50IEJFRk9SRSB0aGUKdHJhbnNmZXIgaXMgdGFraW5nIHBsYWNlLiBUbyBtYWtlIGNvbW1hbmRzIHRha2UgcGxhY2UgYWZ0ZXIgYSBzdWNjZXNzZnVsCnRyYW5zZmVyLCBwcmVmaXggdGhlbSB3aXRoIGEgZGFzaCAnLScuIFlvdSBtYXkgc3BlY2lmeSBhbnkgYW1vdW50IG9mIGNvbW1hbmRzCnRvIGJlIHJ1biBiZWZvcmUgYW5kIGFmdGVyIHRoZSB0cmFuc2Zlci4gSWYgdGhlIHNlcnZlciByZXR1cm5zIGZhaWx1cmUgZm9yIG9uZQpvZiB0aGUgY29tbWFuZHMsIHRoZSBlbnRpcmUgb3BlcmF0aW9uIHdpbGwgYmUgYWJvcnRlZC4KClRoaXMgb3B0aW9uIGNhbiBiZSB1c2VkIG11bHRpcGxlIHRpbWVzLgouSVAgIi1yLy0tcmFuZ2UgPHJhbmdlPiIKKEhUVFAvRlRQKQpSZXRyaWV2ZSBhIGJ5dGUgcmFuZ2UgKGkuZSBhIHBhcnRpYWwgZG9jdW1lbnQpIGZyb20gYSBIVFRQLzEuMSBvciBGVFAKc2VydmVyLiBSYW5nZXMgY2FuIGJlIHNwZWNpZmllZCBpbiBhIG51bWJlciBvZiB3YXlzLgouUlMKLlRQIDEwCi5CIDAtNDk5CnNwZWNpZmllcyB0aGUgZmlyc3QgNTAwIGJ5dGVzCi5UUAouQiA1MDAtOTk5CnNwZWNpZmllcyB0aGUgc2Vjb25kIDUwMCBieXRlcwouVFAKLkIgLTUwMApzcGVjaWZpZXMgdGhlIGxhc3QgNTAwIGJ5dGVzCi5UUAouQiA5NTAwCnNwZWNpZmllcyB0aGUgYnl0ZXMgZnJvbSBvZmZzZXQgOTUwMCBhbmQgZm9yd2FyZAouVFAKLkIgMC0wLC0xCnNwZWNpZmllcyB0aGUgZmlyc3QgYW5kIGxhc3QgYnl0ZSBvbmx5KCopKEgpCi5UUAouQiA1MDAtNzAwLDYwMC03OTkKc3BlY2lmaWVzIDMwMCBieXRlcyBmcm9tIG9mZnNldCA1MDAoSCkKLlRQCi5CIDEwMC0xOTksNTAwLTU5OQpzcGVjaWZpZXMgdHdvIHNlcGFyYXRlIDEwMCBieXRlcyByYW5nZXMoKikoSCkKLlJFCgooKikgPSBOT1RFIHRoYXQgdGhpcyB3aWxsIGNhdXNlIHRoZSBzZXJ2ZXIgdG8gcmVwbHkgd2l0aCBhIG11bHRpcGFydApyZXNwb25zZSEKCllvdSBzaG91bGQgYWxzbyBiZSBhd2FyZSB0aGF0IG1hbnkgSFRUUC8xLjEgc2VydmVycyBkbyBub3QgaGF2ZSB0aGlzIGZlYXR1cmUKZW5hYmxlZCwgc28gdGhhdCB3aGVuIHlvdSBhdHRlbXB0IHRvIGdldCBhIHJhbmdlLCB5b3UnbGwgaW5zdGVhZCBnZXQgdGhlIHdob2xlCmRvY3VtZW50LgoKRlRQIHJhbmdlIGRvd25sb2FkcyBvbmx5IHN1cHBvcnQgdGhlIHNpbXBsZSBzeW50YXggJ3N0YXJ0LXN0b3AnIChvcHRpb25hbGx5CndpdGggb25lIG9mIHRoZSBudW1iZXJzIG9taXR0ZWQpLiBJdCBkZXBlbmRzIG9uIHRoZSBub24tUkZDIGNvbW1hbmQgU0laRS4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCi5JUCAiLXMvLS1zaWxlbnQiClNpbGVudCBtb2RlLiBEb24ndCBzaG93IHByb2dyZXNzIG1ldGVyIG9yIGVycm9yIG1lc3NhZ2VzLiAgTWFrZXMKQ3VybCBtdXRlLgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCB0d2ljZSwgdGhlIHNlY29uZCB3aWxsIGFnYWluIGRpc2FibGUgbXV0ZS4KLklQICItUy8tLXNob3ctZXJyb3IiCldoZW4gdXNlZCB3aXRoIC1zIGl0IG1ha2VzIGN1cmwgc2hvdyBlcnJvciBtZXNzYWdlIGlmIGl0IGZhaWxzLgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCB0d2ljZSwgdGhlIHNlY29uZCB3aWxsIGFnYWluIGRpc2FibGUgc2hvdyBlcnJvci4KLklQICItdC8tLXRlbG5ldC1vcHRpb24gPE9QVD12YWw+IgpQYXNzIG9wdGlvbnMgdG8gdGhlIHRlbG5ldCBwcm90b2NvbC4gU3VwcG9ydGVkIG9wdGlvbnMgYXJlOgoKVFRZUEU9PHRlcm0+IFNldHMgdGhlIHRlcm1pbmFsIHR5cGUuCgpYRElTUExPQz08WCBkaXNwbGF5PiBTZXRzIHRoZSBYIGRpc3BsYXkgbG9jYXRpb24uCgpORVdfRU5WPTx2YXIsdmFsPiBTZXRzIGFuIGVudmlyb25tZW50IHZhcmlhYmxlLgouSVAgIi1ULy0tdXBsb2FkLWZpbGUgPGZpbGU+IgpMaWtlIC10LCBidXQgdGhpcyB0cmFuc2ZlcnMgdGhlIHNwZWNpZmllZCBsb2NhbCBmaWxlLiBJZiB0aGVyZSBpcyBubwpmaWxlIHBhcnQgaW4gdGhlIHNwZWNpZmllZCBVUkwsIEN1cmwgd2lsbCBhcHBlbmQgdGhlIGxvY2FsIGZpbGUKbmFtZS4gTk9URSB0aGF0IHlvdSBtdXN0IHVzZSBhIHRyYWlsaW5nIC8gb24gdGhlIGxhc3QgZGlyZWN0b3J5IHRvCnJlYWxseSBwcm92ZSB0byBDdXJsIHRoYXQgdGhlcmUgaXMgbm8gZmlsZSBuYW1lIG9yIGN1cmwgd2lsbAp0aGluayB0aGF0IHlvdXIgbGFzdCBkaXJlY3RvcnkgbmFtZSBpcyB0aGUgcmVtb3RlIGZpbGUgbmFtZSB0bwp1c2UuIFRoYXQgd2lsbCBtb3N0IGxpa2VseSBjYXVzZSB0aGUgdXBsb2FkIG9wZXJhdGlvbiB0byBmYWlsLiBJZgp0aGlzIGlzIHVzZWQgb24gYSBodHRwKHMpIHNlcnZlciwgdGhlIFBVVCBjb21tYW5kIHdpbGwgYmUgdXNlZC4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCi5JUCAiLXUvLS11c2VyIDx1c2VyOnBhc3N3b3JkPiIKU3BlY2lmeSB1c2VyIGFuZCBwYXNzd29yZCB0byB1c2Ugd2hlbiBmZXRjaGluZy4gU2VlIFJFQURNRS5jdXJsIGZvciBkZXRhaWxlZApleGFtcGxlcyBvZiBob3cgdG8gdXNlIHRoaXMuIElmIG5vIHBhc3N3b3JkIGlzIHNwZWNpZmllZCwgY3VybCB3aWxsCmFzayBmb3IgaXQgaW50ZXJhY3RpdmVseS4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCi5JUCAiLVUvLS1wcm94eS11c2VyIDx1c2VyOnBhc3N3b3JkPiIKU3BlY2lmeSB1c2VyIGFuZCBwYXNzd29yZCB0byB1c2UgZm9yIFByb3h5IGF1dGhlbnRpY2F0aW9uLiBJZiBubwpwYXNzd29yZCBpcyBzcGVjaWZpZWQsIGN1cmwgd2lsbCBhc2sgZm9yIGl0IGludGVyYWN0aXZlbHkuCgpJZiB0aGlzIG9wdGlvbiBpcyB1c2VkIHNlcnZlcmFsIHRpbWVzLCB0aGUgbGFzdCBvbmUgd2lsbCBiZSB1c2VkLgouSVAgIi0tdXJsIDxVUkw+IgpTcGVjaWZ5IGEgVVJMIHRvIGZldGNoLiBUaGlzIG9wdGlvbiBpcyBtb3N0bHkgaGFuZHkgd2hlbiB5b3Ugd2FubmEgc3BlY2lmeQpVUkwocykgaW4gYSBjb25maWcgZmlsZS4KClRoaXMgb3B0aW9uIG1heSBiZSB1c2VkIGFueSBudW1iZXIgb2YgdGltZXMuIFRvIGNvbnRyb2wgd2hlcmUgdGhpcyBVUkwgaXMgd3JpdHRlbiwgdXNlIHRoZQouSSAtbwpvciB0aGUKLkkgLU8Kb3B0aW9ucy4KLklQICItdi8tLXZlcmJvc2UiCk1ha2VzIHRoZSBmZXRjaGluZyBtb3JlIHZlcmJvc2UvdGFsa2F0aXZlLiBNb3N0bHkgdXNhYmxlIGZvcgpkZWJ1Z2dpbmcuIExpbmVzIHN0YXJ0aW5nIHdpdGggJz4nIG1lYW5zIGRhdGEgc2VudCBieSBjdXJsLCAnPCcKbWVhbnMgZGF0YSByZWNlaXZlZCBieSBjdXJsIHRoYXQgaXMgaGlkZGVuIGluIG5vcm1hbCBjYXNlcyBhbmQgbGluZXMKc3RhcnRpbmcgd2l0aCAnKicgbWVhbnMgYWRkaXRpb25hbCBpbmZvIHByb3ZpZGVkIGJ5IGN1cmwuCgpJZiB0aGlzIG9wdGlvbiBpcyB1c2VkIHR3aWNlLCB0aGUgc2Vjb25kIHdpbGwgYWdhaW4gZGlzYWJsZSB2ZXJib3NlLgouSVAgIi1WLy0tdmVyc2lvbiIKRGlzcGxheXMgdGhlIGZ1bGwgdmVyc2lvbiBvZiBjdXJsLCBsaWJjdXJsIGFuZCBvdGhlciAzcmQgcGFydHkgbGlicmFyaWVzCmxpbmtlZCB3aXRoIHRoZSBleGVjdXRhYmxlLgouSVAgIi13Ly0td3JpdGUtb3V0IDxmb3JtYXQ+IgpEZWZpbmVzIHdoYXQgdG8gZGlzcGxheSBhZnRlciBhIGNvbXBsZXRlZCBhbmQgc3VjY2Vzc2Z1bCBvcGVyYXRpb24uIFRoZSBmb3JtYXQKaXMgYSBzdHJpbmcgdGhhdCBtYXkgY29udGFpbiBwbGFpbiB0ZXh0IG1peGVkIHdpdGggYW55IG51bWJlciBvZiB2YXJpYWJsZXMuIFRoZQpzdHJpbmcgY2FuIGJlIHNwZWNpZmllZCBhcyAic3RyaW5nIiwgdG8gZ2V0IHJlYWQgZnJvbSBhIHBhcnRpY3VsYXIgZmlsZSB5b3UKc3BlY2lmeSBpdCAiQGZpbGVuYW1lIiBhbmQgdG8gdGVsbCBjdXJsIHRvIHJlYWQgdGhlIGZvcm1hdCBmcm9tIHN0ZGluIHlvdQp3cml0ZSAiQC0iLgoKVGhlIHZhcmlhYmxlcyBwcmVzZW50IGluIHRoZSBvdXRwdXQgZm9ybWF0IHdpbGwgYmUgc3Vic3RpdHV0ZWQgYnkgdGhlIHZhbHVlIG9yCnRleHQgdGhhdCBjdXJsIHRoaW5rcyBmaXQsIGFzIGRlc2NyaWJlZCBiZWxvdy4gQWxsIHZhcmlhYmxlcyBhcmUgc3BlY2lmaWVkCmxpa2UgJXt2YXJpYWJsZV9uYW1lfSBhbmQgdG8gb3V0cHV0IGEgbm9ybWFsICUgeW91IGp1c3Qgd3JpdGUgdGhlbSBsaWtlCiUlLiBZb3UgY2FuIG91dHB1dCBhIG5ld2xpbmUgYnkgdXNpbmcgXFxuLCBhIGNhcnJpZ2UgcmV0dXJuIHdpdGggXFxyIGFuZCBhIHRhYgpzcGFjZSB3aXRoIFxcdC4KCi5CIE5PVEU6ClRoZSAlLWxldHRlciBpcyBhIHNwZWNpYWwgbGV0dGVyIGluIHRoZSB3aW4zMi1lbnZpcm9ubWVudCwgd2hlcmUgYWxsCm9jY3VycmVuY2VzIG9mICUgbXVzdCBiZSBkb3VibGVkIHdoZW4gdXNpbmcgdGhpcyBvcHRpb24uCgpBdmFpbGFibGUgdmFyaWFibGVzIGFyZSBhdCB0aGlzIHBvaW50OgouUlMKLlRQIDE1Ci5CIHVybF9lZmZlY3RpdmUKVGhlIFVSTCB0aGF0IHdhcyBmZXRjaGVkIGxhc3QuIFRoaXMgaXMgbW9zdGx5IG1lYW5pbmdmdWwgaWYgeW91J3ZlIHRvbGQgY3VybAp0byBmb2xsb3cgbG9jYXRpb246IGhlYWRlcnMuCi5UUAouQiBodHRwX2NvZGUKVGhlIG51bWVyaWNhbCBjb2RlIHRoYXQgd2FzIGZvdW5kIGluIHRoZSBsYXN0IHJldHJpZXZlZCBIVFRQKFMpIHBhZ2UuCi5UUAouQiB0aW1lX3RvdGFsClRoZSB0b3RhbCB0aW1lLCBpbiBzZWNvbmRzLCB0aGF0IHRoZSBmdWxsIG9wZXJhdGlvbiBsYXN0ZWQuIFRoZSB0aW1lIHdpbGwgYmUKZGlzcGxheWVkIHdpdGggbWlsbGlzZWNvbmQgcmVzb2x1dGlvbi4KLlRQCi5CIHRpbWVfbmFtZWxvb2t1cApUaGUgdGltZSwgaW4gc2Vjb25kcywgaXQgdG9vayBmcm9tIHRoZSBzdGFydCB1bnRpbCB0aGUgbmFtZSByZXNvbHZpbmcgd2FzCmNvbXBsZXRlZC4KLlRQCi5CIHRpbWVfY29ubmVjdApUaGUgdGltZSwgaW4gc2Vjb25kcywgaXQgdG9vayBmcm9tIHRoZSBzdGFydCB1bnRpbCB0aGUgY29ubmVjdCB0byB0aGUgcmVtb3RlCmhvc3QgKG9yIHByb3h5KSB3YXMgY29tcGxldGVkLgouVFAKLkIgdGltZV9wcmV0cmFuc2ZlcgpUaGUgdGltZSwgaW4gc2Vjb25kcywgaXQgdG9vayBmcm9tIHRoZSBzdGFydCB1bnRpbCB0aGUgZmlsZSB0cmFuc2ZlciBpcyBqdXN0CmFib3V0IHRvIGJlZ2luLiBUaGlzIGluY2x1ZGVzIGFsbCBwcmUtdHJhbnNmZXIgY29tbWFuZHMgYW5kIG5lZ290aWF0aW9ucyB0aGF0CmFyZSBzcGVjaWZpYyB0byB0aGUgcGFydGljdWxhciBwcm90b2NvbChzKSBpbnZvbHZlZC4KLlRQCi5CIHNpemVfZG93bmxvYWQKVGhlIHRvdGFsIGFtb3VudCBvZiBieXRlcyB0aGF0IHdlcmUgZG93bmxvYWRlZC4KLlRQCi5CIHNpemVfdXBsb2FkClRoZSB0b3RhbCBhbW91bnQgb2YgYnl0ZXMgdGhhdCB3ZXJlIHVwbG9hZGVkLgouVFAKLkIgc2l6ZV9oZWFkZXIKVGhlIHRvdGFsIGFtb3VudCBvZiBieXRlcyBvZiB0aGUgZG93bmxvYWRlZCBoZWFkZXJzLgouVFAKLkIgc2l6ZV9yZXF1ZXN0ClRoZSB0b3RhbCBhbW91bnQgb2YgYnl0ZXMgdGhhdCB3ZXJlIHNlbnQgaW4gdGhlIEhUVFAgcmVxdWVzdC4KLlRQCi5CIHNwZWVkX2Rvd25sb2FkClRoZSBhdmVyYWdlIGRvd25sb2FkIHNwZWVkIHRoYXQgY3VybCBtZWFzdXJlZCBmb3IgdGhlIGNvbXBsZXRlIGRvd25sb2FkLgouVFAKLkIgc3BlZWRfdXBsb2FkClRoZSBhdmVyYWdlIHVwbG9hZCBzcGVlZCB0aGF0IGN1cmwgbWVhc3VyZWQgZm9yIHRoZSBjb21wbGV0ZSB1cGxvYWQuCi5SRQoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCBzZXJ2ZXJhbCB0aW1lcywgdGhlIGxhc3Qgb25lIHdpbGwgYmUgdXNlZC4KLklQICIteC8tLXByb3h5IDxwcm94eWhvc3RbOnBvcnRdPiIKVXNlIHNwZWNpZmllZCBwcm94eS4gSWYgdGhlIHBvcnQgbnVtYmVyIGlzIG5vdCBzcGVjaWZpZWQsIGl0IGlzIGFzc3VtZWQgYXQKcG9ydCAxMDgwLgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCBzZXJ2ZXJhbCB0aW1lcywgdGhlIGxhc3Qgb25lIHdpbGwgYmUgdXNlZC4KLklQICItWC8tLXJlcXVlc3QgPGNvbW1hbmQ+IgooSFRUUCkKU3BlY2lmaWVzIGEgY3VzdG9tIHJlcXVlc3QgdG8gdXNlIHdoZW4gY29tbXVuaWNhdGluZyB3aXRoIHRoZSBIVFRQIHNlcnZlci4KVGhlIHNwZWNpZmllZCByZXF1ZXN0IHdpbGwgYmUgdXNlZCBpbnN0ZWFkIG9mIHRoZSBzdGFuZGFyZCBHRVQuIFJlYWQgdGhlCkhUVFAgMS4xIHNwZWNpZmljYXRpb24gZm9yIGRldGFpbHMgYW5kIGV4cGxhbmF0aW9ucy4KCihGVFApClNwZWNpZmllcyBhIGN1c3RvbSBGVFAgY29tbWFuZCB0byB1c2UgaW5zdGVhZCBvZiBMSVNUIHdoZW4gZG9pbmcgZmlsZSBsaXN0cwp3aXRoIGZ0cC4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCi5JUCAiLXkvLS1zcGVlZC10aW1lIDx0aW1lPiIKSWYgYSBkb3dubG9hZCBpcyBzbG93ZXIgdGhhbiBzcGVlZC1saW1pdCBieXRlcyBwZXIgc2Vjb25kIGR1cmluZyBhIHNwZWVkLXRpbWUKcGVyaW9kLCB0aGUgZG93bmxvYWQgZ2V0cyBhYm9ydGVkLiBJZiBzcGVlZC10aW1lIGlzIHVzZWQsIHRoZSBkZWZhdWx0CnNwZWVkLWxpbWl0IHdpbGwgYmUgMSB1bmxlc3Mgc2V0IHdpdGggLXkuCgpJZiB0aGlzIG9wdGlvbiBpcyB1c2VkIHNlcnZlcmFsIHRpbWVzLCB0aGUgbGFzdCBvbmUgd2lsbCBiZSB1c2VkLgouSVAgIi1ZLy0tc3BlZWQtbGltaXQgPHNwZWVkPiIKSWYgYSBkb3dubG9hZCBpcyBzbG93ZXIgdGhhbiB0aGlzIGdpdmVuIHNwZWVkLCBpbiBieXRlcyBwZXIgc2Vjb25kLCBmb3IKc3BlZWQtdGltZSBzZWNvbmRzIGl0IGdldHMgYWJvcnRlZC4gc3BlZWQtdGltZSBpcyBzZXQgd2l0aCAtWSBhbmQgaXMgMzAgaWYKbm90IHNldC4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCi5JUCAiLXovLS10aW1lLWNvbmQgPGRhdGUgZXhwcmVzc2lvbj4iCihIVFRQKQpSZXF1ZXN0IHRvIGdldCBhIGZpbGUgdGhhdCBoYXMgYmVlbiBtb2RpZmllZCBsYXRlciB0aGFuIHRoZSBnaXZlbiB0aW1lIGFuZApkYXRlLCBvciBvbmUgdGhhdCBoYXMgYmVlbiBtb2RpZmllZCBiZWZvcmUgdGhhdCB0aW1lLiBUaGUgZGF0ZSBleHByZXNzaW9uIGNhbgpiZSBhbGwgc29ydHMgb2YgZGF0ZSBzdHJpbmdzIG9yIGlmIGl0IGRvZXNuJ3QgbWF0Y2ggYW55IGludGVybmFsIG9uZXMsIGl0CnRyaWVzIHRvIGdldCB0aGUgdGltZSBmcm9tIGEgZ2l2ZW4gZmlsZSBuYW1lIGluc3RlYWQhIFNlZSB0aGUKLkJSICJHTlUgZGF0ZSgxKSIKb3IKLkJSICJjdXJsX2dldGRhdGUoMykiCm1hbiBwYWdlcyBmb3IgZGF0ZSBleHByZXNzaW9uIGRldGFpbHMuCgpTdGFydCB0aGUgZGF0ZSBleHByZXNzaW9uIHdpdGggYSBkYXNoICgtKSB0byBtYWtlIGl0IHJlcXVlc3QgZm9yIGEgZG9jdW1lbnQKdGhhdCBpcyBvbGRlciB0aGFuIHRoZSBnaXZlbiBkYXRlL3RpbWUsIGRlZmF1bHQgaXMgYSBkb2N1bWVudCB0aGF0IGlzIG5ld2VyCnRoYW4gdGhlIHNwZWNpZmllZCBkYXRlL3RpbWUuCgpJZiB0aGlzIG9wdGlvbiBpcyB1c2VkIHNlcnZlcmFsIHRpbWVzLCB0aGUgbGFzdCBvbmUgd2lsbCBiZSB1c2VkLgouSVAgIi0zLy0tc3NsdjMiCihIVFRQUykKRm9yY2VzIGN1cmwgdG8gdXNlIFNTTCB2ZXJzaW9uIDMgd2hlbiBuZWdvdGlhdGluZyB3aXRoIGEgcmVtb3RlIFNTTCBzZXJ2ZXIuCi5JUCAiLTIvLS1zc2x2MiIKKEhUVFBTKQpGb3JjZXMgY3VybCB0byB1c2UgU1NMIHZlcnNpb24gMiB3aGVuIG5lZ290aWF0aW5nIHdpdGggYSByZW1vdGUgU1NMIHNlcnZlci4KLklQICItIy8tLXByb2dyZXNzLWJhciIKTWFrZSBjdXJsIGRpc3BsYXkgcHJvZ3Jlc3MgaW5mb3JtYXRpb24gYXMgYSBwcm9ncmVzcyBiYXIgaW5zdGVhZCBvZiB0aGUKZGVmYXVsdCBzdGF0aXN0aWNzLgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCB0d2ljZSwgdGhlIHNlY29uZCB3aWxsIGFnYWluIGRpc2FibGUgdGhlIHByb2dyZXNzIGJhci4KLklQICItLWNybGYiCihGVFApIENvbnZlcnQgTEYgdG8gQ1JMRiBpbiB1cGxvYWQuIFVzZWZ1bCBmb3IgTVZTIChPUy8zOTApLgoKSWYgdGhpcyBvcHRpb24gaXMgdXNlZCB0d2ljZSwgdGhlIHNlY29uZCB3aWxsIGFnYWluIGRpc2FibGUgY3JsZiBjb252ZXJ0aW5nLgouSVAgIi0tc3RkZXJyIDxmaWxlPiIKUmVkaXJlY3QgYWxsIHdyaXRlcyB0byBzdGRlcnIgdG8gdGhlIHNwZWNpZmllZCBmaWxlIGluc3RlYWQuIElmIHRoZSBmaWxlIG5hbWUKaXMgYSBwbGFpbiAnLScsIGl0IGlzIGluc3RlYWQgd3JpdHRlbiB0byBzdGRvdXQuIFRoaXMgb3B0aW9uIGhhcyBubyBwb2ludCB3aGVuCnlvdSdyZSB1c2luZyBhIHNoZWxsIHdpdGggZGVjZW50IHJlZGlyZWN0aW5nIGNhcGFiaWxpdGllcy4KCklmIHRoaXMgb3B0aW9uIGlzIHVzZWQgc2VydmVyYWwgdGltZXMsIHRoZSBsYXN0IG9uZSB3aWxsIGJlIHVzZWQuCi5TSCBGSUxFUwouSSB+Ly5jdXJscmMKLlJTCkRlZmF1bHQgY29uZmlnIGZpbGUuCgouU0ggRU5WSVJPTk1FTlQKLklQICJIVFRQX1BST1hZIFtwcm90b2NvbDovL108aG9zdD5bOnBvcnRdIgpTZXRzIHByb3h5IHNlcnZlciB0byB1c2UgZm9yIEhUVFAuCi5JUCAiSFRUUFNfUFJPWFkgW3Byb3RvY29sOi8vXTxob3N0Pls6cG9ydF0iClNldHMgcHJveHkgc2VydmVyIHRvIHVzZSBmb3IgSFRUUFMuCi5JUCAiRlRQX1BST1hZIFtwcm90b2NvbDovL108aG9zdD5bOnBvcnRdIgpTZXRzIHByb3h5IHNlcnZlciB0byB1c2UgZm9yIEZUUC4KLklQICJHT1BIRVJfUFJPWFkgW3Byb3RvY29sOi8vXTxob3N0Pls6cG9ydF0iClNldHMgcHJveHkgc2VydmVyIHRvIHVzZSBmb3IgR09QSEVSLgouSVAgIkFMTF9QUk9YWSBbcHJvdG9jb2w6Ly9dPGhvc3Q+Wzpwb3J0XSIKU2V0cyBwcm94eSBzZXJ2ZXIgdG8gdXNlIGlmIG5vIHByb3RvY29sLXNwZWNpZmljIHByb3h5IGlzIHNldC4KLklQICJOT19QUk9YWSA8Y29tbWEtc2VwYXJhdGVkIGxpc3Qgb2YgaG9zdHM+IgpsaXN0IG9mIGhvc3QgbmFtZXMgdGhhdCBzaG91bGRuJ3QgZ28gdGhyb3VnaCBhbnkgcHJveHkuIElmIHNldCB0byBhCmFzdGVyaXNrICcqJyBvbmx5LCBpdCBtYXRjaGVzIGFsbCBob3N0cy4KLklQICJDT0xVTU5TIDxpbnRlZ2VyPiIKVGhlIHdpZHRoIG9mIHRoZSB0ZXJtaW5hbC4gIFRoaXMgdmFyaWFibGUgb25seSBhZmZlY3RzIGN1cmwgd2hlbiB0aGUKLS1wcm9ncmVzcy1iYXIgb3B0aW9uIGlzIHVzZWQuCi5TSCBFWElUIENPREVTClRoZXJlIGV4aXN0cyBhIGJ1bmNoIG9mIGRpZmZlcmVudCBlcnJvciBjb2RlcyBhbmQgdGhlaXIgY29ycmVzcG9uZGluZyBlcnJvcgptZXNzYWdlcyB0aGF0IG1heSBhcHBlYXIgZHVyaW5nIGJhZCBjb25kaXRpb25zLiBBdCB0aGUgdGltZSBvZiB0aGlzIHdyaXRpbmcsCnRoZSBleGl0IGNvZGVzIGFyZToKLklQIDEKVW5zdXBwb3J0ZWQgcHJvdG9jb2wuIFRoaXMgYnVpbGQgb2YgY3VybCBoYXMgbm8gc3VwcG9ydCBmb3IgdGhpcyBwcm90b2NvbC4KLklQIDIKRmFpbGVkIHRvIGluaXRpYWxpemUuCi5JUCAzClVSTCBtYWxmb3JtYXQuIFRoZSBzeW50YXggd2FzIG5vdCBjb3JyZWN0LgouSVAgNApVUkwgdXNlciBtYWxmb3JtYXR0ZWQuIFRoZSB1c2VyLXBhcnQgb2YgdGhlIFVSTCBzeW50YXggd2FzIG5vdCBjb3JyZWN0LgouSVAgNQpDb3VsZG4ndCByZXNvbHZlIHByb3h5LiBUaGUgZ2l2ZW4gcHJveHkgaG9zdCBjb3VsZCBub3QgYmUgcmVzb2x2ZWQuCi5JUCA2CkNvdWxkbid0IHJlc29sdmUgaG9zdC4gVGhlIGdpdmVuIHJlbW90ZSBob3N0IHdhcyBub3QgcmVzb2x2ZWQuCi5JUCA3CkZhaWxlZCB0byBjb25uZWN0IHRvIGhvc3QuCi5JUCA4CkZUUCB3ZWlyZCBzZXJ2ZXIgcmVwbHkuIFRoZSBzZXJ2ZXIgc2VudCBkYXRhIGN1cmwgY291bGRuJ3QgcGFyc2UuCi5JUCA5CkZUUCBhY2Nlc3MgZGVuaWVkLiBUaGUgc2VydmVyIGRlbmllZCBsb2dpbi4KLklQIDEwCkZUUCB1c2VyL3Bhc3N3b3JkIGluY29ycmVjdC4gRWl0aGVyIG9uZSBvciBib3RoIHdlcmUgbm90IGFjY2VwdGVkIGJ5IHRoZQpzZXJ2ZXIuCi5JUCAxMQpGVFAgd2VpcmQgUEFTUyByZXBseS4gQ3VybCBjb3VsZG4ndCBwYXJzZSB0aGUgcmVwbHkgc2VudCB0byB0aGUgUEFTUyByZXF1ZXN0LgouSVAgMTIKRlRQIHdlaXJkIFVTRVIgcmVwbHkuIEN1cmwgY291bGRuJ3QgcGFyc2UgdGhlIHJlcGx5IHNlbnQgdG8gdGhlIFVTRVIgcmVxdWVzdC4KLklQIDEzCkZUUCB3ZWlyZCBQQVNWIHJlcGx5LCBDdXJsIGNvdWxkbid0IHBhcnNlIHRoZSByZXBseSBzZW50IHRvIHRoZSBQQVNWIHJlcXVlc3QuCi5JUCAxNApGVFAgd2VpcmQgMjI3IGZvcm1hdC4gQ3VybCBjb3VsZG4ndCBwYXJzZSB0aGUgMjI3LWxpbmUgdGhlIHNlcnZlciBzZW50LgouSVAgMTUKRlRQIGNhbid0IGdldCBob3N0LiBDb3VsZG4ndCByZXNvbHZlIHRoZSBob3N0IElQIHdlIGdvdCBpbiB0aGUgMjI3LWxpbmUuCi5JUCAxNgpGVFAgY2FuJ3QgcmVjb25uZWN0LiBDb3VsZG4ndCBjb25uZWN0IHRvIHRoZSBob3N0IHdlIGdvdCBpbiB0aGUgMjI3LWxpbmUuCi5JUCAxNwpGVFAgY291bGRuJ3Qgc2V0IGJpbmFyeS4gQ291bGRuJ3QgY2hhbmdlIHRyYW5zZmVyIG1ldGhvZCB0byBiaW5hcnkuCi5JUCAxOApQYXJ0aWFsIGZpbGUuIE9ubHkgYSBwYXJ0IG9mIHRoZSBmaWxlIHdhcyB0cmFuc2ZlcmVkLgouSVAgMTkKRlRQIGNvdWxkbid0IFJFVFIgZmlsZS4gVGhlIFJFVFIgY29tbWFuZCBmYWlsZWQuCi5JUCAyMApGVFAgd3JpdGUgZXJyb3IuIFRoZSB0cmFuc2ZlciB3YXMgcmVwb3J0ZWQgYmFkIGJ5IHRoZSBzZXJ2ZXIuCi5JUCAyMQpGVFAgcXVvdGUgZXJyb3IuIEEgcXVvdGUgY29tbWFuZCByZXR1cm5lZCBlcnJvciBmcm9tIHRoZSBzZXJ2ZXIuCi5JUCAyMgpIVFRQIG5vdCBmb3VuZC4gVGhlIHJlcXVlc3RlZCBwYWdlIHdhcyBub3QgZm91bmQuIFRoaXMgcmV0dXJuIGNvZGUgb25seQphcHBlYXJzIGlmIC0tZmFpbCBpcyB1c2VkLgouSVAgMjMKV3JpdGUgZXJyb3IuIEN1cmwgY291bGRuJ3Qgd3JpdGUgZGF0YSB0byBhIGxvY2FsIGZpbGVzeXN0ZW0gb3Igc2ltaWxhci4KLklQIDI0Ck1hbGZvcm1hdCB1c2VyLiBVc2VyIG5hbWUgYmFkbHkgc3BlY2lmaWVkLgouSVAgMjUKRlRQIGNvdWxkbid0IFNUT1IgZmlsZS4gVGhlIHNlcnZlciBkZW5pZWQgdGhlIFNUT1Igb3BlcmF0aW9uLgouSVAgMjYKUmVhZCBlcnJvci4gVmFyaW91cyByZWFkaW5nIHByb2JsZW1zLgouSVAgMjcKT3V0IG9mIG1lbW9yeS4gQSBtZW1vcnkgYWxsb2NhdGlvbiByZXF1ZXN0IGZhaWxlZC4KLklQIDI4Ck9wZXJhdGlvbiB0aW1lb3V0LiBUaGUgc3BlY2lmaWVkIHRpbWUtb3V0IHBlcmlvZCB3YXMgcmVhY2hlZCBhY2NvcmRpbmcgdG8gdGhlCmNvbmRpdGlvbnMuCi5JUCAyOQpGVFAgY291bGRuJ3Qgc2V0IEFTQ0lJLiBUaGUgc2VydmVyIHJldHVybmVkIGFuIHVua25vd24gcmVwbHkuCi5JUCAzMApGVFAgUE9SVCBmYWlsZWQuIFRoZSBQT1JUIGNvbW1hbmQgZmFpbGVkLgouSVAgMzEKRlRQIGNvdWxkbid0IHVzZSBSRVNULiBUaGUgUkVTVCBjb21tYW5kIGZhaWxlZC4KLklQIDMyCkZUUCBjb3VsZG4ndCB1c2UgU0laRS4gVGhlIFNJWkUgY29tbWFuZCBmYWlsZWQuIFRoZSBjb21tYW5kIGlzIGFuIGV4dGVuc2lvbgp0byB0aGUgb3JpZ2luYWwgRlRQIHNwZWMgUkZDIDk1OS4KLklQIDMzCkhUVFAgcmFuZ2UgZXJyb3IuIFRoZSByYW5nZSAiY29tbWFuZCIgZGlkbid0IHdvcmsuCi5JUCAzNApIVFRQIHBvc3QgZXJyb3IuIEludGVybmFsIHBvc3QtcmVxdWVzdCBnZW5lcmF0aW9uIGVycm9yLgouSVAgMzUKU1NMIGNvbm5lY3QgZXJyb3IuIFRoZSBTU0wgaGFuZHNoYWtpbmcgZmFpbGVkLgouSVAgMzYKRlRQIGJhZCBkb3dubG9hZCByZXN1bWUuIENvdWxkbid0IGNvbnRpbnVlIGFuIGVhcmxpZXIgYWJvcnRlZCBkb3dubG9hZC4KLklQIDM3CkZJTEUgY291bGRuJ3QgcmVhZCBmaWxlLiBGYWlsZWQgdG8gb3BlbiB0aGUgZmlsZS4gUGVybWlzc2lvbnM/Ci5JUCAzOApMREFQIGNhbm5vdCBiaW5kLiBMREFQIGJpbmQgb3BlcmF0aW9uIGZhaWxlZC4KLklQIDM5CkxEQVAgc2VhcmNoIGZhaWxlZC4KLklQIDQwCkxpYnJhcnkgbm90IGZvdW5kLiBUaGUgTERBUCBsaWJyYXJ5IHdhcyBub3QgZm91bmQuCi5JUCA0MQpGdW5jdGlvbiBub3QgZm91bmQuIEEgcmVxdWlyZWQgTERBUCBmdW5jdGlvbiB3YXMgbm90IGZvdW5kLgouSVAgNDIKQWJvcnRlZCBieSBjYWxsYmFjay4gQW4gYXBwbGljYXRpb24gdG9sZCBjdXJsIHRvIGFib3J0IHRoZSBvcGVyYXRpb24uCi5JUCA0MwpJbnRlcm5hbCBlcnJvci4gQSBmdW5jdGlvbiB3YXMgY2FsbGVkIHdpdGggYSBiYWQgcGFyYW1ldGVyLgouSVAgNDQKSW50ZXJuYWwgZXJyb3IuIEEgZnVuY3Rpb24gd2FzIGNhbGxlZCBpbiBhIGJhZCBvcmRlci4KLklQIDQ1CkludGVyZmFjZSBlcnJvci4gQSBzcGVjaWZpZWQgb3V0Z29pbmcgaW50ZXJmYWNlIGNvdWxkIG5vdCBiZSB1c2VkLgouSVAgNDYKQmFkIHBhc3N3b3JkIGVudGVyZWQuIEFuIGVycm9yIHdhcyBzaWduYWxsZWQgd2hlbiB0aGUgcGFzc3dvcmQgd2FzIGVudGVyZWQuCi5JUCA0NwpUb28gbWFueSByZWRpcmVjdHMuIFdoZW4gZm9sbG93aW5nIHJlZGlyZWN0cywgY3VybCBoaXQgdGhlIG1heGltdW0gYW1vdW50LgouSVAgWFgKVGhlcmUgd2lsbCBhcHBlYXIgbW9yZSBlcnJvciBjb2RlcyBoZXJlIGluIGZ1dHVyZSByZWxlYXNlcy4gVGhlIGV4aXN0aW5nIG9uZXMKYXJlIG1lYW50IHRvIG5ldmVyIGNoYW5nZS4KLlNIIEJVR1MKSWYgeW91IGRvIGZpbmQgYnVncywgbWFpbCB0aGVtIHRvIGN1cmwtYnVnQGhheHguc2UuCi5TSCBBVVRIT1JTIC8gQ09OVFJJQlVUT1JTCiAtIERhbmllbCBTdGVuYmVyZyA8RGFuaWVsLlN0ZW5iZXJnQGhheHguc2U+CiAtIFJhZmFlbCBTYWd1bGEgPHNhZ3VsYUBpbmYudWZyZ3MuYnI+CiAtIFNhbXBvIEtlbGxvbWFraSA8c2FtcG9AaWtpLmZpPgogLSBMaW5hcyBWZXBzdGFzIDxsaW5hc0BsaW5hcy5vcmc+CiAtIEJqb3JuIFJlZXNlIDxicmVlc2VAbWFpbDEuc3RvZmFuZXQuZGs+CiAtIEpvaGFuIEFuZGVyc29uIDxqb2hhbkBob21lbWFpbC5jb20+CiAtIEtqZWxsIEVyaWNzb24gPEtqZWxsLkVyaWNzb25AaGF4eC5zZT4KIC0gVHJveSBFbmdlbCA8dGVuZ2VsQHNvbmljLm5ldD4KIC0gUnlhbiBOZWxzb24gPHJ5YW5AaW5jaC5jb20+CiAtIEJq9nJuIFN0ZW5iZXJnIDxCam9ybi5TdGVuYmVyZ0BoYXh4LnNlPgogLSBBbmd1cyBNYWNrYXkgPGFtYWNrYXlAZ3VzLm1sLm9yZz4KIC0gRXJpYyBZb3VuZyA8ZWF5QGNyeXB0c29mdC5jb20+CiAtIFNpbW9uIERpY2sgPHNpbW9uZEB0b3RhbGx5LmlycmVsZXZhbnQub3JnPgogLSBPcmVuIFRpcm9zaCA8b3JlbkBtb250eS5oaXNob21lLm5ldD4KIC0gU3RldmVuIEcuIEpvaG5zb24gPHN0ZXZlbmpAYWx1bS5taXQuZWR1PgogLSBHaWxiZXJ0IFJhbWlyZXogSnIuIDxncmFtQHZlcmRpY3QudXRoc2NzYS5lZHU+CiAtIEFuZHLpcyBHYXJj7WEgPG9ybmFsdXhAcmVkZXN0Yi5lcz4KIC0gRG91Z2xhcyBFLiBXZWdzY2hlaWQgPHdlZ3NjZEB3aGlybHBvb2wuY29tPgogLSBNYXJrIEJ1dGxlciA8YnV0bGVybUB4bWlzc2lvbi5jb20+CiAtIEVyaWMgVGhlbGluIDxlcmljQGdlbmVyYXRpb24taS5jb20+CiAtIE1hcmMgQm91Y2hlciA8bWFyY0BtYnNpLmNhPgogLSBHcmVnIE9udWZlciA8R3JlZy5PbnVmZXJARW5nLlN1bi5DT00+CiAtIERvdWcgS2F1Zm1hbiA8ZGthdWZtYW5AcmFodWwubmV0PgogLSBEYXZpZCBFcmlrc3NvbiA8ZGF2aWRAMmdvb2QuY29tPgogLSBSYWxwaCBCZWNrbWFubiA8cmFiZUB1bmktcGFkZXJib3JuLmRlPgogLSBULiBZYW1hZGEgPHRhaUBpbWFzeS5vci5qcD4KIC0gTGFycyBKLiBBYXMgPGxhcnNhQHNpbS5ubz4KIC0gSvZybiBIYXJ0cm90aCA8Sm9lcm4uSGFydHJvdGhAY29tcHV0ZXIub3JnPgogLSBNYXR0aGV3IENsYXJrZSA8Y2xhbWF0QHZhbi5tYXZlcy5jYT4KIC0gTGludXMgTmllbHNlbiBGZWx0emluZyA8bGludXNAaGF4eC5zZT4KIC0gRmVsaXggdm9uIExlaXRuZXIgPGZlbGl4QGNvbnZlcmdlbmNlLmRlPgogLSBEYW4gWml0dGVyIDxkeml0dGVyQHppdHRlci5uZXQ+CiAtIEpvbmdraSBTdXdhbmRpIDxKb25na2kuU3V3YW5kaUBlbmcuc3VuLmNvbT4KIC0gQ2hyaXMgTWFsdGJ5IDxjaHJpc0BhdXJlbWEuY29tPgogLSBSb24gWmFwcCA8cnphcHBlckB5YWhvby5jb20+CiAtIFBhdWwgTWFycXVpcyA8cG1hcnF1aXNAaW5hbWUuY29tPgogLSBFbGxpcyBQcml0Y2hhcmQgPGVsbGlzQGNpdHJpYS5jb20+CiAtIERhbWllbiBBZGFudCA8ZGFtc0B1c2EubmV0PgogLSBDaHJpcyA8Y2JheWxpc3NAY3NjLmNvbWU+CiAtIE1hcmNvIEcuIFNhbHZhZ25vIDxtZ3NAd2hpei5jamIubmV0PgogLSBQYXVsIE1hcnF1aXMgPHBtYXJxdWlzQGluYW1lLmNvbT4KIC0gRGF2aWQgTGVCbGFuYyA8ZGxlYmxhbmNAcW54LmNvbT4KIC0gUmljaCBHcmF5IGF0IFBsdXMgVGVjaG5vbG9naWVzCiAtIEx1b25nIERpbmggRHVuZyA8dThsdW9uZ0BsaHN5c3RlbXMuaHU+CiAtIFRvcnN0ZW4gRm9lcnRzY2ggPHRvcnN0ZW4uZm9lcnRzY2hAZ214Lm5ldD4KIC0gS3Jpc3RpYW4gS/ZobnRvcHAgPGtyaXNAa29laG50b3BwLmRlPgogLSBGcmVkIE5veiA8Rk5vekBzaWFjLmNvbT4KIC0gQ2FvbGFuIE1jTmFtYXJhIDxjYW9sYW5AY3NuLnVsLmllPgogLSBBbGJlcnQgQ2hpbi1BLVlvdW5nIDxjaGluYUB0aGV3cml0dGVud29yZC5jb20+CiAtIFN0ZXBoZW4gS2ljayA8c2tpY2tAZXBpY3JlYWxtLmNvbT4KIC0gTWFydGluIEhlZGVuZmFsayA8bWhlQHN0YWNrZW4ua3RoLnNlPgogLSBSaWNoYXJkIFByZXNjb3R0CiAtIEphc29uIFMuIFByaWViZSA8cHJpZWJlQHdyYWwtdHYuY29tPgogLSBULiBCaGFyYXRoIDxUQmhhcmF0aEByZXNwb25zZW5ldHdvcmtzLmNvbT4KIC0gQWxleGFuZGVyIEtvdXJha29zIDxhd2tAdXNlcnMuc291cmNlZm9yZ2UubmV0PgogLSBKYW1lcyBHcmlmZml0aHMgPGdyaWZmaXRoc19qYW1lc0B5YWhvby5jb20+CiAtIExvaWMgRGFjaGFyeSA8bG9pY0BzZW5nYS5vcmc+CiAtIFJvYmVydCBXZWF2ZXIgPHJvYmVydC53ZWF2ZXJAc2FicmUuY29tPgogLSBJbmdvIFJhbGYgQmx1bSA8aW5nb3JhbGZibHVtQGluZ29yYWxmYmx1bS5jb20+CiAtIEp1bi1pY2hpcm8gaXRvanVuIEhhZ2lubyA8aXRvanVuQGlpamxhYi5uZXQ+CgouU0ggV1dXCmh0dHA6Ly9jdXJsLmhheHguc2UKLlNIIEZUUApmdHA6Ly9mdHAuc3VuZXQuc2UvcHViL3d3dy91dGlsaXRpZXMvY3VybC8KLlNIICJTRUUgQUxTTyIKLkJSIGZ0cCAoMSksCi5CUiB3Z2V0ICgxKSwKLkJSIHNuYXJmICgxKQo=