SW50cm8KLS0tLS0KVGhpcyBkZXNjcmliZXMgYW4gYWRhcHRpdmUsIHN0YWJsZSwgbmF0dXJhbCBtZXJnZXNvcnQsIG1vZGVzdGx5IGNhbGxlZAp0aW1zb3J0IChoZXksIEkgZWFybmVkIGl0IDx3aW5rPikuICBJdCBoYXMgc3VwZXJuYXR1cmFsIHBlcmZvcm1hbmNlIG9uIG1hbnkKa2luZHMgb2YgcGFydGlhbGx5IG9yZGVyZWQgYXJyYXlzIChsZXNzIHRoYW4gbGcoTiEpIGNvbXBhcmlzb25zIG5lZWRlZCwgYW5kCmFzIGZldyBhcyBOLTEpLCB5ZXQgYXMgZmFzdCBhcyBQeXRob24ncyBwcmV2aW91cyBoaWdobHkgdHVuZWQgc2FtcGxlc29ydApoeWJyaWQgb24gcmFuZG9tIGFycmF5cy4KCkluIGEgbnV0c2hlbGwsIHRoZSBtYWluIHJvdXRpbmUgbWFyY2hlcyBvdmVyIHRoZSBhcnJheSBvbmNlLCBsZWZ0IHRvIHJpZ2h0LAphbHRlcm5hdGVseSBpZGVudGlmeWluZyB0aGUgbmV4dCBydW4sIHRoZW4gbWVyZ2luZyBpdCBpbnRvIHRoZSBwcmV2aW91cwpydW5zICJpbnRlbGxpZ2VudGx5Ii4gIEV2ZXJ5dGhpbmcgZWxzZSBpcyBjb21wbGljYXRpb24gZm9yIHNwZWVkLCBhbmQgc29tZQpoYXJkLXdvbiBtZWFzdXJlIG9mIG1lbW9yeSBlZmZpY2llbmN5LgoKCkNvbXBhcmlzb24gd2l0aCBQeXRob24ncyBTYW1wbGVzb3J0IEh5YnJpZAotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyB0aW1zb3J0IGNhbiByZXF1aXJlIGEgdGVtcCBhcnJheSBjb250YWluaW5nIGFzIG1hbnkgYXMgTi8vMiBwb2ludGVycywKICB3aGljaCBtZWFucyBhcyBtYW55IGFzIDIqTiBleHRyYSBieXRlcyBvbiAzMi1iaXQgYm94ZXMuICBJdCBjYW4gYmUKICBleHBlY3RlZCB0byByZXF1aXJlIGEgdGVtcCBhcnJheSB0aGlzIGxhcmdlIHdoZW4gc29ydGluZyByYW5kb20gZGF0YTsgb24KICBkYXRhIHdpdGggc2lnbmlmaWNhbnQgc3RydWN0dXJlLCBpdCBtYXkgZ2V0IGF3YXkgd2l0aG91dCB1c2luZyBhbnkgZXh0cmEKICBoZWFwIG1lbW9yeS4gIFRoaXMgYXBwZWFycyB0byBiZSB0aGUgc3Ryb25nZXN0IGFyZ3VtZW50IGFnYWluc3QgaXQsIGJ1dAogIGNvbXBhcmVkIHRvIHRoZSBzaXplIG9mIGFuIG9iamVjdCwgMiB0ZW1wIGJ5dGVzIHdvcnN0LWNhc2UgKGFsc28gZXhwZWN0ZWQtCiAgY2FzZSBmb3IgcmFuZG9tIGRhdGEpIGRvZXNuJ3Qgc2NhcmUgbWUgbXVjaC4KCiAgSXQgdHVybnMgb3V0IHRoYXQgUGVybCBpcyBtb3ZpbmcgdG8gYSBzdGFibGUgbWVyZ2Vzb3J0LCBhbmQgdGhlIGNvZGUgZm9yCiAgdGhhdCBhcHBlYXJzIGFsd2F5cyB0byByZXF1aXJlIGEgdGVtcCBhcnJheSB3aXRoIHJvb20gZm9yIGF0IGxlYXN0IE4KICBwb2ludGVycy4gKE5vdGUgdGhhdCBJIHdvdWxkbid0IHdhbnQgdG8gZG8gdGhhdCBldmVuIGlmIHNwYWNlIHdlcmVuJ3QgYW4KICBpc3N1ZTsgSSBiZWxpZXZlIGl0cyBlZmZvcnRzIGF0IG1lbW9yeSBmcnVnYWxpdHkgYWxzbyBzYXZlIHRpbXNvcnQKICBzaWduaWZpY2FudCBwb2ludGVyLWNvcHlpbmcgY29zdHMsIGFuZCBhbGxvdyBpdCB0byBoYXZlIGEgc21hbGxlciB3b3JraW5nCiAgc2V0LikKCisgQWNyb3NzIGFib3V0IGZvdXIgaG91cnMgb2YgZ2VuZXJhdGluZyByYW5kb20gYXJyYXlzLCBhbmQgc29ydGluZyB0aGVtCiAgdW5kZXIgYm90aCBtZXRob2RzLCBzYW1wbGVzb3J0IHJlcXVpcmVkIGFib3V0IDEuNSUgbW9yZSBjb21wYXJpc29ucwogICh0aGUgcHJvZ3JhbSBpcyBhdCB0aGUgZW5kIG9mIHRoaXMgZmlsZSkuCgorIEluIHJlYWwgbGlmZSwgdGhpcyBtYXkgYmUgZmFzdGVyIG9yIHNsb3dlciBvbiByYW5kb20gYXJyYXlzIHRoYW4KICBzYW1wbGVzb3J0IHdhcywgZGVwZW5kaW5nIG9uIHBsYXRmb3JtIHF1aXJrcy4gIFNpbmNlIGl0IGRvZXMgZmV3ZXIKICBjb21wYXJpc29ucyBvbiBhdmVyYWdlLCBpdCBjYW4gYmUgZXhwZWN0ZWQgdG8gZG8gYmV0dGVyIHRoZSBtb3JlCiAgZXhwZW5zaXZlIGEgY29tcGFyaXNvbiBmdW5jdGlvbiBpcy4gIE9UT0gsIGl0IGRvZXMgbW9yZSBkYXRhIG1vdmVtZW50CiAgKHBvaW50ZXIgY29weWluZykgdGhhbiBzYW1wbGVzb3J0LCBhbmQgdGhhdCBtYXkgbmVnYXRlIGl0cyBzbWFsbAogIGNvbXBhcmlzb24gYWR2YW50YWdlIChkZXBlbmRpbmcgb24gcGxhdGZvcm0gcXVpcmtzKSB1bmxlc3MgY29tcGFyaXNvbgogIGlzIHZlcnkgZXhwZW5zaXZlLgoKKyBPbiBhcnJheXMgd2l0aCBtYW55IGtpbmRzIG9mIHByZS1leGlzdGluZyBvcmRlciwgdGhpcyBibG93cyBzYW1wbGVzb3J0IG91dAogIG9mIHRoZSB3YXRlci4gIEl0J3Mgc2lnbmlmaWNhbnRseSBmYXN0ZXIgdGhhbiBzYW1wbGVzb3J0IGV2ZW4gb24gc29tZQogIGNhc2VzIHNhbXBsZXNvcnQgd2FzIHNwZWNpYWwtY2FzaW5nIHRoZSBzbm90IG91dCBvZi4gIEkgYmVsaWV2ZSB0aGF0IGxpc3RzCiAgdmVyeSBvZnRlbiBkbyBoYXZlIGV4cGxvaXRhYmxlIHBhcnRpYWwgb3JkZXIgaW4gcmVhbCBsaWZlLCBhbmQgdGhpcyBpcyB0aGUKICBzdHJvbmdlc3QgYXJndW1lbnQgaW4gZmF2b3Igb2YgdGltc29ydCAoaW5kZWVkLCBzYW1wbGVzb3J0J3Mgc3BlY2lhbCBjYXNlcwogIGZvciBleHRyZW1lIHBhcnRpYWwgb3JkZXIgYXJlIGFwcHJlY2lhdGVkIGJ5IHJlYWwgdXNlcnMsIGFuZCB0aW1zb3J0IGdvZXMKICBtdWNoIGRlZXBlciB0aGFuIHRob3NlLCBpbiBwYXJ0aWN1bGFyIG5hdHVyYWxseSBjb3ZlcmluZyBldmVyeSBjYXNlIHdoZXJlCiAgc29tZW9uZSBoYXMgc3VnZ2VzdGVkICJhbmQgaXQgd291bGQgYmUgY29vbCBpZiBsaXN0LnNvcnQoKSBoYWQgYSBzcGVjaWFsCiAgY2FzZSBmb3IgdGhpcyB0b28gLi4uIGFuZCBmb3IgdGhhdCAuLi4iKS4KCisgSGVyZSBhcmUgZXhhY3QgY29tcGFyaXNvbiBjb3VudHMgYWNyb3NzIGFsbCB0aGUgdGVzdHMgaW4gc29ydHBlcmYucHksCiAgd2hlbiBydW4gd2l0aCBhcmd1bWVudHMgIjE1IDIwIDEiLgoKICBDb2x1bW4gS2V5OgogICAgICAqc29ydDogcmFuZG9tIGRhdGEKICAgICAgXHNvcnQ6IGRlc2NlbmRpbmcgZGF0YQogICAgICAvc29ydDogYXNjZW5kaW5nIGRhdGEKICAgICAgM3NvcnQ6IGFzY2VuZGluZywgdGhlbiAzIHJhbmRvbSBleGNoYW5nZXMKICAgICAgK3NvcnQ6IGFzY2VuZGluZywgdGhlbiAxMCByYW5kb20gYXQgdGhlIGVuZAogICAgICB+c29ydDogbWFueSBkdXBsaWNhdGVzCiAgICAgID1zb3J0OiBhbGwgZXF1YWwKICAgICAgIXNvcnQ6IHdvcnN0IGNhc2Ugc2NlbmFyaW8KCiAgRmlyc3QgdGhlIHRyaXZpYWwgY2FzZXMsIHRyaXZpYWwgZm9yIHNhbXBsZXNvcnQgYmVjYXVzZSBpdCBzcGVjaWFsLWNhc2VkCiAgdGhlbSwgYW5kIHRyaXZpYWwgZm9yIHRpbXNvcnQgYmVjYXVzZSBpdCBuYXR1cmFsbHkgd29ya3Mgb24gcnVucy4gIFdpdGhpbgogIGFuICJuIiBibG9jaywgdGhlIGZpcnN0IGxpbmUgZ2l2ZXMgdGhlICMgb2YgY29tcGFyZXMgZG9uZSBieSBzYW1wbGVzb3J0LAogIHRoZSBzZWNvbmQgbGluZSBieSB0aW1zb3J0LCBhbmQgdGhlIHRoaXJkIGxpbmUgaXMgdGhlIHBlcmNlbnRhZ2UgYnkKICB3aGljaCB0aGUgc2FtcGxlc29ydCBjb3VudCBleGNlZWRzIHRoZSB0aW1zb3J0IGNvdW50OgoKICAgICAgbiAgIFxzb3J0ICAgL3NvcnQgICA9c29ydAotLS0tLS0tICAtLS0tLS0gIC0tLS0tLSAgLS0tLS0tCiAgMzI3NjggICAzMjc2OCAgIDMyNzY3ICAgMzI3NjcgIHNhbXBsZXNvcnQKICAgICAgICAgIDMyNzY3ICAgMzI3NjcgICAzMjc2NyAgdGltc29ydAogICAgICAgICAgMC4wMCUgICAwLjAwJSAgIDAuMDAlICAoc2FtcGxlc29ydCAtIHRpbXNvcnQpIC8gdGltc29ydAoKICA2NTUzNiAgIDY1NTM2ICAgNjU1MzUgICA2NTUzNQogICAgICAgICAgNjU1MzUgICA2NTUzNSAgIDY1NTM1CiAgICAgICAgICAwLjAwJSAgIDAuMDAlICAgMC4wMCUKCiAxMzEwNzIgIDEzMTA3MiAgMTMxMDcxICAxMzEwNzEKICAgICAgICAgMTMxMDcxICAxMzEwNzEgIDEzMTA3MQogICAgICAgICAgMC4wMCUgICAwLjAwJSAgIDAuMDAlCgogMjYyMTQ0ICAyNjIxNDQgIDI2MjE0MyAgMjYyMTQzCiAgICAgICAgIDI2MjE0MyAgMjYyMTQzICAyNjIxNDMKICAgICAgICAgIDAuMDAlICAgMC4wMCUgICAwLjAwJQoKIDUyNDI4OCAgNTI0Mjg4ICA1MjQyODcgIDUyNDI4NwogICAgICAgICA1MjQyODcgIDUyNDI4NyAgNTI0Mjg3CiAgICAgICAgICAwLjAwJSAgIDAuMDAlICAgMC4wMCUKCjEwNDg1NzYgMTA0ODU3NiAxMDQ4NTc1IDEwNDg1NzUKICAgICAgICAxMDQ4NTc1IDEwNDg1NzUgMTA0ODU3NQogICAgICAgICAgMC4wMCUgICAwLjAwJSAgIDAuMDAlCgogIFRoZSBhbGdvcml0aG1zIGFyZSBlZmZlY3RpdmVseSBpZGVudGljYWwgaW4gdGhlc2UgY2FzZXMsIGV4Y2VwdCB0aGF0CiAgdGltc29ydCBkb2VzIG9uZSBsZXNzIGNvbXBhcmUgaW4gXHNvcnQuCgogIE5vdyBmb3IgdGhlIG1vcmUgaW50ZXJlc3RpbmcgY2FzZXMuICBsZyhuISkgaXMgdGhlIGluZm9ybWF0aW9uLXRoZW9yZXRpYwogIGxpbWl0IGZvciB0aGUgYmVzdCBhbnkgY29tcGFyaXNvbi1iYXNlZCBzb3J0aW5nIGFsZ29yaXRobSBjYW4gZG8gb24KICBhdmVyYWdlIChhY3Jvc3MgYWxsIHBlcm11dGF0aW9ucykuICBXaGVuIGEgbWV0aG9kIGdldHMgc2lnbmlmaWNhbnRseQogIGJlbG93IHRoYXQsIGl0J3MgZWl0aGVyIGFzdHJvbm9taWNhbGx5IGx1Y2t5LCBvciBpcyBmaW5kaW5nIGV4cGxvaXRhYmxlCiAgc3RydWN0dXJlIGluIHRoZSBkYXRhLgoKICAgICAgbiAgIGxnKG4hKSAgICAqc29ydCAgICAzc29ydCAgICAgK3NvcnQgICAlc29ydCAgICB+c29ydCAgICAgIXNvcnQKLS0tLS0tLSAgLS0tLS0tLSAgIC0tLS0tLSAgIC0tLS0tLS0gIC0tLS0tLS0gIC0tLS0tLSAgLS0tLS0tLSAgLS0tLS0tLS0KICAzMjc2OCAgIDQ0NDI1NSAgIDQ1MzA5NiAgIDQ1MzYxNCAgICAzMjkwOCAgIDQ1Mjg3MSAgIDEzMDQ5MSAgICA0NjkxNDEgb2xkCiAgICAgICAgICAgICAgICAgICA0NDg4ODUgICAgMzMwMTYgICAgMzMwMDcgICAgNTA0MjYgICAxODIwODMgICAgIDY1NTM0IG5ldwogICAgICAgICAgICAgICAgICAgIDAuOTQlIDEyNzMuOTIlICAgLTAuMzAlICA3OTguMDklICAtMjguMzMlICAgNjE1Ljg3JSAlY2ggZnJvbSBuZXcKCiAgNjU1MzYgICA5NTQwMzcgICA5NzI2OTkgICA5ODE5NDAgICAgNjU2ODYgICA5NzMxMDQgICAyNjAwMjkgICAxMDA0NjA3CiAgICAgICAgICAgICAgICAgICA5NjI5OTEgICAgNjU4MjEgICAgNjU4MDggICAxMDE2NjcgICAzNjQzNDEgICAgMTMxMDcwCiAgICAgICAgICAgICAgICAgICAgMS4wMSUgMTM5MS44MyUgICAtMC4xOSUgIDg1Ny4xNSUgIC0yOC42MyUgICA2NjYuNDclCgogMTMxMDcyICAyMDM5MTM3ICAyMTAxODgxICAyMDkxNDkxICAgMTMxMjMyICAyMDkyODk0ICAgNTU0NzkwICAgMjE2MTM3OQogICAgICAgICAgICAgICAgICAyMDU3NTMzICAgMTMxNDEwICAgMTMxMzYxICAgMjA2MTkzICAgNzI4ODcxICAgIDI2MjE0MgogICAgICAgICAgICAgICAgICAgIDIuMTYlIDE0OTEuNTglICAgLTAuMTAlICA5MTUuMDIlICAtMjMuODglICAgNzI0LjUxJQoKIDI2MjE0NCAgNDM0MDQwOSAgNDQ2NDQ2MCAgNDQwMzIzMyAgIDI2MjMxNCAgNDQ0NTg4NCAgMTEwNzg0MiAgIDQ1ODQ1NjAKICAgICAgICAgICAgICAgICAgNDM3NzQwMiAgIDI2MjQzNyAgIDI2MjQ1OSAgIDQxNjM0NyAgMTQ1Nzk0NSAgICA1MjQyODYKICAgICAgICAgICAgICAgICAgICAxLjk5JSAxNTc3LjgyJSAgIC0wLjA2JSAgOTY3LjgzJSAgLTI0LjAxJSAgIDc3NC40NCUKCiA1MjQyODggIDkyMDUwOTYgIDk0NTMzNTYgIDk0MDg0NjMgICA1MjQ0NjggIDk0NDE5MzAgIDIyMTg1NzcgICA5NjkyMDE1CiAgICAgICAgICAgICAgICAgIDkyNzg3MzQgICA1MjQ1ODAgICA1MjQ2MzMgICA4Mzc5NDcgIDI5MTYxMDcgICAxMDQ4NTc0CiAgICAgICAgICAgICAgICAgICAxLjg4JSAgMTY5My41MiUgICAtMC4wMyUgMTAyNi43OSUgIC0yMy45MiUgICA4MjQuMzAlCgoxMDQ4NTc2IDE5NDU4NzU2IDE5OTUwMjcyIDE5ODM4NTg4ICAxMDQ4NzY2IDE5OTEyMTM0ICA0NDMwNjQ5ICAyMDQzNDIxMgogICAgICAgICAgICAgICAgIDE5NjA2MDI4ICAxMDQ4OTU4ICAxMDQ4OTQxICAxNjk0ODk2ICA1ODMyNDQ1ICAgMjA5NzE1MAogICAgICAgICAgICAgICAgICAgIDEuNzYlIDE3OTEuMjclICAgLTAuMDIlIDEwNzQuODMlICAtMjQuMDMlICAgODc0LjM4JQoKICBEaXNjdXNzaW9uIG9mIGNhc2VzOgoKICAqc29ydDogIFRoZXJlJ3Mgbm8gc3RydWN0dXJlIGluIHJhbmRvbSBkYXRhIHRvIGV4cGxvaXQsIHNvIHRoZSB0aGVvcmV0aWNhbAogIGxpbWl0IGlzIGxnKG4hKS4gIEJvdGggbWV0aG9kcyBnZXQgY2xvc2UgdG8gdGhhdCwgYW5kIHRpbXNvcnQgaXMgaHVnZ2luZwogIGl0IChpbmRlZWQsIGluIGEgKm1hcmdpbmFsKiBzZW5zZSwgaXQncyBhIHNwZWN0YWN1bGFyIGltcHJvdmVtZW50IC0tCiAgdGhlcmUncyBvbmx5IGFib3V0IDElIGxlZnQgYmVmb3JlIGhpdHRpbmcgdGhlIHdhbGwsIGFuZCB0aW1zb3J0IGtub3dzCiAgZGFybmVkIHdlbGwgaXQncyBkb2luZyBjb21wYXJlcyB0aGF0IHdvbid0IHBheSBvbiByYW5kb20gZGF0YSAtLSBidXQgc28KICBkb2VzIHRoZSBzYW1wbGVzb3J0IGh5YnJpZCkuICBGb3IgY29udHJhc3QsIEhvYXJlJ3Mgb3JpZ2luYWwgcmFuZG9tLXBpdm90CiAgcXVpY2tzb3J0IGRvZXMgYWJvdXQgMzklIG1vcmUgY29tcGFyZXMgdGhhbiB0aGUgbGltaXQsIGFuZCB0aGUgbWVkaWFuLW9mLTMKICB2YXJpYW50IGFib3V0IDE5JSBtb3JlLgoKICAzc29ydCwgJXNvcnQsIGFuZCAhc29ydDogIE5vIGNvbnRlc3Q7IHRoZXJlJ3Mgc3RydWN0dXJlIGluIHRoaXMgZGF0YSwgYnV0CiAgbm90IG9mIHRoZSBzcGVjaWZpYyBraW5kcyBzYW1wbGVzb3J0IHNwZWNpYWwtY2FzZXMuICBOb3RlIHRoYXQgc3RydWN0dXJlCiAgaW4gIXNvcnQgd2Fzbid0IHB1dCB0aGVyZSBvbiBwdXJwb3NlIC0tIGl0IHdhcyBjcmFmdGVkIGFzIGEgd29yc3QgY2FzZSBmb3IKICBhIHByZXZpb3VzIHF1aWNrc29ydCBpbXBsZW1lbnRhdGlvbi4gIFRoYXQgdGltc29ydCBuYWlscyBpdCBjYW1lIGFzIGEKICBzdXJwcmlzZSB0byBtZSAoYWx0aG91Z2ggaXQncyBvYnZpb3VzIGluIHJldHJvc3BlY3QpLgoKICArc29ydDogIHNhbXBsZXNvcnQgc3BlY2lhbC1jYXNlcyB0aGlzIGRhdGEsIGFuZCBkb2VzIGEgZmV3IGxlc3MgY29tcGFyZXMKICB0aGFuIHRpbXNvcnQuICBIb3dldmVyLCB0aW1zb3J0IHJ1bnMgdGhpcyBjYXNlIHNpZ25pZmljYW50bHkgZmFzdGVyIG9uIGFsbAogIGJveGVzIHdlIGhhdmUgdGltaW5ncyBmb3IsIGJlY2F1c2UgdGltc29ydCBpcyBpbiB0aGUgYnVzaW5lc3Mgb2YgbWVyZ2luZwogIHJ1bnMgZWZmaWNpZW50bHksIHdoaWxlIHNhbXBsZXNvcnQgZG9lcyBtdWNoIG1vcmUgZGF0YSBtb3ZlbWVudCBpbiB0aGlzCiAgKGZvciBpdCkgc3BlY2lhbCBjYXNlLgoKICB+c29ydDogIHNhbXBsZXNvcnQncyBzcGVjaWFsIGNhc2VzIGZvciBsYXJnZSBtYXNzZXMgb2YgZXF1YWwgZWxlbWVudHMgYXJlCiAgZXh0cmVtZWx5IGVmZmVjdGl2ZSBvbiB+c29ydCdzIHNwZWNpZmljIGRhdGEgcGF0dGVybiwgYW5kIHRpbXNvcnQganVzdAogIGlzbid0IGdvaW5nIHRvIGdldCBjbG9zZSB0byB0aGF0LCBkZXNwaXRlIHRoYXQgaXQncyBjbGVhcmx5IGdldHRpbmcgYQogIGdyZWF0IGRlYWwgb2YgYmVuZWZpdCBvdXQgb2YgdGhlIGR1cGxpY2F0ZXMgKHRoZSAjIG9mIGNvbXBhcmVzIGlzIG11Y2ggbGVzcwogIHRoYW4gbGcobiEpKS4gIH5zb3J0IGhhcyBhIHBlcmZlY3RseSB1bmlmb3JtIGRpc3RyaWJ1dGlvbiBvZiBqdXN0IDQKICBkaXN0aW5jdCB2YWx1ZXMsIGFuZCBhcyB0aGUgZGlzdHJpYnV0aW9uIGdldHMgbW9yZSBza2V3ZWQsIHNhbXBsZXNvcnQncwogIGVxdWFsLWVsZW1lbnQgZ2ltbWlja3MgYmVjb21lIGxlc3MgZWZmZWN0aXZlLCB3aGlsZSB0aW1zb3J0J3MgYWRhcHRpdmUKICBzdHJhdGVnaWVzIGZpbmQgbW9yZSB0byBleHBsb2l0OyBpbiBhIGRhdGFiYXNlIHN1cHBsaWVkIGJ5IEtldmluIEFsdGlzLCBhCiAgc29ydCBvbiBpdHMgaGlnaGx5IHNrZXdlZCAib24gd2hpY2ggc3RvY2sgZXhjaGFuZ2UgZG9lcyB0aGlzIGNvbXBhbnkncwogIHN0b2NrIHRyYWRlPyIgZmllbGQgcmFuIG92ZXIgdHdpY2UgYXMgZmFzdCB1bmRlciB0aW1zb3J0LgoKICBIb3dldmVyLCBkZXNwaXRlIHRoYXQgdGltc29ydCBkb2VzIG1hbnkgbW9yZSBjb21wYXJpc29ucyBvbiB+c29ydCwgYW5kCiAgdGhhdCBvbiBzZXZlcmFsIHBsYXRmb3JtcyB+c29ydCBydW5zIGhpZ2hseSBzaWduaWZpY2FudGx5IHNsb3dlciB1bmRlcgogIHRpbXNvcnQsIG9uIG90aGVyIHBsYXRmb3JtcyB+c29ydCBydW5zIGhpZ2hseSBzaWduaWZpY2FudGx5IGZhc3RlciB1bmRlcgogIHRpbXNvcnQuICBObyBvdGhlciBraW5kIG9mIGRhdGEgaGFzIHNob3duIHRoaXMgd2lsZCB4LXBsYXRmb3JtIGJlaGF2aW9yLAogIGFuZCB3ZSBkb24ndCBoYXZlIGFuIGV4cGxhbmF0aW9uIGZvciBpdC4gIFRoZSBvbmx5IHRoaW5nIEkgY2FuIHRoaW5rIG9mCiAgdGhhdCBjb3VsZCB0cmFuc2Zvcm0gd2hhdCAic2hvdWxkIGJlIiBoaWdobHkgc2lnbmlmaWNhbnQgc2xvd2Rvd25zIGludG8KICBoaWdobHkgc2lnbmlmaWNhbnQgc3BlZWR1cHMgb24gc29tZSBib3hlcyBhcmUgY2F0YXN0cm9waGljIGNhY2hlIGVmZmVjdHMKICBpbiBzYW1wbGVzb3J0LgoKICBCdXQgdGltc29ydCAic2hvdWxkIGJlIiBzbG93ZXIgdGhhbiBzYW1wbGVzb3J0IG9uIH5zb3J0LCBzbyBpdCdzIGhhcmQKICB0byBjb3VudCB0aGF0IGl0IGlzbid0IG9uIHNvbWUgYm94ZXMgYXMgYSBzdHJpa2UgYWdhaW5zdCBpdCA8d2luaz4uCgorIEhlcmUncyB0aGUgaGlnaHdhdGVyIG1hcmsgZm9yIHRoZSBudW1iZXIgb2YgaGVhcC1iYXNlZCB0ZW1wIHNsb3RzICg0CiAgYnl0ZXMgZWFjaCBvbiB0aGlzIGJveCkgbmVlZGVkIGJ5IGVhY2ggdGVzdCwgYWdhaW4gd2l0aCBhcmd1bWVudHMKICAiMTUgMjAgMSI6CgogICAyKippICAqc29ydCBcc29ydCAvc29ydCAgM3NvcnQgICtzb3J0ICAlc29ydCAgfnNvcnQgID1zb3J0ICAhc29ydAogIDMyNzY4ICAxNjM4NCAgICAgMCAgICAgMCAgIDYyNTYgICAgICAwICAxMDgyMSAgMTIyODggICAgICAwICAxNjM4MwogIDY1NTM2ICAzMjc2NiAgICAgMCAgICAgMCAgMjE2NTIgICAgICAwICAzMTI3NiAgMjQ1NzYgICAgICAwICAzMjc2NwogMTMxMDcyICA2NTUzNCAgICAgMCAgICAgMCAgMTcyNTggICAgICAwICA1ODExMiAgNDkxNTIgICAgICAwICA2NTUzNQogMjYyMTQ0IDEzMTA3MiAgICAgMCAgICAgMCAgMzU2NjAgICAgICAwIDEyMzU2MSAgOTgzMDQgICAgICAwIDEzMTA3MQogNTI0Mjg4IDI2MjE0MiAgICAgMCAgICAgMCAgMzEzMDIgICAgICAwIDIxMjA1NyAxOTY2MDggICAgICAwIDI2MjE0MwoxMDQ4NTc2IDUyNDI4NiAgICAgMCAgICAgMCAzMTI0MzggICAgICAwIDQ4NDk0MiAzOTMyMTYgICAgICAwIDUyNDI4NwoKICBEaXNjdXNzaW9uOiAgVGhlIHRlc3RzIHRoYXQgZW5kIHVwIGRvaW5nIChjbG9zZSB0bykgcGVyZmVjdGx5IGJhbGFuY2VkCiAgbWVyZ2VzICgqc29ydCwgIXNvcnQpIG5lZWQgYWxsIE4vLzIgdGVtcCBzbG90cyAob3IgYWxtb3N0IGFsbCkuICB+c29ydAogIGFsc28gZW5kcyB1cCBkb2luZyBiYWxhbmNlZCBtZXJnZXMsIGJ1dCBzeXN0ZW1hdGljYWxseSBiZW5lZml0cyBhIGxvdCBmcm9tCiAgdGhlIHByZWxpbWluYXJ5IHByZS1tZXJnZSBzZWFyY2hlcyBkZXNjcmliZWQgdW5kZXIgIk1lcmdlIE1lbW9yeSIgbGF0ZXIuCiAgJXNvcnQgYXBwcm9hY2hlcyBoYXZpbmcgYSBiYWxhbmNlZCBtZXJnZSBhdCB0aGUgZW5kIGJlY2F1c2UgdGhlIHJhbmRvbQogIHNlbGVjdGlvbiBvZiBlbGVtZW50cyB0byByZXBsYWNlIGlzIGV4cGVjdGVkIHRvIHByb2R1Y2UgYW4gb3V0LW9mLW9yZGVyCiAgZWxlbWVudCBuZWFyIHRoZSBtaWRwb2ludC4gIFxzb3J0LCAvc29ydCwgPXNvcnQgYXJlIHRoZSB0cml2aWFsIG9uZS1ydW4KICBjYXNlcywgbmVlZGluZyBubyBtZXJnaW5nIGF0IGFsbC4gICtzb3J0IGVuZHMgdXAgaGF2aW5nIG9uZSB2ZXJ5IGxvbmcgcnVuCiAgYW5kIG9uZSB2ZXJ5IHNob3J0LCBhbmQgc28gZ2V0cyBhbGwgdGhlIHRlbXAgc3BhY2UgaXQgbmVlZHMgZnJvbSB0aGUgc21hbGwKICB0ZW1wYXJyYXkgbWVtYmVyIG9mIHRoZSBNZXJnZVN0YXRlIHN0cnVjdCAobm90ZSB0aGF0IHRoZSBzYW1lIHdvdWxkIGJlCiAgdHJ1ZSBpZiB0aGUgbmV3IHJhbmRvbSBlbGVtZW50cyB3ZXJlIHByZWZpeGVkIHRvIHRoZSBzb3J0ZWQgbGlzdCBpbnN0ZWFkLAogIGJ1dCBub3QgaWYgdGhleSBhcHBlYXJlZCAiaW4gdGhlIG1pZGRsZSIpLiAgM3NvcnQgYXBwcm9hY2hlcyBOLy8zIHRlbXAKICBzbG90cyB0d2ljZSwgYnV0IHRoZSBydW4gbGVuZ3RocyB0aGF0IHJlbWFpbiBhZnRlciAzIHJhbmRvbSBleGNoYW5nZXMKICBjbGVhcmx5IGhhcyB2ZXJ5IGhpZ2ggdmFyaWFuY2UuCgoKQSBkZXRhaWxlZCBkZXNjcmlwdGlvbiBvZiB0aW1zb3J0IGZvbGxvd3MuCgpSdW5zCi0tLS0KY291bnRfcnVuKCkgcmV0dXJucyB0aGUgIyBvZiBlbGVtZW50cyBpbiB0aGUgbmV4dCBydW4uICBBIHJ1biBpcyBlaXRoZXIKImFzY2VuZGluZyIsIHdoaWNoIG1lYW5zIG5vbi1kZWNyZWFzaW5nOgoKICAgIGEwIDw9IGExIDw9IGEyIDw9IC4uLgoKb3IgImRlc2NlbmRpbmciLCB3aGljaCBtZWFucyBzdHJpY3RseSBkZWNyZWFzaW5nOgoKICAgIGEwID4gYTEgPiBhMiA+IC4uLgoKTm90ZSB0aGF0IGEgcnVuIGlzIGFsd2F5cyBhdCBsZWFzdCAyIGxvbmcsIHVubGVzcyB3ZSBzdGFydCBhdCB0aGUgYXJyYXkncwpsYXN0IGVsZW1lbnQuCgpUaGUgZGVmaW5pdGlvbiBvZiBkZXNjZW5kaW5nIGlzIHN0cmljdCwgYmVjYXVzZSB0aGUgbWFpbiByb3V0aW5lIHJldmVyc2VzCmEgZGVzY2VuZGluZyBydW4gaW4tcGxhY2UsIHRyYW5zZm9ybWluZyBhIGRlc2NlbmRpbmcgcnVuIGludG8gYW4gYXNjZW5kaW5nCnJ1bi4gIFJldmVyc2FsIGlzIGRvbmUgdmlhIHRoZSBvYnZpb3VzIGZhc3QgInN3YXAgZWxlbWVudHMgc3RhcnRpbmcgYXQgZWFjaAplbmQsIGFuZCBjb252ZXJnZSBhdCB0aGUgbWlkZGxlIiBtZXRob2QsIGFuZCB0aGF0IGNhbiB2aW9sYXRlIHN0YWJpbGl0eSBpZgp0aGUgc2xpY2UgY29udGFpbnMgYW55IGVxdWFsIGVsZW1lbnRzLiAgVXNpbmcgYSBzdHJpY3QgZGVmaW5pdGlvbiBvZgpkZXNjZW5kaW5nIGVuc3VyZXMgdGhhdCBhIGRlc2NlbmRpbmcgcnVuIGNvbnRhaW5zIGRpc3RpbmN0IGVsZW1lbnRzLgoKSWYgYW4gYXJyYXkgaXMgcmFuZG9tLCBpdCdzIHZlcnkgdW5saWtlbHkgd2UnbGwgc2VlIGxvbmcgcnVucy4gIElmIGEgbmF0dXJhbApydW4gY29udGFpbnMgbGVzcyB0aGFuIG1pbnJ1biBlbGVtZW50cyAoc2VlIG5leHQgc2VjdGlvbiksIHRoZSBtYWluIGxvb3AKYXJ0aWZpY2lhbGx5IGJvb3N0cyBpdCB0byBtaW5ydW4gZWxlbWVudHMsIHZpYSBhIHN0YWJsZSBiaW5hcnkgaW5zZXJ0aW9uIHNvcnQKYXBwbGllZCB0byB0aGUgcmlnaHQgbnVtYmVyIG9mIGFycmF5IGVsZW1lbnRzIGZvbGxvd2luZyB0aGUgc2hvcnQgbmF0dXJhbApydW4uICBJbiBhIHJhbmRvbSBhcnJheSwgKmFsbCogcnVucyBhcmUgbGlrZWx5IHRvIGJlIG1pbnJ1biBsb25nIGFzIGEKcmVzdWx0LiAgVGhpcyBoYXMgdHdvIHByaW1hcnkgZ29vZCBlZmZlY3RzOgoKMS4gUmFuZG9tIGRhdGEgc3Ryb25nbHkgdGVuZHMgdGhlbiB0b3dhcmQgcGVyZmVjdGx5IGJhbGFuY2VkIChib3RoIHJ1bnMgaGF2ZQogICB0aGUgc2FtZSBsZW5ndGgpIG1lcmdlcywgd2hpY2ggaXMgdGhlIG1vc3QgZWZmaWNpZW50IHdheSB0byBwcm9jZWVkIHdoZW4KICAgZGF0YSBpcyByYW5kb20uCgoyLiBCZWNhdXNlIHJ1bnMgYXJlIG5ldmVyIHZlcnkgc2hvcnQsIHRoZSByZXN0IG9mIHRoZSBjb2RlIGRvZXNuJ3QgbWFrZQogICBoZXJvaWMgZWZmb3J0cyB0byBzaGF2ZSBhIGZldyBjeWNsZXMgb2ZmIHBlci1tZXJnZSBvdmVyaGVhZHMuICBGb3IKICAgZXhhbXBsZSwgcmVhc29uYWJsZSB1c2Ugb2YgZnVuY3Rpb24gY2FsbHMgaXMgbWFkZSwgcmF0aGVyIHRoYW4gdHJ5aW5nIHRvCiAgIGlubGluZSBldmVyeXRoaW5nLiAgU2luY2UgdGhlcmUgYXJlIG5vIG1vcmUgdGhhbiBOL21pbnJ1biBydW5zIHRvIGJlZ2luCiAgIHdpdGgsIGEgZmV3ICJleHRyYSIgZnVuY3Rpb24gY2FsbHMgcGVyIG1lcmdlIGlzIGJhcmVseSBtZWFzdXJhYmxlLgoKCkNvbXB1dGluZyBtaW5ydW4KLS0tLS0tLS0tLS0tLS0tLQpJZiBOIDwgNjQsIG1pbnJ1biBpcyBOLiAgSU9XLCBiaW5hcnkgaW5zZXJ0aW9uIHNvcnQgaXMgdXNlZCBmb3IgdGhlIHdob2xlCmFycmF5IHRoZW47IGl0J3MgaGFyZCB0byBiZWF0IHRoYXQgZ2l2ZW4gdGhlIG92ZXJoZWFkcyBvZiB0cnlpbmcgc29tZXRoaW5nCmZhbmNpZXIuCgpXaGVuIE4gaXMgYSBwb3dlciBvZiAyLCB0ZXN0aW5nIG9uIHJhbmRvbSBkYXRhIHNob3dlZCB0aGF0IG1pbnJ1biB2YWx1ZXMgb2YKMTYsIDMyLCA2NCBhbmQgMTI4IHdvcmtlZCBhYm91dCBlcXVhbGx5IHdlbGwuICBBdCAyNTYgdGhlIGRhdGEtbW92ZW1lbnQgY29zdAppbiBiaW5hcnkgaW5zZXJ0aW9uIHNvcnQgY2xlYXJseSBodXJ0LCBhbmQgYXQgOCB0aGUgaW5jcmVhc2UgaW4gdGhlIG51bWJlcgpvZiBmdW5jdGlvbiBjYWxscyBjbGVhcmx5IGh1cnQuICBQaWNraW5nICpzb21lKiBwb3dlciBvZiAyIGlzIGltcG9ydGFudApoZXJlLCBzbyB0aGF0IHRoZSBtZXJnZXMgZW5kIHVwIHBlcmZlY3RseSBiYWxhbmNlZCAoc2VlIG5leHQgc2VjdGlvbikuICBXZQpwaWNrIDMyIGFzIGEgZ29vZCB2YWx1ZSBpbiB0aGUgc3dlZXQgcmFuZ2U7IHBpY2tpbmcgYSB2YWx1ZSBhdCB0aGUgbG93IGVuZAphbGxvd3MgdGhlIGFkYXB0aXZlIGdpbW1pY2tzIG1vcmUgb3Bwb3J0dW5pdHkgdG8gZXhwbG9pdCBzaG9ydGVyIG5hdHVyYWwKcnVucy4KCkJlY2F1c2Ugc29ydHBlcmYucHkgb25seSB0cmllcyBwb3dlcnMgb2YgMiwgaXQgdG9vayBhIGxvbmcgdGltZSB0byBub3RpY2UKdGhhdCAzMiBpc24ndCBhIGdvb2QgY2hvaWNlIGZvciB0aGUgZ2VuZXJhbCBjYXNlISAgQ29uc2lkZXIgTj0yMTEyOgoKPj4+IGRpdm1vZCgyMTEyLCAzMikKKDY2LCAwKQo+Pj4KCklmIHRoZSBkYXRhIGlzIHJhbmRvbWx5IG9yZGVyZWQsIHdlJ3JlIHZlcnkgbGlrZWx5IHRvIGVuZCB1cCB3aXRoIDY2IHJ1bnMKZWFjaCBvZiBsZW5ndGggMzIuICBUaGUgZmlyc3QgNjQgb2YgdGhlc2UgdHJpZ2dlciBhIHNlcXVlbmNlIG9mIHBlcmZlY3RseQpiYWxhbmNlZCBtZXJnZXMgKHNlZSBuZXh0IHNlY3Rpb24pLCBsZWF2aW5nIHJ1bnMgb2YgbGVuZ3RocyAyMDQ4IGFuZCA2NCB0bwptZXJnZSBhdCB0aGUgZW5kLiAgVGhlIGFkYXB0aXZlIGdpbW1pY2tzIGNhbiBkbyB0aGF0IHdpdGggZmV3ZXIgdGhhbiAyMDQ4KzY0CmNvbXBhcmVzLCBidXQgaXQncyBzdGlsbCBtb3JlIGNvbXBhcmVzIHRoYW4gbmVjZXNzYXJ5LCBhbmQtLSBtZXJnZXNvcnQncwpidWdhYm9vIHJlbGF0aXZlIHRvIHNhbXBsZXNvcnQgLS1hIGxvdCBtb3JlIGRhdGEgbW92ZW1lbnQgKE8oTikgY29waWVzIGp1c3QKdG8gZ2V0IDY0IGVsZW1lbnRzIGludG8gcGxhY2UpLgoKSWYgd2UgdGFrZSBtaW5ydW49MzMgaW4gdGhpcyBjYXNlLCB0aGVuIHdlJ3JlIHZlcnkgbGlrZWx5IHRvIGVuZCB1cCB3aXRoIDY0CnJ1bnMgZWFjaCBvZiBsZW5ndGggMzMsIGFuZCB0aGVuIGFsbCBtZXJnZXMgYXJlIHBlcmZlY3RseSBiYWxhbmNlZC4gIEJldHRlciEKCldoYXQgd2Ugd2FudCB0byBhdm9pZCBpcyBwaWNraW5nIG1pbnJ1biBzdWNoIHRoYXQgaW4KCiAgICBxLCByID0gZGl2bW9kKE4sIG1pbnJ1bikKCnEgaXMgYSBwb3dlciBvZiAyIGFuZCByPjAgKHRoZW4gdGhlIGxhc3QgbWVyZ2Ugb25seSBnZXRzIHIgZWxlbWVudHMgaW50bwpwbGFjZSwgYW5kIHIgPCBtaW5ydW4gaXMgc21hbGwgY29tcGFyZWQgdG8gTiksIG9yIHEgYSBsaXR0bGUgbGFyZ2VyIHRoYW4gYQpwb3dlciBvZiAyIHJlZ2FyZGxlc3Mgb2YgciAodGhlbiB3ZSd2ZSBnb3QgYSBjYXNlIHNpbWlsYXIgdG8gIjIxMTIiLCBhZ2FpbgpsZWF2aW5nIHRvbyBsaXR0bGUgd29yayBmb3IgdGhlIGxhc3QgbWVyZ2UgdG8gZG8pLgoKSW5zdGVhZCB3ZSBwaWNrIGEgbWlucnVuIGluIHJhbmdlKDMyLCA2NSkgc3VjaCB0aGF0IE4vbWlucnVuIGlzIGV4YWN0bHkgYQpwb3dlciBvZiAyLCBvciBpZiB0aGF0IGlzbid0IHBvc3NpYmxlLCBpcyBjbG9zZSB0bywgYnV0IHN0cmljdGx5IGxlc3MgdGhhbiwKYSBwb3dlciBvZiAyLiAgVGhpcyBpcyBlYXNpZXIgdG8gZG8gdGhhbiBpdCBtYXkgc291bmQ6ICB0YWtlIHRoZSBmaXJzdCA2CmJpdHMgb2YgTiwgYW5kIGFkZCAxIGlmIGFueSBvZiB0aGUgcmVtYWluaW5nIGJpdHMgYXJlIHNldC4gIEluIGZhY3QsIHRoYXQKcnVsZSBjb3ZlcnMgZXZlcnkgY2FzZSBpbiB0aGlzIHNlY3Rpb24sIGluY2x1ZGluZyBzbWFsbCBOIGFuZCBleGFjdCBwb3dlcnMKb2YgMjsgbWVyZ2VfY29tcHV0ZV9taW5ydW4oKSBpcyBhIGRlY2VwdGl2ZWx5IHNpbXBsZSBmdW5jdGlvbi4KCgpUaGUgTWVyZ2UgUGF0dGVybgotLS0tLS0tLS0tLS0tLS0tLQpJbiBvcmRlciB0byBleHBsb2l0IHJlZ3VsYXJpdGllcyBpbiB0aGUgZGF0YSwgd2UncmUgbWVyZ2luZyBvbiBuYXR1cmFsCnJ1biBsZW5ndGhzLCBhbmQgdGhleSBjYW4gYmVjb21lIHdpbGRseSB1bmJhbGFuY2VkLiAgVGhhdCdzIGEgR29vZCBUaGluZwpmb3IgdGhpcyBzb3J0ISAgSXQgbWVhbnMgd2UgaGF2ZSB0byBmaW5kIGEgd2F5IHRvIG1hbmFnZSBhbiBhc3NvcnRtZW50IG9mCnBvdGVudGlhbGx5IHZlcnkgZGlmZmVyZW50IHJ1biBsZW5ndGhzLCB0aG91Z2guCgpTdGFiaWxpdHkgY29uc3RyYWlucyBwZXJtaXNzaWJsZSBtZXJnaW5nIHBhdHRlcm5zLiAgRm9yIGV4YW1wbGUsIGlmIHdlIGhhdmUKMyBjb25zZWN1dGl2ZSBydW5zIG9mIGxlbmd0aHMKCiAgICBBOjEwMDAwICBCOjIwMDAwICBDOjEwMDAwCgp3ZSBkYXJlIG5vdCBtZXJnZSBBIHdpdGggQyBmaXJzdCwgYmVjYXVzZSBpZiBBLCBCIGFuZCBDIGhhcHBlbiB0byBjb250YWluCmEgY29tbW9uIGVsZW1lbnQsIGl0IHdvdWxkIGdldCBvdXQgb2Ygb3JkZXIgd3J0IGl0cyBvY2N1cmVuY2UocykgaW4gQi4gIFRoZQptZXJnaW5nIG11c3QgYmUgZG9uZSBhcyAoQStCKStDIG9yIEErKEIrQykgaW5zdGVhZC4KClNvIG1lcmdpbmcgaXMgYWx3YXlzIGRvbmUgb24gdHdvIGNvbnNlY3V0aXZlIHJ1bnMgYXQgYSB0aW1lLCBhbmQgaW4tcGxhY2UsCmFsdGhvdWdoIHRoaXMgbWF5IHJlcXVpcmUgc29tZSB0ZW1wIG1lbW9yeSAobW9yZSBvbiB0aGF0IGxhdGVyKS4KCldoZW4gYSBydW4gaXMgaWRlbnRpZmllZCwgaXRzIGJhc2UgYWRkcmVzcyBhbmQgbGVuZ3RoIGFyZSBwdXNoZWQgb24gYSBzdGFjawppbiB0aGUgTWVyZ2VTdGF0ZSBzdHJ1Y3QuICBtZXJnZV9jb2xsYXBzZSgpIGlzIHRoZW4gY2FsbGVkIHRvIHNlZSB3aGV0aGVyIGl0CnNob3VsZCBtZXJnZSBpdCB3aXRoIHByZWNlZGluZyBydW4ocykuICBXZSB3b3VsZCBsaWtlIHRvIGRlbGF5IG1lcmdpbmcgYXMKbG9uZyBhcyBwb3NzaWJsZSBpbiBvcmRlciB0byBleHBsb2l0IHBhdHRlcm5zIHRoYXQgbWF5IGNvbWUgdXAgbGF0ZXIsIGJ1dCB3ZQpsaWtlIGV2ZW4gbW9yZSB0byBkbyBtZXJnaW5nIGFzIHNvb24gYXMgcG9zc2libGUgdG8gZXhwbG9pdCB0aGF0IHRoZSBydW4ganVzdApmb3VuZCBpcyBzdGlsbCBoaWdoIGluIHRoZSBtZW1vcnkgaGllcmFyY2h5LiAgV2UgYWxzbyBjYW4ndCBkZWxheSBtZXJnaW5nCiJ0b28gbG9uZyIgYmVjYXVzZSBpdCBjb25zdW1lcyBtZW1vcnkgdG8gcmVtZW1iZXIgdGhlIHJ1bnMgdGhhdCBhcmUgc3RpbGwKdW5tZXJnZWQsIGFuZCB0aGUgc3RhY2sgaGFzIGEgZml4ZWQgc2l6ZS4KCldoYXQgdHVybmVkIG91dCB0byBiZSBhIGdvb2QgY29tcHJvbWlzZSBtYWludGFpbnMgdHdvIGludmFyaWFudHMgb24gdGhlCnN0YWNrIGVudHJpZXMsIHdoZXJlIEEsIEIgYW5kIEMgYXJlIHRoZSBsZW5ndGhzIG9mIHRoZSB0aHJlZSByaWdobW9zdCBub3QteWV0Cm1lcmdlZCBzbGljZXM6CgoxLiAgQSA+IEIrQwoyLiAgQiA+IEMKCk5vdGUgdGhhdCwgYnkgaW5kdWN0aW9uLCAjMiBpbXBsaWVzIHRoZSBsZW5ndGhzIG9mIHBlbmRpbmcgcnVucyBmb3JtIGEKZGVjcmVhc2luZyBzZXF1ZW5jZS4gICMxIGltcGxpZXMgdGhhdCwgcmVhZGluZyB0aGUgbGVuZ3RocyByaWdodCB0byBsZWZ0LAp0aGUgcGVuZGluZy1ydW4gbGVuZ3RocyBncm93IGF0IGxlYXN0IGFzIGZhc3QgYXMgdGhlIEZpYm9uYWNjaSBudW1iZXJzLgpUaGVyZWZvcmUgdGhlIHN0YWNrIGNhbiBuZXZlciBncm93IGxhcmdlciB0aGFuIGFib3V0IGxvZ19iYXNlX3BoaShOKSBlbnRyaWVzLAp3aGVyZSBwaGkgPSAoMStzcXJ0KDUpKS8yIH49IDEuNjE4LiAgVGh1cyBhIHNtYWxsICMgb2Ygc3RhY2sgc2xvdHMgc3VmZmljZQpmb3IgdmVyeSBsYXJnZSBhcnJheXMuCgpJZiBBIDw9IEIrQywgdGhlIHNtYWxsZXIgb2YgQSBhbmQgQyBpcyBtZXJnZWQgd2l0aCBCICh0aWVzIGZhdm9yIEMsIGZvciB0aGUKZnJlc2huZXNzLWluLWNhY2hlIHJlYXNvbiksIGFuZCB0aGUgbmV3IHJ1biByZXBsYWNlcyB0aGUgQSxCIG9yIEIsQyBlbnRyaWVzOwplLmcuLCBpZiB0aGUgbGFzdCAzIGVudHJpZXMgYXJlCgogICAgQTozMCAgQjoyMCAgQzoxMAoKdGhlbiBCIGlzIG1lcmdlZCB3aXRoIEMsIGxlYXZpbmcKCiAgICBBOjMwICBCQzozMAoKb24gdGhlIHN0YWNrLiAgT3IgaWYgdGhleSB3ZXJlCgogICAgQTo1MDAgIEI6NDAwOiAgQzoxMDAwCgp0aGVuIEEgaXMgbWVyZ2VkIHdpdGggQiwgbGVhdmluZwoKICAgIEFCOjkwMCAgQzoxMDAwCgpvbiB0aGUgc3RhY2suCgpJbiBib3RoIGV4YW1wbGVzLCB0aGUgc3RhY2sgY29uZmlndXJhdGlvbiBhZnRlciB0aGUgbWVyZ2Ugc3RpbGwgdmlvbGF0ZXMKaW52YXJpYW50ICMyLCBhbmQgbWVyZ2VfY29sbGFwc2UoKSBnb2VzIG9uIHRvIGNvbnRpbnVlIG1lcmdpbmcgcnVucyB1bnRpbApib3RoIGludmFyaWFudHMgYXJlIHNhdGlzZmllZC4gIEFzIGFuIGV4dHJlbWUgY2FzZSwgc3VwcG9zZSB3ZSBkaWRuJ3QgZG8gdGhlCm1pbnJ1biBnaW1taWNrLCBhbmQgbmF0dXJhbCBydW5zIHdlcmUgb2YgbGVuZ3RocyAxMjgsIDY0LCAzMiwgMTYsIDgsIDQsIDIsCmFuZCAyLiAgTm90aGluZyB3b3VsZCBnZXQgbWVyZ2VkIHVudGlsIHRoZSBmaW5hbCAyIHdhcyBzZWVuLCBhbmQgdGhhdCB3b3VsZAp0cmlnZ2VyIDcgcGVyZmVjdGx5IGJhbGFuY2VkIG1lcmdlcy4KClRoZSB0aHJ1c3Qgb2YgdGhlc2UgcnVsZXMgd2hlbiB0aGV5IHRyaWdnZXIgbWVyZ2luZyBpcyB0byBiYWxhbmNlIHRoZSBydW4KbGVuZ3RocyBhcyBjbG9zZWx5IGFzIHBvc3NpYmxlLCB3aGlsZSBrZWVwaW5nIGEgbG93IGJvdW5kIG9uIHRoZSBudW1iZXIgb2YKcnVucyB3ZSBoYXZlIHRvIHJlbWVtYmVyLiAgVGhpcyBpcyBtYXhpbWFsbHkgZWZmZWN0aXZlIGZvciByYW5kb20gZGF0YSwKd2hlcmUgYWxsIHJ1bnMgYXJlIGxpa2VseSB0byBiZSBvZiAoYXJ0aWZpY2lhbGx5IGZvcmNlZCkgbGVuZ3RoIG1pbnJ1biwgYW5kCnRoZW4gd2UgZ2V0IGEgc2VxdWVuY2Ugb2YgcGVyZmVjdGx5IGJhbGFuY2VkIG1lcmdlcyAod2l0aCwgcGVyaGFwcywgc29tZQpvZGRiYWxscyBhdCB0aGUgZW5kKS4KCk9UT0gsIG9uZSByZWFzb24gdGhpcyBzb3J0IGlzIHNvIGdvb2QgZm9yIHBhcnRseSBvcmRlcmVkIGRhdGEgaGFzIHRvIGRvCndpdGggd2lsZGx5IHVuYmFsYW5jZWQgcnVuIGxlbmd0aHMuCgoKTWVyZ2UgTWVtb3J5Ci0tLS0tLS0tLS0tLQpNZXJnaW5nIGFkamFjZW50IHJ1bnMgb2YgbGVuZ3RocyBBIGFuZCBCIGluLXBsYWNlIGlzIHZlcnkgZGlmZmljdWx0LgpUaGVvcmV0aWNhbCBjb25zdHJ1Y3Rpb25zIGFyZSBrbm93biB0aGF0IGNhbiBkbyBpdCwgYnV0IHRoZXkncmUgdG9vIGRpZmZpY3VsdAphbmQgc2xvdyBmb3IgcHJhY3RpY2FsIHVzZS4gIEJ1dCBpZiB3ZSBoYXZlIHRlbXAgbWVtb3J5IGVxdWFsIHRvIG1pbihBLCBCKSwKaXQncyBlYXN5LgoKSWYgQSBpcyBzbWFsbGVyIChmdW5jdGlvbiBtZXJnZV9sbyksIGNvcHkgQSB0byBhIHRlbXAgYXJyYXksIGxlYXZlIEIgYWxvbmUsCmFuZCB0aGVuIHdlIGNhbiBkbyB0aGUgb2J2aW91cyBtZXJnZSBhbGdvcml0aG0gbGVmdCB0byByaWdodCwgZnJvbSB0aGUgdGVtcAphcmVhIGFuZCBCLCBzdGFydGluZyB0aGUgc3RvcmVzIGludG8gd2hlcmUgQSB1c2VkIHRvIGxpdmUuICBUaGVyZSdzIGFsd2F5cyBhCmZyZWUgYXJlYSBpbiB0aGUgb3JpZ2luYWwgYXJlYSBjb21wcmlzaW5nIGEgbnVtYmVyIG9mIGVsZW1lbnRzIGVxdWFsIHRvIHRoZQpudW1iZXIgbm90IHlldCBtZXJnZWQgZnJvbSB0aGUgdGVtcCBhcnJheSAodHJpdmlhbGx5IHRydWUgYXQgdGhlIHN0YXJ0Owpwcm9jZWVkIGJ5IGluZHVjdGlvbikuICBUaGUgb25seSB0cmlja3kgYml0IGlzIHRoYXQgaWYgYSBjb21wYXJpc29uIHJhaXNlcyBhbgpleGNlcHRpb24sIHdlIGhhdmUgdG8gcmVtZW1iZXIgdG8gY29weSB0aGUgcmVtYWluaW5nIGVsZW1lbnRzIGJhY2sgaW4gZnJvbQp0aGUgdGVtcCBhcmVhLCBsZXN0IHRoZSBhcnJheSBlbmQgdXAgd2l0aCBkdXBsaWNhdGUgZW50cmllcyBmcm9tIEIuICBCdXQKdGhhdCdzIGV4YWN0bHkgdGhlIHNhbWUgdGhpbmcgd2UgbmVlZCB0byBkbyBpZiB3ZSByZWFjaCB0aGUgZW5kIG9mIEIgZmlyc3QsCnNvIHRoZSBleGl0IGNvZGUgaXMgcGxlYXNhbnRseSBjb21tb24gdG8gYm90aCB0aGUgbm9ybWFsIGFuZCBlcnJvciBjYXNlcy4KCklmIEIgaXMgc21hbGxlciAoZnVuY3Rpb24gbWVyZ2VfaGksIHdoaWNoIGlzIG1lcmdlX2xvJ3MgIm1pcnJvciBpbWFnZSIpLAptdWNoIHRoZSBzYW1lLCBleGNlcHQgdGhhdCB3ZSBuZWVkIHRvIG1lcmdlIHJpZ2h0IHRvIGxlZnQsIGNvcHlpbmcgQiBpbnRvIGEKdGVtcCBhcnJheSBhbmQgc3RhcnRpbmcgdGhlIHN0b3JlcyBhdCB0aGUgcmlnaHQgZW5kIG9mIHdoZXJlIEIgdXNlZCB0byBsaXZlLgoKQSByZWZpbmVtZW50OiAgV2hlbiB3ZSdyZSBhYm91dCB0byBtZXJnZSBhZGphY2VudCBydW5zIEEgYW5kIEIsIHdlIGZpcnN0IGRvCmEgZm9ybSBvZiBiaW5hcnkgc2VhcmNoIChtb3JlIG9uIHRoYXQgbGF0ZXIpIHRvIHNlZSB3aGVyZSBCWzBdIHNob3VsZCBlbmQgdXAKaW4gQS4gIEVsZW1lbnRzIGluIEEgcHJlY2VkaW5nIHRoYXQgcG9pbnQgYXJlIGFscmVhZHkgaW4gdGhlaXIgZmluYWwKcG9zaXRpb25zLCBlZmZlY3RpdmVseSBzaHJpbmtpbmcgdGhlIHNpemUgb2YgQS4gIExpa2V3aXNlIHdlIGFsc28gc2VhcmNoIHRvCnNlZSB3aGVyZSBBWy0xXSBzaG91bGQgZW5kIHVwIGluIEIsIGFuZCBlbGVtZW50cyBvZiBCIGFmdGVyIHRoYXQgcG9pbnQgY2FuCmFsc28gYmUgaWdub3JlZC4gIFRoaXMgY3V0cyB0aGUgYW1vdW50IG9mIHRlbXAgbWVtb3J5IG5lZWRlZCBieSB0aGUgc2FtZQphbW91bnQuCgpUaGVzZSBwcmVsaW1pbmFyeSBzZWFyY2hlcyBtYXkgbm90IHBheSBvZmYsIGFuZCBjYW4gYmUgZXhwZWN0ZWQgKm5vdCogdG8KcmVwYXkgdGhlaXIgY29zdCBpZiB0aGUgZGF0YSBpcyByYW5kb20uICBCdXQgdGhleSBjYW4gd2luIGh1Z2UgaW4gYWxsIG9mCnRpbWUsIGNvcHlpbmcsIGFuZCBtZW1vcnkgc2F2aW5ncyB3aGVuIHRoZXkgZG8gcGF5LCBzbyB0aGlzIGlzIG9uZSBvZiB0aGUKInBlci1tZXJnZSBvdmVyaGVhZHMiIG1lbnRpb25lZCBhYm92ZSB0aGF0IHdlJ3JlIGhhcHB5IHRvIGVuZHVyZSBiZWNhdXNlCnRoZXJlIGlzIGF0IG1vc3Qgb25lIHZlcnkgc2hvcnQgcnVuLiAgSXQncyBnZW5lcmFsbHkgdHJ1ZSBpbiB0aGlzIGFsZ29yaXRobQp0aGF0IHdlJ3JlIHdpbGxpbmcgdG8gZ2FtYmxlIGEgbGl0dGxlIHRvIHdpbiBhIGxvdCwgZXZlbiB0aG91Z2ggdGhlIG5ldApleHBlY3RhdGlvbiBpcyBuZWdhdGl2ZSBmb3IgcmFuZG9tIGRhdGEuCgoKTWVyZ2UgQWxnb3JpdGhtcwotLS0tLS0tLS0tLS0tLS0tCm1lcmdlX2xvKCkgYW5kIG1lcmdlX2hpKCkgYXJlIHdoZXJlIHRoZSBidWxrIG9mIHRoZSB0aW1lIGlzIHNwZW50LiAgbWVyZ2VfbG8KZGVhbHMgd2l0aCBydW5zIHdoZXJlIEEgPD0gQiwgYW5kIG1lcmdlX2hpIHdoZXJlIEEgPiBCLiAgVGhleSBkb24ndCBrbm93CndoZXRoZXIgdGhlIGRhdGEgaXMgY2x1c3RlcmVkIG9yIHVuaWZvcm0sIGJ1dCBhIGxvdmVseSB0aGluZyBhYm91dCBtZXJnaW5nCmlzIHRoYXQgbWFueSBraW5kcyBvZiBjbHVzdGVyaW5nICJyZXZlYWwgdGhlbXNlbHZlcyIgYnkgaG93IG1hbnkgdGltZXMgaW4gYQpyb3cgdGhlIHdpbm5pbmcgbWVyZ2UgZWxlbWVudCBjb21lcyBmcm9tIHRoZSBzYW1lIHJ1bi4gIFdlJ2xsIG9ubHkgZGlzY3VzcwptZXJnZV9sbyBoZXJlOyBtZXJnZV9oaSBpcyBleGFjdGx5IGFuYWxvZ291cy4KCk1lcmdpbmcgYmVnaW5zIGluIHRoZSB1c3VhbCwgb2J2aW91cyB3YXksIGNvbXBhcmluZyB0aGUgZmlyc3QgZWxlbWVudCBvZiBBCnRvIHRoZSBmaXJzdCBvZiBCLCBhbmQgbW92aW5nIEJbMF0gdG8gdGhlIG1lcmdlIGFyZWEgaWYgaXQncyBsZXNzIHRoYW4gQVswXSwKZWxzZSBtb3ZpbmcgQVswXSB0byB0aGUgbWVyZ2UgYXJlYS4gIENhbGwgdGhhdCB0aGUgIm9uZSBwYWlyIGF0IGEgdGltZSIKbW9kZS4gIFRoZSBvbmx5IHR3aXN0IGhlcmUgaXMga2VlcGluZyB0cmFjayBvZiBob3cgbWFueSB0aW1lcyBpbiBhIHJvdyAidGhlCndpbm5lciIgY29tZXMgZnJvbSB0aGUgc2FtZSBydW4uCgpJZiB0aGF0IGNvdW50IHJlYWNoZXMgTUlOX0dBTExPUCwgd2Ugc3dpdGNoIHRvICJnYWxsb3BpbmcgbW9kZSIuICBIZXJlCndlICpzZWFyY2gqIEIgZm9yIHdoZXJlIEFbMF0gYmVsb25ncywgYW5kIG1vdmUgb3ZlciBhbGwgdGhlIEIncyBiZWZvcmUKdGhhdCBwb2ludCBpbiBvbmUgY2h1bmsgdG8gdGhlIG1lcmdlIGFyZWEsIHRoZW4gbW92ZSBBWzBdIHRvIHRoZSBtZXJnZQphcmVhLiAgVGhlbiB3ZSBzZWFyY2ggQSBmb3Igd2hlcmUgQlswXSBiZWxvbmdzLCBhbmQgc2ltaWxhcmx5IG1vdmUgYQpzbGljZSBvZiBBIGluIG9uZSBjaHVuay4gIFRoZW4gYmFjayB0byBzZWFyY2hpbmcgQiBmb3Igd2hlcmUgQVswXSBiZWxvbmdzLApldGMuICBXZSBzdGF5IGluIGdhbGxvcGluZyBtb2RlIHVudGlsIGJvdGggc2VhcmNoZXMgZmluZCBzbGljZXMgdG8gY29weQpsZXNzIHRoYW4gTUlOX0dBTExPUCBlbGVtZW50cyBsb25nLCBhdCB3aGljaCBwb2ludCB3ZSBnbyBiYWNrIHRvIG9uZS1wYWlyLQphdC1hLXRpbWUgbW9kZS4KCkEgcmVmaW5lbWVudDogIFRoZSBNZXJnZVN0YXRlIHN0cnVjdCBjb250YWlucyB0aGUgdmFsdWUgb2YgbWluX2dhbGxvcCB0aGF0CmNvbnRyb2xzIHdoZW4gd2UgZW50ZXIgZ2FsbG9waW5nIG1vZGUsIGluaXRpYWxpemVkIHRvIE1JTl9HQUxMT1AuCm1lcmdlX2xvKCkgYW5kIG1lcmdlX2hpKCkgYWRqdXN0IHRoaXMgaGlnaGVyIHdoZW4gZ2FsbG9waW5nIGlzbid0IHBheWluZwpvZmYsIGFuZCBsb3dlciB3aGVuIGl0IGlzLgoKCkdhbGxvcGluZwotLS0tLS0tLS0KU3RpbGwgd2l0aG91dCBsb3NzIG9mIGdlbmVyYWxpdHksIGFzc3VtZSBBIGlzIHRoZSBzaG9ydGVyIHJ1bi4gIEluIGdhbGxvcGluZwptb2RlLCB3ZSBmaXJzdCBsb29rIGZvciBBWzBdIGluIEIuICBXZSBkbyB0aGlzIHZpYSAiZ2FsbG9waW5nIiwgY29tcGFyaW5nCkFbMF0gaW4gdHVybiB0byBCWzBdLCBCWzFdLCBCWzNdLCBCWzddLCAuLi4sIEJbMioqaiAtIDFdLCAuLi4sIHVudGlsIGZpbmRpbmcKdGhlIGsgc3VjaCB0aGF0IEJbMioqKGstMSkgLSAxXSA8IEFbMF0gPD0gQlsyKiprIC0gMV0uICBUaGlzIHRha2VzIGF0IG1vc3QKcm91Z2hseSBsZyhCKSBjb21wYXJpc29ucywgYW5kLCB1bmxpa2UgYSBzdHJhaWdodCBiaW5hcnkgc2VhcmNoLCBmYXZvcnMKZmluZGluZyB0aGUgcmlnaHQgc3BvdCBlYXJseSBpbiBCIChtb3JlIG9uIHRoYXQgbGF0ZXIpLgoKQWZ0ZXIgZmluZGluZyBzdWNoIGEgaywgdGhlIHJlZ2lvbiBvZiB1bmNlcnRhaW50eSBpcyByZWR1Y2VkIHRvIDIqKihrLTEpIC0gMQpjb25zZWN1dGl2ZSBlbGVtZW50cywgYW5kIGEgc3RyYWlnaHQgYmluYXJ5IHNlYXJjaCByZXF1aXJlcyBleGFjdGx5IGstMQphZGRpdGlvbmFsIGNvbXBhcmlzb25zIHRvIG5haWwgaXQuICBUaGVuIHdlIGNvcHkgYWxsIHRoZSBCJ3MgdXAgdG8gdGhhdApwb2ludCBpbiBvbmUgY2h1bmssIGFuZCB0aGVuIGNvcHkgQVswXS4gIE5vdGUgdGhhdCBubyBtYXR0ZXIgd2hlcmUgQVswXQpiZWxvbmdzIGluIEIsIHRoZSBjb21iaW5hdGlvbiBvZiBnYWxsb3BpbmcgKyBiaW5hcnkgc2VhcmNoIGZpbmRzIGl0IGluIG5vCm1vcmUgdGhhbiBhYm91dCAyKmxnKEIpIGNvbXBhcmlzb25zLgoKSWYgd2UgZGlkIGEgc3RyYWlnaHQgYmluYXJ5IHNlYXJjaCwgd2UgY291bGQgZmluZCBpdCBpbiBubyBtb3JlIHRoYW4KY2VpbGluZyhsZyhCKzEpKSBjb21wYXJpc29ucyAtLSBidXQgc3RyYWlnaHQgYmluYXJ5IHNlYXJjaCB0YWtlcyB0aGF0IG1hbnkKY29tcGFyaXNvbnMgbm8gbWF0dGVyIHdoZXJlIEFbMF0gYmVsb25ncy4gIFN0cmFpZ2h0IGJpbmFyeSBzZWFyY2ggdGh1cyBsb3Nlcwp0byBnYWxsb3BpbmcgdW5sZXNzIHRoZSBydW4gaXMgcXVpdGUgbG9uZywgYW5kIHdlIHNpbXBseSBjYW4ndCBndWVzcwp3aGV0aGVyIGl0IGlzIGluIGFkdmFuY2UuCgpJZiBkYXRhIGlzIHJhbmRvbSBhbmQgcnVucyBoYXZlIHRoZSBzYW1lIGxlbmd0aCwgQVswXSBiZWxvbmdzIGF0IEJbMF0gaGFsZgp0aGUgdGltZSwgYXQgQlsxXSBhIHF1YXJ0ZXIgb2YgdGhlIHRpbWUsIGFuZCBzbyBvbjogIGEgY29uc2VjdXRpdmUgd2lubmluZwpzdWItcnVuIGluIEIgb2YgbGVuZ3RoIGsgb2NjdXJzIHdpdGggcHJvYmFiaWxpdHkgMS8yKiooaysxKS4gIFNvIGxvbmcKd2lubmluZyBzdWItcnVucyBhcmUgZXh0cmVtZWx5IHVubGlrZWx5IGluIHJhbmRvbSBkYXRhLCBhbmQgZ3Vlc3NpbmcgdGhhdCBhCndpbm5pbmcgc3ViLXJ1biBpcyBnb2luZyB0byBiZSBsb25nIGlzIGEgZGFuZ2Vyb3VzIGdhbWUuCgpPVE9ILCBpZiBkYXRhIGlzIGxvcHNpZGVkIG9yIGx1bXB5IG9yIGNvbnRhaW5zIG1hbnkgZHVwbGljYXRlcywgbG9uZwpzdHJldGNoZXMgb2Ygd2lubmluZyBzdWItcnVucyBhcmUgdmVyeSBsaWtlbHksIGFuZCBjdXR0aW5nIHRoZSBudW1iZXIgb2YKY29tcGFyaXNvbnMgbmVlZGVkIHRvIGZpbmQgb25lIGZyb20gTyhCKSB0byBPKGxvZyBCKSBpcyBhIGh1Z2Ugd2luLgoKR2FsbG9waW5nIGNvbXByb21pc2VzIGJ5IGdldHRpbmcgb3V0IGZhc3QgaWYgdGhlcmUgaXNuJ3QgYSBsb25nIHdpbm5pbmcKc3ViLXJ1biwgeWV0IGZpbmRpbmcgc3VjaCB2ZXJ5IGVmZmljaWVudGx5IHdoZW4gdGhleSBleGlzdC4KCkkgZmlyc3QgbGVhcm5lZCBhYm91dCB0aGUgZ2FsbG9waW5nIHN0cmF0ZWd5IGluIGEgcmVsYXRlZCBjb250ZXh0OyBzZWU6CgogICAgIkFkYXB0aXZlIFNldCBJbnRlcnNlY3Rpb25zLCBVbmlvbnMsIGFuZCBEaWZmZXJlbmNlcyIgKDIwMDApCiAgICBFcmlrIEQuIERlbWFpbmUsIEFsZWphbmRybyBM83Blei1PcnRpeiwgSi4gSWFuIE11bnJvCgphbmQgaXRzIGZvbGxvd3VwKHMpLiAgQW4gZWFybGllciBwYXBlciBjYWxsZWQgdGhlIHNhbWUgc3RyYXRlZ3kKImV4cG9uZW50aWFsIHNlYXJjaCI6CgogICAiT3B0aW1pc3RpYyBTb3J0aW5nIGFuZCBJbmZvcm1hdGlvbiBUaGVvcmV0aWMgQ29tcGxleGl0eSIKICAgUGV0ZXIgTWNJbHJveQogICBTT0RBIChGb3VydGggQW5udWFsIEFDTS1TSUFNIFN5bXBvc2l1bSBvbiBEaXNjcmV0ZSBBbGdvcml0aG1zKSwgcHAKICAgNDY3LTQ3NCwgQXVzdGluLCBUZXhhcywgMjUtMjcgSmFudWFyeSAxOTkzLgoKYW5kIGl0IHByb2JhYmx5IGRhdGVzIGJhY2sgdG8gYW4gZWFybGllciBwYXBlciBieSBCZW50bGV5IGFuZCBZYW8uICBUaGUKTWNJbG9yeSBwYXBlciBpbiBwYXJ0aWN1bGFyIGhhcyBnb29kIGFuYWx5c2lzIG9mIGEgbWVyZ2Vzb3J0IHRoYXQncwpwcm9iYWJseSBzdHJvbmdseSByZWxhdGVkIHRvIHRoaXMgb25lIGluIGl0cyBnYWxsb3Bpbmcgc3RyYXRlZ3kuCgoKR2FsbG9waW5nIHdpdGggYSBCcm9rZW4gTGVnCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpTbyB3aHkgZG9uJ3Qgd2UgYWx3YXlzIGdhbGxvcD8gIEJlY2F1c2UgaXQgY2FuIGxvc2UsIG9uIHR3byBjb3VudHM6CgoxLiBXaGlsZSB3ZSdyZSB3aWxsaW5nIHRvIGVuZHVyZSBzbWFsbCBwZXItbWVyZ2Ugb3ZlcmhlYWRzLCBwZXItY29tcGFyaXNvbgogICBvdmVyaGVhZHMgYXJlIGEgZGlmZmVyZW50IHN0b3J5LiAgQ2FsbGluZyBZZXQgQW5vdGhlciBGdW5jdGlvbiBwZXIKICAgY29tcGFyaXNvbiBpcyBleHBlbnNpdmUsIGFuZCBnYWxsb3BfbGVmdCgpIGFuZCBnYWxsb3BfcmlnaHQoKSBhcmUKICAgdG9vIGxvbmctd2luZGVkIGZvciBzYW5lIGlubGluaW5nLgoKMi4gR2FsbG9waW5nIGNhbi0tIGFsYXMgLS1yZXF1aXJlIG1vcmUgY29tcGFyaXNvbnMgdGhhbiBsaW5lYXIgb25lLWF0LXRpbWUKICAgc2VhcmNoLCBkZXBlbmRpbmcgb24gdGhlIGRhdGEuCgojMiByZXF1aXJlcyBkZXRhaWxzLiAgSWYgQVswXSBiZWxvbmdzIGJlZm9yZSBCWzBdLCBnYWxsb3BpbmcgcmVxdWlyZXMgMQpjb21wYXJlIHRvIGRldGVybWluZSB0aGF0LCBzYW1lIGFzIGxpbmVhciBzZWFyY2gsIGV4Y2VwdCBpdCBjb3N0cyBtb3JlCnRvIGNhbGwgdGhlIGdhbGxvcCBmdW5jdGlvbi4gIElmIEFbMF0gYmVsb25ncyByaWdodCBiZWZvcmUgQlsxXSwgZ2FsbG9waW5nCnJlcXVpcmVzIDIgY29tcGFyZXMsIGFnYWluIHNhbWUgYXMgbGluZWFyIHNlYXJjaC4gIE9uIHRoZSB0aGlyZCBjb21wYXJlLApnYWxsb3BpbmcgY2hlY2tzIEFbMF0gYWdhaW5zdCBCWzNdLCBhbmQgaWYgaXQncyA8PSwgcmVxdWlyZXMgb25lIG1vcmUKY29tcGFyZSB0byBkZXRlcm1pbmUgd2hldGhlciBBWzBdIGJlbG9uZ3MgYXQgQlsyXSBvciBCWzNdLiAgVGhhdCdzIGEgdG90YWwKb2YgNCBjb21wYXJlcywgYnV0IGlmIEFbMF0gZG9lcyBiZWxvbmcgYXQgQlsyXSwgbGluZWFyIHNlYXJjaCB3b3VsZCBoYXZlCmRpc2NvdmVyZWQgdGhhdCBpbiBvbmx5IDMgY29tcGFyZXMsIGFuZCB0aGF0J3MgYSBodWdlIGxvc3MhICBSZWFsbHkuICBJdCdzCmFuIGluY3JlYXNlIG9mIDMzJSBpbiB0aGUgbnVtYmVyIG9mIGNvbXBhcmVzIG5lZWRlZCwgYW5kIGNvbXBhcmlzb25zIGFyZQpleHBlbnNpdmUgaW4gUHl0aG9uLgoKaW5kZXggaW4gQiB3aGVyZSAgICAjIGNvbXBhcmVzIGxpbmVhciAgIyBnYWxsb3AgICMgYmluYXJ5ICBnYWxsb3AKQVswXSBiZWxvbmdzICAgICAgICBzZWFyY2ggbmVlZHMgICAgICAgY29tcGFyZXMgIGNvbXBhcmVzICB0b3RhbAotLS0tLS0tLS0tLS0tLS0tICAgIC0tLS0tLS0tLS0tLS0tLS0tICAtLS0tLS0tLSAgLS0tLS0tLS0gIC0tLS0tLQogICAgICAgICAgICAgICAwICAgICAgICAgICAgICAgICAgICAxICAgICAgICAgMSAgICAgICAgIDAgICAgICAgMQoKICAgICAgICAgICAgICAgMSAgICAgICAgICAgICAgICAgICAgMiAgICAgICAgIDIgICAgICAgICAwICAgICAgIDIKCiAgICAgICAgICAgICAgIDIgICAgICAgICAgICAgICAgICAgIDMgICAgICAgICAzICAgICAgICAgMSAgICAgICA0CiAgICAgICAgICAgICAgIDMgICAgICAgICAgICAgICAgICAgIDQgICAgICAgICAzICAgICAgICAgMSAgICAgICA0CgogICAgICAgICAgICAgICA0ICAgICAgICAgICAgICAgICAgICA1ICAgICAgICAgNCAgICAgICAgIDIgICAgICAgNgogICAgICAgICAgICAgICA1ICAgICAgICAgICAgICAgICAgICA2ICAgICAgICAgNCAgICAgICAgIDIgICAgICAgNgogICAgICAgICAgICAgICA2ICAgICAgICAgICAgICAgICAgICA3ICAgICAgICAgNCAgICAgICAgIDIgICAgICAgNgogICAgICAgICAgICAgICA3ICAgICAgICAgICAgICAgICAgICA4ICAgICAgICAgNCAgICAgICAgIDIgICAgICAgNgoKICAgICAgICAgICAgICAgOCAgICAgICAgICAgICAgICAgICAgOSAgICAgICAgIDUgICAgICAgICAzICAgICAgIDgKICAgICAgICAgICAgICAgOSAgICAgICAgICAgICAgICAgICAxMCAgICAgICAgIDUgICAgICAgICAzICAgICAgIDgKICAgICAgICAgICAgICAxMCAgICAgICAgICAgICAgICAgICAxMSAgICAgICAgIDUgICAgICAgICAzICAgICAgIDgKICAgICAgICAgICAgICAxMSAgICAgICAgICAgICAgICAgICAxMiAgICAgICAgIDUgICAgICAgICAzICAgICAgIDgKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC4uLgoKSW4gZ2VuZXJhbCwgaWYgQVswXSBiZWxvbmdzIGF0IEJbaV0sIGxpbmVhciBzZWFyY2ggcmVxdWlyZXMgaSsxIGNvbXBhcmlzb25zCnRvIGRldGVybWluZSB0aGF0LCBhbmQgZ2FsbG9waW5nIGEgdG90YWwgb2YgMipmbG9vcihsZyhpKSkrMiBjb21wYXJpc29ucy4KVGhlIGFkdmFudGFnZSBvZiBnYWxsb3BpbmcgaXMgdW5ib3VuZGVkIGFzIGkgZ3Jvd3MsIGJ1dCBpdCBkb2Vzbid0IHdpbiBhdAphbGwgdW50aWwgaT02LiAgQmVmb3JlIHRoZW4sIGl0IGxvc2VzIHR3aWNlIChhdCBpPTIgYW5kIGk9NCksIGFuZCB0aWVzCmF0IHRoZSBvdGhlciB2YWx1ZXMuICBBdCBhbmQgYWZ0ZXIgaT02LCBnYWxsb3BpbmcgYWx3YXlzIHdpbnMuCgpXZSBjYW4ndCBndWVzcyBpbiBhZHZhbmNlIHdoZW4gaXQncyBnb2luZyB0byB3aW4sIHRob3VnaCwgc28gd2UgZG8gb25lIHBhaXIKYXQgYSB0aW1lIHVudGlsIHRoZSBldmlkZW5jZSBzZWVtcyBzdHJvbmcgdGhhdCBnYWxsb3BpbmcgbWF5IHBheS4gIE1JTl9HQUxMT1AKaXMgNywgYW5kIHRoYXQncyBwcmV0dHkgc3Ryb25nIGV2aWRlbmNlLiAgSG93ZXZlciwgaWYgdGhlIGRhdGEgaXMgcmFuZG9tLCBpdApzaW1wbHkgd2lsbCB0cmlnZ2VyIGdhbGxvcGluZyBtb2RlIHB1cmVseSBieSBsdWNrIGV2ZXJ5IG5vdyBhbmQgYWdhaW4sIGFuZAppdCdzIHF1aXRlIGxpa2VseSB0byBoaXQgb25lIG9mIHRoZSBsb3NpbmcgY2FzZXMgbmV4dC4gIE9uIHRoZSBvdGhlciBoYW5kLAppbiBjYXNlcyBsaWtlIH5zb3J0LCBnYWxsb3BpbmcgYWx3YXlzIHBheXMsIGFuZCBNSU5fR0FMTE9QIGlzIGxhcmdlciB0aGFuIGl0CiJzaG91bGQgYmUiIHRoZW4uICBTbyB0aGUgTWVyZ2VTdGF0ZSBzdHJ1Y3Qga2VlcHMgYSBtaW5fZ2FsbG9wIHZhcmlhYmxlCnRoYXQgbWVyZ2VfbG8gYW5kIG1lcmdlX2hpIGFkanVzdDogIHRoZSBsb25nZXIgd2Ugc3RheSBpbiBnYWxsb3BpbmcgbW9kZSwKdGhlIHNtYWxsZXIgbWluX2dhbGxvcCBnZXRzLCBtYWtpbmcgaXQgZWFzaWVyIHRvIHRyYW5zaXRpb24gYmFjayB0bwpnYWxsb3BpbmcgbW9kZSAoaWYgd2UgZXZlciBsZWF2ZSBpdCBpbiB0aGUgY3VycmVudCBtZXJnZSwgYW5kIGF0IHRoZQpzdGFydCBvZiB0aGUgbmV4dCBtZXJnZSkuICBCdXQgd2hlbmV2ZXIgdGhlIGdhbGxvcCBsb29wIGRvZXNuJ3QgcGF5LAptaW5fZ2FsbG9wIGlzIGluY3JlYXNlZCBieSBvbmUsIG1ha2luZyBpdCBoYXJkZXIgdG8gdHJhbnNpdGlvbiBiYWNrCnRvIGdhbGxvcGluZyBtb2RlIChhbmQgYWdhaW4gYm90aCB3aXRoaW4gYSBtZXJnZSBhbmQgYWNyb3NzIG1lcmdlcykuICBGb3IKcmFuZG9tIGRhdGEsIHRoaXMgYWxsIGJ1dCBlbGltaW5hdGVzIHRoZSBnYWxsb3AgcGVuYWx0eTogIG1pbl9nYWxsb3AgZ3Jvd3MKbGFyZ2UgZW5vdWdoIHRoYXQgd2UgYWxtb3N0IG5ldmVyIGdldCBpbnRvIGdhbGxvcGluZyBtb2RlLiAgQW5kIGZvciBjYXNlcwpsaWtlIH5zb3J0LCBtaW5fZ2FsbG9wIGNhbiBmYWxsIHRvIGFzIGxvdyBhcyAxLiAgVGhpcyBzZWVtcyB0byB3b3JrIHdlbGwsCmJ1dCBpbiBhbGwgaXQncyBhIG1pbm9yIGltcHJvdmVtZW50IG92ZXIgdXNpbmcgYSBmaXhlZCBNSU5fR0FMTE9QIHZhbHVlLgoKCkdhbGxvcGluZyBDb21wbGljYXRpb24KLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpUaGUgZGVzY3JpcHRpb24gYWJvdmUgd2FzIGZvciBtZXJnZV9sby4gIG1lcmdlX2hpIGhhcyB0byBtZXJnZSAiZnJvbSB0aGUKb3RoZXIgZW5kIiwgYW5kIHJlYWxseSBuZWVkcyB0byBnYWxsb3Agc3RhcnRpbmcgYXQgdGhlIGxhc3QgZWxlbWVudCBpbiBhIHJ1bgppbnN0ZWFkIG9mIHRoZSBmaXJzdC4gIEdhbGxvcGluZyBmcm9tIHRoZSBmaXJzdCBzdGlsbCB3b3JrcywgYnV0IGRvZXMgbW9yZQpjb21wYXJpc29ucyB0aGFuIGl0IHNob3VsZCAodGhpcyBpcyBzaWduaWZpY2FudCAtLSBJIHRpbWVkIGl0IGJvdGggd2F5cykuCkZvciB0aGlzIHJlYXNvbiwgdGhlIGdhbGxvcF9sZWZ0KCkgYW5kIGdhbGxvcF9yaWdodCgpIGZ1bmN0aW9ucyBoYXZlIGEKImhpbnQiIGFyZ3VtZW50LCB3aGljaCBpcyB0aGUgaW5kZXggYXQgd2hpY2ggZ2FsbG9waW5nIHNob3VsZCBiZWdpbi4gIFNvCmdhbGxvcGluZyBjYW4gYWN0dWFsbHkgc3RhcnQgYXQgYW55IGluZGV4LCBhbmQgcHJvY2VlZCBhdCBvZmZzZXRzIG9mIDEsIDMsCjcsIDE1LCAuLi4gb3IgLTEsIC0zLCAtNywgLTE1LCAuLi4gZnJvbSB0aGUgc3RhcnRpbmcgaW5kZXguCgpJbiB0aGUgY29kZSBhcyBJIHR5cGUgaXQncyBhbHdheXMgY2FsbGVkIHdpdGggZWl0aGVyIDAgb3Igbi0xICh3aGVyZSBuIGlzCnRoZSAjIG9mIGVsZW1lbnRzIGluIGEgcnVuKS4gIEl0J3MgdGVtcHRpbmcgdG8gdHJ5IHRvIGRvIHNvbWV0aGluZyBmYW5jaWVyLAptZWxkaW5nIGdhbGxvcGluZyB3aXRoIHNvbWUgZm9ybSBvZiBpbnRlcnBvbGF0aW9uIHNlYXJjaDsgZm9yIGV4YW1wbGUsIGlmCndlJ3JlIG1lcmdpbmcgYSBydW4gb2YgbGVuZ3RoIDEgd2l0aCBhIHJ1biBvZiBsZW5ndGggMTAwMDAsIGluZGV4IDUwMDAgaXMKcHJvYmFibHkgYSBiZXR0ZXIgZ3Vlc3MgYXQgdGhlIGZpbmFsIHJlc3VsdCB0aGFuIGVpdGhlciAwIG9yIDk5OTkuICBCdXQKaXQncyB1bmNsZWFyIGhvdyB0byBnZW5lcmFsaXplIHRoYXQgaW50dWl0aW9uIHVzZWZ1bGx5LCBhbmQgbWVyZ2luZyBvZgp3aWxkbHkgdW5iYWxhbmNlZCBydW5zIGFscmVhZHkgZW5qb3lzIGV4Y2VsbGVudCBwZXJmb3JtYW5jZS4KCn5zb3J0IGlzIGEgZ29vZCBleGFtcGxlIG9mIHdoZW4gYmFsYW5jZWQgcnVucyBjb3VsZCBiZW5lZml0IGZyb20gYSBiZXR0ZXIKaGludCB2YWx1ZTogIHRvIHRoZSBleHRlbnQgcG9zc2libGUsIHRoaXMgd291bGQgbGlrZSB0byB1c2UgYSBzdGFydGluZwpvZmZzZXQgZXF1YWwgdG8gdGhlIHByZXZpb3VzIHZhbHVlIG9mIGFjb3VudC9iY291bnQuICBEb2luZyBzbyBzYXZlcyBhYm91dAoxMCUgb2YgdGhlIGNvbXBhcmVzIGluIH5zb3J0LiAgSG93ZXZlciwgZG9pbmcgc28gaXMgYWxzbyBhIG1peGVkIGJhZywKaHVydGluZyBvdGhlciBjYXNlcy4KCgpDb21wYXJpbmcgQXZlcmFnZSAjIG9mIENvbXBhcmVzIG9uIFJhbmRvbSBBcnJheXMKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCltOT1RFOiAgVGhpcyB3YXMgZG9uZSB3aGVuIHRoZSBuZXcgYWxnb3JpdGhtIHVzZWQgYWJvdXQgMC4xJSBtb3JlIGNvbXBhcmVzCiBvbiByYW5kb20gZGF0YSB0aGFuIGRvZXMgaXRzIGN1cnJlbnQgaW5jYXJuYXRpb24uXQoKSGVyZSBsaXN0LnNvcnQoKSBpcyBzYW1wbGVzb3J0LCBhbmQgbGlzdC5tc29ydCgpIHRoaXMgc29ydDoKCiIiIgppbXBvcnQgcmFuZG9tCmZyb20gdGltZSBpbXBvcnQgY2xvY2sgYXMgbm93CgpkZWYgZmlsbChuKToKICAgIGZyb20gcmFuZG9tIGltcG9ydCByYW5kb20KICAgIHJldHVybiBbcmFuZG9tKCkgZm9yIGkgaW4geHJhbmdlKG4pXQoKZGVmIG15Y21wKHgsIHkpOgogICAgZ2xvYmFsIG5jbXAKICAgIG5jbXAgKz0gMQogICAgcmV0dXJuIGNtcCh4LCB5KQoKZGVmIHRpbWVpdCh2YWx1ZXMsIG1ldGhvZCk6CiAgICBnbG9iYWwgbmNtcAogICAgWCA9IHZhbHVlc1s6XQogICAgYm91bmQgPSBnZXRhdHRyKFgsIG1ldGhvZCkKICAgIG5jbXAgPSAwCiAgICB0MSA9IG5vdygpCiAgICBib3VuZChteWNtcCkKICAgIHQyID0gbm93KCkKICAgIHJldHVybiB0Mi10MSwgbmNtcAoKZm9ybWF0ID0gIiU1cyAgJTkuMmYgICUxMWQiCmYyICAgICA9ICIlNXMgICU5LjJmICAlMTEuMmYiCgpkZWYgZHJpdmUoKToKICAgIGNvdW50ID0gc3N0ID0gc3NjbXAgPSBtc3QgPSBtc2NtcCA9IG5lbHRzID0gMAogICAgd2hpbGUgVHJ1ZToKICAgICAgICBuID0gcmFuZG9tLnJhbmRyYW5nZSgxMDAwMDApCiAgICAgICAgbmVsdHMgKz0gbgogICAgICAgIHggPSBmaWxsKG4pCgogICAgICAgIHQsIGMgPSB0aW1laXQoeCwgJ3NvcnQnKQogICAgICAgIHNzdCArPSB0CiAgICAgICAgc3NjbXAgKz0gYwoKICAgICAgICB0LCBjID0gdGltZWl0KHgsICdtc29ydCcpCiAgICAgICAgbXN0ICs9IHQKICAgICAgICBtc2NtcCArPSBjCgogICAgICAgIGNvdW50ICs9IDEKICAgICAgICBpZiBjb3VudCAlIDEwOgogICAgICAgICAgICBjb250aW51ZQoKICAgICAgICBwcmludCAiY291bnQiLCBjb3VudCwgIm5lbHRzIiwgbmVsdHMKICAgICAgICBwcmludCBmb3JtYXQgJSAoInNvcnQiLCAgc3N0LCBzc2NtcCkKICAgICAgICBwcmludCBmb3JtYXQgJSAoIm1zb3J0IiwgbXN0LCBtc2NtcCkKICAgICAgICBwcmludCBmMiAgICAgJSAoIiIsIChzc3QtbXN0KSoxZTIvbXN0LCAoc3NjbXAtbXNjbXApKjFlMi9tc2NtcCkKCmRyaXZlKCkKIiIiCgpJIHJhbiB0aGlzIG9uIFdpbmRvd3MgYW5kIGtlcHQgdXNpbmcgdGhlIGNvbXB1dGVyIGxpZ2h0bHkgd2hpbGUgaXQgd2FzCnJ1bm5pbmcuICB0aW1lLmNsb2NrKCkgaXMgd2FsbC1jbG9jayB0aW1lIG9uIFdpbmRvd3MsIHdpdGggYmV0dGVyIHRoYW4KbWljcm9zZWNvbmQgcmVzb2x1dGlvbi4gIHNhbXBsZXNvcnQgc3RhcnRlZCB3aXRoIGEgMS41MiUgIy1vZi1jb21wYXJpc29ucwpkaXNhZHZhbnRhZ2UsIGZlbGwgcXVpY2tseSB0byAxLjQ4JSwgYW5kIHRoZW4gZmx1Y3R1YXRlZCB3aXRoaW4gdGhhdCBzbWFsbApyYW5nZS4gIEhlcmUncyB0aGUgbGFzdCBjaHVuayBvZiBvdXRwdXQgYmVmb3JlIEkga2lsbGVkIHRoZSBqb2I6Cgpjb3VudCAyNjMwIG5lbHRzIDEzMDkwNjU0Mwogc29ydCAgICA2MTEwLjgwICAgMTkzNzg4NzU3Mwptc29ydCAgICA2MDAyLjc4ICAgMTkwOTM4OTM4MQogICAgICAgICAgICAxLjgwICAgICAgICAgMS40OQoKV2UndmUgZG9uZSBuZWFybHkgMiBiaWxsaW9uIGNvbXBhcmlzb25zIGFwaWVjZSBhdCBQeXRob24gc3BlZWQgdGhlcmUsIGFuZAp0aGF0J3MgZW5vdWdoIDx3aW5rPi4KCkZvciByYW5kb20gYXJyYXlzIG9mIHNpemUgMiAoeWVzLCB0aGVyZSBhcmUgb25seSAyIGludGVyZXN0aW5nIG9uZXMpLApzYW1wbGVzb3J0IGhhcyBhIDUwJSghKSBjb21wYXJpc29uIGRpc2FkdmFudGFnZS4gIFRoaXMgaXMgYSBjb25zZXF1ZW5jZSBvZgpzYW1wbGVzb3J0IHNwZWNpYWwtY2FzaW5nIGF0IG1vc3Qgb25lIGFzY2VuZGluZyBydW4gYXQgdGhlIHN0YXJ0LCB0aGVuCmZhbGxpbmcgYmFjayB0byB0aGUgZ2VuZXJhbCBjYXNlIGlmIGl0IGRvZXNuJ3QgZmluZCBhbiBhc2NlbmRpbmcgcnVuCmltbWVkaWF0ZWx5LiAgVGhlIGNvbnNlcXVlbmNlIGlzIHRoYXQgaXQgZW5kcyB1cCB1c2luZyB0d28gY29tcGFyZXMgdG8gc29ydApbMiwgMV0uICBHcmF0aWZ5aW5nbHksIHRpbXNvcnQgZG9lc24ndCBkbyBhbnkgc3BlY2lhbC1jYXNpbmcsIHNvIGhhZCB0byBiZQp0YXVnaHQgaG93IHRvIGRlYWwgd2l0aCBtaXh0dXJlcyBvZiBhc2NlbmRpbmcgYW5kIGRlc2NlbmRpbmcgcnVucwplZmZpY2llbnRseSBpbiBhbGwgY2FzZXMuCg==