Km9wdGlvbnMudHh0KglGb3IgVmltIHZlcnNpb24gNy4wYWEuICBMYXN0IGNoYW5nZTogMjAwNSBKdWwgMDIKCgoJCSAgVklNIFJFRkVSRU5DRSBNQU5VQUwJICBieSBCcmFtIE1vb2xlbmFhcgoKCk9wdGlvbnMJCQkJCQkJKm9wdGlvbnMqCgoxLiBTZXR0aW5nIG9wdGlvbnMJCQl8c2V0LW9wdGlvbnwKMi4gQXV0b21hdGljYWxseSBzZXR0aW5nIG9wdGlvbnMJfGF1dG8tc2V0dGluZ3wKMy4gT3B0aW9ucyBzdW1tYXJ5CQkJfG9wdGlvbi1zdW1tYXJ5fAoKRm9yIGFuIG92ZXJ2aWV3IG9mIG9wdGlvbnMgc2VlIGhlbHAudHh0IHxvcHRpb24tbGlzdHwuCgpWaW0gaGFzIGEgbnVtYmVyIG9mIGludGVybmFsIHZhcmlhYmxlcyBhbmQgc3dpdGNoZXMgd2hpY2ggY2FuIGJlIHNldCB0bwphY2hpZXZlIHNwZWNpYWwgZWZmZWN0cy4gIFRoZXNlIG9wdGlvbnMgY29tZSBpbiB0aHJlZSBmb3JtczoKCWJvb2xlYW4JCWNhbiBvbmx5IGJlIG9uIG9yIG9mZgkJKmJvb2xlYW4qICp0b2dnbGUqCgludW1iZXIJCWhhcyBhIG51bWVyaWMgdmFsdWUKCXN0cmluZwkJaGFzIGEgc3RyaW5nIHZhbHVlCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMS4gU2V0dGluZyBvcHRpb25zCQkJCQkqc2V0LW9wdGlvbioKCgkJCQkJCQkqOnNlKiAqOnNldCoKOnNlW3RdCQkJU2hvdyBhbGwgb3B0aW9ucyB0aGF0IGRpZmZlciBmcm9tIHRoZWlyIGRlZmF1bHQgdmFsdWUuCgo6c2VbdF0gYWxsCQlTaG93IGFsbCBidXQgdGVybWluYWwgb3B0aW9ucy4KCjpzZVt0XSB0ZXJtY2FwCQlTaG93IGFsbCB0ZXJtaW5hbCBvcHRpb25zLiAgTm90ZSB0aGF0IGluIHRoZSBHVUkgdGhlCgkJCWtleSBjb2RlcyBhcmUgbm90IHNob3duLCBiZWNhdXNlIHRoZXkgYXJlIGdlbmVyYXRlZAoJCQlpbnRlcm5hbGx5IGFuZCBjYW4ndCBiZSBjaGFuZ2VkLiAgQ2hhbmdpbmcgdGhlIHRlcm1pbmFsCgkJCWNvZGVzIGluIHRoZSBHVUkgaXMgbm90IHVzZWZ1bCBlaXRoZXIuLi4KCgkJCQkJCQkJKkU1MTgqICpFNTE5Kgo6c2VbdF0ge29wdGlvbn0/CVNob3cgdmFsdWUgb2Yge29wdGlvbn0uCgo6c2VbdF0ge29wdGlvbn0JCVRvZ2dsZSBvcHRpb246IHNldCwgc3dpdGNoIGl0IG9uLgoJCQlOdW1iZXIgb3B0aW9uOiBzaG93IHZhbHVlLgoJCQlTdHJpbmcgb3B0aW9uOiBzaG93IHZhbHVlLgoKOnNlW3RdIG5ve29wdGlvbn0JVG9nZ2xlIG9wdGlvbjogUmVzZXQsIHN3aXRjaCBpdCBvZmYuCgo6c2VbdF0ge29wdGlvbn0hICAgb3IKOnNlW3RdIGludntvcHRpb259CVRvZ2dsZSBvcHRpb246IEludmVydCB2YWx1ZS4ge25vdCBpbiBWaX0KCgkJCQkqOnNldC1kZWZhdWx0KiAqOnNldC0mKiAqOnNldC0mdmkqICo6c2V0LSZ2aW0qCjpzZVt0XSB7b3B0aW9ufSYJUmVzZXQgb3B0aW9uIHRvIGl0cyBkZWZhdWx0IHZhbHVlLiAgTWF5IGRlcGVuZCBvbiB0aGUKCQkJY3VycmVudCB2YWx1ZSBvZiAnY29tcGF0aWJsZScuIHtub3QgaW4gVml9CjpzZVt0XSB7b3B0aW9ufSZ2aQlSZXNldCBvcHRpb24gdG8gaXRzIFZpIGRlZmF1bHQgdmFsdWUuIHtub3QgaW4gVml9CjpzZVt0XSB7b3B0aW9ufSZ2aW0JUmVzZXQgb3B0aW9uIHRvIGl0cyBWaW0gZGVmYXVsdCB2YWx1ZS4ge25vdCBpbiBWaX0KCjpzZVt0XSBhbGwmCQlTZXQgYWxsIG9wdGlvbnMsIGV4Y2VwdCB0ZXJtaW5hbCBvcHRpb25zLCB0byB0aGVpcgoJCQlkZWZhdWx0IHZhbHVlLiAgVGhlIHZhbHVlcyBvZiAndGVybScsICdsaW5lcycgYW5kCgkJCSdjb2x1bW5zJyBhcmUgbm90IGNoYW5nZWQuIHtub3QgaW4gVml9CgoJCQkJCQkqOnNldC1hcmdzKiAqRTQ4NyogKkU1MjEqCjpzZVt0XSB7b3B0aW9ufT17dmFsdWV9CQlvcgo6c2VbdF0ge29wdGlvbn06e3ZhbHVlfQoJCQlTZXQgc3RyaW5nIG9yIG51bWJlciBvcHRpb24gdG8ge3ZhbHVlfS4KCQkJRm9yIG51bWVyaWMgb3B0aW9ucyB0aGUgdmFsdWUgY2FuIGJlIGdpdmVuIGluIGRlY2ltYWwsCgkJCWhleCAocHJlY2VkZWQgd2l0aCAweCkgb3Igb2N0YWwgKHByZWNlZGVkIHdpdGggJzAnKQoJCQkoaGV4IGFuZCBvY3RhbCBhcmUgb25seSBhdmFpbGFibGUgZm9yIG1hY2hpbmVzIHdoaWNoCgkJCWhhdmUgdGhlIHN0cnRvbCgpIGZ1bmN0aW9uKS4KCQkJVGhlIG9sZCB2YWx1ZSBjYW4gYmUgaW5zZXJ0ZWQgYnkgdHlwaW5nICd3aWxkY2hhcicgKGJ5CgkJCWRlZmF1bHQgdGhpcyBpcyBhIDxUYWI+IG9yIENUUkwtRSBpZiAnY29tcGF0aWJsZScgaXMKCQkJc2V0KS4gIFNlZSB8Y21kbGluZS1jb21wbGV0aW9ufC4KCQkJV2hpdGUgc3BhY2UgYmV0d2VlbiB7b3B0aW9ufSBhbmQgJz0nIGlzIGFsbG93ZWQgYW5kCgkJCXdpbGwgYmUgaWdub3JlZC4gIFdoaXRlIHNwYWNlIGJldHdlZW4gJz0nIGFuZCB7dmFsdWV9CgkJCWlzIG5vdCBhbGxvd2VkLgoJCQlTZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGZvciB1c2luZyB3aGl0ZSBzcGFjZSBhbmQKCQkJYmFja3NsYXNoZXMgaW4ge3ZhbHVlfS4KCjpzZVt0XSB7b3B0aW9ufSs9e3ZhbHVlfQkJCQkqOnNldCs9KgoJCQlBZGQgdGhlIHt2YWx1ZX0gdG8gYSBudW1iZXIgb3B0aW9uLCBvciBhcHBlbmQgdGhlCgkJCXt2YWx1ZX0gdG8gYSBzdHJpbmcgb3B0aW9uLiAgV2hlbiB0aGUgb3B0aW9uIGlzIGEKCQkJY29tbWEgc2VwYXJhdGVkIGxpc3QsIGEgY29tbWEgaXMgYWRkZWQsIHVubGVzcyB0aGUKCQkJdmFsdWUgd2FzIGVtcHR5LgoJCQlJZiB0aGUgb3B0aW9uIGlzIGEgbGlzdCBvZiBmbGFncywgc3VwZXJmbHVvdXMgZmxhZ3MKCQkJYXJlIHJlbW92ZWQuICBPdGhlcndpc2UgdGhlcmUgaXMgbm8gY2hlY2sgZm9yIGRvdWJsZWQKCQkJdmFsdWVzLiAgWW91IGNhbiBhdm9pZCB0aGlzIGJ5IHJlbW92aW5nIGEgdmFsdWUgZmlyc3QuCgkJCUV4YW1wbGU6ID4KCQkJCTpzZXQgZ3Vpb3B0aW9ucy09VCBndWlvcHRpb25zKz1UCjwJCQlBbHNvIHNlZSB8OnNldC1hcmdzfCBhYm92ZS4KCQkJe25vdCBpbiBWaX0KCjpzZVt0XSB7b3B0aW9ufV49e3ZhbHVlfQkJCQkqOnNldF49KgoJCQlNdWx0aXBseSB0aGUge3ZhbHVlfSB0byBhIG51bWJlciBvcHRpb24sIG9yIHByZXBlbmQKCQkJdGhlIHt2YWx1ZX0gdG8gYSBzdHJpbmcgb3B0aW9uLiAgV2hlbiB0aGUgb3B0aW9uIGlzIGEKCQkJY29tbWEgc2VwYXJhdGVkIGxpc3QsIGEgY29tbWEgaXMgYWRkZWQsIHVubGVzcyB0aGUKCQkJdmFsdWUgd2FzIGVtcHR5LgoJCQlBbHNvIHNlZSB8OnNldC1hcmdzfCBhYm92ZS4KCQkJe25vdCBpbiBWaX0KCjpzZVt0XSB7b3B0aW9ufS09e3ZhbHVlfQkJCQkqOnNldC09KgoJCQlTdWJ0cmFjdCB0aGUge3ZhbHVlfSBmcm9tIGEgbnVtYmVyIG9wdGlvbiwgb3IgcmVtb3ZlCgkJCXRoZSB7dmFsdWV9IGZyb20gYSBzdHJpbmcgb3B0aW9uLCBpZiBpdCBpcyB0aGVyZS4KCQkJSWYgdGhlIHt2YWx1ZX0gaXMgbm90IGZvdW5kIGluIGEgc3RyaW5nIG9wdGlvbiwgdGhlcmUKCQkJaXMgbm8gZXJyb3Igb3Igd2FybmluZy4gIFdoZW4gdGhlIG9wdGlvbiBpcyBhIGNvbW1hCgkJCXNlcGFyYXRlZCBsaXN0LCBhIGNvbW1hIGlzIGRlbGV0ZWQsIHVubGVzcyB0aGUgb3B0aW9uCgkJCWJlY29tZXMgZW1wdHkuCgkJCVdoZW4gdGhlIG9wdGlvbiBpcyBhIGxpc3Qgb2YgZmxhZ3MsIHt2YWx1ZX0gbXVzdCBiZQoJCQlleGFjdGx5IGFzIHRoZXkgYXBwZWFyIGluIHRoZSBvcHRpb24uICBSZW1vdmUgZmxhZ3MKCQkJb25lIGJ5IG9uZSB0byBhdm9pZCBwcm9ibGVtcy4KCQkJQWxzbyBzZWUgfDpzZXQtYXJnc3wgYWJvdmUuCgkJCXtub3QgaW4gVml9CgpUaGUge29wdGlvbn0gYXJndW1lbnRzIHRvICI6c2V0IiBtYXkgYmUgcmVwZWF0ZWQuICBGb3IgZXhhbXBsZTogPgoJOnNldCBhaSBub3NpIHN3PTMgdHM9MwpJZiB5b3UgbWFrZSBhbiBlcnJvciBpbiBvbmUgb2YgdGhlIGFyZ3VtZW50cywgYW4gZXJyb3IgbWVzc2FnZSB3aWxsIGJlIGdpdmVuCmFuZCB0aGUgZm9sbG93aW5nIGFyZ3VtZW50cyB3aWxsIGJlIGlnbm9yZWQuCgoJCQkJCQkJKjpzZXQtdmVyYm9zZSoKV2hlbiAndmVyYm9zZScgaXMgbm9uLXplcm8sIGRpc3BsYXlpbmcgYW4gb3B0aW9uIHZhbHVlIHdpbGwgYWxzbyB0ZWxsIHdoZXJlIGl0CndhcyBsYXN0IHNldC4gIEV4YW1wbGU6ID4KCTp2ZXJib3NlIHNldCBzaGlmdHdpZHRoIGNpbmRlbnQ/CgkgIHNoaWZ0d2lkdGg9NAoJCSAgTGFzdCBzZXQgZnJvbSBtb2RlbGluZQoJICBjaW5kZW50CgkJICBMYXN0IHNldCBmcm9tIC91c3IvbG9jYWwvc2hhcmUvdmltL3ZpbTYwL2Z0cGx1Z2luL2MudmltClRoaXMgaXMgb25seSBkb25lIHdoZW4gc3BlY2lmaWMgb3B0aW9uIHZhbHVlcyBhcmUgcmVxdWVzdGVkLCBub3QgZm9yICI6c2V0CmFsbCIgb3IgIjpzZXQiIHdpdGhvdXQgYW4gYXJndW1lbnQuCldoZW4gdGhlIG9wdGlvbiB3YXMgc2V0IGJ5IGhhbmQgdGhlcmUgaXMgbm8gIkxhc3Qgc2V0IiBtZXNzYWdlLiAgVGhlcmUgaXMgb25seQpvbmUgdmFsdWUgZm9yIGFsbCBsb2NhbCBvcHRpb25zIHdpdGggdGhlIHNhbWUgbmFtZS4gIFRodXMgdGhlIG1lc3NhZ2UgYXBwbGllcwp0byB0aGUgb3B0aW9uIG5hbWUsIG5vdCBuZWNlc3NhcmlseSBpdHMgdmFsdWUuCldoZW4gdGhlIG9wdGlvbiB3YXMgc2V0IHdoaWxlIGV4ZWN1dGluZyBhIGZ1bmN0aW9uLCB1c2VyIGNvbW1hbmQgb3IKYXV0b2NvbW1hbmQsIHRoZSBzY3JpcHQgaW4gd2hpY2ggaXQgd2FzIGRlZmluZWQgaXMgcmVwb3J0ZWQuCk5vdGUgdGhhdCBhbiBvcHRpb24gbWF5IGFsc28gaGF2ZSBiZWVuIHNldCBhcyBhIHNpZGUgZWZmZWN0IG9mIHNldHRpbmcKJ2NvbXBhdGlibGUnLgp7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlICtldmFsIGZlYXR1cmV9CgoJCQkJCQkJKjpzZXQtdGVybWNhcCogKkU1MjIqCkZvciB7b3B0aW9ufSB0aGUgZm9ybSAidF94eCIgbWF5IGJlIHVzZWQgdG8gc2V0IGEgdGVybWNhcCBvcHRpb24uICBUaGlzIHdpbGwKb3ZlcnJpZGUgdGhlIHZhbHVlIGZyb20gdGhlIHRlcm1jYXAuICBZb3UgY2FuIHRoZW4gdXNlIGl0IGluIGEgbWFwcGluZy4gIElmCnRoZSAieHgiIHBhcnQgY29udGFpbnMgc3BlY2lhbCBjaGFyYWN0ZXJzLCB1c2UgdGhlIDx0X3h4PiBmb3JtOiA+Cgk6c2V0IDx0XyM0Pj1eW090ClRoaXMgY2FuIGFsc28gYmUgdXNlZCB0byB0cmFuc2xhdGUgYSBzcGVjaWFsIGNvZGUgZm9yIGEgbm9ybWFsIGtleS4gIEZvcgpleGFtcGxlLCBpZiBBbHQtYiBwcm9kdWNlcyA8RXNjPmIsIHVzZSB0aGlzOiA+Cgk6c2V0IDxNLWI+PV5bYgoodGhlIF5bIGlzIGEgcmVhbCA8RXNjPiBoZXJlLCB1c2UgQ1RSTC1WIDxFc2M+IHRvIGVudGVyIGl0KQpUaGUgYWR2YW50YWdlIG92ZXIgYSBtYXBwaW5nIGlzIHRoYXQgaXQgd29ya3MgaW4gYWxsIHNpdHVhdGlvbnMuCgpUaGUgdF94eCBvcHRpb25zIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCnNlY3VyaXR5IHJlYXNvbnMuCgpUaGUgbGlzdGluZyBmcm9tICI6c2V0IiBsb29rcyBkaWZmZXJlbnQgZnJvbSBWaS4gIExvbmcgc3RyaW5nIG9wdGlvbnMgYXJlIHB1dAphdCB0aGUgZW5kIG9mIHRoZSBsaXN0LiAgVGhlIG51bWJlciBvZiBvcHRpb25zIGlzIHF1aXRlIGxhcmdlLiAgVGhlIG91dHB1dCBvZgoic2V0IGFsbCIgcHJvYmFibHkgZG9lcyBub3QgZml0IG9uIHRoZSBzY3JlZW4sIGNhdXNpbmcgVmltIHRvIGdpdmUgdGhlCnxtb3JlLXByb21wdHwuCgoJCQkJCQkJKm9wdGlvbi1iYWNrc2xhc2gqClRvIGluY2x1ZGUgd2hpdGUgc3BhY2UgaW4gYSBzdHJpbmcgb3B0aW9uIHZhbHVlIGl0IGhhcyB0byBiZSBwcmVjZWRlZCB3aXRoIGEKYmFja3NsYXNoLiAgVG8gaW5jbHVkZSBhIGJhY2tzbGFzaCB5b3UgaGF2ZSB0byB1c2UgdHdvLiAgRWZmZWN0aXZlbHkgdGhpcwptZWFucyB0aGF0IHRoZSBudW1iZXIgb2YgYmFja3NsYXNoZXMgaW4gYW4gb3B0aW9uIHZhbHVlIGlzIGhhbHZlZCAocm91bmRlZApkb3duKS4KQSBmZXcgZXhhbXBsZXM6ID4KICAgOnNldCB0YWdzPXRhZ3NcIC91c3IvdGFncwkgICAgcmVzdWx0cyBpbiAidGFncyAvdXNyL3RhZ3MiCiAgIDpzZXQgdGFncz10YWdzXFwsZmlsZQkgICAgcmVzdWx0cyBpbiAidGFnc1wsZmlsZSIKICAgOnNldCB0YWdzPXRhZ3NcXFwgZmlsZQkgICAgcmVzdWx0cyBpbiAidGFnc1wgZmlsZSIKClRoZSAifCIgY2hhcmFjdGVyIHNlcGFyYXRlcyBhICI6c2V0IiBjb21tYW5kIGZyb20gYSBmb2xsb3dpbmcgY29tbWFuZC4gIFRvCmluY2x1ZGUgdGhlICJ8IiBpbiB0aGUgb3B0aW9uIHZhbHVlLCB1c2UgIlx8IiBpbnN0ZWFkLiAgVGhpcyBleGFtcGxlIHNldHMgdGhlCid0aXRsZXN0cmluZycgb3B0aW9uIHRvICJoaXx0aGVyZSI6ID4KICAgOnNldCB0aXRsZXN0cmluZz1oaVx8dGhlcmUKVGhpcyBzZXRzIHRoZSAndGl0bGVzdHJpbmcnIG9wdGlvbiB0byAiaGkiIGFuZCAnaWNvbnN0cmluZycgdG8gInRoZXJlIjogPgogICA6c2V0IHRpdGxlc3RyaW5nPWhpfHNldCBpY29uc3RyaW5nPXRoZXJlCgpGb3IgTVMtRE9TIGFuZCBXSU4zMiBiYWNrc2xhc2hlcyBpbiBmaWxlIG5hbWVzIGFyZSBtb3N0bHkgbm90IHJlbW92ZWQuICBNb3JlCnByZWNpc2U6IEZvciBvcHRpb25zIHRoYXQgZXhwZWN0IGEgZmlsZSBuYW1lICh0aG9zZSB3aGVyZSBlbnZpcm9ubWVudAp2YXJpYWJsZXMgYXJlIGV4cGFuZGVkKSBhIGJhY2tzbGFzaCBiZWZvcmUgYSBub3JtYWwgZmlsZSBuYW1lIGNoYXJhY3RlciBpcyBub3QKcmVtb3ZlZC4gIEJ1dCBhIGJhY2tzbGFzaCBiZWZvcmUgYSBzcGVjaWFsIGNoYXJhY3RlciAoc3BhY2UsIGJhY2tzbGFzaCwgY29tbWEsCmV0Yy4pIGlzIHVzZWQgbGlrZSBleHBsYWluZWQgYWJvdmUuClRoZXJlIGlzIG9uZSBzcGVjaWFsIHNpdHVhdGlvbiwgd2hlbiB0aGUgdmFsdWUgc3RhcnRzIHdpdGggIlxcIjogPgogICA6c2V0IGRpcj1cXG1hY2hpbmVccGF0aAkgICAgcmVzdWx0cyBpbiAiXFxtYWNoaW5lXHBhdGgiCiAgIDpzZXQgZGlyPVxcXFxtYWNoaW5lXFxwYXRoCSAgICByZXN1bHRzIGluICJcXG1hY2hpbmVccGF0aCIKICAgOnNldCBkaXI9XFxwYXRoXFxmaWxlCSAgICByZXN1bHRzIGluICJcXHBhdGhcZmlsZSIgKHdyb25nISkKRm9yIHRoZSBmaXJzdCBvbmUgdGhlIHN0YXJ0IGlzIGtlcHQsIGJ1dCBmb3IgdGhlIHNlY29uZCBvbmUgdGhlIGJhY2tzbGFzaGVzCmFyZSBoYWx2ZWQuICBUaGlzIG1ha2VzIHN1cmUgaXQgd29ya3MgYm90aCB3aGVuIHlvdSBleHBlY3QgYmFja3NsYXNoZXMgdG8gYmUKaGFsdmVkIGFuZCB3aGVuIHlvdSBleHBlY3QgdGhlIGJhY2tzbGFzaGVzIHRvIGJlIGtlcHQuICBUaGUgdGhpcmQgZ2l2ZXMgYQpyZXN1bHQgd2hpY2ggaXMgcHJvYmFibHkgbm90IHdoYXQgeW91IHdhbnQuICBBdm9pZCBpdC4KCgkJCQkqYWRkLW9wdGlvbi1mbGFncyogKnJlbW92ZS1vcHRpb24tZmxhZ3MqCgkJCQkqRTUzOSogKkU1NTAqICpFNTUxKiAqRTU1MioKU29tZSBvcHRpb25zIGFyZSBhIGxpc3Qgb2YgZmxhZ3MuICBXaGVuIHlvdSB3YW50IHRvIGFkZCBhIGZsYWcgdG8gc3VjaCBhbgpvcHRpb24sIHdpdGhvdXQgY2hhbmdpbmcgdGhlIGV4aXN0aW5nIG9uZXMsIHlvdSBjYW4gZG8gaXQgbGlrZSB0aGlzOiA+CiAgIDpzZXQgZ3Vpb3B0aW9ucys9YQpSZW1vdmUgYSBmbGFnIGZyb20gYW4gb3B0aW9uIGxpa2UgdGhpczogPgogICA6c2V0IGd1aW9wdGlvbnMtPWEKVGhpcyByZW1vdmVzIHRoZSAnYScgZmxhZyBmcm9tICdndWlvcHRpb25zJy4KTm90ZSB0aGF0IHlvdSBzaG91bGQgYWRkIG9yIHJlbW92ZSBvbmUgZmxhZyBhdCBhIHRpbWUuICBJZiAnZ3Vpb3B0aW9ucycgaGFzCnRoZSB2YWx1ZSAiYWIiLCB1c2luZyAic2V0IGd1aW9wdGlvbnMtPWJhIiB3b24ndCB3b3JrLCBiZWNhdXNlIHRoZSBzdHJpbmcgImJhIgpkb2Vzbid0IGFwcGVhci4KCgkJCSAgICo6c2V0X2VudiogKmV4cGFuZC1lbnYqICpleHBhbmQtZW52aXJvbm1lbnQtdmFyKgpFbnZpcm9ubWVudCB2YXJpYWJsZXMgaW4gc3BlY2lmaWMgc3RyaW5nIG9wdGlvbnMgd2lsbCBiZSBleHBhbmRlZC4gIElmIHRoZQplbnZpcm9ubWVudCB2YXJpYWJsZSBleGlzdHMgdGhlICckJyBhbmQgdGhlIGZvbGxvd2luZyBlbnZpcm9ubWVudCB2YXJpYWJsZQpuYW1lIGlzIHJlcGxhY2VkIHdpdGggaXRzIHZhbHVlLiAgSWYgaXQgZG9lcyBub3QgZXhpc3QgdGhlICckJyBhbmQgdGhlIG5hbWUKYXJlIG5vdCBtb2RpZmllZC4gIEFueSBub24taWQgY2hhcmFjdGVyIChub3QgYSBsZXR0ZXIsIGRpZ2l0IG9yICdfJykgbWF5CmZvbGxvdyB0aGUgZW52aXJvbm1lbnQgdmFyaWFibGUgbmFtZS4gIFRoYXQgY2hhcmFjdGVyIGFuZCB3aGF0IGZvbGxvd3MgaXMKYXBwZW5kZWQgdG8gdGhlIHZhbHVlIG9mIHRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZS4gIEV4YW1wbGVzOiA+CiAgIDpzZXQgdGVybT0kVEVSTS5uZXcKICAgOnNldCBwYXRoPS91c3IvJElOQ0xVREUsJEhPTUUvaW5jbHVkZSwuCldoZW4gYWRkaW5nIG9yIHJlbW92aW5nIGEgc3RyaW5nIGZyb20gYW4gb3B0aW9uIHdpdGggIjpzZXQgb3B0LT12YWwiIG9yICI6c2V0Cm9wdCs9dmFsIiB0aGUgZXhwYW5zaW9uIGlzIGRvbmUgYmVmb3JlIHRoZSBhZGRpbmcgb3IgcmVtb3ZpbmcuCgoKSGFuZGxpbmcgb2YgbG9jYWwgb3B0aW9ucwkJCSpsb2NhbC1vcHRpb25zKgoKU29tZSBvZiB0aGUgb3B0aW9ucyBvbmx5IGFwcGx5IHRvIGEgd2luZG93IG9yIGJ1ZmZlci4gIEVhY2ggd2luZG93IG9yIGJ1ZmZlcgpoYXMgaXRzIG93biBjb3B5IG9mIHRoaXMgb3B0aW9uLCB0aHVzIGNhbiBlYWNoIGhhdmUgdGhlaXIgb3duIHZhbHVlLiAgVGhpcwphbGxvd3MgeW91IHRvIHNldCAnbGlzdCcgaW4gb25lIHdpbmRvdyBidXQgbm90IGluIGFub3RoZXIuICBBbmQgc2V0CidzaGlmdHdpZHRoJyB0byAzIGluIG9uZSBidWZmZXIgYW5kIDQgaW4gYW5vdGhlci4KClRoZSBmb2xsb3dpbmcgZXhwbGFpbnMgd2hhdCBoYXBwZW5zIHRvIHRoZXNlIGxvY2FsIG9wdGlvbnMgaW4gc3BlY2lmaWMKc2l0dWF0aW9ucy4gIFlvdSBkb24ndCByZWFsbHkgbmVlZCB0byBrbm93IGFsbCBvZiB0aGlzLCBzaW5jZSBWaW0gbW9zdGx5IHVzZXMKdGhlIG9wdGlvbiB2YWx1ZXMgeW91IHdvdWxkIGV4cGVjdC4gIFVuZm9ydHVuYXRlbHksIGRvaW5nIHdoYXQgdGhlIHVzZXIKZXhwZWN0cyBpcyBhIGJpdCBjb21wbGljYXRlZC4uLgoKV2hlbiBzcGxpdHRpbmcgYSB3aW5kb3csIHRoZSBsb2NhbCBvcHRpb25zIGFyZSBjb3BpZWQgdG8gdGhlIG5ldyB3aW5kb3cuICBUaHVzCnJpZ2h0IGFmdGVyIHRoZSBzcGxpdCB0aGUgY29udGVudHMgb2YgdGhlIHR3byB3aW5kb3dzIGxvb2sgdGhlIHNhbWUuCgpXaGVuIGVkaXRpbmcgYSBuZXcgYnVmZmVyLCBpdHMgbG9jYWwgb3B0aW9uIHZhbHVlcyBtdXN0IGJlIGluaXRpYWxpemVkLiAgU2luY2UKdGhlIGxvY2FsIG9wdGlvbnMgb2YgdGhlIGN1cnJlbnQgYnVmZmVyIG1pZ2h0IGJlIHNwZWNpZmljYWxseSBmb3IgdGhhdCBidWZmZXIsCnRoZXNlIGFyZSBub3QgdXNlZC4gIEluc3RlYWQsIGZvciBlYWNoIGJ1ZmZlci1sb2NhbCBvcHRpb24gdGhlcmUgYWxzbyBpcyBhCmdsb2JhbCB2YWx1ZSwgd2hpY2ggaXMgdXNlZCBmb3IgbmV3IGJ1ZmZlcnMuICBXaXRoICI6c2V0IiBib3RoIHRoZSBsb2NhbCBhbmQKZ2xvYmFsIHZhbHVlIGlzIGNoYW5nZWQuICBXaXRoICJzZXRsb2NhbCIgb25seSB0aGUgbG9jYWwgdmFsdWUgaXMgY2hhbmdlZCwKdGh1cyB0aGlzIHZhbHVlIGlzIG5vdCB1c2VkIHdoZW4gZWRpdGluZyBhIG5ldyBidWZmZXIuCgpXaGVuIGVkaXRpbmcgYSBidWZmZXIgdGhhdCBoYXMgYmVlbiBlZGl0ZWQgYmVmb3JlLCB0aGUgbGFzdCB1c2VkIHdpbmRvdwpvcHRpb25zIGFyZSB1c2VkIGFnYWluLiAgSWYgdGhpcyBidWZmZXIgaGFzIGJlZW4gZWRpdGVkIGluIHRoaXMgd2luZG93LCB0aGUKdmFsdWVzIGZyb20gYmFjayB0aGVuIGFyZSB1c2VkLiAgT3RoZXJ3aXNlIHRoZSB2YWx1ZXMgZnJvbSB0aGUgd2luZG93IHdoZXJlCnRoZSBidWZmZXIgd2FzIGVkaXRlZCBsYXN0IGFyZSB1c2VkLgoKSXQncyBwb3NzaWJsZSB0byBzZXQgYSBsb2NhbCB3aW5kb3cgb3B0aW9uIHNwZWNpZmljYWxseSBmb3IgYSB0eXBlIG9mIGJ1ZmZlci4KV2hlbiB5b3UgZWRpdCBhbm90aGVyIGJ1ZmZlciBpbiB0aGUgc2FtZSB3aW5kb3csIHlvdSBkb24ndCB3YW50IHRvIGtlZXAKdXNpbmcgdGhlc2UgbG9jYWwgd2luZG93IG9wdGlvbnMuICBUaGVyZWZvcmUgVmltIGtlZXBzIGEgZ2xvYmFsIHZhbHVlIG9mIHRoZQpsb2NhbCB3aW5kb3cgb3B0aW9ucywgd2hpY2ggaXMgdXNlZCB3aGVuIGVkaXRpbmcgYW5vdGhlciBidWZmZXIuICBFYWNoIHdpbmRvdwpoYXMgaXRzIG93biBjb3B5IG9mIHRoZXNlIHZhbHVlcy4gIFRodXMgdGhlc2UgYXJlIGxvY2FsIHRvIHRoZSB3aW5kb3csIGJ1dApnbG9iYWwgdG8gYWxsIGJ1ZmZlcnMgaW4gdGhlIHdpbmRvdy4gIFdpdGggdGhpcyB5b3UgY2FuIGRvOiA+Cgk6ZSBvbmUKCTpzZXQgbGlzdAoJOmUgdHdvCk5vdyB0aGUgJ2xpc3QnIG9wdGlvbiB3aWxsIGFsc28gYmUgc2V0IGluICJ0d28iLCBzaW5jZSB3aXRoIHRoZSAiOnNldCBsaXN0Igpjb21tYW5kIHlvdSBoYXZlIGFsc28gc2V0IHRoZSBnbG9iYWwgdmFsdWUuID4KCTpzZXQgbm9saXN0Cgk6ZSBvbmUKCTpzZXRsb2NhbCBsaXN0Cgk6ZSB0d28KTm93IHRoZSAnbGlzdCcgb3B0aW9uIGlzIG5vdCBzZXQsIGJlY2F1c2UgIjpzZXQgbm9saXN0IiByZXNldHMgdGhlIGdsb2JhbAp2YWx1ZSwgIjpzZXRsb2NhbCBsaXN0IiBvbmx5IGNoYW5nZXMgdGhlIGxvY2FsIHZhbHVlIGFuZCAiOmUgdHdvIiBnZXRzIHRoZQpnbG9iYWwgdmFsdWUuICBOb3RlIHRoYXQgaWYgeW91IGRvIHRoaXMgbmV4dDogPgoJOmUgb25lCllvdSB3aWxsIG5vdCBnZXQgYmFjayB0aGUgJ2xpc3QnIHZhbHVlIGFzIGl0IHdhcyB0aGUgbGFzdCB0aW1lIHlvdSBlZGl0ZWQKIm9uZSIuICBUaGUgb3B0aW9ucyBsb2NhbCB0byBhIHdpbmRvdyBhcmUgbm90IHJlbWVtYmVyZWQgZm9yIGVhY2ggYnVmZmVyLgoKCQkJCQkJCSo6c2V0bCogKjpzZXRsb2NhbCoKOnNldGxbb2NhbF0gLi4uCQlMaWtlICI6c2V0IiBidXQgc2V0IG9ubHkgdGhlIHZhbHVlIGxvY2FsIHRvIHRoZQoJCQljdXJyZW50IGJ1ZmZlciBvciB3aW5kb3cuICBOb3QgYWxsIG9wdGlvbnMgaGF2ZSBhCgkJCWxvY2FsIHZhbHVlLiAgSWYgdGhlIG9wdGlvbiBkb2VzIG5vdCBoYXZlIGEgbG9jYWwKCQkJdmFsdWUgdGhlIGdsb2JhbCB2YWx1ZSBpcyBzZXQuCgkJCVdpdGggdGhlICJhbGwiIGFyZ3VtZW50OiBkaXNwbGF5IGFsbCBsb2NhbCBvcHRpb24ncwoJCQlsb2NhbCB2YWx1ZXMuCgkJCVdpdGhvdXQgYXJndW1lbnQ6IERpc3BsYXkgYWxsIGxvY2FsIG9wdGlvbidzIGxvY2FsCgkJCXZhbHVlcyB3aGljaCBhcmUgZGlmZmVyZW50IGZyb20gdGhlIGRlZmF1bHQuCgkJCVdoZW4gZGlzcGxheWluZyBhIHNwZWNpZmljIGxvY2FsIG9wdGlvbiwgc2hvdyB0aGUKCQkJbG9jYWwgdmFsdWUuICBGb3IgYSBnbG9iYWwgb3B0aW9uIHRoZSBnbG9iYWwgdmFsdWUgaXMKCQkJc2hvd24gKGJ1dCB0aGF0IG1pZ2h0IGNoYW5nZSBpbiB0aGUgZnV0dXJlKS4KCQkJe25vdCBpbiBWaX0KCjpzZXRsW29jYWxdIHtvcHRpb259PAlTZXQgdGhlIGxvY2FsIHZhbHVlIG9mIHtvcHRpb259IHRvIGl0cyBnbG9iYWwgdmFsdWUuCgkJCXtub3QgaW4gVml9CgoJCQkJCQkJKjpzZXRnKiAqOnNldGdsb2JhbCoKOnNldGdbbG9iYWxdIC4uLglMaWtlICI6c2V0IiBidXQgc2V0IG9ubHkgdGhlIGdsb2JhbCB2YWx1ZSBmb3IgYSBsb2NhbAoJCQlvcHRpb24gd2l0aG91dCBjaGFuZ2luZyB0aGUgbG9jYWwgdmFsdWUuCgkJCVdoZW4gZGlzcGxheWluZyBhbiBvcHRpb24sIHRoZSBnbG9iYWwgdmFsdWUgaXMgc2hvd24uCgkJCVdpdGggdGhlICJhbGwiIGFyZ3VtZW50OiBkaXNwbGF5IGFsbCBsb2NhbCBvcHRpb24ncwoJCQlnbG9iYWwgdmFsdWVzLgoJCQlXaXRob3V0IGFyZ3VtZW50OiBkaXNwbGF5IGFsbCBsb2NhbCBvcHRpb24ncyBnbG9iYWwKCQkJdmFsdWVzIHdoaWNoIGFyZSBkaWZmZXJlbnQgZnJvbSB0aGUgZGVmYXVsdC4KCQkJe25vdCBpbiBWaX0KCkZvciBidWZmZXItbG9jYWwgYW5kIHdpbmRvdy1sb2NhbCBvcHRpb25zOgoJQ29tbWFuZAkJIGdsb2JhbCB2YWx1ZQkgICAgbG9jYWwgdmFsdWUgfgogICAgICA6c2V0IG9wdGlvbj12YWx1ZQkgICAgIHNldAkJc2V0CiA6c2V0bG9jYWwgb3B0aW9uPXZhbHVlCSAgICAgIC0JCQlzZXQKOnNldGdsb2JhbCBvcHRpb249dmFsdWUJICAgICBzZXQJCSAtCiAgICAgIDpzZXQgb3B0aW9uPwkgICAgICAtCQkgICAgICAgZGlzcGxheQogOnNldGxvY2FsIG9wdGlvbj8JICAgICAgLQkJICAgICAgIGRpc3BsYXkKOnNldGdsb2JhbCBvcHRpb24/CSAgICBkaXNwbGF5CQkgLQoKCkdsb2JhbCBvcHRpb25zIHdpdGggYSBsb2NhbCB2YWx1ZQkJCSpnbG9iYWwtbG9jYWwqCgpPcHRpb25zIGFyZSBnbG9iYWwgd2hlbiB5b3UgbW9zdGx5IHVzZSBvbmUgdmFsdWUgZm9yIGFsbCBidWZmZXJzIGFuZCB3aW5kb3dzLgpGb3Igc29tZSBnbG9iYWwgb3B0aW9ucyBpdCdzIHVzZWZ1bCB0byBzb21ldGltZXMgaGF2ZSBhIGRpZmZlcmVudCBsb2NhbCB2YWx1ZS4KWW91IGNhbiBzZXQgdGhlIGxvY2FsIHZhbHVlIHdpdGggIjpzZXRsb2NhbCIuICBUaGF0IGJ1ZmZlciBvciB3aW5kb3cgd2lsbCB0aGVuCnVzZSB0aGUgbG9jYWwgdmFsdWUsIHdoaWxlIG90aGVyIGJ1ZmZlcnMgYW5kIHdpbmRvd3MgY29udGludWUgdXNpbmcgdGhlIGdsb2JhbAp2YWx1ZS4KCkZvciBleGFtcGxlLCB5b3UgaGF2ZSB0d28gd2luZG93cywgYm90aCBvbiBDIHNvdXJjZSBjb2RlLiAgVGhleSB1c2UgdGhlIGdsb2JhbAonbWFrZXByZycgb3B0aW9uLiAgSWYgeW91IGRvIHRoaXMgaW4gb25lIG9mIHRoZSB0d28gd2luZG93czogPgoJOnNldCBtYWtlcHJnPWdtYWtlCnRoZW4gdGhlIG90aGVyIHdpbmRvdyB3aWxsIHN3aXRjaCB0byB0aGUgc2FtZSB2YWx1ZS4gIFRoZXJlIGlzIG5vIG5lZWQgdG8gc2V0CnRoZSAnbWFrZXByZycgb3B0aW9uIGluIHRoZSBvdGhlciBDIHNvdXJjZSB3aW5kb3cgdG9vLgpIb3dldmVyLCBpZiB5b3Ugc3RhcnQgZWRpdGluZyBhIFBlcmwgZmlsZSBpbiBhIG5ldyB3aW5kb3csIHlvdSB3YW50IHRvIHVzZQphbm90aGVyICdtYWtlcHJvZycgZm9yIGl0LCB3aXRob3V0IGNoYW5naW5nIHRoZSB2YWx1ZSB1c2VkIGZvciB0aGUgQyBzb3VyY2UKZmlsZXMuICBZb3UgdXNlIHRoaXMgY29tbWFuZDogPgoJOnNldGxvY2FsIG1ha2Vwcmc9cGVybG1ha2UKWW91IGNhbiBzd2l0Y2ggYmFjayB0byB1c2luZyB0aGUgZ2xvYmFsIHZhbHVlIGJ5IG1ha2luZyB0aGUgbG9jYWwgdmFsdWUgZW1wdHk6ID4KCTpzZXRsb2NhbCBtYWtlcHJnPQpUaGlzIG9ubHkgd29ya3MgZm9yIGEgc3RyaW5nIG9wdGlvbi4gIEZvciBhIGJvb2xlYW4gb3B0aW9uIHlvdSBuZWVkIHRvIHVzZSB0aGUKIjwiIGZsYWcsIGxpa2UgdGhpczogPgoJOnNldGxvY2FsIGF1dG9yZWFkPApOb3RlIHRoYXQgZm9yIG5vbi1ib29sZWFuIG9wdGlvbnMgdXNpbmcgIjwiIGNvcGllcyB0aGUgZ2xvYmFsIHZhbHVlIHRvIHRoZQpsb2NhbCB2YWx1ZSwgaXQgZG9lc24ndCBzd2l0Y2ggYmFjayB0byB1c2luZyB0aGUgZ2xvYmFsIHZhbHVlICh0aGF0IG1hdHRlcnMKd2hlbiBjaGFuZ2luZyB0aGUgZ2xvYmFsIHZhbHVlIGxhdGVyKS4KTm90ZTogSW4gdGhlIGZ1dHVyZSBtb3JlIGdsb2JhbCBvcHRpb25zIGNhbiBiZSBtYWRlIGdsb2JhbC1sb2NhbC4gIFVzaW5nCiI6c2V0bG9jYWwiIG9uIGEgZ2xvYmFsIG9wdGlvbiBtaWdodCB3b3JrIGRpZmZlcmVudGx5IHRoZW4uCgoKU2V0dGluZyB0aGUgZmlsZXR5cGUKCjpzZXRmW2lsZXR5cGVdIHtmaWxldHlwZX0JCQkqOnNldGYqICo6c2V0ZmlsZXR5cGUqCgkJCVNldCB0aGUgJ2ZpbGV0eXBlJyBvcHRpb24gdG8ge2ZpbGV0eXBlfSwgYnV0IG9ubHkgaWYKCQkJbm90IGRvbmUgeWV0IGluIGEgc2VxdWVuY2Ugb2YgKG5lc3RlZCkgYXV0b2NvbW1hbmRzLgoJCQlUaGlzIGlzIHNob3J0IGZvcjogPgoJCQkJOmlmICFkaWRfZmlsZXR5cGUoKQoJCQkJOiAgc2V0bG9jYWwgZmlsZXR5cGU9e2ZpbGV0eXBlfQoJCQkJOmVuZGlmCjwJCQlUaGlzIGNvbW1hbmQgaXMgdXNlZCBpbiBhIGZpbGV0eXBlLnZpbSBmaWxlIHRvIGF2b2lkCgkJCXNldHRpbmcgdGhlICdmaWxldHlwZScgb3B0aW9uIHR3aWNlLCBjYXVzaW5nIGRpZmZlcmVudAoJCQlzZXR0aW5ncyBhbmQgc3ludGF4IGZpbGVzIHRvIGJlIGxvYWRlZC4KCQkJe25vdCBpbiBWaX0KCjpicm9bd3NlXSBzZVt0XQkJCSo6c2V0LWJyb3dzZSogKjpicm93c2Utc2V0KiAqOm9wdCogKjpvcHRpb25zKgo6b3B0W2lvbnNdCQlPcGVuIGEgd2luZG93IGZvciB2aWV3aW5nIGFuZCBzZXR0aW5nIGFsbCBvcHRpb25zLgoJCQlPcHRpb25zIGFyZSBncm91cGVkIGJ5IGZ1bmN0aW9uLgoJCQlPZmZlcnMgc2hvcnQgaGVscCBmb3IgZWFjaCBvcHRpb24uICBIaXQgPENSPiBvbiB0aGUKCQkJc2hvcnQgaGVscCB0byBvcGVuIGEgaGVscCB3aW5kb3cgd2l0aCBtb3JlIGhlbHAgZm9yCgkJCXRoZSBvcHRpb24uCgkJCU1vZGlmeSB0aGUgdmFsdWUgb2YgdGhlIG9wdGlvbiBhbmQgaGl0IDxDUj4gb24gdGhlCgkJCSJzZXQiIGxpbmUgdG8gc2V0IHRoZSBuZXcgdmFsdWUuICBGb3Igd2luZG93IGFuZAoJCQlidWZmZXIgc3BlY2lmaWMgb3B0aW9ucywgdGhlIGxhc3QgYWNjZXNzZWQgd2luZG93IGlzCgkJCXVzZWQgdG8gc2V0IHRoZSBvcHRpb24gdmFsdWUgaW4sIHVubGVzcyB0aGlzIGlzIGEgaGVscAoJCQl3aW5kb3csIGluIHdoaWNoIGNhc2UgdGhlIHdpbmRvdyBiZWxvdyBoZWxwIHdpbmRvdyBpcwoJCQl1c2VkIChza2lwcGluZyB0aGUgb3B0aW9uLXdpbmRvdykuCgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCtldmFsfCBvcgoJCQl8K2F1dG9jbWR8IGZlYXR1cmVzfQoKCQkJCQkJCQkqJEhPTUUqClVzaW5nICJ+IiBpcyBsaWtlIHVzaW5nICIkSE9NRSIsIGJ1dCBpdCBpcyBvbmx5IHJlY29nbml6ZWQgYXQgdGhlIHN0YXJ0IG9mIGFuCm9wdGlvbiBhbmQgYWZ0ZXIgYSBzcGFjZSBvciBjb21tYS4KCk9uIFVuaXggc3lzdGVtcyAifnVzZXIiIGNhbiBiZSB1c2VkIHRvby4gIEl0IGlzIHJlcGxhY2VkIGJ5IHRoZSBob21lIGRpcmVjdG9yeQpvZiB1c2VyICJ1c2VyIi4gIEV4YW1wbGU6ID4KICAgIDpzZXQgcGF0aD1+bW9vbC9pbmNsdWRlLC91c3IvaW5jbHVkZSwuCgpPbiBVbml4IHN5c3RlbXMgdGhlIGZvcm0gIiR7SE9NRX0iIGNhbiBiZSB1c2VkIHRvby4gIFRoZSBuYW1lIGJldHdlZW4ge30gY2FuCmNvbnRhaW4gbm9uLWlkIGNoYXJhY3RlcnMgdGhlbi4gIE5vdGUgdGhhdCBpZiB5b3Ugd2FudCB0byB1c2UgdGhpcyBmb3IgdGhlCiJnZiIgY29tbWFuZCwgeW91IG5lZWQgdG8gYWRkIHRoZSAneycgYW5kICd9JyBjaGFyYWN0ZXJzIHRvICdpc2ZuYW1lJy4KCk5PVEU6IGV4cGFuZGluZyBlbnZpcm9ubWVudCB2YXJpYWJsZXMgYW5kICJ+LyIgaXMgb25seSBkb25lIHdpdGggdGhlICI6c2V0Igpjb21tYW5kLCBub3Qgd2hlbiBhc3NpZ25pbmcgYSB2YWx1ZSB0byBhbiBvcHRpb24gd2l0aCAiOmxldCIuCgoKTm90ZSB0aGUgbWF4aW11bSBsZW5ndGggb2YgYW4gZXhwYW5kZWQgb3B0aW9uIGlzIGxpbWl0ZWQuICBIb3cgbXVjaCBkZXBlbmRzIG9uCnRoZSBzeXN0ZW0sIG1vc3RseSBpdCBpcyBzb21ldGhpbmcgbGlrZSAyNTYgb3IgMTAyNCBjaGFyYWN0ZXJzLgoKCQkJCQkJCSo6Zml4KiAqOmZpeGRlbCoKOmZpeFtkZWxdCQlTZXQgdGhlIHZhbHVlIG9mICd0X2tEJzoKCQkJCSd0X2tiJyBpcyAgICAgJ3Rfa0QnIGJlY29tZXMJfgoJCQkJICBDVFJMLT8JQ1RSTC1ICgkJCQlub3QgQ1RSTC0/CUNUUkwtPwoKCQkJKENUUkwtPyBpcyAwMTc3IG9jdGFsLCAweDdmIGhleCkge25vdCBpbiBWaX0KCgkJCUlmIHlvdXIgZGVsZXRlIGtleSB0ZXJtaW5hbCBjb2RlIGlzIHdyb25nLCBidXQgdGhlCgkJCWNvZGUgZm9yIGJhY2tzcGFjZSBpcyBhbHJpZ2h0LCB5b3UgY2FuIHB1dCB0aGlzIGluCgkJCXlvdXIgLnZpbXJjOiA+CgkJCQk6Zml4ZGVsCjwJCQlUaGlzIHdvcmtzIG5vIG1hdHRlciB3aGF0IHRoZSBhY3R1YWwgY29kZSBmb3IKCQkJYmFja3NwYWNlIGlzLgoKCQkJSWYgdGhlIGJhY2tzcGFjZSBrZXkgdGVybWluYWwgY29kZSBpcyB3cm9uZyB5b3UgY2FuCgkJCXVzZSB0aGlzOiA+CgkJCQk6aWYgJnRlcm0gPT0gInRlcm1uYW1lIgoJCQkJOiAgc2V0IHRfa2I9XlY8QlM+CgkJCQk6ICBmaXhkZWwKCQkJCTplbmRpZgo8CQkJV2hlcmUgIl5WIiBpcyBDVFJMLVYgYW5kICI8QlM+IiBpcyB0aGUgYmFja3NwYWNlIGtleQoJCQkoZG9uJ3QgdHlwZSBmb3VyIGNoYXJhY3RlcnMhKS4gIFJlcGxhY2UgInRlcm1uYW1lIgoJCQl3aXRoIHlvdXIgdGVybWluYWwgbmFtZS4KCgkJCUlmIHlvdXIgPERlbGV0ZT4ga2V5IHNlbmRzIGEgc3RyYW5nZSBrZXkgc2VxdWVuY2UgKG5vdAoJCQlDVFJMLT8gb3IgQ1RSTC1IKSB5b3UgY2Fubm90IHVzZSAiOmZpeGRlbCIuICBUaGVuIHVzZTogPgoJCQkJOmlmICZ0ZXJtID09ICJ0ZXJtbmFtZSIKCQkJCTogIHNldCB0X2tEPV5WPERlbGV0ZT4KCQkJCTplbmRpZgo8CQkJV2hlcmUgIl5WIiBpcyBDVFJMLVYgYW5kICI8RGVsZXRlPiIgaXMgdGhlIGRlbGV0ZSBrZXkKCQkJKGRvbid0IHR5cGUgZWlnaHQgY2hhcmFjdGVycyEpLiAgUmVwbGFjZSAidGVybW5hbWUiCgkJCXdpdGggeW91ciB0ZXJtaW5hbCBuYW1lLgoKCQkJCQkJCSpMaW51eC1iYWNrc3BhY2UqCgkJCU5vdGUgYWJvdXQgTGludXg6IEJ5IGRlZmF1bHQgdGhlIGJhY2tzcGFjZSBrZXkKCQkJcHJvZHVjZXMgQ1RSTC0/LCB3aGljaCBpcyB3cm9uZy4gIFlvdSBjYW4gZml4IGl0IGJ5CgkJCXB1dHRpbmcgdGhpcyBsaW5lIGluIHlvdXIgcmMubG9jYWw6ID4KCQkJCWVjaG8gImtleWNvZGUgMTQgPSBCYWNrU3BhY2UiIHwgbG9hZGtleXMKPAoJCQkJCQkJKk5ldEJTRC1iYWNrc3BhY2UqCgkJCU5vdGUgYWJvdXQgTmV0QlNEOiBJZiB5b3VyIGJhY2tzcGFjZSBkb2Vzbid0IHByb2R1Y2UKCQkJdGhlIHJpZ2h0IGNvZGUsIHRyeSB0aGlzOiA+CgkJCQl4bW9kbWFwIC1lICJrZXljb2RlIDIyID0gQmFja1NwYWNlIgo8CQkJSWYgdGhpcyB3b3JrcywgYWRkIHRoaXMgaW4geW91ciAuWG1vZG1hcCBmaWxlOiA+CgkJCQlrZXlzeW0gMjIgPSBCYWNrU3BhY2UKPAkJCVlvdSBuZWVkIHRvIHJlc3RhcnQgZm9yIHRoaXMgdG8gdGFrZSBlZmZlY3QuCgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KMi4gQXV0b21hdGljYWxseSBzZXR0aW5nIG9wdGlvbnMJCQkqYXV0by1zZXR0aW5nKgoKQmVzaWRlcyBjaGFuZ2luZyBvcHRpb25zIHdpdGggdGhlICI6c2V0IiBjb21tYW5kLCB0aGVyZSBhcmUgdGhyZWUgYWx0ZXJuYXRpdmVzCnRvIHNldCBvcHRpb25zIGF1dG9tYXRpY2FsbHkgZm9yIG9uZSBvciBtb3JlIGZpbGVzOgoKMS4gV2hlbiBzdGFydGluZyBWaW0gaW5pdGlhbGl6YXRpb25zIGFyZSByZWFkIGZyb20gdmFyaW91cyBwbGFjZXMuICBTZWUKICAgfGluaXRpYWxpemF0aW9ufC4gIE1vc3Qgb2YgdGhlbSBhcmUgcGVyZm9ybWVkIGZvciBhbGwgZWRpdGluZyBzZXNzaW9ucywKICAgYW5kIHNvbWUgb2YgdGhlbSBkZXBlbmQgb24gdGhlIGRpcmVjdG9yeSB3aGVyZSBWaW0gaXMgc3RhcnRlZC4KICAgWW91IGNhbiBjcmVhdGUgYW4gaW5pdGlhbGl6YXRpb24gZmlsZSB3aXRoIHw6bWt2aW1yY3wsIHw6bWt2aWV3fCBhbmQKICAgfDpta3Nlc3Npb258LgoyLiBJZiB5b3Ugc3RhcnQgZWRpdGluZyBhIG5ldyBmaWxlLCB0aGUgYXV0b21hdGljIGNvbW1hbmRzIGFyZSBleGVjdXRlZC4KICAgVGhpcyBjYW4gYmUgdXNlZCB0byBzZXQgb3B0aW9ucyBmb3IgZmlsZXMgbWF0Y2hpbmcgYSBwYXJ0aWN1bGFyIHBhdHRlcm4gYW5kCiAgIG1hbnkgb3RoZXIgdGhpbmdzLiAgU2VlIHxhdXRvY29tbWFuZHwuCjMuIElmIHlvdSBzdGFydCBlZGl0aW5nIGEgbmV3IGZpbGUsIGFuZCB0aGUgJ21vZGVsaW5lJyBvcHRpb24gaXMgb24sIGEKICAgbnVtYmVyIG9mIGxpbmVzIGF0IHRoZSBiZWdpbm5pbmcgYW5kIGVuZCBvZiB0aGUgZmlsZSBhcmUgY2hlY2tlZCBmb3IKICAgbW9kZWxpbmVzLiAgVGhpcyBpcyBleHBsYWluZWQgaGVyZS4KCgkJCQkJKm1vZGVsaW5lKiAqdmltOiogKnZpOiogKmV4OiogKkU1MjAqClRoZXJlIGFyZSB0d28gZm9ybXMgb2YgbW9kZWxpbmVzLiAgVGhlIGZpcnN0IGZvcm06CglbdGV4dF17d2hpdGV9e3ZpOnx2aW06fGV4On1bd2hpdGVde29wdGlvbnN9CgpbdGV4dF0JCWFueSB0ZXh0IG9yIGVtcHR5Cnt3aGl0ZX0JCWF0IGxlYXN0IG9uZSBibGFuayBjaGFyYWN0ZXIgKDxTcGFjZT4gb3IgPFRhYj4pCnt2aTp8dmltOnxleDp9CXRoZSBzdHJpbmcgInZpOiIsICJ2aW06IiBvciAiZXg6Igpbd2hpdGVdCQlvcHRpb25hbCB3aGl0ZSBzcGFjZQp7b3B0aW9uc30JYSBsaXN0IG9mIG9wdGlvbiBzZXR0aW5ncywgc2VwYXJhdGVkIHdpdGggd2hpdGUgc3BhY2Ugb3IgJzonLAoJCXdoZXJlIGVhY2ggcGFydCBiZXR3ZWVuICc6JyBpcyB0aGUgYXJndW1lbnQgZm9yIGEgIjpzZXQiCgkJY29tbWFuZAoKRXhhbXBsZTogPgogICB2aTpub2FpOnN3PTMgdHM9NgoKVGhlIHNlY29uZCBmb3JtICh0aGlzIGlzIGNvbXBhdGlibGUgd2l0aCBzb21lIHZlcnNpb25zIG9mIFZpKToKCglbdGV4dF17d2hpdGV9e3ZpOnx2aW06fGV4On1bd2hpdGVdc2VbdF0ge29wdGlvbnN9Olt0ZXh0XQoKW3RleHRdCQlhbnkgdGV4dCBvciBlbXB0eQp7d2hpdGV9CQlhdCBsZWFzdCBvbmUgYmxhbmsgY2hhcmFjdGVyICg8U3BhY2U+IG9yIDxUYWI+KQp7dmk6fHZpbTp8ZXg6fQl0aGUgc3RyaW5nICJ2aToiLCAidmltOiIgb3IgImV4OiIKW3doaXRlXQkJb3B0aW9uYWwgd2hpdGUgc3BhY2UKc2VbdF0JCXRoZSBzdHJpbmcgInNldCAiIG9yICJzZSAiIChub3RlIHRoZSBzcGFjZSkKe29wdGlvbnN9CWEgbGlzdCBvZiBvcHRpb25zLCBzZXBhcmF0ZWQgd2l0aCB3aGl0ZSBzcGFjZSwgd2hpY2ggaXMgdGhlCgkJYXJndW1lbnQgZm9yIGEgIjpzZXQiIGNvbW1hbmQKOgkJYSBjb2xvbgpbdGV4dF0JCWFueSB0ZXh0IG9yIGVtcHR5CgpFeGFtcGxlOiA+CiAgIC8qIHZpbTogc2V0IGFpIHR3PTc1OiAqLwoKVGhlIHdoaXRlIHNwYWNlIGJlZm9yZSB7dmk6fHZpbTp8ZXg6fSBpcyByZXF1aXJlZC4gIFRoaXMgbWluaW1pemVzIHRoZSBjaGFuY2UKdGhhdCBhIG5vcm1hbCB3b3JkIGxpa2UgImxleDoiIGlzIGNhdWdodC4gIFRoZXJlIGlzIG9uZSBleGNlcHRpb246ICJ2aToiIGFuZAoidmltOiIgY2FuIGFsc28gYmUgYXQgdGhlIHN0YXJ0IG9mIHRoZSBsaW5lIChmb3IgY29tcGF0aWJpbGl0eSB3aXRoIHZlcnNpb24KMy4wKS4gIFVzaW5nICJleDoiIGF0IHRoZSBzdGFydCBvZiB0aGUgbGluZSB3aWxsIGJlIGlnbm9yZWQgKHRoaXMgY291bGQgYmUKc2hvcnQgZm9yICJleGFtcGxlOiIpLgoKCQkJCQkJCSptb2RlbGluZS1sb2NhbCoKVGhlIG9wdGlvbnMgYXJlIHNldCBsaWtlIHdpdGggIjpzZXRsb2NhbCI6IFRoZSBuZXcgdmFsdWUgb25seSBhcHBsaWVzIHRvIHRoZQpidWZmZXIgYW5kIHdpbmRvdyB0aGF0IGNvbnRhaW4gdGhlIGZpbGUuICBBbHRob3VnaCBpdCdzIHBvc3NpYmxlIHRvIHNldCBnbG9iYWwKb3B0aW9ucyBmcm9tIGEgbW9kZWxpbmUsIHRoaXMgaXMgdW51c3VhbC4gIElmIHlvdSBoYXZlIHR3byB3aW5kb3dzIG9wZW4gYW5kCnRoZSBmaWxlcyBpbiBpdCBzZXQgdGhlIHNhbWUgZ2xvYmFsIG9wdGlvbiB0byBhIGRpZmZlcmVudCB2YWx1ZSwgdGhlIHJlc3VsdApkZXBlbmRzIG9uIHdoaWNoIG9uZSB3YXMgb3BlbmVkIGxhc3QuCgpXaGVuIGVkaXRpbmcgYSBmaWxlIHRoYXQgd2FzIGFscmVhZHkgbG9hZGVkLCBvbmx5IHRoZSB3aW5kb3ctbG9jYWwgb3B0aW9ucwpmcm9tIHRoZSBtb2RlbGluZSBhcmUgdXNlZC4gIFRodXMgaWYgeW91IG1hbnVhbGx5IGNoYW5nZWQgYSBidWZmZXItbG9jYWwKb3B0aW9uIGFmdGVyIG9wZW5pbmcgdGhlIGZpbGUsIGl0IHdvbid0IGJlIGNoYW5nZWQgaWYgeW91IGVkaXQgdGhlIHNhbWUgYnVmZmVyCmluIGFub3RoZXIgd2luZG93LiAgQnV0IHdpbmRvdy1sb2NhbCBvcHRpb25zIHdpbGwgYmUgc2V0LgoKCQkJCQkJCSptb2RlbGluZS12ZXJzaW9uKgpJZiB0aGUgbW9kZWxpbmUgaXMgb25seSB0byBiZSB1c2VkIGZvciBzb21lIHZlcnNpb25zIG9mIFZpbSwgdGhlIHZlcnNpb24KbnVtYmVyIGNhbiBiZSBzcGVjaWZpZWQgd2hlcmUgInZpbToiIGlzIHVzZWQ6Cgl2aW17dmVyc306CXZlcnNpb24ge3ZlcnN9IG9yIGxhdGVyCgl2aW08e3ZlcnN9Ogl2ZXJzaW9uIGJlZm9yZSB7dmVyc30KCXZpbT17dmVyc306CXZlcnNpb24ge3ZlcnN9Cgl2aW0+e3ZlcnN9Ogl2ZXJzaW9uIGFmdGVyIHt2ZXJzfQp7dmVyc30gaXMgNjAwIGZvciBWaW0gNi4wIChodW5kcmVkIHRpbWVzIHRoZSBtYWpvciB2ZXJzaW9uIHBsdXMgbWlub3IpLgpGb3IgZXhhbXBsZSwgdG8gdXNlIGEgbW9kZWxpbmUgb25seSBmb3IgVmltIDYuMCBhbmQgbGF0ZXI6ID4KCS8qIHZpbTYwMDogc2V0IGZvbGRtZXRob2Q9bWFya2VyOiAqLwpUbyB1c2UgYSBtb2RlbGluZSBmb3IgVmltIGJlZm9yZSB2ZXJzaW9uIDUuNzogPgoJLyogdmltPDU3MDogc2V0IHN3PTQ6ICovClRoZXJlIGNhbiBiZSBubyBibGFua3MgYmV0d2VlbiAidmltIiBhbmQgdGhlICI6Ii4KCgpUaGUgbnVtYmVyIG9mIGxpbmVzIHRoYXQgYXJlIGNoZWNrZWQgY2FuIGJlIHNldCB3aXRoIHRoZSAnbW9kZWxpbmVzJyBvcHRpb24uCklmICdtb2RlbGluZScgaXMgb2ZmIG9yICdtb2RlbGluZXMnIGlzIDAgbm8gbGluZXMgYXJlIGNoZWNrZWQuCgpOb3RlIHRoYXQgZm9yIHRoZSBmaXJzdCBmb3JtIGFsbCBvZiB0aGUgcmVzdCBvZiB0aGUgbGluZSBpcyB1c2VkLCB0aHVzIGEgbGluZQpsaWtlOiA+CiAgIC8qIHZpOnRzPTQ6ICovCndpbGwgZ2l2ZSBhbiBlcnJvciBtZXNzYWdlIGZvciB0aGUgdHJhaWxpbmcgIiovIi4gIFRoaXMgbGluZSBpcyBPSzogPgogICAvKiB2aTpzZXQgdHM9NDogKi8KCklmIGFuIGVycm9yIGlzIGRldGVjdGVkIHRoZSByZXN0IG9mIHRoZSBsaW5lIGlzIHNraXBwZWQuCgpJZiB5b3Ugd2FudCB0byBpbmNsdWRlIGEgJzonIGluIGEgc2V0IGNvbW1hbmQgcHJlY2VkZSBpdCB3aXRoIGEgJ1wnLiAgVGhlCmJhY2tzbGFzaCBpbiBmcm9udCBvZiB0aGUgJzonIHdpbGwgYmUgcmVtb3ZlZC4gIEV4YW1wbGU6ID4KICAgLyogdmk6c2V0IGRpcj1jXDpcdG1wOiAqLwpUaGlzIHNldHMgdGhlICdkaXInIG9wdGlvbiB0byAiYzpcdG1wIi4gIE9ubHkgYSBzaW5nbGUgYmFja3NsYXNoIGJlZm9yZSB0aGUKJzonIGlzIHJlbW92ZWQuICBUaHVzIHRvIGluY2x1ZGUgIlw6IiB5b3UgaGF2ZSB0byBzcGVjaWZ5ICJcXDoiLgoKTm8gb3RoZXIgY29tbWFuZHMgdGhhbiAic2V0IiBhcmUgc3VwcG9ydGVkLCBmb3Igc2VjdXJpdHkgcmVhc29ucyAoc29tZWJvZHkKbWlnaHQgY3JlYXRlIGEgVHJvamFuIGhvcnNlIHRleHQgZmlsZSB3aXRoIG1vZGVsaW5lcykuCgpIaW50OiBJZiB5b3Ugd291bGQgbGlrZSB0byBkbyBzb21ldGhpbmcgZWxzZSB0aGFuIHNldHRpbmcgYW4gb3B0aW9uLCB5b3UgY291bGQKZGVmaW5lIGFuIGF1dG9jb21tYW5kIHRoYXQgY2hlY2tzIHRoZSBmaWxlIGZvciBhIHNwZWNpZmljIHN0cmluZy4gIEZvcgpleGFtcGxlOiA+CglhdSBCdWZSZWFkUG9zdCAqIGlmIGdldGxpbmUoMSkgPX4gIlZBUiIgfCBjYWxsIFNldFZhcigpIHwgZW5kaWYKQW5kIGRlZmluZSBhIGZ1bmN0aW9uIFNldFZhcigpIHRoYXQgZG9lcyBzb21ldGhpbmcgd2l0aCB0aGUgbGluZSBjb250YWluaW5nCiJWQVIiLgoKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CjMuIE9wdGlvbnMgc3VtbWFyeQkJCQkJKm9wdGlvbi1zdW1tYXJ5KgoKSW4gdGhlIGxpc3QgYmVsb3cgYWxsIHRoZSBvcHRpb25zIGFyZSBtZW50aW9uZWQgd2l0aCB0aGVpciBmdWxsIG5hbWUgYW5kIHdpdGgKYW4gYWJicmV2aWF0aW9uIGlmIHRoZXJlIGlzIG9uZS4gIEJvdGggZm9ybXMgbWF5IGJlIHVzZWQuCgpJbiB0aGlzIGRvY3VtZW50IHdoZW4gYSBib29sZWFuIG9wdGlvbiBpcyAic2V0IiB0aGF0IG1lYW5zIHRoYXQgIjpzZXQgb3B0aW9uIgppcyBlbnRlcmVkLiAgV2hlbiBhbiBvcHRpb24gaXMgInJlc2V0IiwgIjpzZXQgbm9vcHRpb24iIGlzIHVzZWQuCgpGb3Igc29tZSBvcHRpb25zIHRoZXJlIGFyZSB0d28gZGVmYXVsdCB2YWx1ZXM6IFRoZSAiVmltIGRlZmF1bHQiLCB3aGljaCBpcwp1c2VkIHdoZW4gJ2NvbXBhdGlibGUnIGlzIG5vdCBzZXQsIGFuZCB0aGUgIlZpIGRlZmF1bHQiLCB3aGljaCBpcyB1c2VkIHdoZW4KJ2NvbXBhdGlibGUnIGlzIHNldC4KCk1vc3Qgb3B0aW9ucyBhcmUgdGhlIHNhbWUgaW4gYWxsIHdpbmRvd3MgYW5kIGJ1ZmZlcnMuICBUaGVyZSBhcmUgYSBmZXcgdGhhdAphcmUgc3BlY2lmaWMgdG8gaG93IHRoZSB0ZXh0IGlzIHByZXNlbnRlZCBpbiBhIHdpbmRvdy4gIFRoZXNlIGNhbiBiZSBzZXQgdG8gYQpkaWZmZXJlbnQgdmFsdWUgaW4gZWFjaCB3aW5kb3cuICBGb3IgZXhhbXBsZSB0aGUgJ2xpc3QnIG9wdGlvbiBjYW4gYmUgc2V0IGluCm9uZSB3aW5kb3cgYW5kIHJlc2V0IGluIGFub3RoZXIgZm9yIHRoZSBzYW1lIHRleHQsIGdpdmluZyBib3RoIHR5cGVzIG9mIHZpZXcKYXQgdGhlIHNhbWUgdGltZS4gIFRoZXJlIGFyZSBhIGZldyBvcHRpb25zIHRoYXQgYXJlIHNwZWNpZmljIHRvIGEgY2VydGFpbgpmaWxlLiAgVGhlc2UgY2FuIGhhdmUgYSBkaWZmZXJlbnQgdmFsdWUgZm9yIGVhY2ggZmlsZSBvciBidWZmZXIuICBGb3IgZXhhbXBsZQp0aGUgJ3RleHR3aWR0aCcgb3B0aW9uIGNhbiBiZSA3OCBmb3IgYSBub3JtYWwgdGV4dCBmaWxlIGFuZCAwIGZvciBhIEMKcHJvZ3JhbS4KCglnbG9iYWwJCQlvbmUgb3B0aW9uIGZvciBhbGwgYnVmZmVycyBhbmQgd2luZG93cwoJbG9jYWwgdG8gd2luZG93CQllYWNoIHdpbmRvdyBoYXMgaXRzIG93biBjb3B5IG9mIHRoaXMgb3B0aW9uCglsb2NhbCB0byBidWZmZXIJCWVhY2ggYnVmZmVyIGhhcyBpdHMgb3duIGNvcHkgb2YgdGhpcyBvcHRpb24KCldoZW4gY3JlYXRpbmcgYSBuZXcgd2luZG93IHRoZSBvcHRpb24gdmFsdWVzIGZyb20gdGhlIGN1cnJlbnRseSBhY3RpdmUgd2luZG93CmFyZSB1c2VkIGFzIGEgZGVmYXVsdCB2YWx1ZSBmb3IgdGhlIHdpbmRvdy1zcGVjaWZpYyBvcHRpb25zLiAgRm9yIHRoZQpidWZmZXItc3BlY2lmaWMgb3B0aW9ucyB0aGlzIGRlcGVuZHMgb24gdGhlICdzJyBhbmQgJ1MnIGZsYWdzIGluIHRoZQonY3BvcHRpb25zJyBvcHRpb24uICBJZiAncycgaXMgaW5jbHVkZWQgKHdoaWNoIGlzIHRoZSBkZWZhdWx0KSB0aGUgdmFsdWVzIGZvcgpidWZmZXIgb3B0aW9ucyBhcmUgY29waWVkIGZyb20gdGhlIGN1cnJlbnRseSBhY3RpdmUgYnVmZmVyIHdoZW4gYSBidWZmZXIgaXMKZmlyc3QgZW50ZXJlZC4gIElmICdTJyBpcyBwcmVzZW50IHRoZSBvcHRpb25zIGFyZSBjb3BpZWQgZWFjaCB0aW1lIHRoZSBidWZmZXIKaXMgZW50ZXJlZCwgdGhpcyBpcyBhbG1vc3QgbGlrZSBoYXZpbmcgZ2xvYmFsIG9wdGlvbnMuICBJZiAncycgYW5kICdTJyBhcmUgbm90CnByZXNlbnQsIHRoZSBvcHRpb25zIGFyZSBjb3BpZWQgZnJvbSB0aGUgY3VycmVudGx5IGFjdGl2ZSBidWZmZXIgd2hlbiB0aGUKYnVmZmVyIGlzIGNyZWF0ZWQuCgpOb3QgYWxsIG9wdGlvbnMgYXJlIHN1cHBvcnRlZCBpbiBhbGwgdmVyc2lvbnMuICBUbyB0ZXN0IGlmIG9wdGlvbiAiZm9vIiBjYW4gYmUKdXNlZCB3aXRoICI6c2V0IiB1c2UgImV4aXN0cygnJmZvbycpIi4gIFRoaXMgZG9lc24ndCBtZWFuIHRoZSB2YWx1ZSBpcwphY3R1YWxseSByZW1lbWJlcmVkIGFuZCB3b3Jrcy4gIFNvbWUgb3B0aW9ucyBhcmUgaGlkZGVuLCB3aGljaCBtZWFucyB0aGF0IHlvdQpjYW4gc2V0IHRoZW0gYnV0IHRoZSB2YWx1ZSBpcyBub3QgcmVtZW1iZXJlZC4gIFRvIHRlc3QgaWYgb3B0aW9uICJmb28iIGlzCnJlYWxseSBzdXBwb3J0ZWQgdXNlICJleGlzdHMoJytmb28nKSIuCgoJCQkJCQkJKkUzNTUqCkEganVtcCB0YWJsZSBmb3IgdGhlIG9wdGlvbnMgd2l0aCBhIHNob3J0IGRlc2NyaXB0aW9uIGNhbiBiZSBmb3VuZCBhdCB8UV9vcHwuCgoJCQkJCSonYWxlcGgnKiAqJ2FsJyogKmFsZXBoKiAqQWxlcGgqCidhbGVwaCcgJ2FsJwkJbnVtYmVyCShkZWZhdWx0IDEyOCBmb3IgTVMtRE9TLCAyMjQgb3RoZXJ3aXNlKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtyaWdodGxlZnR8CgkJCWZlYXR1cmV9CglUaGUgQVNDSUkgY29kZSBmb3IgdGhlIGZpcnN0IGxldHRlciBvZiB0aGUgSGVicmV3IGFscGhhYmV0LiAgVGhlCglyb3V0aW5lIHRoYXQgbWFwcyB0aGUga2V5Ym9hcmQgaW4gSGVicmV3IG1vZGUsIGJvdGggaW4gSW5zZXJ0IG1vZGUKCSh3aGVuIGhrbWFwIGlzIHNldCkgYW5kIG9uIHRoZSBjb21tYW5kLWxpbmUgKHdoZW4gaGl0dGluZyBDVFJMLV8pCglvdXRwdXRzIHRoZSBIZWJyZXcgY2hhcmFjdGVycyBpbiB0aGUgcmFuZ2UgW2FsZXBoLi5hbGVwaCsyNl0uCglhbGVwaD0xMjggYXBwbGllcyB0byBQQyBjb2RlLCBhbmQgYWxlcGg9MjI0IGFwcGxpZXMgdG8gSVNPIDg4NTktOC4KCVNlZSB8cmlsZWZ0LnR4dHwuCgoJCQkqJ2FsbG93cmV2aW5zJyogKidhcmknKiAqJ25vYWxsb3dyZXZpbnMnKiAqJ25vYXJpJyoKJ2FsbG93cmV2aW5zJyAnYXJpJwlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmlnaHRsZWZ0fAoJCQlmZWF0dXJlfQoJQWxsb3cgQ1RSTC1fIGluIEluc2VydCBhbmQgQ29tbWFuZC1saW5lIG1vZGUuICBUaGlzIGlzIGRlZmF1bHQgb2ZmLCB0bwoJYXZvaWQgdGhhdCB1c2VycyB0aGF0IGFjY2lkZW50YWxseSB0eXBlIENUUkwtXyBpbnN0ZWFkIG9mIFNISUZULV8gZ2V0CglpbnRvIHJldmVyc2UgSW5zZXJ0IG1vZGUsIGFuZCBkb24ndCBrbm93IGhvdyB0byBnZXQgb3V0LiAgU2VlCgkncmV2aW5zJy4KCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHJlc2V0IHdoZW4gJ2NvbXBhdGlibGUnIGlzIHNldC4KCgkJCSAqJ2FsdGtleW1hcCcqIConYWttJyogKidub2FsdGtleW1hcCcqIConbm9ha20nKgonYWx0a2V5bWFwJyAnYWttJwlib29sZWFuIChkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrZmFyc2l8CgkJCWZlYXR1cmV9CglXaGVuIG9uLCB0aGUgc2Vjb25kIGxhbmd1YWdlIGlzIEZhcnNpLiAgSW4gZWRpdGluZyBtb2RlIENUUkwtXyB0b2dnbGVzCgl0aGUga2V5Ym9hcmQgbWFwIGJldHdlZW4gRmFyc2kgYW5kIEVuZ2xpc2gsIHdoZW4gJ2FsbG93cmV2aW5zJyBzZXQuCgoJV2hlbiBvZmYsIHRoZSBrZXlib2FyZCBtYXAgdG9nZ2xlcyBiZXR3ZWVuIEhlYnJldyBhbmQgRW5nbGlzaC4gIFRoaXMKCWlzIHVzZWZ1bCB0byBzdGFydCB0aGUgVmltIGluIG5hdGl2ZSBtb2RlIGkuZS4gRW5nbGlzaCAobGVmdC10by1yaWdodAoJbW9kZSkgYW5kIGhhdmUgZGVmYXVsdCBzZWNvbmQgbGFuZ3VhZ2UgRmFyc2kgb3IgSGVicmV3IChyaWdodC10by1sZWZ0Cgltb2RlKS4gIFNlZSB8ZmFyc2kudHh0fC4KCgkJCQkJCSonYW1iaXdpZHRoJyogKidhbWJ3JyoKJ2FtYml3aWR0aCcgJ2FtYncnCXN0cmluZyAoZGVmYXVsdDogInNpbmdsZSIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K211bHRpX2J5dGV8CgkJCWZlYXR1cmV9CglPbmx5IGVmZmVjdGl2ZSB3aGVuICdlbmNvZGluZycgaXMgInV0Zi04IiBvciBhbm90aGVyIFVuaWNvZGUgZW5jb2RpbmcuCglUZWxscyBWaW0gd2hhdCB0byBkbyB3aXRoIGNoYXJhY3RlcnMgd2l0aCBFYXN0IEFzaWFuIFdpZHRoIENsYXNzCglBbWJpZ3VvdXMgKHN1Y2ggYXMgRXVybywgUmVnaXN0ZXJlZCBTaWduLCBDb3B5cmlnaHQgU2lnbiwgR3JlZWsKCWxldHRlcnMsIEN5cmlsbGljIGxldHRlcnMpLgoKCVRoZXJlIGFyZSBjdXJyZW50bHkgdHdvIHBvc3NpYmxlIHZhbHVlczoKCSJzaW5nbGUiOglVc2UgdGhlIHNhbWUgd2lkdGggYXMgY2hhcmFjdGVycyBpbiBVUy1BU0NJSS4gIFRoaXMgaXMKCQkJZXhwZWN0ZWQgYnkgbW9zdCB1c2Vycy4KCSJkb3VibGUiOglVc2UgdHdpY2UgdGhlIHdpZHRoIG9mIEFTQ0lJIGNoYXJhY3RlcnMuCgoJVGhlcmUgYXJlIGEgbnVtYmVyIG9mIENKSyBmb250cyBmb3Igd2hpY2ggdGhlIHdpZHRoIG9mIGdseXBocyBmb3IKCXRob3NlIGNoYXJhY3RlcnMgYXJlIHNvbGVseSBiYXNlZCBvbiBob3cgbWFueSBvY3RldHMgdGhleSB0YWtlIGluCglsZWdhY3kvdHJhZGl0aW9uYWwgQ0pLIGVuY29kaW5ncy4gIEluIHRob3NlIGVuY29kaW5ncywgRXVybywKCVJlZ2lzdGVyZWQgc2lnbiwgR3JlZWsvQ3lyaWxsaWMgbGV0dGVycyBhcmUgcmVwcmVzZW50ZWQgYnkgdHdvIG9jdGV0cywKCXRoZXJlZm9yZSB0aG9zZSBmb250cyBoYXZlICJ3aWRlIiBnbHlwaHMgZm9yIHRoZW0uICBUaGlzIGlzIGFsc28KCXRydWUgb2Ygc29tZSBsaW5lIGRyYXdpbmcgY2hhcmFjdGVycyB1c2VkIHRvIG1ha2UgdGFibGVzIGluIHRleHQKCWZpbGUuICBUaGVyZWZvcmUsIHdoZW4gYSBDSksgZm9udCBpcyB1c2VkIGZvciBHVUkgVmltIG9yCglWaW0gaXMgcnVubmluZyBpbnNpZGUgYSB0ZXJtaW5hbCAoZW11bGF0b3JzKSB0aGF0IHVzZXMgYSBDSksgZm9udAoJKG9yIFZpbSBpcyBydW4gaW5zaWRlIGFuIHh0ZXJtIGludm9rZWQgd2l0aCAiLWNqa3dpZHRoIiBvcHRpb24uKSwKCXRoaXMgb3B0aW9uIHNob3VsZCBiZSBzZXQgdG8gImRvdWJsZSIgdG8gbWF0Y2ggdGhlIHdpZHRoIHBlcmNlaXZlZAoJYnkgVmltIHdpdGggdGhlIHdpZHRoIG9mIGdseXBocyBpbiB0aGUgZm9udC4gIFBlcmhhcHMgaXQgYWxzbyBoYXMKCXRvIGJlIHNldCB0byAiZG91YmxlIiB1bmRlciBDSksgV2luZG93cyA5eC9NRSBvciBXaW5kb3dzIDJrL1hQCgl3aGVuIHRoZSBzeXN0ZW0gbG9jYWxlIGlzIHNldCB0byBvbmUgb2YgQ0pLIGxvY2FsZXMuICBTZWUgVW5pY29kZQoJU3RhbmRhcmQgQW5uZXggIzExIChodHRwOi8vd3d3LnVuaWNvZGUub3JnL3JlcG9ydHMvdHIxMSkuCgoJCQkqJ2FudGlhbGlhcycqIConYW50aScqIConbm9hbnRpYWxpYXMnKiAqJ25vYW50aScqCidhbnRpYWxpYXMnICdhbnRpJwlib29sZWFuIChkZWZhdWx0OiBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIEdVSSBlbmFibGVkCgkJCW9uIE1hYyBPUyBYfQoJVGhpcyBvcHRpb24gb25seSBoYXMgYW4gZWZmZWN0IGluIHRoZSBHVUkgdmVyc2lvbiBvZiBWaW0gb24gTWFjIE9TIFgKCXYxMC4yIG9yIGxhdGVyLiAgV2hlbiBvbiwgVmltIHdpbGwgdXNlIHNtb290aCAoImFudGlhbGlhc2VkIikgZm9udHMsCgl3aGljaCBjYW4gYmUgZWFzaWVyIHRvIHJlYWQgYXQgY2VydGFpbiBzaXplcyBvbiBjZXJ0YWluIGRpc3BsYXlzLgoJU2V0dGluZyB0aGlzIG9wdGlvbiBjYW4gc29tZXRpbWVzIGNhdXNlIHByb2JsZW1zIGlmICdndWlmb250JyBpcyBzZXQKCXRvIGl0cyBkZWZhdWx0IChlbXB0eSBzdHJpbmcpLgoKCQkJKidhdXRvY2hkaXInKiAqJ2FjZCcqIConbm9hdXRvY2hkaXInKiAqJ25vYWNkJyoKJ2F1dG9jaGRpcicgJ2FjZCcJYm9vbGVhbiAoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZQoJCQl8K25ldGJlYW5zX2ludGd8IG9yIHwrc3VuX3dvcmtzaG9wfCBmZWF0dXJlfQoJV2hlbiBvbiwgVmltIHdpbGwgY2hhbmdlIGl0cyB2YWx1ZSBmb3IgdGhlIGN1cnJlbnQgd29ya2luZyBkaXJlY3RvcnkKCXdoZW5ldmVyIHlvdSBvcGVuIGEgZmlsZSwgc3dpdGNoIGJ1ZmZlcnMsIGRlbGV0ZSBhIGJ1ZmZlciBvcgoJb3Blbi9jbG9zZSBhIHdpbmRvdy4gIEl0IHdpbGwgY2hhbmdlIHRvIHRoZSBkaXJlY3RvcnkgY29udGFpbmluZyB0aGUKCWZpbGUgd2hpY2ggd2FzIG9wZW5lZCBvciBzZWxlY3RlZC4gIFRoaXMgb3B0aW9uIGlzIHByb3ZpZGVkIGZvcgoJYmFja3dhcmQgY29tcGF0aWJpbGl0eSB3aXRoIHRoZSBWaW0gcmVsZWFzZWQgd2l0aCBTdW4gT05FIFN0dWRpbyA0CglFbnRlcnByaXNlIEVkaXRpb24uCgoJCQkJKidhcmFiaWMnKiAqJ2FyYWInKiAqJ25vYXJhYmljJyogKidub2FyYWInKgonYXJhYmljJyAnYXJhYicJCWJvb2xlYW4gKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byB3aW5kb3cKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCthcmFiaWN8CgkJCWZlYXR1cmV9CglUaGlzIG9wdGlvbiBjYW4gYmUgc2V0IHRvIHN0YXJ0IGVkaXRpbmcgQXJhYmljIHRleHQuCglTZXR0aW5nIHRoaXMgb3B0aW9uIHdpbGw6CgktIFNldCB0aGUgJ3JpZ2h0bGVmdCcgb3B0aW9uLCB1bmxlc3MgJ3Rlcm1iaWRpJyBpcyBzZXQuCgktIFNldCB0aGUgJ2FyYWJpY3NoYXBlJyBvcHRpb24sIHVubGVzcyAndGVybWJpZGknIGlzIHNldC4KCS0gU2V0IHRoZSAna2V5bWFwJyBvcHRpb24gdG8gImFyYWJpYyI7IGluIEluc2VydCBtb2RlIENUUkwtXiB0b2dnbGVzCgkgIGJldHdlZW4gdHlwaW5nIEVuZ2xpc2ggYW5kIEFyYWJpYyBrZXkgbWFwcGluZy4KCS0gU2V0IHRoZSAnZGVsY29tYmluZScgb3B0aW9uCglOb3RlIHRoYXQgJ2VuY29kaW5nJyBtdXN0IGJlICJ1dGYtOCIgZm9yIHdvcmtpbmcgd2l0aCBBcmFiaWMgdGV4dC4KCglSZXNldHRpbmcgdGhpcyBvcHRpb24gd2lsbDoKCS0gUmVzZXQgdGhlICdyaWdodGxlZnQnIG9wdGlvbi4KCS0gRGlzYWJsZSB0aGUgdXNlIG9mICdrZXltYXAnICh3aXRob3V0IGNoYW5naW5nIGl0cyB2YWx1ZSkuCglOb3RlIHRoYXQgJ2FyYWJpY3NoYXBlJyBhbmQgJ2RlbGNvbWJpbmUnIGFyZSBub3QgcmVzZXQgKGl0IGlzIGEgZ2xvYmFsCglvcHRpb24uCglBbHNvIHNlZSB8YXJhYmljLnR4dHwuCgoJCQkJCSonYXJhYmljc2hhcGUnKiAqJ2Fyc2hhcGUnKgoJCQkJCSonbm9hcmFiaWNzaGFwZScqIConbm9hcnNoYXBlJyoKJ2FyYWJpY3NoYXBlJyAnYXJzaGFwZScJYm9vbGVhbiAoZGVmYXVsdCBvbikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrYXJhYmljfAoJCQlmZWF0dXJlfQoJV2hlbiBvbiBhbmQgJ3Rlcm1iaWRpJyBpcyBvZmYsIHRoZSByZXF1aXJlZCB2aXN1YWwgY2hhcmFjdGVyCgljb3JyZWN0aW9ucyB0aGF0IG5lZWQgdG8gdGFrZSBwbGFjZSBmb3IgZGlzcGxheWluZyB0aGUgQXJhYmljIGxhbmd1YWdlCgl0YWtlIGFmZmVjdC4gIFNoYXBpbmcsIGluIGVzc2VuY2UsIGdldHMgZW5hYmxlZDsgdGhlIHRlcm0gaXMgYSBicm9hZAoJb25lIHdoaWNoIGVuY29tcGFzc2VzOgoJICBhKSB0aGUgY2hhbmdpbmcvbW9ycGhpbmcgb2YgY2hhcmFjdGVycyBiYXNlZCBvbiB0aGVpciBsb2NhdGlvbgoJICAgICB3aXRoaW4gYSB3b3JkIChpbml0aWFsLCBtZWRpYWwsIGZpbmFsIGFuZCBzdGFuZC1hbG9uZSkuCgkgIGIpIHRoZSBlbmFibGluZyBvZiB0aGUgYWJpbGl0eSB0byBjb21wb3NlIGNoYXJhY3RlcnMKCSAgYykgdGhlIGVuYWJsaW5nIG9mIHRoZSByZXF1aXJlZCBjb21iaW5pbmcgb2Ygc29tZSBjaGFyYWN0ZXJzCglXaGVuIGRpc2FibGVkIHRoZSBjaGFyYWN0ZXIgZGlzcGxheSByZXZlcnRzIGJhY2sgdG8gZWFjaCBjaGFyYWN0ZXIncwoJdHJ1ZSBzdGFuZC1hbG9uZSBmb3JtLgoJQXJhYmljIGlzIGEgY29tcGxleCBsYW5ndWFnZSB3aGljaCByZXF1aXJlcyBvdGhlciBzZXR0aW5ncywgZm9yCglmdXJ0aGVyIGRldGFpbHMgc2VlIHxhcmFiaWMudHh0fC4KCgkJCSonYXV0b2luZGVudCcqIConYWknKiAqJ25vYXV0b2luZGVudCcqIConbm9haScqCidhdXRvaW5kZW50JyAnYWknCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byBidWZmZXIKCUNvcHkgaW5kZW50IGZyb20gY3VycmVudCBsaW5lIHdoZW4gc3RhcnRpbmcgYSBuZXcgbGluZSAodHlwaW5nIDxDUj4KCWluIEluc2VydCBtb2RlIG9yIHdoZW4gdXNpbmcgdGhlICJvIiBvciAiTyIgY29tbWFuZCkuICBJZiB5b3UgZG8gbm90Cgl0eXBlIGFueXRoaW5nIG9uIHRoZSBuZXcgbGluZSBleGNlcHQgPEJTPiBvciBDVFJMLUQgYW5kIHRoZW4gdHlwZQoJPEVzYz4gb3IgPENSPiwgdGhlIGluZGVudCBpcyBkZWxldGVkIGFnYWluLiAgTW92aW5nIHRoZSBjdXJzb3IgdG8KCWFub3RoZXIgbGluZSBoYXMgdGhlIHNhbWUgZWZmZWN0LCB1bmxlc3MgdGhlICdJJyBmbGFnIGlzIGluY2x1ZGVkIGluCgknY3BvcHRpb25zJy4KCVdoZW4gYXV0b2luZGVudCBpcyBvbiwgZm9ybWF0dGluZyAod2l0aCB0aGUgImdxIiBjb21tYW5kIG9yIHdoZW4geW91CglyZWFjaCAndGV4dHdpZHRoJyBpbiBJbnNlcnQgbW9kZSkgdXNlcyB0aGUgaW5kZW50YXRpb24gb2YgdGhlIGZpcnN0CglsaW5lLgoJV2hlbiAnc21hcnRpbmRlbnQnIG9yICdjaW5kZW50JyBpcyBvbiB0aGUgaW5kZW50IGlzIGNoYW5nZWQgaW4KCWEgZGlmZmVyZW50IHdheS4KCVRoZSAnYXV0b2luZGVudCcgb3B0aW9uIGlzIHJlc2V0IHdoZW4gdGhlICdwYXN0ZScgb3B0aW9uIGlzIHNldC4KCXtzbWFsbCBkaWZmZXJlbmNlIGZyb20gVmk6IEFmdGVyIHRoZSBpbmRlbnQgaXMgZGVsZXRlZCB3aGVuIHR5cGluZwoJPEVzYz4gb3IgPENSPiwgdGhlIGN1cnNvciBwb3NpdGlvbiB3aGVuIG1vdmluZyB1cCBvciBkb3duIGlzIGFmdGVyIHRoZQoJZGVsZXRlZCBpbmRlbnQ7IFZpIHB1dHMgdGhlIGN1cnNvciBzb21ld2hlcmUgaW4gdGhlIGRlbGV0ZWQgaW5kZW50fS4KCgkJCQkgKidhdXRvcmVhZCcqIConYXInKiAqJ25vYXV0b3JlYWQnKiAqJ25vYXInKgonYXV0b3JlYWQnICdhcicJCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwgb3IgbG9jYWwgdG8gYnVmZmVyIHxnbG9iYWwtbG9jYWx8CgkJCXtub3QgaW4gVml9CglXaGVuIGEgZmlsZSBoYXMgYmVlbiBkZXRlY3RlZCB0byBoYXZlIGJlZW4gY2hhbmdlZCBvdXRzaWRlIG9mIFZpbSBhbmQKCWl0IGhhcyBub3QgYmVlbiBjaGFuZ2VkIGluc2lkZSBvZiBWaW0sIGF1dG9tYXRpY2FsbHkgcmVhZCBpdCBhZ2Fpbi4KCVdoZW4gdGhlIGZpbGUgaGFzIGJlZW4gZGVsZXRlZCB0aGlzIGlzIG5vdCBkb25lLiAgfHRpbWVzdGFtcHwKCUlmIHRoaXMgb3B0aW9uIGhhcyBhIGxvY2FsIHZhbHVlLCB1c2UgdGhpcyBjb21tYW5kIHRvIHN3aXRjaCBiYWNrIHRvCgl1c2luZyB0aGUgZ2xvYmFsIHZhbHVlOiA+CgkJOnNldCBhdXRvcmVhZDwKPAoJCQkJIConYXV0b3dyaXRlJyogKidhdycqIConbm9hdXRvd3JpdGUnKiAqJ25vYXcnKgonYXV0b3dyaXRlJyAnYXcnCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCVdyaXRlIHRoZSBjb250ZW50cyBvZiB0aGUgZmlsZSwgaWYgaXQgaGFzIGJlZW4gbW9kaWZpZWQsIG9uIGVhY2gKCTpuZXh0LCA6cmV3aW5kLCA6bGFzdCwgOmZpcnN0LCA6cHJldmlvdXMsIDpzdG9wLCA6c3VzcGVuZCwgOnRhZywgOiEsCgk6bWFrZSwgQ1RSTC1dIGFuZCBDVFJMLV4gY29tbWFuZDsgYW5kIHdoZW4gYSBDVFJMLU8sIENUUkwtSSwKCSd7QS1aMC05fSwgb3IgYHtBLVowLTl9IGNvbW1hbmQgdGFrZXMgb25lIHRvIGFub3RoZXIgZmlsZS4KCU5vdGUgdGhhdCBmb3Igc29tZSBjb21tYW5kcyB0aGUgJ2F1dG93cml0ZScgb3B0aW9uIGlzIG5vdCB1c2VkLCBzZWUKCSdhdXRvd3JpdGVhbGwnIGZvciB0aGF0LgoKCQkJIConYXV0b3dyaXRlYWxsJyogKidhd2EnKiAqJ25vYXV0b3dyaXRlYWxsJyogKidub2F3YScqCidhdXRvd3JpdGVhbGwnICdhd2EnCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCUxpa2UgJ2F1dG93cml0ZScsIGJ1dCBhbHNvIHVzZWQgZm9yIGNvbW1hbmRzICI6ZWRpdCIsICI6ZW5ldyIsICI6cXVpdCIsCgkiOnFhbGwiLCAiOmV4aXQiLCAiOnhpdCIsICI6cmVjb3ZlciIgYW5kIGNsb3NpbmcgdGhlIFZpbSB3aW5kb3cuCglTZXR0aW5nIHRoaXMgb3B0aW9uIGFsc28gaW1wbGllcyB0aGF0IFZpbSBiZWhhdmVzIGxpa2UgJ2F1dG93cml0ZScgaGFzCgliZWVuIHNldC4KCgkJCQkJCQkqJ2JhY2tncm91bmQnKiAqJ2JnJyoKJ2JhY2tncm91bmQnICdiZycJc3RyaW5nCShkZWZhdWx0ICJkYXJrIiBvciAibGlnaHQiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVdoZW4gc2V0IHRvICJkYXJrIiwgVmltIHdpbGwgdHJ5IHRvIHVzZSBjb2xvcnMgdGhhdCBsb29rIGdvb2Qgb24gYQoJZGFyayBiYWNrZ3JvdW5kLiAgV2hlbiBzZXQgdG8gImxpZ2h0IiwgVmltIHdpbGwgdHJ5IHRvIHVzZSBjb2xvcnMgdGhhdAoJbG9vayBnb29kIG9uIGEgbGlnaHQgYmFja2dyb3VuZC4gIEFueSBvdGhlciB2YWx1ZSBpcyBpbGxlZ2FsLgoJVmltIHRyaWVzIHRvIHNldCB0aGUgZGVmYXVsdCB2YWx1ZSBhY2NvcmRpbmcgdG8gdGhlIHRlcm1pbmFsIHVzZWQuCglUaGlzIHdpbGwgbm90IGFsd2F5cyBiZSBjb3JyZWN0LgoJU2V0dGluZyB0aGlzIG9wdGlvbiBkb2VzIG5vdCBjaGFuZ2UgdGhlIGJhY2tncm91bmQgY29sb3IsIGl0IHRlbGxzIFZpbQoJd2hhdCB0aGUgYmFja2dyb3VuZCBjb2xvciBsb29rcyBsaWtlLiAgRm9yIGNoYW5naW5nIHRoZSBiYWNrZ3JvdW5kCgljb2xvciwgc2VlIHw6aGktbm9ybWFsfC4KCglXaGVuICdiYWNrZ3JvdW5kJyBpcyBzZXQgVmltIHdpbGwgYWRqdXN0IHRoZSBkZWZhdWx0IGNvbG9yIGdyb3VwcyBmb3IKCXRoZSBuZXcgdmFsdWUuICBCdXQgdGhlIGNvbG9ycyB1c2VkIGZvciBzeW50YXggaGlnaGxpZ2h0aW5nIHdpbGwgbm90CgljaGFuZ2UuCglXaGVuIGEgY29sb3Igc2NoZW1lIGlzIGxvYWRlZCAodGhlICJjb2xvcnNfbmFtZSIgdmFyaWFibGUgaXMgc2V0KQoJc2V0dGluZyAnYmFja2dyb3VuZCcgd2lsbCBjYXVzZSB0aGUgY29sb3Igc2NoZW1lIHRvIGJlIHJlbG9hZGVkLiAgSWYKCXRoZSBjb2xvciBzY2hlbWUgYWRqdXN0cyB0byB0aGUgdmFsdWUgb2YgJ2JhY2tncm91bmQnIHRoaXMgd2lsbCB3b3JrLgoJSG93ZXZlciwgaWYgdGhlIGNvbG9yIHNjaGVtZSBzZXRzICdiYWNrZ3JvdW5kJyBpdHNlbGYgdGhlIGVmZmVjdCBtYXkKCWJlIHVuZG9uZS4gIEZpcnN0IGRlbGV0ZSB0aGUgImNvbG9yc19uYW1lIiB2YXJpYWJsZSB3aGVuIG5lZWRlZC4KCglXaGVuIHNldHRpbmcgJ2JhY2tncm91bmQnIHRvIHRoZSBkZWZhdWx0IHZhbHVlIHdpdGg6ID4KCQk6c2V0IGJhY2tncm91bmQmCjwJVmltIHdpbGwgZ3Vlc3MgdGhlIHZhbHVlLiAgSW4gdGhlIEdVSSB0aGlzIHNob3VsZCB3b3JrIGNvcnJlY3RseSwKCWluIG90aGVyIGNhc2VzIFZpbSBtaWdodCBub3QgYmUgYWJsZSB0byBndWVzcyB0aGUgcmlnaHQgdmFsdWUuCgoJV2hlbiBzdGFydGluZyB0aGUgR1VJLCB0aGUgZGVmYXVsdCB2YWx1ZSBmb3IgJ2JhY2tncm91bmQnIHdpbGwgYmUKCSJsaWdodCIuICBXaGVuIHRoZSB2YWx1ZSBpcyBub3Qgc2V0IGluIHRoZSAuZ3ZpbXJjLCBhbmQgVmltIGRldGVjdHMKCXRoYXQgdGhlIGJhY2tncm91bmQgaXMgYWN0dWFsbHkgcXVpdGUgZGFyaywgJ2JhY2tncm91bmQnIGlzIHNldCB0bwoJImRhcmsiLiAgQnV0IHRoaXMgaGFwcGVucyBvbmx5IEFGVEVSIHRoZSAuZ3ZpbXJjIGZpbGUgaGFzIGJlZW4gcmVhZAoJKGJlY2F1c2UgdGhlIHdpbmRvdyBuZWVkcyB0byBiZSBvcGVuZWQgdG8gZmluZCB0aGUgYWN0dWFsIGJhY2tncm91bmQKCWNvbG9yKS4gIFRvIGdldCBhcm91bmQgdGhpcywgZm9yY2UgdGhlIEdVSSB3aW5kb3cgdG8gYmUgb3BlbmVkIGJ5CglwdXR0aW5nIGEgIjpndWkiIGNvbW1hbmQgaW4gdGhlIC5ndmltcmMgZmlsZSwgYmVmb3JlIHdoZXJlIHRoZSB2YWx1ZQoJb2YgJ2JhY2tncm91bmQnIGlzIHVzZWQgKGUuZy4sIGJlZm9yZSAiOnN5bnRheCBvbiIpLgoJTm9ybWFsbHkgdGhpcyBvcHRpb24gd291bGQgYmUgc2V0IGluIHRoZSAudmltcmMgZmlsZS4gIFBvc3NpYmx5CglkZXBlbmRpbmcgb24gdGhlIHRlcm1pbmFsIG5hbWUuICBFeGFtcGxlOiA+CgkJOmlmICZ0ZXJtID09ICJwY3Rlcm0iCgkJOiAgc2V0IGJhY2tncm91bmQ9ZGFyawoJCTplbmRpZgo8CVdoZW4gdGhpcyBvcHRpb24gaXMgc2V0LCB0aGUgZGVmYXVsdCBzZXR0aW5ncyBmb3IgdGhlIGhpZ2hsaWdodCBncm91cHMKCXdpbGwgY2hhbmdlLiAgVG8gdXNlIG90aGVyIHNldHRpbmdzLCBwbGFjZSAiOmhpZ2hsaWdodCIgY29tbWFuZHMgQUZURVIKCXRoZSBzZXR0aW5nIG9mIHRoZSAnYmFja2dyb3VuZCcgb3B0aW9uLgoJVGhpcyBvcHRpb24gaXMgYWxzbyB1c2VkIGluIHRoZSAiJFZJTVJVTlRJTUUvc3ludGF4L3N5bnRheC52aW0iIGZpbGUKCXRvIHNlbGVjdCB0aGUgY29sb3JzIGZvciBzeW50YXggaGlnaGxpZ2h0aW5nLiAgQWZ0ZXIgY2hhbmdpbmcgdGhpcwoJb3B0aW9uLCB5b3UgbXVzdCBsb2FkIHN5bnRheC52aW0gYWdhaW4gdG8gc2VlIHRoZSByZXN1bHQuICBUaGlzIGNhbiBiZQoJZG9uZSB3aXRoICI6c3ludGF4IG9uIi4KCgkJCQkJCQkqJ2JhY2tzcGFjZScqIConYnMnKgonYmFja3NwYWNlJyAnYnMnCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglJbmZsdWVuY2VzIHRoZSB3b3JraW5nIG9mIDxCUz4sIDxEZWw+LCBDVFJMLVcgYW5kIENUUkwtVSBpbiBJbnNlcnQKCW1vZGUuICBUaGlzIGlzIGEgbGlzdCBvZiBpdGVtcywgc2VwYXJhdGVkIGJ5IGNvbW1hcy4gIEVhY2ggaXRlbSBhbGxvd3MKCWEgd2F5IHRvIGJhY2tzcGFjZSBvdmVyIHNvbWV0aGluZzoKCXZhbHVlCWVmZmVjdAl+CglpbmRlbnQJYWxsb3cgYmFja3NwYWNpbmcgb3ZlciBhdXRvaW5kZW50Cgllb2wJYWxsb3cgYmFja3NwYWNpbmcgb3ZlciBsaW5lIGJyZWFrcyAoam9pbiBsaW5lcykKCXN0YXJ0CWFsbG93IGJhY2tzcGFjaW5nIG92ZXIgdGhlIHN0YXJ0IG9mIGluc2VydDsgQ1RSTC1XIGFuZCBDVFJMLVUKCQlzdG9wIG9uY2UgYXQgdGhlIHN0YXJ0IG9mIGluc2VydC4KCglXaGVuIHRoZSB2YWx1ZSBpcyBlbXB0eSwgVmkgY29tcGF0aWJsZSBiYWNrc3BhY2luZyBpcyB1c2VkLgoKCUZvciBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eSB3aXRoIHZlcnNpb24gNS40IGFuZCBlYXJsaWVyOgoJdmFsdWUJZWZmZWN0CX4KCSAgMAlzYW1lIGFzICI6c2V0IGJhY2tzcGFjZT0iIChWaSBjb21wYXRpYmxlKQoJICAxCXNhbWUgYXMgIjpzZXQgYmFja3NwYWNlPWluZGVudCxlb2wiCgkgIDIJc2FtZSBhcyAiOnNldCBiYWNrc3BhY2U9aW5kZW50LGVvbCxzdGFydCIKCglTZWUgfDpmaXhkZWx8IGlmIHlvdXIgPEJTPiBvciA8RGVsPiBrZXkgZG9lcyBub3QgZG8gd2hhdCB5b3Ugd2FudC4KCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHNldCB0byAiIiB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkJKidiYWNrdXAnKiAqJ2JrJyogKidub2JhY2t1cCcqIConbm9iaycqCidiYWNrdXAnICdiaycJCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCU1ha2UgYSBiYWNrdXAgYmVmb3JlIG92ZXJ3cml0aW5nIGEgZmlsZS4gIExlYXZlIGl0IGFyb3VuZCBhZnRlciB0aGUKCWZpbGUgaGFzIGJlZW4gc3VjY2Vzc2Z1bGx5IHdyaXR0ZW4uICBJZiB5b3UgZG8gbm90IHdhbnQgdG8ga2VlcCB0aGUKCWJhY2t1cCBmaWxlLCBidXQgeW91IGRvIHdhbnQgYSBiYWNrdXAgd2hpbGUgdGhlIGZpbGUgaXMgYmVpbmcKCXdyaXR0ZW4sIHJlc2V0IHRoaXMgb3B0aW9uIGFuZCBzZXQgdGhlICd3cml0ZWJhY2t1cCcgb3B0aW9uICh0aGlzIGlzCgl0aGUgZGVmYXVsdCkuICBJZiB5b3UgZG8gbm90IHdhbnQgYSBiYWNrdXAgZmlsZSBhdCBhbGwgcmVzZXQgYm90aAoJb3B0aW9ucyAodXNlIHRoaXMgaWYgeW91ciBmaWxlIHN5c3RlbSBpcyBhbG1vc3QgZnVsbCkuICBTZWUgdGhlCgl8YmFja3VwLXRhYmxlfCBmb3IgbW9yZSBleHBsYW5hdGlvbnMuCglXaGVuIHRoZSAnYmFja3Vwc2tpcCcgcGF0dGVybiBtYXRjaGVzLCBhIGJhY2t1cCBpcyBub3QgbWFkZSBhbnl3YXkuCglXaGVuICdwYXRjaG1vZGUnIGlzIHNldCwgdGhlIGJhY2t1cCBtYXkgYmUgcmVuYW1lZCB0byBiZWNvbWUgdGhlCglvbGRlc3QgdmVyc2lvbiBvZiBhIGZpbGUuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyByZXNldCB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkJCQkqJ2JhY2t1cGNvcHknKiAqJ2JrYycqCidiYWNrdXBjb3B5JyAnYmtjJwlzdHJpbmcJKFZpIGRlZmF1bHQgZm9yIFVuaXg6ICJ5ZXMiLCBvdGhlcndpc2U6ICJhdXRvIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglXaGVuIHdyaXRpbmcgYSBmaWxlIGFuZCBhIGJhY2t1cCBpcyBtYWRlLCB0aGlzIG9wdGlvbiB0ZWxscyBob3cgaXQncwoJZG9uZS4gIFRoaXMgaXMgYSBjb21tYSBzZXBhcmF0ZWQgbGlzdCBvZiB3b3Jkcy4KCglUaGUgbWFpbiB2YWx1ZXMgYXJlOgoJInllcyIJbWFrZSBhIGNvcHkgb2YgdGhlIGZpbGUgYW5kIG92ZXJ3cml0ZSB0aGUgb3JpZ2luYWwgb25lCgkibm8iCXJlbmFtZSB0aGUgZmlsZSBhbmQgd3JpdGUgYSBuZXcgb25lCgkiYXV0byIJb25lIG9mIHRoZSBwcmV2aW91cywgd2hhdCB3b3JrcyBiZXN0CgoJRXh0cmEgdmFsdWVzIHRoYXQgY2FuIGJlIGNvbWJpbmVkIHdpdGggdGhlIG9uZXMgYWJvdmUgYXJlOgoJImJyZWFrc3ltbGluayIJYWx3YXlzIGJyZWFrIHN5bWxpbmtzIHdoZW4gd3JpdGluZwoJImJyZWFraGFyZGxpbmsiCWFsd2F5cyBicmVhayBoYXJkbGlua3Mgd2hlbiB3cml0aW5nCgoJTWFraW5nIGEgY29weSBhbmQgb3ZlcndyaXRpbmcgdGhlIG9yaWdpbmFsIGZpbGU6CgktIFRha2VzIGV4dHJhIHRpbWUgdG8gY29weSB0aGUgZmlsZS4KCSsgV2hlbiB0aGUgZmlsZSBoYXMgc3BlY2lhbCBhdHRyaWJ1dGVzLCBpcyBhIChoYXJkL3N5bWJvbGljKSBsaW5rIG9yCgkgIGhhcyBhIHJlc291cmNlIGZvcmssIGFsbCB0aGlzIGlzIHByZXNlcnZlZC4KCS0gV2hlbiB0aGUgZmlsZSBpcyBhIGxpbmsgdGhlIGJhY2t1cCB3aWxsIGhhdmUgdGhlIG5hbWUgb2YgdGhlIGxpbmssCgkgIG5vdCBvZiB0aGUgcmVhbCBmaWxlLgoKCVJlbmFtaW5nIHRoZSBmaWxlIGFuZCB3cml0aW5nIGEgbmV3IG9uZToKCSsgSXQncyBmYXN0LgoJLSBTb21ldGltZXMgbm90IGFsbCBhdHRyaWJ1dGVzIG9mIHRoZSBmaWxlIGNhbiBiZSBjb3BpZWQgdG8gdGhlIG5ldwoJICBmaWxlLgoJLSBXaGVuIHRoZSBmaWxlIGlzIGEgbGluayB0aGUgbmV3IGZpbGUgd2lsbCBub3QgYmUgYSBsaW5rLgoKCVRoZSAiYXV0byIgdmFsdWUgaXMgdGhlIG1pZGRsZSB3YXk6IFdoZW4gVmltIHNlZXMgdGhhdCByZW5hbWluZyBmaWxlCglpcyBwb3NzaWJsZSB3aXRob3V0IHNpZGUgZWZmZWN0cyAodGhlIGF0dHJpYnV0ZXMgY2FuIGJlIHBhc3NlZCBvbiBhbmQKCWFuZCB0aGUgZmlsZSBpcyBub3QgYSBsaW5rKSB0aGF0IGlzIHVzZWQuICBXaGVuIHByb2JsZW1zIGFyZSBleHBlY3RlZCwKCWEgY29weSB3aWxsIGJlIG1hZGUuCgoJVGhlICJicmVha3N5bWxpbmsiIGFuZCAiYnJlYWtoYXJkbGluayIgdmFsdWVzIGNhbiBiZSB1c2VkIGluCgljb21iaW5hdGlvbiB3aXRoIGFueSBvZiAieWVzIiwgIm5vIiBhbmQgImF1dG8iLiAgV2hlbiBpbmNsdWRlZCwgdGhleQoJZm9yY2UgVmltIHRvIGFsd2F5cyBicmVhayBlaXRoZXIgc3ltYm9saWMgb3IgaGFyZCBsaW5rcyBieSBkb2luZwoJZXhhY3RseSB3aGF0IHRoZSAibm8iIG9wdGlvbiBkb2VzLCByZW5hbWluZyB0aGUgb3JpZ2luYWwgZmlsZSB0bwoJYmVjb21lIHRoZSBiYWNrdXAgYW5kIHdyaXRpbmcgYSBuZXcgZmlsZSBpbiBpdHMgcGxhY2UuICBUaGlzIGNhbiBiZQoJdXNlZnVsIGZvciBleGFtcGxlIGluIHNvdXJjZSB0cmVlcyB3aGVyZSBhbGwgdGhlIGZpbGVzIGFyZSBzeW1ib2xpYyBvcgoJaGFyZCBsaW5rcyBhbmQgYW55IGNoYW5nZXMgc2hvdWxkIHN0YXkgaW4gdGhlIGxvY2FsIHNvdXJjZSB0cmVlLCBub3QKCWJlIHByb3BhZ2F0ZWQgYmFjayB0byB0aGUgb3JpZ2luYWwgc291cmNlLgoJCQkJCQkJKmNyb250YWIqCglPbmUgc2l0dWF0aW9uIHdoZXJlICJubyIgYW5kICJhdXRvIiB3aWxsIGNhdXNlIHByb2JsZW1zOiBBIHByb2dyYW0KCXRoYXQgb3BlbnMgYSBmaWxlLCBpbnZva2VzIFZpbSB0byBlZGl0IHRoYXQgZmlsZSwgYW5kIHRoZW4gdGVzdHMgaWYKCXRoZSBvcGVuIGZpbGUgd2FzIGNoYW5nZWQgKHRocm91Z2ggdGhlIGZpbGUgZGVzY3JpcHRvcikgd2lsbCBjaGVjayB0aGUKCWJhY2t1cCBmaWxlIGluc3RlYWQgb2YgdGhlIG5ld2x5IGNyZWF0ZWQgZmlsZS4gICJjcm9udGFiIC1lIiBpcyBhbgoJZXhhbXBsZS4KCglXaGVuIGEgY29weSBpcyBtYWRlLCB0aGUgb3JpZ2luYWwgZmlsZSBpcyB0cnVuY2F0ZWQgYW5kIHRoZW4gZmlsbGVkCgl3aXRoIHRoZSBuZXcgdGV4dC4gIFRoaXMgbWVhbnMgdGhhdCBwcm90ZWN0aW9uIGJpdHMsIG93bmVyIGFuZAoJc3ltYm9saWMgbGlua3Mgb2YgdGhlIG9yaWdpbmFsIGZpbGUgYXJlIHVubW9kaWZpZWQuICBUaGUgYmFja3VwIGZpbGUKCWhvd2V2ZXIsIGlzIGEgbmV3IGZpbGUsIG93bmVkIGJ5IHRoZSB1c2VyIHdobyBlZGl0ZWQgdGhlIGZpbGUuICBUaGUKCWdyb3VwIG9mIHRoZSBiYWNrdXAgaXMgc2V0IHRvIHRoZSBncm91cCBvZiB0aGUgb3JpZ2luYWwgZmlsZS4gIElmIHRoaXMKCWZhaWxzLCB0aGUgcHJvdGVjdGlvbiBiaXRzIGZvciB0aGUgZ3JvdXAgYXJlIG1hZGUgdGhlIHNhbWUgYXMgZm9yCglvdGhlcnMuCgoJV2hlbiB0aGUgZmlsZSBpcyByZW5hbWVkIHRoaXMgaXMgdGhlIG90aGVyIHdheSBhcm91bmQ6IFRoZSBiYWNrdXAgaGFzCgl0aGUgc2FtZSBhdHRyaWJ1dGVzIG9mIHRoZSBvcmlnaW5hbCBmaWxlLCBhbmQgdGhlIG5ld2x5IHdyaXR0ZW4gZmlsZQoJaXMgb3duZWQgYnkgdGhlIGN1cnJlbnQgdXNlci4gIFdoZW4gdGhlIGZpbGUgd2FzIGEgKGhhcmQvc3ltYm9saWMpCglsaW5rLCB0aGUgbmV3IGZpbGUgd2lsbCBub3QhICBUaGF0J3Mgd2h5IHRoZSAiYXV0byIgdmFsdWUgZG9lc24ndAoJcmVuYW1lIHdoZW4gdGhlIGZpbGUgaXMgYSBsaW5rLiAgVGhlIG93bmVyIGFuZCBncm91cCBvZiB0aGUgbmV3bHkKCXdyaXR0ZW4gZmlsZSB3aWxsIGJlIHNldCB0byB0aGUgc2FtZSBvbmVzIGFzIHRoZSBvcmlnaW5hbCBmaWxlLCBidXQKCXRoZSBzeXN0ZW0gbWF5IHJlZnVzZSB0byBkbyB0aGlzLiAgSW4gdGhhdCBjYXNlIHRoZSAiYXV0byIgdmFsdWUgd2lsbAoJYWdhaW4gbm90IHJlbmFtZSB0aGUgZmlsZS4KCgkJCQkJCSonYmFja3VwZGlyJyogKidiZGlyJyoKJ2JhY2t1cGRpcicgJ2JkaXInCXN0cmluZwkoZGVmYXVsdCBmb3IgQW1pZ2E6ICIuLHQ6IiwKCQkJCSBmb3IgTVMtRE9TIGFuZCBXaW4zMjogIi4sYzovdG1wLGM6L3RlbXAiCgkJCQkgZm9yIFVuaXg6ICIuLH4vdG1wLH4vIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglMaXN0IG9mIGRpcmVjdG9yaWVzIGZvciB0aGUgYmFja3VwIGZpbGUsIHNlcGFyYXRlZCB3aXRoIGNvbW1hcy4KCS0gVGhlIGJhY2t1cCBmaWxlIHdpbGwgYmUgY3JlYXRlZCBpbiB0aGUgZmlyc3QgZGlyZWN0b3J5IGluIHRoZSBsaXN0CgkgIHdoZXJlIHRoaXMgaXMgcG9zc2libGUuCgktIEVtcHR5IG1lYW5zIHRoYXQgbm8gYmFja3VwIGZpbGUgd2lsbCBiZSBjcmVhdGVkICgncGF0Y2htb2RlJyBpcwoJICBpbXBvc3NpYmxlISkuICBXcml0aW5nIG1heSBmYWlsIGJlY2F1c2Ugb2YgdGhpcy4KCS0gQSBkaXJlY3RvcnkgIi4iIG1lYW5zIHRvIHB1dCB0aGUgYmFja3VwIGZpbGUgaW4gdGhlIHNhbWUgZGlyZWN0b3J5CgkgIGFzIHRoZSBlZGl0ZWQgZmlsZS4KCS0gQSBkaXJlY3Rvcnkgc3RhcnRpbmcgd2l0aCAiLi8iIChvciAiLlwiIGZvciBNUy1ET1MgZXQgYWwuKSBtZWFucyB0bwoJICBwdXQgdGhlIGJhY2t1cCBmaWxlIHJlbGF0aXZlIHRvIHdoZXJlIHRoZSBlZGl0ZWQgZmlsZSBpcy4gIFRoZQoJICBsZWFkaW5nICIuIiBpcyByZXBsYWNlZCB3aXRoIHRoZSBwYXRoIG5hbWUgb2YgdGhlIGVkaXRlZCBmaWxlLgoJICAoIi4iIGluc2lkZSBhIGRpcmVjdG9yeSBuYW1lIGhhcyBubyBzcGVjaWFsIG1lYW5pbmcpLgoJLSBTcGFjZXMgYWZ0ZXIgdGhlIGNvbW1hIGFyZSBpZ25vcmVkLCBvdGhlciBzcGFjZXMgYXJlIGNvbnNpZGVyZWQgcGFydAoJICBvZiB0aGUgZGlyZWN0b3J5IG5hbWUuICBUbyBoYXZlIGEgc3BhY2UgYXQgdGhlIHN0YXJ0IG9mIGEgZGlyZWN0b3J5CgkgIG5hbWUsIHByZWNlZGUgaXQgd2l0aCBhIGJhY2tzbGFzaC4KCS0gVG8gaW5jbHVkZSBhIGNvbW1hIGluIGEgZGlyZWN0b3J5IG5hbWUgcHJlY2VkZSBpdCB3aXRoIGEgYmFja3NsYXNoLgoJLSBBIGRpcmVjdG9yeSBuYW1lIG1heSBlbmQgaW4gYW4gJy8nLgoJLSBFbnZpcm9ubWVudCB2YXJpYWJsZXMgYXJlIGV4cGFuZGVkIHw6c2V0X2VudnwuCgktIENhcmVmdWwgd2l0aCAnXCcgY2hhcmFjdGVycywgdHlwZSBvbmUgYmVmb3JlIGEgc3BhY2UsIHR5cGUgdHdvIHRvCgkgIGdldCBvbmUgaW4gdGhlIG9wdGlvbiAoc2VlIHxvcHRpb24tYmFja3NsYXNofCksIGZvciBleGFtcGxlOiA+CgkgICAgOnNldCBiZGlyPWM6XFx0bXAsXCBkaXJcXCx3aXRoXFwsY29tbWFzLFxcXCBkaXJcIHdpdGhcIHNwYWNlcwo8CS0gRm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5IHdpdGggVmltIHZlcnNpb24gMy4wIGEgJz4nIGF0IHRoZSBzdGFydAoJICBvZiB0aGUgb3B0aW9uIGlzIHJlbW92ZWQuCglTZWUgYWxzbyAnYmFja3VwJyBhbmQgJ3dyaXRlYmFja3VwJyBvcHRpb25zLgoJSWYgeW91IHdhbnQgdG8gaGlkZSB5b3VyIGJhY2t1cCBmaWxlcyBvbiBVbml4LCBjb25zaWRlciB0aGlzIHZhbHVlOiA+CgkJOnNldCBiYWNrdXBkaXI9Li8uYmFja3VwLH4vLmJhY2t1cCwuLC90bXAKPAlZb3UgbXVzdCBjcmVhdGUgYSAiLmJhY2t1cCIgZGlyZWN0b3J5IGluIGVhY2ggZGlyZWN0b3J5IGFuZCBpbiB5b3VyCglob21lIGRpcmVjdG9yeSBmb3IgdGhpcyB0byB3b3JrIHByb3Blcmx5LgoJVGhlIHVzZSBvZiB8OnNldCs9fCBhbmQgfDpzZXQtPXwgaXMgcHJlZmVycmVkIHdoZW4gYWRkaW5nIG9yIHJlbW92aW5nCglkaXJlY3RvcmllcyBmcm9tIHRoZSBsaXN0LiAgVGhpcyBhdm9pZHMgcHJvYmxlbXMgd2hlbiBhIGZ1dHVyZSB2ZXJzaW9uCgl1c2VzIGFub3RoZXIgZGVmYXVsdC4KCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJCQkJKidiYWNrdXBleHQnKiAqJ2JleCcqICpFNTg5KgonYmFja3VwZXh0JyAnYmV4JwlzdHJpbmcJKGRlZmF1bHQgIn4iLCBmb3IgVk1TOiAiXyIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJU3RyaW5nIHdoaWNoIGlzIGFwcGVuZGVkIHRvIGEgZmlsZSBuYW1lIHRvIG1ha2UgdGhlIG5hbWUgb2YgdGhlCgliYWNrdXAgZmlsZS4gIFRoZSBkZWZhdWx0IGlzIHF1aXRlIHVudXN1YWwsIGJlY2F1c2UgdGhpcyBhdm9pZHMKCWFjY2lkZW50YWxseSBvdmVyd3JpdGluZyBleGlzdGluZyBmaWxlcyB3aXRoIGEgYmFja3VwIGZpbGUuICBZb3UgbWlnaHQKCXByZWZlciB1c2luZyAiLmJhayIsIGJ1dCBtYWtlIHN1cmUgdGhhdCB5b3UgZG9uJ3QgaGF2ZSBmaWxlcyB3aXRoCgkiLmJhayIgdGhhdCB5b3Ugd2FudCB0byBrZWVwLgoJT25seSBub3JtYWwgZmlsZSBuYW1lIGNoYXJhY3RlcnMgY2FuIGJlIHVzZWQsICIvXCo/W3w8PiIgYXJlIGlsbGVnYWwuCgoJSWYgeW91IGxpa2UgdG8ga2VlcCBhIGxvdCBvZiBiYWNrdXBzLCB5b3UgY291bGQgdXNlIGEgQnVmV3JpdGVQcmUKCWF1dG9jb21tYW5kIHRvIGNoYW5nZSAnYmFja3VwZXh0JyBqdXN0IGJlZm9yZSB3cml0aW5nIHRoZSBmaWxlIHRvCglpbmNsdWRlIGEgdGltZXN0YW1wLiA+CgkJOmF1IEJ1ZldyaXRlUHJlICogbGV0ICZiZXggPSAnLScgLiBzdHJmdGltZSgiJVklYiVkJVgiKSAuICd+Jwo8CVVzZSAnYmFja3VwZGlyJyB0byBwdXQgdGhlIGJhY2t1cCBpbiBhIGRpZmZlcmVudCBkaXJlY3RvcnkuCgoJCQkJCQkqJ2JhY2t1cHNraXAnKiAqJ2JzaycqCidiYWNrdXBza2lwJyAnYnNrJwlzdHJpbmcJKGRlZmF1bHQ6ICIvdG1wLyosJFRNUERJUi8qLCRUTVAvKiwkVEVNUC8qIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCt3aWxkaWdub3JlfAoJCQlmZWF0dXJlfQoJQSBsaXN0IG9mIGZpbGUgcGF0dGVybnMuICBXaGVuIG9uZSBvZiB0aGUgcGF0dGVybnMgbWF0Y2hlcyB3aXRoIHRoZQoJbmFtZSBvZiB0aGUgZmlsZSB3aGljaCBpcyB3cml0dGVuLCBubyBiYWNrdXAgZmlsZSBpcyBjcmVhdGVkLiAgQm90aAoJdGhlIHNwZWNpZmllZCBmaWxlIG5hbWUgYW5kIHRoZSBmdWxsIHBhdGggbmFtZSBvZiB0aGUgZmlsZSBhcmUgdXNlZC4KCVRoZSBwYXR0ZXJuIGlzIHVzZWQgbGlrZSB3aXRoIHw6YXV0b2NtZHwsIHNlZSB8YXV0b2NtZC1wYXR0ZXJuc3wuCglXYXRjaCBvdXQgZm9yIHNwZWNpYWwgY2hhcmFjdGVycywgc2VlIHxvcHRpb24tYmFja3NsYXNofC4KCVdoZW4gJFRNUERJUiwgJFRNUCBvciAkVEVNUCBpcyBub3QgZGVmaW5lZCwgaXQgaXMgbm90IHVzZWQgZm9yIHRoZQoJZGVmYXVsdCB2YWx1ZS4gICIvdG1wLyoiIGlzIG9ubHkgdXNlZCBmb3IgVW5peC4KCgkJCQkJCSonYmFsbG9vbmRlbGF5JyogKidiZGxheScqCidiYWxsb29uZGVsYXknICdiZGxheScJbnVtYmVyCShkZWZhdWx0OiA2MDApCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2JhbGxvb25fZXZhbHwKCQkJZmVhdHVyZX0KCURlbGF5IGluIG1pbGxpc2Vjb25kcyBiZWZvcmUgYSBiYWxsb29uIG1heSBwb3AgdXAuICBTZWUgfGJhbGxvb24tZXZhbHwuCgoJCSAgICAgICAqJ2JhbGxvb25ldmFsJyogKidiZXZhbCcqIConbm9iYWxsb29uZXZhbCcqIConbm9iZXZhbCcqCidiYWxsb29uZXZhbCcgJ2JldmFsJwlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrYmFsbG9vbl9ldmFsfAoJCQlmZWF0dXJlfQoJU3dpdGNoIG9uIHRoZSB8YmFsbG9vbi1ldmFsfCBmdW5jdGlvbmFsaXR5LgoKCQkJCQkJICAgICAqJ2JhbGxvb25leHByJyogKidiZXhwcicqCidiYWxsb29uZXhwcicgJ2JleHByJwlzdHJpbmcJKGRlZmF1bHQgIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2JhbGxvb25fZXZhbHwKCQkJZmVhdHVyZX0KCUV4cHJlc3Npb24gdG8gc2hvdyBpbiBldmFsdWF0aW9uIGJhbGxvb24uICBJdCBpcyBvbmx5IHVzZWQgd2hlbgoJJ2JhbGxvb25ldmFsJyBpcyBvbi4gIFRoZXNlIHZhcmlhYmxlcyBjYW4gYmUgdXNlZDoKCgl2OmJldmFsX2J1Zm5yCW51bWJlciBvZiB0aGUgYnVmZmVyIGluIHdoaWNoIGJhbGxvb24gaXMgZ29pbmcgdG8gc2hvdwoJdjpiZXZhbF93aW5ucgludW1iZXIgb2YgdGhlIHdpbmRvdwoJdjpiZXZhbF9sbnVtCWxpbmUgbnVtYmVyCgl2OmJldmFsX2NvbAljb2x1bW4gbnVtYmVyIChieXRlIGluZGV4KQoJdjpiZXZhbF90ZXh0CXdvcmQgdW5kZXIgb3IgYWZ0ZXIgdGhlIG1vdXNlIHBvaW50ZXIKCglUaGUgZXZhbHVhdGlvbiBvZiB0aGUgZXhwcmVzc2lvbiBtdXN0IG5vdCBoYXZlIHNpZGUgZWZmZWN0cyEKCUV4YW1wbGU6ID4KICAgIGZ1bmN0aW9uISBNeUJhbGxvb25FeHByKCkKCXJldHVybiAnQ3Vyc29yIGlzIGF0IGxpbmUgJyAuIHY6YmV2YWxfbG51bSAuIAoJCVwnLCBjb2x1bW4gJyAuIHY6YmV2YWxfY29sIC4KCQlcICcgb2YgZmlsZSAnIC4gIGJ1Zm5hbWUodjpiZXZhbF9idWZucikgLgoJCVwgJyBvbiB3b3JkICInIC4gdjpiZXZhbF90ZXh0IC4gJyInCiAgICBlbmRmdW5jdGlvbgogICAgc2V0IGJleHByPU15QmFsbG9vbkV4cHIoKQogICAgc2V0IGJhbGxvb25ldmFsCjwKCU5PVEU6IFRoZSBiYWxsb29uIGlzIGRpc3BsYXllZCBvbmx5IGlmIHRoZSBjdXJzb3IgaXMgb24gYSB0ZXh0CgljaGFyYWN0ZXIuICBJZiB0aGUgcmVzdWx0IG9mIGV2YWx1YXRpbmcgJ2JhbGxvb25leHByJyBpcyBub3QgZW1wdHksCglWaW0gZG9lcyBub3QgdHJ5IHRvIHNlbmQgYSBtZXNzYWdlIHRvIGFuIGV4dGVybmFsIGRlYnVnZ2VyIChOZXRiZWFucwoJb3IgU3VuIFdvcmtzaG9wKS4KCgkJCQkgICAgIConYmluYXJ5JyogKidiaW4nKiAqJ25vYmluYXJ5JyogKidub2JpbicqCidiaW5hcnknICdiaW4nCQlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CglUaGlzIG9wdGlvbiBzaG91bGQgYmUgc2V0IGJlZm9yZSBlZGl0aW5nIGEgYmluYXJ5IGZpbGUuICBZb3UgY2FuIGFsc28KCXVzZSB0aGUgfC1ifCBWaW0gYXJndW1lbnQuICBXaGVuIHRoaXMgb3B0aW9uIGlzIHN3aXRjaGVkIG9uIGEgZmV3CglvcHRpb25zIHdpbGwgYmUgY2hhbmdlZCAoYWxzbyB3aGVuIGl0IGFscmVhZHkgd2FzIG9uKToKCQkndGV4dHdpZHRoJyAgd2lsbCBiZSBzZXQgdG8gMAoJCSd3cmFwbWFyZ2luJyB3aWxsIGJlIHNldCB0byAwCgkJJ21vZGVsaW5lJyAgIHdpbGwgYmUgb2ZmCgkJJ2V4cGFuZHRhYicgIHdpbGwgYmUgb2ZmCglBbHNvLCAnZmlsZWZvcm1hdCcgYW5kICdmaWxlZm9ybWF0cycgb3B0aW9ucyB3aWxsIG5vdCBiZSB1c2VkLCB0aGUKCWZpbGUgaXMgcmVhZCBhbmQgd3JpdHRlbiBsaWtlICdmaWxlZm9ybWF0JyB3YXMgInVuaXgiIChhIHNpbmdsZSA8Tkw+CglzZXBhcmF0ZXMgbGluZXMpLgoJVGhlICdmaWxlZW5jb2RpbmcnIGFuZCAnZmlsZWVuY29kaW5ncycgb3B0aW9ucyB3aWxsIG5vdCBiZSB1c2VkLCB0aGUKCWZpbGUgaXMgcmVhZCB3aXRob3V0IGNvbnZlcnNpb24uCglOT1RFOiBXaGVuIHlvdSBzdGFydCBlZGl0aW5nIGEobm90aGVyKSBmaWxlIHdoaWxlIHRoZSAnYmluJyBvcHRpb24gaXMKCW9uLCBzZXR0aW5ncyBmcm9tIGF1dG9jb21tYW5kcyBtYXkgY2hhbmdlIHRoZSBzZXR0aW5ncyBhZ2FpbiAoZS5nLiwKCSd0ZXh0d2lkdGgnKSwgY2F1c2luZyB0cm91YmxlIHdoZW4gZWRpdGluZy4gIFlvdSBtaWdodCB3YW50IHRvIHNldAoJJ2JpbicgYWdhaW4gd2hlbiB0aGUgZmlsZSBoYXMgYmVlbiBsb2FkZWQuCglUaGUgcHJldmlvdXMgdmFsdWVzIG9mIHRoZXNlIG9wdGlvbnMgYXJlIHJlbWVtYmVyZWQgYW5kIHJlc3RvcmVkIHdoZW4KCSdiaW4nIGlzIHN3aXRjaGVkIGZyb20gb24gdG8gb2ZmLiAgRWFjaCBidWZmZXIgaGFzIGl0cyBvd24gc2V0IG9mCglzYXZlZCBvcHRpb24gdmFsdWVzLgoJVG8gZWRpdCBhIGZpbGUgd2l0aCAnYmluYXJ5JyBzZXQgeW91IGNhbiB1c2UgdGhlIHwrK2JpbnwgYXJndW1lbnQuCglUaGlzIGF2b2lkcyB5b3UgaGF2ZSB0byBkbyAiOnNldCBiaW4iLCB3aGljaCB3b3VsZCBoYXZlIGVmZmVjdCBmb3IgYWxsCglmaWxlcyB5b3UgZWRpdC4KCVdoZW4gd3JpdGluZyBhIGZpbGUgdGhlIDxFT0w+IGZvciB0aGUgbGFzdCBsaW5lIGlzIG9ubHkgd3JpdHRlbiBpZgoJdGhlcmUgd2FzIG9uZSBpbiB0aGUgb3JpZ2luYWwgZmlsZSAobm9ybWFsbHkgVmltIGFwcGVuZHMgYW4gPEVPTD4gdG8KCXRoZSBsYXN0IGxpbmUgaWYgdGhlcmUgaXMgbm9uZTsgdGhpcyB3b3VsZCBtYWtlIHRoZSBmaWxlIGxvbmdlcikuICBTZWUKCXRoZSAnZW5kb2ZsaW5lJyBvcHRpb24uCgoJCQkqJ2Jpb3NrZXknKiAqJ2Jpb3NrJyogKidub2Jpb3NrZXknKiAqJ25vYmlvc2snKgonYmlvc2tleScgJ2Jpb3NrJwlib29sZWFuCShkZWZhdWx0IG9uKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0gIHtvbmx5IGZvciBNUy1ET1N9CglXaGVuIG9uIHRoZSBiaW9zIGlzIGNhbGxlZCB0byBvYnRhaW4gYSBrZXlib2FyZCBjaGFyYWN0ZXIuICBUaGlzIHdvcmtzCgliZXR0ZXIgdG8gZGV0ZWN0IENUUkwtQywgYnV0IG9ubHkgd29ya3MgZm9yIHRoZSBjb25zb2xlLiAgV2hlbiB1c2luZyBhCgl0ZXJtaW5hbCBvdmVyIGEgc2VyaWFsIHBvcnQgcmVzZXQgdGhpcyBvcHRpb24uCglBbHNvIHNlZSB8J2NvbnNrZXknfC4KCgkJCQkJCQkqJ2JvbWInKiAqJ25vYm9tYicqCidib21iJwkJCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCttdWx0aV9ieXRlfAoJCQlmZWF0dXJlfQoJV2hlbiB3cml0aW5nIGEgZmlsZSBhbmQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZSBtZXQsIGEgQk9NIChCeXRlCglPcmRlciBNYXJrKSBpcyBwcmVwZW5kZWQgdG8gdGhlIGZpbGU6CgktIHRoaXMgb3B0aW9uIGlzIG9uCgktIHRoZSAnYmluYXJ5JyBvcHRpb24gaXMgb2ZmCgktICdmaWxlZW5jb2RpbmcnIGlzICJ1dGYtOCIsICJ1Y3MtMiIsICJ1Y3MtNCIgb3Igb25lIG9mIHRoZSBsaXR0bGUvYmlnCgkgIGVuZGlhbiB2YXJpYW50cy4KCVNvbWUgYXBwbGljYXRpb25zIHVzZSB0aGUgQk9NIHRvIHJlY29nbml6ZSB0aGUgZW5jb2Rpbmcgb2YgdGhlIGZpbGUuCglPZnRlbiB1c2VkIGZvciBVQ1MtMiBmaWxlcyBvbiBNUy1XaW5kb3dzLiAgRm9yIG90aGVyIGFwcGxpY2F0aW9ucyBpdAoJY2F1c2VzIHRyb3VibGUsIGZvciBleGFtcGxlOiAiY2F0IGZpbGUxIGZpbGUyIiBtYWtlcyB0aGUgQk9NIG9mIGZpbGUyCglhcHBlYXIgaGFsZndheSB0aGUgcmVzdWx0aW5nIGZpbGUuCglXaGVuIFZpbSByZWFkcyBhIGZpbGUgYW5kICdmaWxlZW5jb2RpbmdzJyBzdGFydHMgd2l0aCAidWNzLWJvbSIsIGEKCWNoZWNrIGZvciB0aGUgcHJlc2VuY2Ugb2YgdGhlIEJPTSBpcyBkb25lIGFuZCAnYm9tYicgc2V0IGFjY29yZGluZ2x5LgoJVW5sZXNzICdiaW5hcnknIGlzIHNldCwgaXQgaXMgcmVtb3ZlZCBmcm9tIHRoZSBmaXJzdCBsaW5lLCBzbyB0aGF0IHlvdQoJZG9uJ3Qgc2VlIGl0IHdoZW4gZWRpdGluZy4gIFdoZW4geW91IGRvbid0IGNoYW5nZSB0aGUgb3B0aW9ucywgdGhlIEJPTQoJd2lsbCBiZSByZXN0b3JlZCB3aGVuIHdyaXRpbmcgdGhlIGZpbGUuCgoJCQkJCQkqJ2JyZWFrYXQnKiAqJ2JyaycqCidicmVha2F0JyAnYnJrJwkJc3RyaW5nCShkZWZhdWx0ICIgXkkhQCotKzs6LC4vPyIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlICB8K2xpbmVicmVha3wKCQkJZmVhdHVyZX0KCVRoaXMgb3B0aW9uIGxldHMgeW91IGNob29zZSB3aGljaCBjaGFyYWN0ZXJzIG1pZ2h0IGNhdXNlIGEgbGluZQoJYnJlYWsgaWYgJ2xpbmVicmVhaycgaXMgb24uCgoJCQkJCQkqJ2Jyb3dzZWRpcicqIConYnNkaXInKgonYnJvd3NlZGlyJyAnYnNkaXInCXN0cmluZwkoZGVmYXVsdDogImxhc3QiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0ge29ubHkgZm9yIE1vdGlmIGFuZCBXaW4zMiBHVUl9CglXaGljaCBkaXJlY3RvcnkgdG8gdXNlIGZvciB0aGUgZmlsZSBicm93c2VyOgoJICAgbGFzdAkJVXNlIHNhbWUgZGlyZWN0b3J5IGFzIHdpdGggbGFzdCBmaWxlIGJyb3dzZXIuCgkgICBidWZmZXIJVXNlIHRoZSBkaXJlY3Rvcnkgb2YgdGhlIHJlbGF0ZWQgYnVmZmVyLgoJICAgY3VycmVudAlVc2UgdGhlIGN1cnJlbnQgZGlyZWN0b3J5LgoJICAge3BhdGh9CVVzZSB0aGUgc3BlY2lmaWVkIGRpcmVjdG9yeQoKCQkJCQkJKididWZoaWRkZW4nKiAqJ2JoJyoKJ2J1ZmhpZGRlbicgJ2JoJwlzdHJpbmcgKGRlZmF1bHQ6ICIiKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3F1aWNrZml4fAoJCQlmZWF0dXJlfQoJVGhpcyBvcHRpb24gc3BlY2lmaWVzIHdoYXQgaGFwcGVucyB3aGVuIGEgYnVmZmVyIGlzIG5vIGxvbmdlcgoJZGlzcGxheWVkIGluIGEgd2luZG93OgoJICA8ZW1wdHk+CWZvbGxvdyB0aGUgZ2xvYmFsICdoaWRkZW4nIG9wdGlvbgoJICBoaWRlCQloaWRlIHRoZSBidWZmZXIgKGRvbid0IHVubG9hZCBpdCksIGFsc28gd2hlbiAnaGlkZGVuJwoJCQlpcyBub3Qgc2V0CgkgIHVubG9hZAl1bmxvYWQgdGhlIGJ1ZmZlciwgYWxzbyB3aGVuICdoaWRkZW4nIGlzIHNldCBvciB1c2luZwoJCQl8OmhpZGV8CgkgIGRlbGV0ZQlkZWxldGUgdGhlIGJ1ZmZlciBmcm9tIHRoZSBidWZmZXIgbGlzdCwgYWxzbyB3aGVuCgkJCSdoaWRkZW4nIGlzIHNldCBvciB1c2luZyB8OmhpZGV8LCBsaWtlIHVzaW5nCgkJCXw6YmRlbGV0ZXwKCSAgd2lwZQkJd2lwZSBvdXQgdGhlIGJ1ZmZlciBmcm9tIHRoZSBidWZmZXIgbGlzdCwgYWxzbyB3aGVuCgkJCSdoaWRkZW4nIGlzIHNldCBvciB1c2luZyB8OmhpZGV8LCBsaWtlIHVzaW5nCgkJCXw6YndpcGVvdXR8CgoJQ0FSRUZVTDogd2hlbiAidW5sb2FkIiwgImRlbGV0ZSIgb3IgIndpcGUiIGlzIHVzZWQgY2hhbmdlcyBpbiBhIGJ1ZmZlcgoJYXJlIGxvc3Qgd2l0aG91dCBhIHdhcm5pbmcuCglUaGlzIG9wdGlvbiBpcyB1c2VkIHRvZ2V0aGVyIHdpdGggJ2J1ZnR5cGUnIGFuZCAnc3dhcGZpbGUnIHRvIHNwZWNpZnkKCXNwZWNpYWwga2luZHMgb2YgYnVmZmVycy4gICBTZWUgfHNwZWNpYWwtYnVmZmVyc3wuCgoJCQkqJ2J1Zmxpc3RlZCcqIConYmwnKiAqJ25vYnVmbGlzdGVkJyogKidub2JsJyogKkU4NSoKJ2J1Zmxpc3RlZCcgJ2JsJwlib29sZWFuIChkZWZhdWx0OiBvbikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CglXaGVuIHRoaXMgb3B0aW9uIGlzIHNldCwgdGhlIGJ1ZmZlciBzaG93cyB1cCBpbiB0aGUgYnVmZmVyIGxpc3QuICBJZgoJaXQgaXMgcmVzZXQgaXQgaXMgbm90IHVzZWQgZm9yICI6Ym5leHQiLCAibHMiLCB0aGUgQnVmZmVycyBtZW51LCBldGMuCglUaGlzIG9wdGlvbiBpcyByZXNldCBieSBWaW0gZm9yIGJ1ZmZlcnMgdGhhdCBhcmUgb25seSB1c2VkIHRvIHJlbWVtYmVyCglhIGZpbGUgbmFtZSBvciBtYXJrcy4gIFZpbSBzZXRzIGl0IHdoZW4gc3RhcnRpbmcgdG8gZWRpdCBhIGJ1ZmZlci4KCUJ1dCBub3Qgd2hlbiBtb3ZpbmcgdG8gYSBidWZmZXIgd2l0aCAiOmJ1ZmZlciIuCgoJCQkJCQkqJ2J1ZnR5cGUnKiAqJ2J0JyogKkUzODIqCididWZ0eXBlJyAnYnQnCQlzdHJpbmcgKGRlZmF1bHQ6ICIiKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3F1aWNrZml4fAoJCQlmZWF0dXJlfQoJVGhlIHZhbHVlIG9mIHRoaXMgb3B0aW9uIHNwZWNpZmllcyB0aGUgdHlwZSBvZiBhIGJ1ZmZlcjoKCSAgPGVtcHR5Pglub3JtYWwgYnVmZmVyCgkgIG5vZmlsZQlidWZmZXIgd2hpY2ggaXMgbm90IHJlbGF0ZWQgdG8gYSBmaWxlIGFuZCB3aWxsIG5vdCBiZQoJCQl3cml0dGVuCgkgIG5vd3JpdGUJYnVmZmVyIHdoaWNoIHdpbGwgbm90IGJlIHdyaXR0ZW4KCSAgYWN3cml0ZQlidWZmZXIgd2hpY2ggd2lsbCBhbHdheXMgYmUgd3JpdHRlbiB3aXRoIEJ1ZldyaXRlQ21kCgkgIAkJYXV0b2NvbW1hbmRzLiB7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlCgkJCXwrYXV0b2NtZHwgZmVhdHVyZX0KCSAgcXVpY2tmaXgJcXVpY2tmaXggYnVmZmVyLCBjb250YWlucyBsaXN0IG9mIGVycm9ycyB8OmN3aW5kb3d8CgkgIGhlbHAJCWhlbHAgYnVmZmVyICh5b3UgYXJlIG5vdCBzdXBwb3NlZCB0byBzZXQgdGhpcwoJCQltYW51YWxseSkKCglUaGlzIG9wdGlvbiBpcyB1c2VkIHRvZ2V0aGVyIHdpdGggJ2J1ZmhpZGRlbicgYW5kICdzd2FwZmlsZScgdG8KCXNwZWNpZnkgc3BlY2lhbCBraW5kcyBvZiBidWZmZXJzLiAgIFNlZSB8c3BlY2lhbC1idWZmZXJzfC4KCglCZSBjYXJlZnVsIHdpdGggY2hhbmdpbmcgdGhpcyBvcHRpb24sIGl0IGNhbiBoYXZlIG1hbnkgc2lkZSBlZmZlY3RzIQoKCUEgInF1aWNrZml4IiBidWZmZXIgaXMgb25seSB1c2VkIGZvciB0aGUgZXJyb3IgbGlzdC4gIFRoaXMgdmFsdWUgaXMKCXNldCBieSB0aGUgfDpjd2luZG93fCBjb21tYW5kIGFuZCB5b3UgYXJlIG5vdCBzdXBwb3NlZCB0byBjaGFuZ2UgaXQuCgoJIm5vZmlsZSIgYW5kICJub3dyaXRlIiBidWZmZXJzIGFyZSBzaW1pbGFyOgoJYm90aDoJCVRoZSBidWZmZXIgaXMgbm90IHRvIGJlIHdyaXR0ZW4gdG8gZGlzaywgIjp3IiBkb2Vzbid0CgkJCXdvcmsgKCI6dyBmaWxlbmFtZSIgZG9lcyB3b3JrIHRob3VnaCkuCglib3RoOgkJVGhlIGJ1ZmZlciBpcyBuZXZlciBjb25zaWRlcmVkIHRvIGJlIHwnbW9kaWZpZWQnfC4KCQkJVGhlcmUgaXMgbm8gd2FybmluZyB3aGVuIHRoZSBjaGFuZ2VzIHdpbGwgYmUgbG9zdCwgZm9yCgkJCWV4YW1wbGUgd2hlbiB5b3UgcXVpdCBWaW0uCglib3RoOgkJQSBzd2FwIGZpbGUgaXMgb25seSBjcmVhdGVkIHdoZW4gdXNpbmcgdG9vIG11Y2ggbWVtb3J5CgkJCSh3aGVuICdzd2FwZmlsZScgaGFzIGJlZW4gcmVzZXQgdGhlcmUgaXMgbmV2ZXIgYSBzd2FwCgkJCWZpbGUpLgoJbm9maWxlIG9ubHk6CVRoZSBidWZmZXIgbmFtZSBpcyBmaXhlZCwgaXQgaXMgbm90IGhhbmRsZWQgbGlrZSBhCgkJCWZpbGUgbmFtZS4gIEl0IGlzIG5vdCBtb2RpZmllZCBpbiByZXNwb25zZSB0byBhIHw6Y2R8CgkJCWNvbW1hbmQuCgkJCQkJCQkqRTY3NioKCSJhY3dyaXRlIiBpbXBsaWVzIHRoYXQgdGhlIGJ1ZmZlciBuYW1lIGlzIG5vdCByZWxhdGVkIHRvIGEgZmlsZSwgbGlrZQoJIm5vZmlsZSIsIGJ1dCBpdCB3aWxsIGJlIHdyaXR0ZW4uICBUaHVzLCBpbiBjb250cmFzdCB0byAibm9maWxlIiBhbmQKCSJub3dyaXRlIiwgIjp3IiBkb2VzIHdvcmsgYW5kIGEgbW9kaWZpZWQgYnVmZmVyIGNhbid0IGJlIGFiYW5kb25lZAoJd2l0aG91dCBzYXZpbmcuICBGb3Igd3JpdGluZyB0aGVyZSBtdXN0IGJlIG1hdGNoaW5nIHxCdWZXcml0ZUNtZHwsCgl8RmlsZVdyaXRlQ21kfCBvciB8RmlsZUFwcGVuZENtZHwgYXV0b2NvbW1hbmRzLgoKCQkJCQkJKidjYXNlbWFwJyogKidjbXAnKgonY2FzZW1hcCcgJ2NtcCcJCXN0cmluZwkoZGVmYXVsdDogImludGVybmFsLGtlZXBhc2NpaSIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJU3BlY2lmaWVzIGRldGFpbHMgYWJvdXQgY2hhbmdpbmcgdGhlIGNhc2Ugb2YgbGV0dGVycy4gIEl0IG1heSBjb250YWluCgl0aGVzZSB3b3Jkcywgc2VwYXJhdGVkIGJ5IGEgY29tbWE6CglpbnRlcm5hbAlVc2UgaW50ZXJuYWwgY2FzZSBtYXBwaW5nIGZ1bmN0aW9ucywgdGhlIGN1cnJlbnQKCQkJbG9jYWxlIGRvZXMgbm90IGNoYW5nZSB0aGUgY2FzZSBtYXBwaW5nLiAgVGhpcyBvbmx5CgkJCW1hdHRlcnMgd2hlbiAnZW5jb2RpbmcnIGlzIGEgVW5pY29kZSBlbmNvZGluZy4gIFdoZW4KCQkJImludGVybmFsIiBpcyBvbWl0dGVkLCB0aGUgdG93dXBwZXIoKSBhbmQgdG93bG93ZXIoKQoJCQlzeXN0ZW0gbGlicmFyeSBmdW5jdGlvbnMgYXJlIHVzZWQgd2hlbiBhdmFpbGFibGUuCglrZWVwYXNjaWkJRm9yIHRoZSBBU0NJSSBjaGFyYWN0ZXJzICgweDAwIHRvIDB4N2YpIHVzZSB0aGUgVVMKCQkJY2FzZSBtYXBwaW5nLCB0aGUgY3VycmVudCBsb2NhbGUgaXMgbm90IGVmZmVjdGl2ZS4KCQkJVGhpcyBwcm9iYWJseSBvbmx5IG1hdHRlcnMgZm9yIFR1cmtpc2guCgoJCQkJCQkqJ2NkcGF0aCcqIConY2QnKiAqRTM0NCogKkUzNDYqCidjZHBhdGgnICdjZCcJCXN0cmluZwkoZGVmYXVsdDogZXF1aXZhbGVudCB0byAkQ0RQQVRIIG9yICIsLCIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlCgkJCXwrZmlsZV9pbl9wYXRofCBmZWF0dXJlfQoJVGhpcyBpcyBhIGxpc3Qgb2YgZGlyZWN0b3JpZXMgd2hpY2ggd2lsbCBiZSBzZWFyY2hlZCB3aGVuIHVzaW5nIHRoZQoJfDpjZHwgYW5kIHw6bGNkfCBjb21tYW5kcywgcHJvdmlkZWQgdGhhdCB0aGUgZGlyZWN0b3J5IGJlaW5nIHNlYXJjaGVkCglmb3IgaGFzIGEgcmVsYXRpdmUgcGF0aCAobm90IHN0YXJ0aW5nIHdpdGggIi8iLCAiLi8iIG9yICIuLi8iKS4KCVRoZSAnY2RwYXRoJyBvcHRpb24ncyB2YWx1ZSBoYXMgdGhlIHNhbWUgZm9ybSBhbmQgc2VtYW50aWNzIGFzCgl8J3BhdGgnfC4gIEFsc28gc2VlIHxmaWxlLXNlYXJjaGluZ3wuCglUaGUgZGVmYXVsdCB2YWx1ZSBpcyB0YWtlbiBmcm9tICRDRFBBVEgsIHdpdGggYSAiLCIgcHJlcGVuZGVkIHRvIGxvb2sKCWluIHRoZSBjdXJyZW50IGRpcmVjdG9yeSBmaXJzdC4KCUlmIHRoZSBkZWZhdWx0IHZhbHVlIHRha2VuIGZyb20gJENEUEFUSCBpcyBub3Qgd2hhdCB5b3Ugd2FudCwgaW5jbHVkZQoJYSBtb2RpZmllZCB2ZXJzaW9uIG9mIHRoZSBmb2xsb3dpbmcgY29tbWFuZCBpbiB5b3VyIHZpbXJjIGZpbGUgdG8KCW92ZXJyaWRlIGl0OiA+CgkgIDpsZXQgJmNkcGF0aCA9ICcsJyAuIHN1YnN0aXR1dGUoc3Vic3RpdHV0ZSgkQ0RQQVRILCAnWywgXScsICdcXFwwJywgJ2cnKSwgJzonLCAnLCcsICdnJykKPAlUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCShwYXJ0cyBvZiAnY2RwYXRoJyBjYW4gYmUgcGFzc2VkIHRvIHRoZSBzaGVsbCB0byBleHBhbmQgZmlsZSBuYW1lcykuCgoJCQkJCQkqJ2NlZGl0JyoKJ2NlZGl0JwkJCXN0cmluZwkoVmkgZGVmYXVsdDogIiIsIFZpbSBkZWZhdWx0OiBDVFJMLUYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrdmVydHNwbGl0fAoJCQlmZWF0dXJlfQoJVGhlIGtleSB1c2VkIGluIENvbW1hbmQtbGluZSBNb2RlIHRvIG9wZW4gdGhlIGNvbW1hbmQtbGluZSB3aW5kb3cuCglUaGUgZGVmYXVsdCBpcyBDVFJMLUYgd2hlbiAnY29tcGF0aWJsZScgaXMgb2ZmLgoJT25seSBub24tcHJpbnRhYmxlIGtleXMgYXJlIGFsbG93ZWQuCglUaGUga2V5IGNhbiBiZSBzcGVjaWZpZWQgYXMgYSBzaW5nbGUgY2hhcmFjdGVyLCBidXQgaXQgaXMgZGlmZmljdWx0IHRvCgl0eXBlLiAgVGhlIHByZWZlcnJlZCB3YXkgaXMgdG8gdXNlIHRoZSA8PiBub3RhdGlvbi4gIEV4YW1wbGVzOiA+CgkJOnNldCBjZWRpdD08Qy1ZPgoJCTpzZXQgY2VkaXQ9PEVzYz4KPAl8TnZpfCBhbHNvIGhhcyB0aGlzIG9wdGlvbiwgYnV0IGl0IG9ubHkgdXNlcyB0aGUgZmlyc3QgY2hhcmFjdGVyLgoJU2VlIHxjbWR3aW58LgoKCQkJCSonY2hhcmNvbnZlcnQnKiAqJ2NjdicqICpFMjAyKiAqRTIxNCogKkU1MTMqCidjaGFyY29udmVydCcgJ2NjdicJc3RyaW5nIChkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCttdWx0aV9ieXRlfAoJCQlmZWF0dXJlIGFuZCB0aGUgfCtldmFsfCBmZWF0dXJlfQoJCQl7bm90IGluIFZpfQoJQW4gZXhwcmVzc2lvbiB0aGF0IGlzIHVzZWQgZm9yIGNoYXJhY3RlciBlbmNvZGluZyBjb252ZXJzaW9uLiAgSXQgaXMKCWV2YWx1YXRlZCB3aGVuIGEgZmlsZSB0aGF0IGlzIHRvIGJlIHJlYWQgb3IgaGFzIGJlZW4gd3JpdHRlbiBoYXMgYQoJZGlmZmVyZW50IGVuY29kaW5nIGZyb20gd2hhdCBpcyBkZXNpcmVkLgoJJ2NoYXJjb252ZXJ0JyBpcyBub3QgdXNlZCB3aGVuIHRoZSBpbnRlcm5hbCBpY29udigpIGZ1bmN0aW9uIGlzCglzdXBwb3J0ZWQgYW5kIGlzIGFibGUgdG8gZG8gdGhlIGNvbnZlcnNpb24uICBVc2luZyBpY29udigpIGlzCglwcmVmZXJyZWQsIGJlY2F1c2UgaXQgaXMgbXVjaCBmYXN0ZXIuCgknY2hhcmNvbnZlcnQnIGlzIG5vdCB1c2VkIHdoZW4gcmVhZGluZyBzdGRpbiB8LS18LCBiZWNhdXNlIHRoZXJlIGlzIG5vCglmaWxlIHRvIGNvbnZlcnQgZnJvbS4gIFlvdSB3aWxsIGhhdmUgdG8gc2F2ZSB0aGUgdGV4dCBpbiBhIGZpbGUgZmlyc3QuCglUaGUgZXhwcmVzc2lvbiBtdXN0IHJldHVybiB6ZXJvIG9yIGFuIGVtcHR5IHN0cmluZyBmb3Igc3VjY2VzcywKCW5vbi16ZXJvIGZvciBmYWlsdXJlLgoJVGhlIHBvc3NpYmxlIGVuY29kaW5nIG5hbWVzIGVuY291bnRlcmVkIGFyZSBpbiAnZW5jb2RpbmcnLgoJQWRkaXRpb25hbGx5LCBuYW1lcyBnaXZlbiBpbiAnZmlsZWVuY29kaW5ncycgYW5kICdmaWxlZW5jb2RpbmcnIGFyZQoJdXNlZC4KCUNvbnZlcnNpb24gYmV0d2VlbiAibGF0aW4xIiwgInVuaWNvZGUiLCAidWNzLTIiLCAidWNzLTQiIGFuZCAidXRmLTgiCglpcyBkb25lIGludGVybmFsbHkgYnkgVmltLCAnY2hhcmNvbnZlcnQnIGlzIG5vdCB1c2VkIGZvciB0aGlzLgoJJ2NoYXJjb252ZXJ0JyBpcyBhbHNvIHVzZWQgdG8gY29udmVydCB0aGUgdmltaW5mbyBmaWxlLCBpZiB0aGUgJ2MnCglmbGFnIGlzIHByZXNlbnQgaW4gJ3ZpbWluZm8nLiAgQWxzbyB1c2VkIGZvciBVbmljb2RlIGNvbnZlcnNpb24uCglFeGFtcGxlOiA+CgkJc2V0IGNoYXJjb252ZXJ0PUNoYXJDb252ZXJ0KCkKCQlmdW4gQ2hhckNvbnZlcnQoKQoJCSAgc3lzdGVtKCJyZWNvZGUgIgoJCQlcIC4gdjpjaGFyY29udmVydF9mcm9tIC4gIi4uIiAuIHY6Y2hhcmNvbnZlcnRfdG8KCQkJXCAuICIgPCIgLiB2OmZuYW1lX2luIC4gIiA+IiB2OmZuYW1lX291dCkKCQkgIHJldHVybiB2OnNoZWxsX2Vycm9yCgkJZW5kZnVuCjwJVGhlIHJlbGF0ZWQgVmltIHZhcmlhYmxlcyBhcmU6CgkJdjpjaGFyY29udmVydF9mcm9tCW5hbWUgb2YgdGhlIGN1cnJlbnQgZW5jb2RpbmcKCQl2OmNoYXJjb252ZXJ0X3RvCW5hbWUgb2YgdGhlIGRlc2lyZWQgZW5jb2RpbmcKCQl2OmZuYW1lX2luCQluYW1lIG9mIHRoZSBpbnB1dCBmaWxlCgkJdjpmbmFtZV9vdXQJCW5hbWUgb2YgdGhlIG91dHB1dCBmaWxlCglOb3RlIHRoYXQgdjpmbmFtZV9pbiBhbmQgdjpmbmFtZV9vdXQgd2lsbCBuZXZlciBiZSB0aGUgc2FtZS4KCU5vdGUgdGhhdCB2OmNoYXJjb252ZXJ0X2Zyb20gYW5kIHY6Y2hhcmNvbnZlcnRfdG8gbWF5IGJlIGRpZmZlcmVudAoJZnJvbSAnZW5jb2RpbmcnLiAgVmltIGludGVybmFsbHkgdXNlcyBVVEYtOCBpbnN0ZWFkIG9mIFVDUy0yIG9yIFVDUy00LgoJRW5jcnlwdGlvbiBpcyBub3QgZG9uZSBieSBWaW0gd2hlbiB1c2luZyAnY2hhcmNvbnZlcnQnLiAgSWYgeW91IHdhbnQKCXRvIGVuY3J5cHQgdGhlIGZpbGUgYWZ0ZXIgY29udmVyc2lvbiwgJ2NoYXJjb252ZXJ0JyBzaG91bGQgdGFrZSBjYXJlCglvZiB0aGlzLgoJVGhpcyBvcHRpb24gY2Fubm90IGJlIHNldCBmcm9tIGEgfG1vZGVsaW5lfCBvciBpbiB0aGUgfHNhbmRib3h8LCBmb3IKCXNlY3VyaXR5IHJlYXNvbnMuCgoJCQkJICAgKidjaW5kZW50JyogKidjaW4nKiAqJ25vY2luZGVudCcqIConbm9jaW4nKgonY2luZGVudCcgJ2NpbicJCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2NpbmRlbnR8CgkJCWZlYXR1cmV9CglFbmFibGVzIGF1dG9tYXRpYyBDIHByb2dyYW0gaW5kZW50aW5nICBTZWUgJ2NpbmtleXMnIHRvIHNldCB0aGUga2V5cwoJdGhhdCB0cmlnZ2VyIHJlaW5kZW50aW5nIGluIGluc2VydCBtb2RlIGFuZCAnY2lub3B0aW9ucycgdG8gc2V0IHlvdXIKCXByZWZlcnJlZCBpbmRlbnQgc3R5bGUuCglJZiAnaW5kZW50ZXhwcicgaXMgbm90IGVtcHR5LCBpdCBvdmVycnVsZXMgJ2NpbmRlbnQnLgoJSWYgJ2xpc3AnIGlzIG5vdCBvbiBhbmQgYm90aCAnaW5kZW50ZXhwcicgYW5kICdlcXVhbHByZycgYXJlIGVtcHR5LAoJdGhlICI9IiBvcGVyYXRvciBpbmRlbnRzIHVzaW5nIHRoaXMgYWxnb3JpdGhtIHJhdGhlciB0aGFuIGNhbGxpbmcgYW4KCWV4dGVybmFsIHByb2dyYW0uCglTZWUgfEMtaW5kZW50aW5nfC4KCVdoZW4geW91IGRvbid0IGxpa2UgdGhlIHdheSAnY2luZGVudCcgd29ya3MsIHRyeSB0aGUgJ3NtYXJ0aW5kZW50JwoJb3B0aW9uIG9yICdpbmRlbnRleHByJy4KCVRoaXMgb3B0aW9uIGlzIG5vdCB1c2VkIHdoZW4gJ3Bhc3RlJyBpcyBzZXQuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyByZXNldCB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkJCQkJKidjaW5rZXlzJyogKidjaW5rJyoKJ2NpbmtleXMnICdjaW5rJwlzdHJpbmcJKGRlZmF1bHQgIjB7LDB9LDApLDosMCMsIV5GLG8sTyxlIikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCtjaW5kZW50fAoJCQlmZWF0dXJlfQoJQSBsaXN0IG9mIGtleXMgdGhhdCwgd2hlbiB0eXBlZCBpbiBJbnNlcnQgbW9kZSwgY2F1c2UgcmVpbmRlbnRpbmcgb2YKCXRoZSBjdXJyZW50IGxpbmUuICBPbmx5IHVzZWQgaWYgJ2NpbmRlbnQnIGlzIG9uIGFuZCAnaW5kZW50ZXhwcicgaXMKCWVtcHR5LgoJRm9yIHRoZSBmb3JtYXQgb2YgdGhpcyBvcHRpb24gc2VlIHxjaW5rZXlzLWZvcm1hdHwuCglTZWUgfEMtaW5kZW50aW5nfC4KCgkJCQkJCSonY2lub3B0aW9ucycqIConY2lubycqCidjaW5vcHRpb25zJyAnY2lubycJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2NpbmRlbnR8CgkJCWZlYXR1cmV9CglUaGUgJ2Npbm9wdGlvbnMnIGFmZmVjdCB0aGUgd2F5ICdjaW5kZW50JyByZWluZGVudHMgbGluZXMgaW4gYSBDCglwcm9ncmFtLiAgU2VlIHxjaW5vcHRpb25zLXZhbHVlc3wgZm9yIHRoZSB2YWx1ZXMgb2YgdGhpcyBvcHRpb24sIGFuZAoJfEMtaW5kZW50aW5nfCBmb3IgaW5mbyBvbiBDIGluZGVudGluZyBpbiBnZW5lcmFsLgoKCgkJCQkJCSonY2lud29yZHMnKiAqJ2NpbncnKgonY2lud29yZHMnICdjaW53JwlzdHJpbmcJKGRlZmF1bHQgImlmLGVsc2Usd2hpbGUsZG8sZm9yLHN3aXRjaCIpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgYm90aCB0aGUKCQkJfCtjaW5kZW50fCBhbmQgdGhlIHwrc21hcnRpbmRlbnR8IGZlYXR1cmVzfQoJVGhlc2Uga2V5d29yZHMgc3RhcnQgYW4gZXh0cmEgaW5kZW50IGluIHRoZSBuZXh0IGxpbmUgd2hlbgoJJ3NtYXJ0aW5kZW50JyBvciAnY2luZGVudCcgaXMgc2V0LiAgRm9yICdjaW5kZW50JyB0aGlzIGlzIG9ubHkgZG9uZSBhdAoJYW4gYXBwcm9wcmlhdGUgcGxhY2UgKGluc2lkZSB7fSkuCglOb3RlIHRoYXQgJ2lnbm9yZWNhc2UnIGlzbid0IHVzZWQgZm9yICdjaW53b3JkcycuICBJZiBjYXNlIGRvZXNuJ3QKCW1hdHRlciwgaW5jbHVkZSB0aGUga2V5d29yZCBib3RoIHRoZSB1cHBlcmNhc2UgYW5kIGxvd2VyY2FzZToKCSJpZixJZixJRiIuCgoJCQkJCQkqJ2NsaXBib2FyZCcqIConY2InKgonY2xpcGJvYXJkJyAnY2InCXN0cmluZwkoZGVmYXVsdCAiYXV0b3NlbGVjdCxleGNsdWRlOmNvbnNcfGxpbnV4IgoJCQkJCQkgIGZvciBYLXdpbmRvd3MsICIiIG90aGVyd2lzZSkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGluIEdVSSB2ZXJzaW9ucyBvciB3aGVuIHRoZSB8K3h0ZXJtX2NsaXBib2FyZHwKCQkJZmVhdHVyZSBpcyBpbmNsdWRlZH0KCVRoaXMgb3B0aW9uIGlzIGEgbGlzdCBvZiBjb21tYSBzZXBhcmF0ZWQgbmFtZXMuCglUaGVzZSBuYW1lcyBhcmUgcmVjb2duaXplZDoKCgl1bm5hbWVkCQlXaGVuIGluY2x1ZGVkLCBWaW0gd2lsbCB1c2UgdGhlIGNsaXBib2FyZCByZWdpc3RlciAnKicKCQkJZm9yIGFsbCB5YW5rLCBkZWxldGUsIGNoYW5nZSBhbmQgcHV0IG9wZXJhdGlvbnMgd2hpY2gKCQkJd291bGQgbm9ybWFsbHkgZ28gdG8gdGhlIHVubmFtZWQgcmVnaXN0ZXIuICBXaGVuIGEKCQkJcmVnaXN0ZXIgaXMgZXhwbGljaXRseSBzcGVjaWZpZWQsIGl0IHdpbGwgYWx3YXlzIGJlCgkJCXVzZWQgcmVnYXJkbGVzcyBvZiB3aGV0aGVyICJ1bm5hbWVkIiBpcyBpbiAnY2xpcGJvYXJkJwoJCQlvciBub3QuICBUaGUgY2xpcGJvYXJkIHJlZ2lzdGVyIGNhbiBhbHdheXMgYmUKCQkJZXhwbGljaXRseSBhY2Nlc3NlZCB1c2luZyB0aGUgIiogbm90YXRpb24uICBBbHNvIHNlZQoJCQl8Z3VpLWNsaXBib2FyZHwuCgoJYXV0b3NlbGVjdAlXb3JrcyBsaWtlIHRoZSAnYScgZmxhZyBpbiAnZ3Vpb3B0aW9ucyc6IElmIHByZXNlbnQsCgkJCXRoZW4gd2hlbmV2ZXIgVmlzdWFsIG1vZGUgaXMgc3RhcnRlZCwgb3IgdGhlIFZpc3VhbAoJCQlhcmVhIGV4dGVuZGVkLCBWaW0gdHJpZXMgdG8gYmVjb21lIHRoZSBvd25lciBvZiB0aGUKCQkJd2luZG93aW5nIHN5c3RlbSdzIGdsb2JhbCBzZWxlY3Rpb24gb3IgcHV0IHRoZQoJCQlzZWxlY3RlZCB0ZXh0IG9uIHRoZSBjbGlwYm9hcmQgdXNlZCBieSB0aGUgc2VsZWN0aW9uCgkJCXJlZ2lzdGVyICIqLiAgU2VlIHxndWlvcHRpb25zX2F8IGFuZCB8cXVvdGVzdGFyfCBmb3IKCQkJZGV0YWlscy4gIFdoZW4gdGhlIEdVSSBpcyBhY3RpdmUsIHRoZSAnYScgZmxhZyBpbgoJCQknZ3Vpb3B0aW9ucycgaXMgdXNlZCwgd2hlbiB0aGUgR1VJIGlzIG5vdCBhY3RpdmUsIHRoaXMKCQkJImF1dG9zZWxlY3QiIGZsYWcgaXMgdXNlZC4KCQkJQWxzbyBhcHBsaWVzIHRvIHRoZSBtb2RlbGVzcyBzZWxlY3Rpb24uCgoJYXV0b3NlbGVjdG1sCUxpa2UgImF1dG9zZWxlY3QiLCBidXQgZm9yIHRoZSBtb2RlbGVzcyBzZWxlY3Rpb24KCQkJb25seS4gIENvbXBhcmUgdG8gdGhlICdBJyBmbGFnIGluICdndWlvcHRpb25zJy4KCglleGNsdWRlOntwYXR0ZXJufQoJCQlEZWZpbmVzIGEgcGF0dGVybiB0aGF0IGlzIG1hdGNoZWQgYWdhaW5zdCB0aGUgbmFtZSBvZgoJCQl0aGUgdGVybWluYWwgJ3Rlcm0nLiAgSWYgdGhlcmUgaXMgYSBtYXRjaCwgbm8KCQkJY29ubmVjdGlvbiB3aWxsIGJlIG1hZGUgdG8gdGhlIFggc2VydmVyLiAgVGhpcyBpcwoJCQl1c2VmdWwgaW4gdGhpcyBzaXR1YXRpb246CgkJCS0gUnVubmluZyBWaW0gaW4gYSBjb25zb2xlLgoJCQktICRESVNQTEFZIGlzIHNldCB0byBzdGFydCBhcHBsaWNhdGlvbnMgb24gYW5vdGhlcgoJCQkgIGRpc3BsYXkuCgkJCS0gWW91IGRvIG5vdCB3YW50IHRvIGNvbm5lY3QgdG8gdGhlIFggc2VydmVyIGluIHRoZQoJCQkgIGNvbnNvbGUsIGJ1dCBkbyB3YW50IHRoaXMgaW4gYSB0ZXJtaW5hbCBlbXVsYXRvci4KCQkJVG8gbmV2ZXIgY29ubmVjdCB0byB0aGUgWCBzZXJ2ZXIgdXNlOiA+CgkJCQlleGNsdWRlOi4qCjwJCQlUaGlzIGhhcyB0aGUgc2FtZSBlZmZlY3QgYXMgdXNpbmcgdGhlIHwtWHwgYXJndW1lbnQuCgkJCU5vdGUgdGhhdCB3aGVuIHRoZXJlIGlzIG5vIGNvbm5lY3Rpb24gdG8gdGhlIFggc2VydmVyCgkJCXRoZSB3aW5kb3cgdGl0bGUgd29uJ3QgYmUgcmVzdG9yZWQgYW5kIHRoZSBjbGlwYm9hcmQKCQkJY2Fubm90IGJlIGFjY2Vzc2VkLgoJCQlUaGUgdmFsdWUgb2YgJ21hZ2ljJyBpcyBpZ25vcmVkLCB7cGF0dGVybn0gaXMKCQkJaW50ZXJwcmV0ZWQgYXMgaWYgJ21hZ2ljJyB3YXMgb24uCgkJCVRoZSByZXN0IG9mIHRoZSBvcHRpb24gdmFsdWUgd2lsbCBiZSB1c2VkIGZvcgoJCQl7cGF0dGVybn0sIHRoaXMgbXVzdCBiZSB0aGUgbGFzdCBlbnRyeS4KCgkJCQkJCSonY21kaGVpZ2h0JyogKidjaCcqCidjbWRoZWlnaHQnICdjaCcJbnVtYmVyCShkZWZhdWx0IDEpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJTnVtYmVyIG9mIHNjcmVlbiBsaW5lcyB0byB1c2UgZm9yIHRoZSBjb21tYW5kLWxpbmUuICBIZWxwcyBhdm9pZGluZwoJfGhpdC1lbnRlcnwgcHJvbXB0cy4KCgkJCQkJCSonY21kd2luaGVpZ2h0JyogKidjd2gnKgonY21kd2luaGVpZ2h0JyAnY3doJwludW1iZXIJKGRlZmF1bHQgNykKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCt2ZXJ0c3BsaXR8CgkJCWZlYXR1cmV9CglOdW1iZXIgb2Ygc2NyZWVuIGxpbmVzIHRvIHVzZSBmb3IgdGhlIGNvbW1hbmQtbGluZSB3aW5kb3cuIHxjbWR3aW58CgoJCQkJCQkqJ2NvbHVtbnMnKiAqJ2NvJyogKkU1OTQqCidjb2x1bW5zJyAnY28nCQludW1iZXIJKGRlZmF1bHQgODAgb3IgdGVybWluYWwgd2lkdGgpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJTnVtYmVyIG9mIGNvbHVtbnMgb2YgdGhlIHNjcmVlbi4gIE5vcm1hbGx5IHRoaXMgaXMgc2V0IGJ5IHRoZSB0ZXJtaW5hbAoJaW5pdGlhbGl6YXRpb24gYW5kIGRvZXMgbm90IGhhdmUgdG8gYmUgc2V0IGJ5IGhhbmQuICBBbHNvIHNlZQoJfHBvc2l4LXNjcmVlbi1zaXplfC4KCVdoZW4gVmltIGlzIHJ1bm5pbmcgaW4gdGhlIEdVSSBvciBpbiBhIHJlc2l6YWJsZSB3aW5kb3csIHNldHRpbmcgdGhpcwoJb3B0aW9uIHdpbGwgY2F1c2UgdGhlIHdpbmRvdyBzaXplIHRvIGJlIGNoYW5nZWQuICBXaGVuIHlvdSBvbmx5IHdhbnQKCXRvIHVzZSB0aGUgc2l6ZSBmb3IgdGhlIEdVSSwgcHV0IHRoZSBjb21tYW5kIGluIHlvdXIgfGd2aW1yY3wgZmlsZS4KCVdoZW4geW91IHNldCB0aGlzIG9wdGlvbiBhbmQgVmltIGlzIHVuYWJsZSB0byBjaGFuZ2UgdGhlIHBoeXNpY2FsCgludW1iZXIgb2YgY29sdW1ucyBvZiB0aGUgZGlzcGxheSwgdGhlIGRpc3BsYXkgbWF5IGJlIG1lc3NlZCB1cC4KCgkJCQkJKidjb21tZW50cycqIConY29tJyogKkU1MjQqICpFNTI1KgonY29tbWVudHMnICdjb20nCXN0cmluZwkoZGVmYXVsdAoJCQkJInMxOi8qLG1iOiosZXg6Ki8sOi8vLGI6Iyw6JSw6WENPTU0sbjo+LGZiOi0iKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2NvbW1lbnRzfAoJCQlmZWF0dXJlfQoJQSBjb21tYSBzZXBhcmF0ZWQgbGlzdCBvZiBzdHJpbmdzIHRoYXQgY2FuIHN0YXJ0IGEgY29tbWVudCBsaW5lLiAgU2VlCgl8Zm9ybWF0LWNvbW1lbnRzfC4gIFNlZSB8b3B0aW9uLWJhY2tzbGFzaHwgYWJvdXQgdXNpbmcgYmFja3NsYXNoZXMgdG8KCWluc2VydCBhIHNwYWNlLgoKCQkJCQkqJ2NvbW1lbnRzdHJpbmcnKiAqJ2NtcycqICpFNTM3KgonY29tbWVudHN0cmluZycgJ2NtcycJc3RyaW5nCShkZWZhdWx0ICIvKiVzKi8iKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2ZvbGRpbmd8CgkJCWZlYXR1cmV9CglBIHRlbXBsYXRlIGZvciBhIGNvbW1lbnQuICBUaGUgIiVzIiBpbiB0aGUgdmFsdWUgaXMgcmVwbGFjZWQgd2l0aCB0aGUKCWNvbW1lbnQgdGV4dC4gIEN1cnJlbnRseSBvbmx5IHVzZWQgdG8gYWRkIG1hcmtlcnMgZm9yIGZvbGRpbmcsIHNlZQoJfGZvbGQtbWFya2VyfC4KCgkJCSonY29tcGF0aWJsZScqIConY3AnKiAqJ25vY29tcGF0aWJsZScqIConbm9jcCcqCidjb21wYXRpYmxlJyAnY3AnCWJvb2xlYW4JKGRlZmF1bHQgb24sIG9mZiB3aGVuIGEgLnZpbXJjIG9yIC5ndmltcmMgZmlsZQoJCQkJCQkJCWlzIGZvdW5kKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVRoaXMgb3B0aW9uIGhhcyB0aGUgZWZmZWN0IG9mIG1ha2luZyBWaW0gZWl0aGVyIG1vcmUgVmktY29tcGF0aWJsZSwgb3IKCW1ha2UgVmltIGJlaGF2ZSBpbiBhIG1vcmUgdXNlZnVsIHdheS4KCVRoaXMgaXMgYSBzcGVjaWFsIGtpbmQgb2Ygb3B0aW9uLCBiZWNhdXNlIHdoZW4gaXQncyBzZXQgb3IgcmVzZXQsCglvdGhlciBvcHRpb25zIGFyZSBhbHNvIGNoYW5nZWQgYXMgYSBzaWRlIGVmZmVjdC4gIENBUkVGVUw6IFNldHRpbmcgb3IKCXJlc2V0dGluZyB0aGlzIG9wdGlvbiBjYW4gaGF2ZSBhIGxvdCBvZiB1bmV4cGVjdGVkIGVmZmVjdHM6IE1hcHBpbmdzCglhcmUgaW50ZXJwcmV0ZWQgaW4gYW5vdGhlciB3YXksIHVuZG8gYmVoYXZlcyBkaWZmZXJlbnRseSwgZXRjLiAgSWYgeW91CglzZXQgdGhpcyBvcHRpb24gaW4geW91ciB2aW1yYyBmaWxlLCB5b3Ugc2hvdWxkIHByb2JhYmx5IHB1dCBpdCBhdCB0aGUKCXZlcnkgc3RhcnQuCglCeSBkZWZhdWx0IHRoaXMgb3B0aW9uIGlzIG9uIGFuZCB0aGUgVmkgZGVmYXVsdHMgYXJlIHVzZWQgZm9yIHRoZQoJb3B0aW9ucy4gIFRoaXMgZGVmYXVsdCB3YXMgY2hvc2VuIGZvciB0aG9zZSBwZW9wbGUgd2hvIHdhbnQgdG8gdXNlIFZpbQoJanVzdCBsaWtlIFZpLCBhbmQgZG9uJ3QgZXZlbiAod2FudCB0bykga25vdyBhYm91dCB0aGUgJ2NvbXBhdGlibGUnCglvcHRpb24uCglXaGVuIGEgIi52aW1yYyIgb3IgIi5ndmltcmMiIGZpbGUgaXMgZm91bmQgd2hpbGUgVmltIGlzIHN0YXJ0aW5nIHVwLAoJdGhpcyBvcHRpb24gaXMgc3dpdGNoZWQgb2ZmLCBhbmQgYWxsIG9wdGlvbnMgdGhhdCBoYXZlIG5vdCBiZWVuCgltb2RpZmllZCB3aWxsIGJlIHNldCB0byB0aGUgVmltIGRlZmF1bHRzLiAgRWZmZWN0aXZlbHksIHRoaXMgbWVhbnMKCXRoYXQgd2hlbiBhICIudmltcmMiIG9yICIuZ3ZpbXJjIiBmaWxlIGV4aXN0cywgVmltIHdpbGwgdXNlIHRoZSBWaW0KCWRlZmF1bHRzLCBvdGhlcndpc2UgaXQgd2lsbCB1c2UgdGhlIFZpIGRlZmF1bHRzLiAgKE5vdGU6IFRoaXMgZG9lc24ndAoJaGFwcGVuIGZvciB0aGUgc3lzdGVtLXdpZGUgdmltcmMgb3IgZ3ZpbXJjIGZpbGUpLiAgQWxzbyBzZWUKCXxjb21wYXRpYmxlLWRlZmF1bHR8IGFuZCB8cG9zaXgtY29tcGxpYW5jZXwuCglZb3UgY2FuIGFsc28gc2V0IHRoaXMgb3B0aW9uIHdpdGggdGhlICItQyIgYXJndW1lbnQsIGFuZCByZXNldCBpdCB3aXRoCgkiLU4iLiAgU2VlIHwtQ3wgYW5kIHwtTnwuCglTd2l0Y2hpbmcgdGhpcyBvcHRpb24gb2ZmIG1ha2VzIHRoZSBWaW0gZGVmYXVsdHMgYmUgdXNlZCBmb3Igb3B0aW9ucwoJdGhhdCBoYXZlIGEgZGlmZmVyZW50IFZpIGFuZCBWaW0gZGVmYXVsdCB2YWx1ZS4gIFNlZSB0aGUgb3B0aW9ucwoJbWFya2VkIHdpdGggYSAnKycgYmVsb3cuICBPdGhlciBvcHRpb25zIGFyZSBub3QgbW9kaWZpZWQuCglBdCB0aGUgbW9tZW50IHRoaXMgb3B0aW9uIGlzIHNldCwgc2V2ZXJhbCBvdGhlciBvcHRpb25zIHdpbGwgYmUgc2V0CglvciByZXNldCB0byBtYWtlIFZpbSBhcyBWaS1jb21wYXRpYmxlIGFzIHBvc3NpYmxlLiAgU2VlIHRoZSB0YWJsZQoJYmVsb3cuICBUaGlzIGNhbiBiZSB1c2VkIGlmIHlvdSB3YW50IHRvIHJldmVydCB0byBWaSBjb21wYXRpYmxlCgllZGl0aW5nLgoJU2VlIGFsc28gJ2Nwb3B0aW9ucycuCgoJb3B0aW9uCQkrIHNldCB2YWx1ZQllZmZlY3QJfgoKCSdhbGxvd3JldmlucycJICBvZmYJCW5vIENUUkwtXyBjb21tYW5kCgknYmFja3VwY29weScJICBVbml4OiAieWVzIgkgIGJhY2t1cCBmaWxlIGlzIGEgY29weQoJCQkgIG90aGVyczogImF1dG8iICBjb3B5IG9yIHJlbmFtZSBiYWNrdXAgZmlsZQoJJ2JhY2tzcGFjZScJICAiIgkJbm9ybWFsIGJhY2tzcGFjZQoJJ2JhY2t1cCcJICBvZmYJCW5vIGJhY2t1cCBmaWxlCgknY2luZGVudCcJICBvZmYJCW5vIEMgY29kZSBpbmRlbnRhdGlvbgoJJ2NlZGl0JwkJKyAiIgkJbm8ga2V5IHRvIG9wZW4gdGhlIHxjbWR3aW58CgknY3BvcHRpb25zJwkrIChhbGwgZmxhZ3MpCVZpLWNvbXBhdGlibGUgZmxhZ3MKCSdjc2NvcGV0YWcnCSAgb2ZmCQlkb24ndCB1c2UgY3Njb3BlIGZvciAiOnRhZyIKCSdjc2NvcGV0YWdvcmRlcicgIDAJCXNlZSB8Y3Njb3BldGFnb3JkZXJ8CgknY3Njb3BldmVyYm9zZScJICBvZmYJCXNlZSB8Y3Njb3BldmVyYm9zZXwKCSdkaWdyYXBoJwkgIG9mZgkJbm8gZGlncmFwaHMKCSdlc2NrZXlzJwkrIG9mZgkJbm8gPEVzYz4ta2V5cyBpbiBJbnNlcnQgbW9kZQoJJ2V4cGFuZHRhYicJICBvZmYJCXRhYnMgbm90IGV4cGFuZGVkIHRvIHNwYWNlcwoJJ2ZpbGVmb3JtYXRzJwkrICIiCQlubyBhdXRvbWF0aWMgZmlsZSBmb3JtYXQgZGV0ZWN0aW9uLAoJCQkgICJkb3MsdW5peCIJZXhjZXB0IGZvciBET1MsIFdpbmRvd3MgYW5kIE9TLzIKCSdmb3JtYXRvcHRpb25zJwkrICJ2dCIJCVZpIGNvbXBhdGlibGUgZm9ybWF0dGluZwoJJ2dkZWZhdWx0JwkgIG9mZgkJbm8gZGVmYXVsdCAnZycgZmxhZyBmb3IgIjpzIgoJJ2hpc3RvcnknCSsgMAkJbm8gY29tbWFuZGxpbmUgaGlzdG9yeQoJJ2hrbWFwJwkJICBvZmYJCW5vIEhlYnJldyBrZXlib2FyZCBtYXBwaW5nCgknaGttYXBwJwkgIG9mZgkJbm8gcGhvbmV0aWMgSGVicmV3IGtleWJvYXJkIG1hcHBpbmcKCSdobHNlYXJjaCcJICBvZmYJCW5vIGhpZ2hsaWdodGluZyBvZiBzZWFyY2ggbWF0Y2hlcwoJJ2luY3NlYXJjaCcJICBvZmYJCW5vIGluY3JlbWVudGFsIHNlYXJjaGluZwoJJ2luZGVudGV4cHInCSAgIiIJCW5vIGluZGVudGluZyBieSBleHByZXNzaW9uCgknaW5zZXJ0bW9kZScJICBvZmYJCWRvIG5vdCBzdGFydCBpbiBJbnNlcnQgbW9kZQoJJ2lza2V5d29yZCcJKyAiQCw0OC01NyxfIglrZXl3b3JkcyBjb250YWluIGFscGhhbnVtZXJpYwoJCQkJCQljaGFyYWN0ZXJzIGFuZCAnXycKCSdqb2luc3BhY2VzJwkgIG9uCQlpbnNlcnQgMiBzcGFjZXMgYWZ0ZXIgcGVyaW9kCgknbW9kZWxpbmUnCSsgb2ZmCQlubyBtb2RlbGluZXMKCSdtb3JlJwkJKyBvZmYJCW5vIHBhdXNlcyBpbiBsaXN0aW5ncwoJJ3JldmlucycJICBvZmYJCW5vIHJldmVyc2UgaW5zZXJ0CgkncnVsZXInCQkgIG9mZgkJbm8gcnVsZXIKCSdzY3JvbGxqdW1wJwkgIDEJCW5vIGp1bXAgc2Nyb2xsCgknc2Nyb2xsb2ZmJwkgIDAJCW5vIHNjcm9sbCBvZmZzZXQKCSdzaGlmdHJvdW5kJwkgIG9mZgkJaW5kZW50IG5vdCByb3VuZGVkIHRvIHNoaWZ0d2lkdGgKCSdzaG9ydG1lc3MnCSsgIiIJCW5vIHNob3J0ZW5pbmcgb2YgbWVzc2FnZXMKCSdzaG93Y21kJwkrIG9mZgkJY29tbWFuZCBjaGFyYWN0ZXJzIG5vdCBzaG93bgoJJ3Nob3dtb2RlJwkrIG9mZgkJY3VycmVudCBtb2RlIG5vdCBzaG93bgoJJ3NtYXJ0Y2FzZScJICBvZmYJCW5vIGF1dG9tYXRpYyBpZ25vcmUgY2FzZSBzd2l0Y2gKCSdzbWFydGluZGVudCcJICBvZmYJCW5vIHNtYXJ0IGluZGVudGF0aW9uCgknc21hcnR0YWInCSAgb2ZmCQlubyBzbWFydCB0YWIgc2l6ZQoJJ3NvZnR0YWJzdG9wJwkgIDAJCXRhYnMgYXJlIGFsd2F5cyAndGFic3RvcCcgcG9zaXRpb25zCgknc3RhcnRvZmxpbmUnCSAgb24JCWdvdG8gc3RhcnRvZmxpbmUgd2l0aCBzb21lIGNvbW1hbmRzCgkndGFncmVsYXRpdmUnCSsgb2ZmCQl0YWcgZmlsZSBuYW1lcyBhcmUgbm90IHJlbGF0aXZlCgkndGV4dGF1dG8nCSsgb2ZmCQlubyBhdXRvbWF0aWMgdGV4dG1vZGUgZGV0ZWN0aW9uCgkndGV4dHdpZHRoJwkgIDAJCW5vIGF1dG9tYXRpYyBsaW5lIHdyYXAKCSd0aWxkZW9wJwkgIG9mZgkJdGlsZGUgaXMgbm90IGFuIG9wZXJhdG9yCgkndHRpbWVvdXQnCSAgb2ZmCQlubyB0ZXJtaW5hbCB0aW1lb3V0Cgknd2hpY2h3cmFwJwkrICIiCQlsZWZ0LXJpZ2h0IG1vdmVtZW50cyBkb24ndCB3cmFwCgknd2lsZGNoYXInCSsgQ1RSTC1FCW9ubHkgd2hlbiB0aGUgY3VycmVudCB2YWx1ZSBpcyA8VGFiPgoJCQkJCXVzZSBDVFJMLUUgZm9yIGNtZGxpbmUgY29tcGxldGlvbgoJJ3dyaXRlYmFja3VwJwkgIG9uIG9yIG9mZglkZXBlbmRzIG9uICt3cml0ZWJhY2t1cCBmZWF0dXJlCgoJCQkJCQkqJ2NvbXBsZXRlJyogKidjcHQnKiAqRTUzNSoKJ2NvbXBsZXRlJyAnY3B0JwlzdHJpbmcJKGRlZmF1bHQ6ICIuLHcsYix1LHQsaSIpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJVGhpcyBvcHRpb24gc3BlY2lmaWVzIGhvdyBrZXl3b3JkIGNvbXBsZXRpb24gfGlucy1jb21wbGV0aW9ufCB3b3JrcwoJd2hlbiBDVFJMLVAgb3IgQ1RSTC1OIGFyZSB1c2VkLiAgSXQgaXMgYWxzbyB1c2VkIGZvciB3aG9sZS1saW5lCgljb21wbGV0aW9uIHxpX0NUUkwtWF9DVFJMLUx8LiAgSXQgaW5kaWNhdGVzIHRoZSB0eXBlIG9mIGNvbXBsZXRpb24KCWFuZCB0aGUgcGxhY2VzIHRvIHNjYW4uICBJdCBpcyBhIGNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIGZsYWdzOgoJLglzY2FuIHRoZSBjdXJyZW50IGJ1ZmZlciAoJ3dyYXBzY2FuJyBpcyBpZ25vcmVkKQoJdwlzY2FuIGJ1ZmZlcnMgZnJvbSBvdGhlciB3aW5kb3dzCgliCXNjYW4gb3RoZXIgbG9hZGVkIGJ1ZmZlcnMgdGhhdCBhcmUgaW4gdGhlIGJ1ZmZlciBsaXN0Cgl1CXNjYW4gdGhlIHVubG9hZGVkIGJ1ZmZlcnMgdGhhdCBhcmUgaW4gdGhlIGJ1ZmZlciBsaXN0CglVCXNjYW4gdGhlIGJ1ZmZlcnMgdGhhdCBhcmUgbm90IGluIHRoZSBidWZmZXIgbGlzdAoJawlzY2FuIHRoZSBmaWxlcyBnaXZlbiB3aXRoIHRoZSAnZGljdGlvbmFyeScgb3B0aW9uCglre2RpY3R9CXNjYW4gdGhlIGZpbGUge2RpY3R9LiAgU2V2ZXJhbCAiayIgZmxhZ3MgY2FuIGJlIGdpdmVuLAoJCXBhdHRlcm5zIGFyZSB2YWxpZCB0b28uICBGb3IgZXhhbXBsZTogPgoJCQk6c2V0IGNwdD1rL3Vzci9kaWN0Lyosa34vc3BhbmlzaAo8CXMJc2NhbiB0aGUgZmlsZXMgZ2l2ZW4gd2l0aCB0aGUgJ3RoZXNhdXJ1cycgb3B0aW9uCglze3Rzcn0Jc2NhbiB0aGUgZmlsZSB7dHNyfS4gIFNldmVyYWwgInMiIGZsYWdzIGNhbiBiZSBnaXZlbiwgcGF0dGVybnMKCQlhcmUgdmFsaWQgdG9vLgoJaQlzY2FuIGN1cnJlbnQgYW5kIGluY2x1ZGVkIGZpbGVzCglkCXNjYW4gY3VycmVudCBhbmQgaW5jbHVkZWQgZmlsZXMgZm9yIGRlZmluZWQgbmFtZSBvciBtYWNybwoJCXxpX0NUUkwtWF9DVFJMLUR8CgldCXRhZyBjb21wbGV0aW9uCgl0CXNhbWUgYXMgIl0iCgoJVW5sb2FkZWQgYnVmZmVycyBhcmUgbm90IGxvYWRlZCwgdGh1cyB0aGVpciBhdXRvY21kcyB8OmF1dG9jbWR8IGFyZQoJbm90IGV4ZWN1dGVkLCB0aGlzIG1heSBsZWFkIHRvIHVuZXhwZWN0ZWQgY29tcGxldGlvbnMgZnJvbSBzb21lIGZpbGVzCgkoZ3ppcHBlZCBmaWxlcyBmb3IgZXhhbXBsZSkuICBVbmxvYWRlZCBidWZmZXJzIGFyZSBub3Qgc2Nhbm5lZCBmb3IKCXdob2xlLWxpbmUgY29tcGxldGlvbi4KCglUaGUgZGVmYXVsdCBpcyAiLix3LGIsdSx0LGkiLCB3aGljaCBtZWFucyB0byBzY2FuOgoJICAgMS4gdGhlIGN1cnJlbnQgYnVmZmVyCgkgICAyLiBidWZmZXJzIGluIG90aGVyIHdpbmRvd3MKCSAgIDMuIG90aGVyIGxvYWRlZCBidWZmZXJzCgkgICA0LiB1bmxvYWRlZCBidWZmZXJzCgkgICA1LiB0YWdzCgkgICA2LiBpbmNsdWRlZCBmaWxlcwoKCUFzIHlvdSBjYW4gc2VlLCBDVFJMLU4gYW5kIENUUkwtUCBjYW4gYmUgdXNlZCB0byBkbyBhbnkgJ2lza2V5d29yZCctCgliYXNlZCBleHBhbnNpb24gKGUuZy4sIGRpY3Rpb25hcnkgfGlfQ1RSTC1YX0NUUkwtS3wsIGluY2x1ZGVkIHBhdHRlcm5zCgl8aV9DVFJMLVhfQ1RSTC1JfCwgdGFncyB8aV9DVFJMLVhfQ1RSTC1dfCBhbmQgbm9ybWFsIGV4cGFuc2lvbnMpLgoKCQkJCQkJKidjb21wbGV0ZWZ1bmMnKiAqJ2NmdScqCidjb21wbGV0ZWZ1bmMnICdjZnUnCXN0cmluZwkoZGVmYXVsdDogZW1wdHkpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJVGhpcyBvcHRpb24gc3BlY2lmaWVzIGEgY29tcGxldGlvbiBmdW5jdGlvbiB0byBiZSB1c2VkIGZvciBDVFJMLVgKCUNUUkwtWC4gIFRoZSBmdW5jdGlvbiB3aWxsIGJlIGludm9rZWQgd2l0aCBmb3VyIGFyZ3VtZW50czoKCSAgIGE6bGluZQl0aGUgdGV4dCBvZiB0aGUgY3VycmVudCBsaW5lCgkgICBhOmJhc2UJdGhlIHRleHQgd2l0aCB3aGljaCBtYXRjaGVzIHNob3VsZCBtYXRjaAoJICAgYTpjb2wgICAgICAgIGNvbHVtbiBpbiBhOmxpbmUgd2hlcmUgdGhlIGN1cnNvciBpcywgZmlyc3QgY29sdW1uIGlzCgkgICAJCXplcm8KCSAgIGE6ZmluZHN0YXJ0ICBlaXRoZXIgMSBvciAwCglXaGVuIHRoZSBhOmZpbmRzdGFydCBhcmd1bWVudCBpcyAxLCB0aGUgZnVuY3Rpb24gbXVzdCByZXR1cm4gdGhlCgljb2x1bW4gb2Ygd2hlcmUgdGhlIGNvbXBsZXRpb24gc3RhcnRzLiAgSXQgbXVzdCBiZSBhIG51bWJlciBiZXR3ZWVuCgl6ZXJvIGFuZCAiYTpjb2wiLiAgVGhpcyBpbnZvbHZlcyBsb29raW5nIGF0IHRoZSBjaGFyYWN0ZXJzIGluIGE6bGluZQoJYmVmb3JlIGNvbHVtbiBhOmNvbCBhbmQgaW5jbHVkZSB0aG9zZSBjaGFyYWN0ZXJzIHRoYXQgY291bGQgYmUgcGFydCBvZgoJdGhlIGNvbXBsZXRlZCBpdGVtLgoJV2hlbiB0aGUgYTpmaW5kc3RhcnQgYXJndW1lbnQgaXMgMCB0aGUgZnVuY3Rpb24gbXVzdCByZXR1cm4gYSBzdHJpbmcKCXdpdGggdGhlIG1hdGNoaW5nIHdvcmRzLCBzZXBhcmF0ZWQgYnkgbmV3bGluZXMuICBXaGVuIHRoZXJlIGFyZSBubwoJbWF0Y2hlcyByZXR1cm4gYW4gZW1wdHkgc3RyaW5nLgoJQW4gZXhhbXBsZSB0aGF0IGNvbXBsZXRlcyB0aGUgbmFtZXMgb2YgdGhlIG1vbnRoczogPgoJCWZ1biEgQ29tcGxldGVNb250aHMobGluZSwgYmFzZSwgY29sLCBmaW5kc3RhcnQpCgkJICBpZiBhOmZpbmRzdGFydAoJCSAgICAiIGxvY2F0ZSBzdGFydCBjb2x1bW4gb2Ygd29yZAoJCSAgICBsZXQgc3RhcnQgPSBhOmNvbAoJCSAgICB3aGlsZSBzdGFydCA+IDAgJiYgYTpsaW5lW3N0YXJ0IC0gMV0gPX4gJ1xhJwoJCSAgICAgIGxldCBzdGFydCA9IHN0YXJ0IC0gMQoJCSAgICBlbmR3aGlsZQoJCSAgICByZXR1cm4gc3RhcnQKCQkgIGVsc2UKCQkgICAgIiBmaW5kIG1vbnRocyBtYXRjaGluZyB3aXRoICJhOmJhc2UiCgkJICAgIGxldCByZXMgPSAiSmFuIEZlYiBNYXIgQXByIE1heSBKdW4gSnVsIEF1ZyBTZXAgT2N0IE5vdiBEZWMiCgkJICAgIGlmIGE6YmFzZSAhPSAnJwoJCSAgICAgIGxldCByZXMgPSBzdWJzdGl0dXRlKHJlcywgJ1xjXDxcKFwoJyAuIGE6YmFzZSAuICcuXHstfVw+XClcfC5cey19XD5cKScsICdcMicsICdnJykKCQkgICAgZW5kaWYKCQkgICAgbGV0IHJlcyA9IHN1YnN0aXR1dGUocmVzLCAnIFwrJywgIlxuIiwgJ2cnKQoJCSAgICByZXR1cm4gcmVzCgkJICBlbmRpZgoJCWVuZGZ1bgoJCXNldCBjb21wbGV0ZWZ1bmM9Q29tcGxldGVNb250aHMKPAlOb3RlIHRoYXQgYSBzdWJzdGl0dXRlKCkgZnVuY3Rpb24gaXMgdXNlZCB0byByZWR1Y2UgdGhlIGxpc3Qgb2YKCXBvc3NpYmxlIHZhbHVlcyBhbmQgcmVtb3ZlIHRoZSBvbmVzIHRoYXQgZG9uJ3QgbWF0Y2ggdGhlIGJhc2UuICBUaGUKCXBhcnQgYmVmb3JlIHRoZSAiXHwiIG1hdGNoZXMgdGhlIGJhc2UsIHRoZSBwYXJ0IGFmdGVyIGl0IGlzIHVzZWQKCXdoZW4gdGhlcmUgaXMgbm8gbWF0Y2guICBUaGUgIlwyIiBpbiB0aGUgcmVwbGFjZW1lbnQgaXMgZW1wdHkgaWYgdGhlCglwYXJ0IGJlZm9yZSB0aGUgIlx8IiBkb2VzIG5vdCBtYXRjaC4KCgkJCQkqJ2NvbmZpcm0nKiAqJ2NmJyogKidub2NvbmZpcm0nKiAqJ25vY2YnKgonY29uZmlybScgJ2NmJwkJYm9vbGVhbiAoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiAnY29uZmlybScgaXMgb24sIGNlcnRhaW4gb3BlcmF0aW9ucyB0aGF0IHdvdWxkIG5vcm1hbGx5CglmYWlsIGJlY2F1c2Ugb2YgdW5zYXZlZCBjaGFuZ2VzIHRvIGEgYnVmZmVyLCBlLmcuICI6cSIgYW5kICI6ZSIsCglpbnN0ZWFkIHJhaXNlIGEgfGRpYWxvZ3wgYXNraW5nIGlmIHlvdSB3aXNoIHRvIHNhdmUgdGhlIGN1cnJlbnQKCWZpbGUocykuICBZb3UgY2FuIHN0aWxsIHVzZSBhICEgdG8gdW5jb25kaXRpb25hbGx5IHxhYmFuZG9ufCBhIGJ1ZmZlci4KCUlmICdjb25maXJtJyBpcyBvZmYgeW91IGNhbiBzdGlsbCBhY3RpdmF0ZSBjb25maXJtYXRpb24gZm9yIG9uZQoJY29tbWFuZCBvbmx5ICh0aGlzIGlzIG1vc3QgdXNlZnVsIGluIG1hcHBpbmdzKSB3aXRoIHRoZSB8OmNvbmZpcm18Cgljb21tYW5kLgoJQWxzbyBzZWUgdGhlIHxjb25maXJtKCl8IGZ1bmN0aW9uIGFuZCB0aGUgJ3YnIGZsYWcgaW4gJ2d1aW9wdGlvbnMnLgoKCQkJKidjb25za2V5JyogKidjb25zaycqIConbm9jb25za2V5JyogKidub2NvbnNrJyoKJ2NvbnNrZXknICdjb25zaycJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfSAge29ubHkgZm9yIE1TLURPU30KCVdoZW4gb24gZGlyZWN0IGNvbnNvbGUgSS9PIGlzIHVzZWQgdG8gb2J0YWluIGEga2V5Ym9hcmQgY2hhcmFjdGVyLgoJVGhpcyBzaG91bGQgd29yayBpbiBtb3N0IGNhc2VzLiAgQWxzbyBzZWUgfCdiaW9za2V5J3wuICBUb2dldGhlciwKCXRocmVlIG1ldGhvZHMgb2YgY29uc29sZSBpbnB1dCBhcmUgYXZhaWxhYmxlOgoJJ2NvbnNrZXknICAgJ2Jpb3NrZXknCSAgICBhY3Rpb24gfgoJICAgb24JICAgICBvbiBvciBvZmYJICAgIGRpcmVjdCBjb25zb2xlIGlucHV0CgkgICBvZmYJCW9uCSAgICBCSU9TCgkgICBvZmYJCW9mZgkgICAgU1RESU4KCgkJCSonY29weWluZGVudCcqIConY2knKiAqJ25vY29weWluZGVudCcqIConbm9jaScqCidjb3B5aW5kZW50JyAnY2knCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCUNvcHkgdGhlIHN0cnVjdHVyZSBvZiB0aGUgZXhpc3RpbmcgbGluZXMgaW5kZW50IHdoZW4gYXV0b2luZGVudGluZyBhCgluZXcgbGluZS4gIE5vcm1hbGx5IHRoZSBuZXcgaW5kZW50IGlzIHJlY29uc3RydWN0ZWQgYnkgYSBzZXJpZXMgb2YKCXRhYnMgZm9sbG93ZWQgYnkgc3BhY2VzIGFzIHJlcXVpcmVkICh1bmxlc3MgfCdleHBhbmR0YWInfCBpcyBlbmFibGVkLAoJaW4gd2hpY2ggY2FzZSBvbmx5IHNwYWNlcyBhcmUgdXNlZCkuICBFbmFibGluZyB0aGlzIG9wdGlvbiBtYWtlcyB0aGUKCW5ldyBsaW5lIGNvcHkgd2hhdGV2ZXIgY2hhcmFjdGVycyB3ZXJlIHVzZWQgZm9yIGluZGVudGluZyBvbiB0aGUKCWV4aXN0aW5nIGxpbmUuICBJZiB0aGUgbmV3IGluZGVudCBpcyBncmVhdGVyIHRoYW4gb24gdGhlIGV4aXN0aW5nCglsaW5lLCB0aGUgcmVtYWluaW5nIHNwYWNlIGlzIGZpbGxlZCBpbiB0aGUgbm9ybWFsIG1hbm5lci4KCU5PVEU6ICdjb3B5aW5kZW50JyBpcyByZXNldCB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCglBbHNvIHNlZSAncHJlc2VydmVpbmRlbnQnLgoKCQkJCQkJKidjcG9wdGlvbnMnKiAqJ2NwbycqCidjcG9wdGlvbnMnICdjcG8nCXN0cmluZwkoVmltIGRlZmF1bHQ6ICJhQUJjZUZzIiwKCQkJCSBWaSBkZWZhdWx0OiAgYWxsIGZsYWdzKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCUEgc2VxdWVuY2Ugb2Ygc2luZ2xlIGNoYXJhY3RlciBmbGFncy4gIFdoZW4gYSBjaGFyYWN0ZXIgaXMgcHJlc2VudAoJdGhpcyBpbmRpY2F0ZXMgdmktY29tcGF0aWJsZSBiZWhhdmlvci4gIFRoaXMgaXMgdXNlZCBmb3IgdGhpbmdzIHdoZXJlCglub3QgYmVpbmcgdmktY29tcGF0aWJsZSBpcyBtb3N0bHkgb3Igc29tZXRpbWVzIHByZWZlcnJlZC4KCSdjcG9wdGlvbnMnIHN0YW5kcyBmb3IgImNvbXBhdGlibGUtb3B0aW9ucyIuCglDb21tYXMgY2FuIGJlIGFkZGVkIGZvciByZWFkYWJpbGl0eS4KCVRvIGF2b2lkIHByb2JsZW1zIHdpdGggZmxhZ3MgdGhhdCBhcmUgYWRkZWQgaW4gdGhlIGZ1dHVyZSwgdXNlIHRoZQoJIis9IiBhbmQgIi09IiBmZWF0dXJlIG9mICI6c2V0IiB8YWRkLW9wdGlvbi1mbGFnc3wuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyBzZXQgdG8gdGhlIFZpIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMKCXNldCBhbmQgdG8gdGhlIFZpbSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzIHJlc2V0LgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIHRoZSBQT1NJWCBkZWZhdWx0IHZhbHVlIGF0IHN0YXJ0dXAgd2hlbgoJdGhlIFZpIGRlZmF1bHQgdmFsdWUgd291bGQgYmUgdXNlZCBhbmQgdGhlICRWSU1fUE9TSVggZW52aXJvbm1lbnQKCXZhcmlhYmxlIGV4aXN0cyB8cG9zaXh8LiAgVGhpcyBtZWFucyB0cmllcyB0byBiZWhhdmUgbGlrZSB0aGUgUE9TSVgKCXNwZWNpZmljYXRpb24uCgoJICAgIGNvbnRhaW5zCWJlaGF2aW9yCX4KCQkJCQkJCQkqY3BvLWEqCgkJYQlXaGVuIGluY2x1ZGVkLCBhICI6cmVhZCIgY29tbWFuZCB3aXRoIGEgZmlsZSBuYW1lCgkJCWFyZ3VtZW50IHdpbGwgc2V0IHRoZSBhbHRlcm5hdGUgZmlsZSBuYW1lIGZvciB0aGUKCQkJY3VycmVudCB3aW5kb3cuCgkJCQkJCQkJKmNwby1BKgoJCUEJV2hlbiBpbmNsdWRlZCwgYSAiOndyaXRlIiBjb21tYW5kIHdpdGggYSBmaWxlIG5hbWUKCQkJYXJndW1lbnQgd2lsbCBzZXQgdGhlIGFsdGVybmF0ZSBmaWxlIG5hbWUgZm9yIHRoZQoJCQljdXJyZW50IHdpbmRvdy4KCQkJCQkJCQkqY3BvLWIqCgkJYgkiXHwiIGluIGEgIjptYXAiIGNvbW1hbmQgaXMgcmVjb2duaXplZCBhcyB0aGUgZW5kIG9mCgkJCXRoZSBtYXAgY29tbWFuZC4gIFRoZSAnXCcgaXMgaW5jbHVkZWQgaW4gdGhlIG1hcHBpbmcsCgkJCXRoZSB0ZXh0IGFmdGVyIHRoZSAnfCcgaXMgaW50ZXJwcmV0ZWQgYXMgdGhlIG5leHQKCQkJY29tbWFuZC4gIFVzZSBhIENUUkwtViBpbnN0ZWFkIG9mIGEgYmFja3NsYXNoIHRvCgkJCWluY2x1ZGUgdGhlICd8JyBpbiB0aGUgbWFwcGluZy4gIEFwcGxpZXMgdG8gYWxsCgkJCW1hcHBpbmcsIGFiYnJldmlhdGlvbiwgbWVudSBhbmQgYXV0b2NtZCBjb21tYW5kcy4KCQkJU2VlIGFsc28gfG1hcF9iYXJ8LgoJCQkJCQkJCSpjcG8tQioKCQlCCUEgYmFja3NsYXNoIGhhcyBubyBzcGVjaWFsIG1lYW5pbmcgaW4gbWFwcGluZ3MsCgkJCWFiYnJldmlhdGlvbnMgYW5kIHRoZSAidG8iIHBhcnQgb2YgdGhlIG1lbnUgY29tbWFuZHMuCgkJCVJlbW92ZSB0aGlzIGZsYWcgdG8gYmUgYWJsZSB0byB1c2UgYSBiYWNrc2xhc2ggbGlrZSBhCgkJCUNUUkwtVi4gIEZvciBleGFtcGxlLCB0aGUgY29tbWFuZCAiOm1hcCBYIFw8RXNjPiIKCQkJcmVzdWx0cyBpbiBYIGJlaW5nIG1hcHBlZCB0bzoKCQkJCSdCJyBpbmNsdWRlZDoJIlxeWyIJICheWyBpcyBhIHJlYWwgPEVzYz4pCgkJCQknQicgZXhjbHVkZWQ6CSI8RXNjPiIgICg1IGNoYXJhY3RlcnMpCgkJCQkoJzwnIGV4Y2x1ZGVkIGluIGJvdGggY2FzZXMpCgkJCQkJCQkJKmNwby1jKgoJCWMJU2VhcmNoaW5nIGNvbnRpbnVlcyBhdCB0aGUgZW5kIG9mIGFueSBtYXRjaCBhdCB0aGUKCQkJY3Vyc29yIHBvc2l0aW9uLCBidXQgbm90IGZ1cnRoZXIgdGhhbiB0aGUgc3RhcnQgb2YgdGhlCgkJCW5leHQgbGluZS4gIFdoZW4gbm90IHByZXNlbnQgc2VhcmNoaW5nIGNvbnRpbnVlcwoJCQlvbmUgY2hhcmFjdGVyIGZyb20gdGhlIGN1cnNvciBwb3NpdGlvbi4gIFdpdGggJ2MnCgkJCSJhYmFiYWJhYmFiYWIiIG9ubHkgZ2V0cyB0aHJlZSBtYXRjaGVzIHdoZW4gcmVwZWF0aW5nCgkJCSIvYWJhYiIsIHdpdGhvdXQgJ2MnIHRoZXJlIGFyZSBmaXZlIG1hdGNoZXMuCgkJCQkJCQkJKmNwby1DKgoJCUMJRG8gbm90IGNvbmNhdGVuYXRlIHNvdXJjZWQgbGluZXMgdGhhdCBzdGFydCB3aXRoIGEKCQkJYmFja3NsYXNoLiAgU2VlIHxsaW5lLWNvbnRpbnVhdGlvbnwuCgkJCQkJCQkJKmNwby1kKgoJCWQJVXNpbmcgIi4vIiBpbiB0aGUgJ3RhZ3MnIG9wdGlvbiBkb2Vzbid0IG1lYW4gdG8gdXNlCgkJCXRoZSB0YWdzIGZpbGUgcmVsYXRpdmUgdG8gdGhlIGN1cnJlbnQgZmlsZSwgYnV0IHRoZQoJCQl0YWdzIGZpbGUgaW4gdGhlIGN1cnJlbnQgZGlyZWN0b3J5LgoJCQkJCQkJCSpjcG8tRCoKCQlECUNhbid0IHVzZSBDVFJMLUsgdG8gZW50ZXIgYSBkaWdyYXBoIGFmdGVyIE5vcm1hbCBtb2RlCgkJCWNvbW1hbmRzIHdpdGggYSBjaGFyYWN0ZXIgYXJndW1lbnQsIGxpa2UgfHJ8LCB8ZnwgYW5kCgkJCXx0fC4KCQkJCQkJCQkqY3BvLWUqCgkJZQlXaGVuIGV4ZWN1dGluZyBhIHJlZ2lzdGVyIHdpdGggIjpAciIsIGFsd2F5cyBhZGQgYQoJCQk8Q1I+IHRvIHRoZSBsYXN0IGxpbmUsIGFsc28gd2hlbiB0aGUgcmVnaXN0ZXIgaXMgbm90CgkJCWxpbmV3aXNlLiAgSWYgdGhpcyBmbGFnIGlzIG5vdCBwcmVzZW50LCB0aGUgcmVnaXN0ZXIKCQkJaXMgbm90IGxpbmV3aXNlIGFuZCB0aGUgbGFzdCBsaW5lIGRvZXMgbm90IGVuZCBpbiBhCgkJCTxDUj4sIHRoZW4gdGhlIGxhc3QgbGluZSBpcyBwdXQgb24gdGhlIGNvbW1hbmQtbGluZQoJCQlhbmQgY2FuIGJlIGVkaXRlZCBiZWZvcmUgaGl0dGluZyA8Q1I+LgoJCQkJCQkJCSpjcG8tRSoKCQlFCUl0IGlzIGFuIGVycm9yIHdoZW4gdXNpbmcgInkiLCAiZCIsICJjIiwgImd+IiwgImd1IiBvcgoJCQkiZ1UiIG9uIGFuIEVtcHR5IHJlZ2lvbi4gIFRoZSBvcGVyYXRvcnMgb25seSB3b3JrIHdoZW4KCQkJYXQgbGVhc3Qgb25lIGNoYXJhY3RlciBpcyB0byBiZSBvcGVyYXRlIG9uLiAgRXhhbXBsZToKCQkJVGhpcyBtYWtlcyAieTAiIGZhaWwgaW4gdGhlIGZpcnN0IGNvbHVtbi4KCQkJCQkJCQkqY3BvLWYqCgkJZglXaGVuIGluY2x1ZGVkLCBhICI6cmVhZCIgY29tbWFuZCB3aXRoIGEgZmlsZSBuYW1lCgkJCWFyZ3VtZW50IHdpbGwgc2V0IHRoZSBmaWxlIG5hbWUgZm9yIHRoZSBjdXJyZW50IGJ1ZmZlciwKCQkJaWYgdGhlIGN1cnJlbnQgYnVmZmVyIGRvZXNuJ3QgaGF2ZSBhIGZpbGUgbmFtZSB5ZXQuCgkJCQkJCQkJKmNwby1GKgoJCUYJV2hlbiBpbmNsdWRlZCwgYSAiOndyaXRlIiBjb21tYW5kIHdpdGggYSBmaWxlIG5hbWUKCQkJYXJndW1lbnQgd2lsbCBzZXQgdGhlIGZpbGUgbmFtZSBmb3IgdGhlIGN1cnJlbnQKCQkJYnVmZmVyLCBpZiB0aGUgY3VycmVudCBidWZmZXIgZG9lc24ndCBoYXZlIGEgZmlsZSBuYW1lCgkJCXlldC4KCQkJCQkJCQkqY3BvLWcqCgkJZwlHb3RvIGxpbmUgMSB3aGVuIHVzaW5nICI6ZWRpdCIgd2l0aG91dCBhcmd1bWVudC4KCQkJCQkJCQkqY3BvLUgqCgkJSAlXaGVuIHVzaW5nICJJIiBvbiBhIGxpbmUgd2l0aCBvbmx5IGJsYW5rcywgaW5zZXJ0CgkJCWJlZm9yZSB0aGUgbGFzdCBibGFuay4gIFdpdGhvdXQgdGhpcyBmbGFnIGluc2VydCBhZnRlcgoJCQl0aGUgbGFzdCBibGFuay4KCQkJCQkJCQkqY3BvLWkqCgkJaQlXaGVuIGluY2x1ZGVkLCBpbnRlcnJ1cHRpbmcgdGhlIHJlYWRpbmcgb2YgYSBmaWxlIHdpbGwKCQkJbGVhdmUgaXQgbW9kaWZpZWQuCgkJCQkJCQkJKmNwby1JKgoJCUkJV2hlbiBtb3ZpbmcgdGhlIGN1cnNvciB1cCBvciBkb3duIGp1c3QgYWZ0ZXIgaW5zZXJ0aW5nCgkJCWluZGVudCBmb3IgJ2F1dG9pbmRlbnQnLCBkbyBub3QgZGVsZXRlIHRoZSBpbmRlbnQuCgkJCQkJCQkJKmNwby1qKgoJCWoJV2hlbiBqb2luaW5nIGxpbmVzLCBvbmx5IGFkZCB0d28gc3BhY2VzIGFmdGVyIGEgJy4nLAoJCQlub3QgYWZ0ZXIgJyEnIG9yICc/Jy4gIEFsc28gc2VlICdqb2luc3BhY2VzJy4KCQkJCQkJCQkqY3BvLUoqCgkJSglBIHxzZW50ZW5jZXwgaGFzIHRvIGJlIGZvbGxvd2VkIGJ5IHR3byBzcGFjZXMgYWZ0ZXIKCQkJdGhlICcuJywgJyEnIG9yICc/Jy4gIEEgPFRhYj4gaXMgbm90IHJlY29nbml6ZWQgYXMKCQkJd2hpdGUgc3BhY2UuCgkJCQkJCQkJKmNwby1rKgoJCWsJRGlzYWJsZSB0aGUgcmVjb2duaXRpb24gb2YgcmF3IGtleSBjb2RlcyBpbgoJCQltYXBwaW5ncywgYWJicmV2aWF0aW9ucywgYW5kIHRoZSAidG8iIHBhcnQgb2YgbWVudQoJCQljb21tYW5kcy4gIEZvciBleGFtcGxlLCBpZiA8S2V5PiBzZW5kcyBeW09BICh3aGVyZSBeWwoJCQlpcyA8RXNjPiksIHRoZSBjb21tYW5kICI6bWFwIFggXltPQSIgcmVzdWx0cyBpbiBYCgkJCWJlaW5nIG1hcHBlZCB0bzoKCQkJCSdrJyBpbmNsdWRlZDoJIl5bT0EiCSAoMyBjaGFyYWN0ZXJzKQoJCQkJJ2snIGV4Y2x1ZGVkOgkiPEtleT4iICAob25lIGtleSBjb2RlKQoJCQlBbHNvIHNlZSB0aGUgJzwnIGZsYWcgYmVsb3cuCgkJCQkJCQkJKmNwby1LKgoJCUsJRG9uJ3Qgd2FpdCBmb3IgYSBrZXkgY29kZSB0byBjb21wbGV0ZSB3aGVuIGl0IGlzCgkJCWhhbGZ3YXkgYSBtYXBwaW5nLiAgVGhpcyBicmVha3MgbWFwcGluZyA8RjE+PEYxPiB3aGVuCgkJCW9ubHkgcGFydCBvZiB0aGUgc2Vjb25kIDxGMT4gaGFzIGJlZW4gcmVhZC4gIEl0CgkJCWVuYWJsZXMgY2FuY2VsbGluZyB0aGUgbWFwcGluZyBieSB0eXBpbmcgPEYxPjxFc2M+LgoJCQkJCQkJCSpjcG8tbCoKCQlsCUJhY2tzbGFzaCBpbiBhIFtdIHJhbmdlIGluIGEgc2VhcmNoIHBhdHRlcm4gaXMgdGFrZW4KCQkJbGl0ZXJhbGx5LCBvbmx5ICJcXSIsICJcXiIsICJcLSIgYW5kICJcXCIgYXJlIHNwZWNpYWwuCgkJCVNlZSB8L1tdfAoJCQkgICAnbCcgaW5jbHVkZWQ6ICIvWyBcdF0iICBmaW5kcyA8U3BhY2U+LCAnXCcgYW5kICd0JwoJCQkgICAnbCcgZXhjbHVkZWQ6ICIvWyBcdF0iICBmaW5kcyA8U3BhY2U+IGFuZCA8VGFiPgoJCQlBbHNvIHNlZSB8Y3BvLVx8LgoJCQkJCQkJCSpjcG8tTCoKCQlMCVdoZW4gdGhlICdsaXN0JyBvcHRpb24gaXMgc2V0LCAnd3JhcG1hcmdpbicsCgkJCSd0ZXh0d2lkdGgnLCAnc29mdHRhYnN0b3AnIGFuZCBWaXJ0dWFsIFJlcGxhY2UgbW9kZQoJCQkoc2VlIHxnUnwpIGNvdW50IGEgPFRhYj4gYXMgdHdvIGNoYXJhY3RlcnMsIGluc3RlYWQgb2YKCQkJdGhlIG5vcm1hbCBiZWhhdmlvciBvZiBhIDxUYWI+LgoJCQkJCQkJCSpjcG8tbSoKCQltCVdoZW4gaW5jbHVkZWQsIGEgc2hvd21hdGNoIHdpbGwgYWx3YXlzIHdhaXQgaGFsZiBhCgkJCXNlY29uZC4gIFdoZW4gbm90IGluY2x1ZGVkLCBhIHNob3dtYXRjaCB3aWxsIHdhaXQgaGFsZgoJCQlhIHNlY29uZCBvciB1bnRpbCBhIGNoYXJhY3RlciBpcyB0eXBlZC4gIHwnc2hvd21hdGNoJ3wKCQkJCQkJCQkqY3BvLU0qCgkJTQlXaGVuIGV4Y2x1ZGVkLCAiJSIgbWF0Y2hpbmcgd2lsbCB0YWtlIGJhY2tzbGFzaGVzIGludG8KCQkJYWNjb3VudC4gIFRodXMgaW4gIiggXCggKSIgYW5kICJcKCAoIFwpIiB0aGUgb3V0ZXIKCQkJcGFyZW50aGVzaXMgbWF0Y2guICBXaGVuIGluY2x1ZGVkICIlIiBpZ25vcmVzCgkJCWJhY2tzbGFzaGVzLCB3aGljaCBpcyBWaSBjb21wYXRpYmxlLgoJCQkJCQkJCSpjcG8tbioKCQluCVdoZW4gaW5jbHVkZWQsIHRoZSBjb2x1bW4gdXNlZCBmb3IgJ251bWJlcicgd2lsbCBhbHNvCgkJCWJlIHVzZWQgZm9yIHRleHQgb2Ygd3JhcHBlZCBsaW5lcy4KCQkJCQkJCQkqY3BvLW8qCgkJbwlMaW5lIG9mZnNldCB0byBzZWFyY2ggY29tbWFuZCBpcyBub3QgcmVtZW1iZXJlZCBmb3IKCQkJbmV4dCBzZWFyY2guCgkJCQkJCQkJKmNwby1PKgoJCU8JRG9uJ3QgY29tcGxhaW4gaWYgYSBmaWxlIGlzIGJlaW5nIG92ZXJ3cml0dGVuLCBldmVuCgkJCXdoZW4gaXQgZGlkbid0IGV4aXN0IHdoZW4gZWRpdGluZyBpdC4gIFRoaXMgaXMgYQoJCQlwcm90ZWN0aW9uIGFnYWluc3QgYSBmaWxlIHVuZXhwZWN0ZWRseSBjcmVhdGVkIGJ5CgkJCXNvbWVvbmUgZWxzZS4gIFZpIGRpZG4ndCBjb21wbGFpbiBhYm91dCB0aGlzLgoJCQkJCQkJCSpjcG8tcCoKCQlwCVZpIGNvbXBhdGlibGUgTGlzcCBpbmRlbnRpbmcuICBXaGVuIG5vdCBwcmVzZW50LCBhCgkJCXNsaWdodGx5IGJldHRlciBhbGdvcml0aG0gaXMgdXNlZC4KCQkJCQkJCQkqY3BvLXEqCgkJcQlXaGVuIGpvaW5pbmcgbXVsdGlwbGUgbGluZXMgbGVhdmUgdGhlIGN1cnNvciBhdCB0aGUKCQkJcG9zaXRpb24gd2hlcmUgaXQgd291bGQgYmUgd2hlbiBqb2luaW5nIHR3byBsaW5lcy4KCQkJCQkJCQkqY3BvLXIqCgkJcglSZWRvICgiLiIgY29tbWFuZCkgdXNlcyAiLyIgdG8gcmVwZWF0IGEgc2VhcmNoCgkJCWNvbW1hbmQsIGluc3RlYWQgb2YgdGhlIGFjdHVhbGx5IHVzZWQgc2VhcmNoIHN0cmluZy4KCQkJCQkJCQkqY3BvLVIqCgkJUglSZW1vdmUgbWFya3MgZnJvbSBmaWx0ZXJlZCBsaW5lcy4gIFdpdGhvdXQgdGhpcyBmbGFnCgkJCW1hcmtzIGFyZSBrZXB0IGxpa2UgfDprZWVwbWFya3N8IHdhcyB1c2VkLgoJCQkJCQkJCSpjcG8tcyoKCQlzCVNldCBidWZmZXIgb3B0aW9ucyB3aGVuIGVudGVyaW5nIHRoZSBidWZmZXIgZm9yIHRoZQoJCQlmaXJzdCB0aW1lLiAgVGhpcyBpcyBsaWtlIGl0IGlzIGluIFZpbSB2ZXJzaW9uIDMuMC4KCQkJQW5kIGl0IGlzIHRoZSBkZWZhdWx0LiAgSWYgbm90IHByZXNlbnQgdGhlIG9wdGlvbnMgYXJlCgkJCXNldCB3aGVuIHRoZSBidWZmZXIgaXMgY3JlYXRlZC4KCQkJCQkJCQkqY3BvLVMqCgkJUwlTZXQgYnVmZmVyIG9wdGlvbnMgYWx3YXlzIHdoZW4gZW50ZXJpbmcgYSBidWZmZXIKCQkJKGV4Y2VwdCAncmVhZG9ubHknLCAnZmlsZWZvcm1hdCcsICdmaWxldHlwZScgYW5kCgkJCSdzeW50YXgnKS4gIFRoaXMgaXMgdGhlIChtb3N0KSBWaSBjb21wYXRpYmxlIHNldHRpbmcuCgkJCVRoZSBvcHRpb25zIGFyZSBzZXQgdG8gdGhlIHZhbHVlcyBpbiB0aGUgY3VycmVudAoJCQlidWZmZXIuICBXaGVuIHlvdSBjaGFuZ2UgYW4gb3B0aW9uIGFuZCBnbyB0byBhbm90aGVyCgkJCWJ1ZmZlciwgdGhlIHZhbHVlIGlzIGNvcGllZC4gIEVmZmVjdGl2ZWx5IG1ha2VzIHRoZQoJCQlidWZmZXIgb3B0aW9ucyBnbG9iYWwgdG8gYWxsIGJ1ZmZlcnMuCgoJCQkncycgICAgJ1MnICAgICBjb3B5IGJ1ZmZlciBvcHRpb25zCgkJCW5vICAgICBubyAgICAgIHdoZW4gYnVmZmVyIGNyZWF0ZWQKCQkJeWVzICAgIG5vICAgICAgd2hlbiBidWZmZXIgZmlyc3QgZW50ZXJlZCAoZGVmYXVsdCkKCQkJIFggICAgIHllcyAgICAgZWFjaCB0aW1lIHdoZW4gYnVmZmVyIGVudGVyZWQgKHZpIGNvbXAuKQoJCQkJCQkJCSpjcG8tdCoKCQl0CVNlYXJjaCBwYXR0ZXJuIGZvciB0aGUgdGFnIGNvbW1hbmQgaXMgcmVtZW1iZXJlZCBmb3IKCQkJIm4iIGNvbW1hbmQuICBPdGhlcndpc2UgVmltIG9ubHkgcHV0cyB0aGUgcGF0dGVybiBpbgoJCQl0aGUgaGlzdG9yeSBmb3Igc2VhcmNoIHBhdHRlcm4sIGJ1dCBkb2Vzbid0IGNoYW5nZSB0aGUKCQkJbGFzdCB1c2VkIHNlYXJjaCBwYXR0ZXJuLgoJCQkJCQkJCSpjcG8tdSoKCQl1CVVuZG8gaXMgVmkgY29tcGF0aWJsZS4gIFNlZSB8dW5kby10d28td2F5c3wuCgkJCQkJCQkJKmNwby12KgoJCXYJQmFja3NwYWNlZCBjaGFyYWN0ZXJzIHJlbWFpbiB2aXNpYmxlIG9uIHRoZSBzY3JlZW4gaW4KCQkJSW5zZXJ0IG1vZGUuICBXaXRob3V0IHRoaXMgZmxhZyB0aGUgY2hhcmFjdGVycyBhcmUKCQkJZXJhc2VkIGZyb20gdGhlIHNjcmVlbiByaWdodCBhd2F5LiAgV2l0aCB0aGlzIGZsYWcgdGhlCgkJCXNjcmVlbiBuZXdseSB0eXBlZCB0ZXh0IG92ZXJ3cml0ZXMgYmFja3NwYWNlZAoJCQljaGFyYWN0ZXJzLgoJCQkJCQkJCSpjcG8tdyoKCQl3CVdoZW4gdXNpbmcgImN3IiBvbiBhIGJsYW5rIGNoYXJhY3Rlciwgb25seSBjaGFuZ2Ugb25lCgkJCWNoYXJhY3RlciBhbmQgbm90IGFsbCBibGFua3MgdW50aWwgdGhlIHN0YXJ0IG9mIHRoZQoJCQluZXh0IHdvcmQuCgkJCQkJCQkJKmNwby1XKgoJCVcJRG9uJ3Qgb3ZlcndyaXRlIGEgcmVhZG9ubHkgZmlsZS4gIFdoZW4gb21pdHRlZCwgIjp3ISIKCQkJb3ZlcndyaXRlcyBhIHJlYWRvbmx5IGZpbGUsIGlmIHBvc3NpYmxlLgoJCQkJCQkJCSpjcG8teCoKCQl4CTxFc2M+IG9uIHRoZSBjb21tYW5kLWxpbmUgZXhlY3V0ZXMgdGhlIGNvbW1hbmQtbGluZS4KCQkJVGhlIGRlZmF1bHQgaW4gVmltIGlzIHRvIGFiYW5kb24gdGhlIGNvbW1hbmQtbGluZSwKCQkJYmVjYXVzZSA8RXNjPiBub3JtYWxseSBhYm9ydHMgYSBjb21tYW5kLiAgfGNfPEVzYz58CgkJCQkJCQkJKmNwby1YKgoJCVgJV2hlbiB1c2luZyBhIGNvdW50IHdpdGggIlIiIHRoZSByZXBsYWNlZCB0ZXh0IGlzCgkJCWRlbGV0ZWQgb25seSBvbmNlLiAgQWxzbyB3aGVuIHJlcGVhdGluZyAiUiIgd2l0aCAiLiIKCQkJYW5kIGEgY291bnQuCgkJCQkJCQkJKmNwby15KgoJCXkJQSB5YW5rIGNvbW1hbmQgY2FuIGJlIHJlZG9uZSB3aXRoICIuIi4KCQkJCQkJCQkqY3BvLVoqCgkJWglXaGVuIHVzaW5nICJ3ISIgd2hpbGUgdGhlICdyZWFkb25seScgb3B0aW9uIGlzIHNldCwKCQkJZG9uJ3QgcmVzZXQgJ3JlYWRvbmx5Jy4KCQkJCQkJCQkqY3BvLSEqCgkJIQlXaGVuIHJlZG9pbmcgYSBmaWx0ZXIgY29tbWFuZCwgdXNlIHRoZSBsYXN0IHVzZWQKCQkJZXh0ZXJuYWwgY29tbWFuZCwgd2hhdGV2ZXIgaXQgd2FzLiAgT3RoZXJ3aXNlIHRoZSBsYXN0CgkJCXVzZWQgLWZpbHRlci0gY29tbWFuZCBpcyB1c2VkLgoJCQkJCQkJCSpjcG8tJCoKCQkkCVdoZW4gbWFraW5nIGEgY2hhbmdlIHRvIG9uZSBsaW5lLCBkb24ndCByZWRpc3BsYXkgdGhlCgkJCWxpbmUsIGJ1dCBwdXQgYSAnJCcgYXQgdGhlIGVuZCBvZiB0aGUgY2hhbmdlZCB0ZXh0LgoJCQlUaGUgY2hhbmdlZCB0ZXh0IHdpbGwgYmUgb3ZlcndyaXR0ZW4gd2hlbiB5b3UgdHlwZSB0aGUKCQkJbmV3IHRleHQuICBUaGUgbGluZSBpcyByZWRpc3BsYXllZCBpZiB5b3UgdHlwZSBhbnkKCQkJY29tbWFuZCB0aGF0IG1vdmVzIHRoZSBjdXJzb3IgZnJvbSB0aGUgaW5zZXJ0aW9uCgkJCXBvaW50LgoJCQkJCQkJCSpjcG8tJSoKCQklCVZpLWNvbXBhdGlibGUgbWF0Y2hpbmcgaXMgZG9uZSBmb3IgdGhlICIlIiBjb21tYW5kLgoJCQlEb2VzIG5vdCByZWNvZ25pemUgIiNpZiIsICIjZW5kaWYiLCBldGMuCgkJCURvZXMgbm90IHJlY29nbml6ZSAiLyoiIGFuZCAiKi8iLgoJCQlQYXJlbnMgaW5zaWRlIHNpbmdsZSBhbmQgZG91YmxlIHF1b3RlcyBhcmUgYWxzbwoJCQljb3VudGVkLCBjYXVzaW5nIGEgc3RyaW5nIHRoYXQgY29udGFpbnMgYSBwYXJlbiB0bwoJCQlkaXN0dXJiIHRoZSBtYXRjaGluZy4gIEZvciBleGFtcGxlLCBpbiBhIGxpbmUgbGlrZQoJCQkiaWYgKHN0cmNtcCgiZm9vKCIsIHMpKSIgdGhlIGZpcnN0IHBhcmVuIGRvZXMgbm90CgkJCW1hdGNoIHRoZSBsYXN0IG9uZS4gIFdoZW4gdGhpcyBmbGFnIGlzIG5vdCBpbmNsdWRlZCwKCQkJcGFyZW5zIGluc2lkZSBzaW5nbGUgYW5kIGRvdWJsZSBxdW90ZXMgYXJlIHRyZWF0ZWQKCQkJc3BlY2lhbGx5LiAgV2hlbiBtYXRjaGluZyBhIHBhcmVuIG91dHNpZGUgb2YgcXVvdGVzLAoJCQlldmVyeXRoaW5nIGluc2lkZSBxdW90ZXMgaXMgaWdub3JlZC4gIFdoZW4gbWF0Y2hpbmcgYQoJCQlwYXJlbiBpbnNpZGUgcXVvdGVzLCBpdCB3aWxsIGZpbmQgdGhlIG1hdGNoaW5nIG9uZSAoaWYKCQkJdGhlcmUgaXMgb25lKS4gIFRoaXMgd29ya3MgdmVyeSB3ZWxsIGZvciBDIHByb2dyYW1zLgoJCQlUaGlzIGZsYWcgaXMgYWxzbyB1c2VkIGZvciBvdGhlciBmZWF0dXJlcywgc3VjaCBhcwoJCQlDLWluZGVudGluZy4KCQkJCQkJCQkqY3BvLS0qCgkJLQlXaGVuIGluY2x1ZGVkLCBhIHZlcnRpY2FsIG1vdmVtZW50IGNvbW1hbmQgZmFpbHMgd2hlbgoJCQlpdCB3b3VsZCBhYm92ZSB0aGUgZmlyc3QgbGluZSBvciBiZWxvdyB0aGUgbGFzdCBsaW5lLgoJCQlXaXRob3V0IGl0IHRoZSBjdXJzb3IgbW92ZXMgdG8gdGhlIGZpcnN0IG9yIGxhc3QgbGluZSwKCQkJdW5sZXNzIGl0IGFscmVhZHkgd2FzIGluIHRoYXQgbGluZS4KCQkJQXBwbGllcyB0byB0aGUgY29tbWFuZHMgIi0iLCAiayIsIENUUkwtUCwgIisiLCAiaiIsCgkJCUNUUkwtTiBhbmQgQ1RSTC1KLgoJCQkJCQkJCSpjcG8tKyoKCQkrCVdoZW4gaW5jbHVkZWQsIGEgIjp3cml0ZSBmaWxlIiBjb21tYW5kIHdpbGwgcmVzZXQgdGhlCgkJCSdtb2RpZmllZCcgZmxhZyBvZiB0aGUgYnVmZmVyLCBldmVuIHRob3VnaCB0aGUgYnVmZmVyCgkJCWl0c2VsZiBtYXkgc3RpbGwgYmUgZGlmZmVyZW50IGZyb20gaXRzIGZpbGUuCgkJCSAJCQkJCSpjcG8tc3RhcioKCQkqCVVzZSAiOioiIGluIHRoZSBzYW1lIHdheSBhcyAiOkAiLiAgV2hlbiBub3QgaW5jbHVkZWQsCgkJCSI6KiIgaXMgYW4gYWxpYXMgZm9yICI6JzwsJz4iLCBzZWxlY3QgdGhlIFZpc3VhbCBhcmVhLgoJCQkJCQkJCSpjcG8tPCoKCQk8CURpc2FibGUgdGhlIHJlY29nbml0aW9uIG9mIHNwZWNpYWwga2V5IGNvZGVzIGluIHw8PnwKCQkJZm9ybSBpbiBtYXBwaW5ncywgYWJicmV2aWF0aW9ucywgYW5kIHRoZSAidG8iIHBhcnQgb2YKCQkJbWVudSBjb21tYW5kcy4gIEZvciBleGFtcGxlLCB0aGUgY29tbWFuZAoJCQkiOm1hcCBYIDxUYWI+IiByZXN1bHRzIGluIFggYmVpbmcgbWFwcGVkIHRvOgoJCQkJJzwnIGluY2x1ZGVkOgkiPFRhYj4iICAoNSBjaGFyYWN0ZXJzKQoJCQkJJzwnIGV4Y2x1ZGVkOgkiXkkiCSAoXkkgaXMgYSByZWFsIDxUYWI+KQoJCQlBbHNvIHNlZSB0aGUgJ2snIGZsYWcgYWJvdmUuCgkJCQkJCQkJKmNwby0+KgoJCT4JV2hlbiBhcHBlbmRpbmcgdG8gYSByZWdpc3RlciwgcHV0IGEgbGluZSBicmVhayBiZWZvcmUKCQkJdGhlIGFwcGVuZGVkIHRleHQuCgoJUE9TSVggZmxhZ3MuICBUaGVzZSBhcmUgbm90IGluY2x1ZGVkIGluIHRoZSBWaSBkZWZhdWx0IHZhbHVlLCBleGNlcHQKCXdoZW4gJFZJTV9QT1NJWCB3YXMgc2V0IG9uIHN0YXJ0dXAuIHxwb3NpeHwKCgkgICAgY29udGFpbnMJYmVoYXZpb3IJfgoJCQkgCQkJCQkqY3BvLSMqCgkJIwlBIGNvdW50IGJlZm9yZSAiRCIsICJvIiBhbmQgIk8iIGhhcyBubyBlZmZlY3QuCgkJCQkJCQkJKmNwby0mKgoJCSYJV2hlbiAiOnByZXNlcnZlIiB3YXMgdXNlZCBrZWVwIHRoZSBzd2FwIGZpbGUgd2hlbgoJCQlleGl0aW5nIG5vcm1hbGx5IHdoaWxlIHRoaXMgYnVmZmVyIGlzIHN0aWxsIGxvYWRlZC4KCQkJVGhpcyBmbGFnIGlzIHRlc3RlZCB3aGVuIGV4aXRpbmcuCgkJCQkJCQkJKmNwby1cKgoJCVwJQmFja3NsYXNoIGluIGEgW10gcmFuZ2UgaW4gYSBzZWFyY2ggcGF0dGVybiBpcyB0YWtlbgoJCQlsaXRlcmFsbHksIG9ubHkgIlxdIiBpcyBzcGVjaWFsICBTZWUgfC9bXXwKCQkJICAgJ2wnIGluY2x1ZGVkOiAiL1sgXHRdIiAgZmluZHMgPFNwYWNlPiwgJ1wnIGFuZCAndCcKCQkJICAgJ2wnIGV4Y2x1ZGVkOiAiL1sgXHRdIiAgZmluZHMgPFNwYWNlPiBhbmQgPFRhYj4KCQkJQWxzbyBzZWUgfGNwby1cfC4KCQkJCQkJCQkqY3BvLS8qCgkJLwlXaGVuICIlIiBpcyB1c2VkIGFzIHRoZSByZXBsYWNlbWVudCBzdHJpbmcgaW4gYSB8OnN8CgkJCWNvbW1hbmQsIHVzZSB0aGUgcHJldmlvdXMgcmVwbGFjZW1lbnQgc3RyaW5nLiB8OnMlfAoJCQkJCQkJCSpjcG8teyoKCQl7CVRoZSB8e3wgYW5kIHx9fCBjb21tYW5kcyBhbHNvIHN0b3AgYXQgYSAieyIgY2hhcmFjdGVyCgkJCWF0IHRoZSBzdGFydCBvZiBhIGxpbmUuCgkJCQkJCQkJKmNwby0uKgoJCS4JVGhlICI6Y2hkaXIiIGFuZCAiOmNkIiBjb21tYW5kcyBmYWlsIGlmIHRoZSBjdXJyZW50CgkJCWJ1ZmZlciBpcyBtb2RpZmllZCwgdW5sZXNzICEgaXMgdXNlZC4gIFZpbSBkb2Vzbid0CgkJCW5lZWQgdGhpcywgc2luY2UgaXQgcmVtZW1iZXJzIHRoZSBmdWxsIHBhdGggb2YgYW4KCQkJb3BlbmVkIGZpbGUuCgkJCQkJCQkJKmNwby1iYXIqCgkJfAlUaGUgdmFsdWUgb2YgdGhlICRMSU5FUyBhbmQgJENPTFVNTlMgZW52aXJvbm1lbnQKCQkJdmFyaWFibGVzIG92ZXJydWxlIHRoZSB0ZXJtaW5hbCBzaXplIHZhbHVlcyBvYnRhaW5lZAoJCQl3aXRoIHN5c3RlbSBzcGVjaWZpYyBmdW5jdGlvbnMuCgoKCQkJCQkJKidjc2NvcGVwYXRoY29tcCcqIConY3NwYycqCidjc2NvcGVwYXRoY29tcCcgJ2NzcGMnCW51bWJlcgkoZGVmYXVsdCAwKQoJCQlnbG9iYWwKCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2NzY29wZXwKCQkJZmVhdHVyZX0KCQkJe25vdCBpbiBWaX0KCURldGVybWluZXMgaG93IG1hbnkgY29tcG9uZW50cyBvZiB0aGUgcGF0aCB0byBzaG93IGluIGEgbGlzdCBvZiB0YWdzLgoJU2VlIHxjc2NvcGVwYXRoY29tcHwuCgoJCQkJCQkqJ2NzY29wZXByZycqIConY3NwcmcnKgonY3Njb3BlcHJnJyAnY3NwcmcnCXN0cmluZwkoZGVmYXVsdCAiY3Njb3BlIikKCQkJZ2xvYmFsCgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCtjc2NvcGV8CgkJCWZlYXR1cmV9CgkJCXtub3QgaW4gVml9CglTcGVjaWZpZXMgdGhlIGNvbW1hbmQgdG8gZXhlY3V0ZSBjc2NvcGUuICBTZWUgfGNzY29wZXByZ3wuCglUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCgkJCQkJCSonY3Njb3BlcXVpY2tmaXgnKiAqJ2NzcWYnKgonY3Njb3BlcXVpY2tmaXgnICdjc3FmJyBzdHJpbmcJKGRlZmF1bHQgIiIpCgkJCWdsb2JhbAoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrY3Njb3BlfAoJCQlvciB8K3F1aWNrZml4fCBmZWF0dXJlc30KCQkJe25vdCBpbiBWaX0KCVNwZWNpZmllcyB3aGV0aGVyIHRvIHVzZSBxdWlja2ZpeCB3aW5kb3cgdG8gc2hvdyBjc2NvcGUgcmVzdWx0cy4KCVNlZSB8Y3Njb3BlcXVpY2tmaXh8LgoKCQkJCSonY3Njb3BldGFnJyogKidjc3QnKiAqJ25vY3Njb3BldGFnJyogKidub2NzdCcqCidjc2NvcGV0YWcnICdjc3QnCWJvb2xlYW4gKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2NzY29wZXwKCQkJZmVhdHVyZX0KCQkJe25vdCBpbiBWaX0KCVVzZSBjc2NvcGUgZm9yIHRhZyBjb21tYW5kcy4gIFNlZSB8Y3Njb3BlLW9wdGlvbnN8LgoJTk9URTogVGhpcyBvcHRpb24gaXMgcmVzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJKidjc2NvcGV0YWdvcmRlcicqIConY3N0bycqCidjc2NvcGV0YWdvcmRlcicgJ2NzdG8nCW51bWJlcgkoZGVmYXVsdCAwKQoJCQlnbG9iYWwKCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2NzY29wZXwKCQkJZmVhdHVyZX0KCQkJe25vdCBpbiBWaX0KCURldGVybWluZXMgdGhlIG9yZGVyIGluIHdoaWNoICI6Y3N0YWciIHBlcmZvcm1zIGEgc2VhcmNoLiAgU2VlCgl8Y3Njb3BldGFnb3JkZXJ8LgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIDAgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkqJ2NzY29wZXZlcmJvc2UnKiAqJ2NzdmVyYicqCgkJCQkJKidub2NzY29wZXZlcmJvc2UnKiAqJ25vY3N2ZXJiJyoKJ2NzY29wZXZlcmJvc2UnICdjc3ZlcmInIGJvb2xlYW4gKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2NzY29wZXwKCQkJZmVhdHVyZX0KCQkJe25vdCBpbiBWaX0KCUdpdmUgbWVzc2FnZXMgd2hlbiBhZGRpbmcgYSBjc2NvcGUgZGF0YWJhc2UuICBTZWUgfGNzY29wZXZlcmJvc2V8LgoJTk9URTogVGhpcyBvcHRpb24gaXMgcmVzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJKidkZWJ1ZycqCidkZWJ1ZycJCQlzdHJpbmcJKGRlZmF1bHQgIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiBzZXQgdG8gIm1zZyIsIGVycm9yIG1lc3NhZ2VzIHRoYXQgd291bGQgb3RoZXJ3aXNlIGJlIG9taXR0ZWQgd2lsbAoJYmUgZ2l2ZW4gYW55d2F5LiAgVGhpcyBpcyB1c2VmdWwgd2hlbiBkZWJ1Z2dpbmcgJ2ZvbGRleHByJyBvcgoJJ2luZGVudGV4cHInLgoJV2hlbiBzZXQgdG8gImJlZXAiLCBhIG1lc3NhZ2Ugd2lsbCBiZSBnaXZlbiB3aGVuIG90aGVyd2lzZSBvbmx5IGEgYmVlcAoJd291bGQgYmUgcHJvZHVjZWQuCglUaGUgdmFsdWVzIGNhbiBiZSBjb21iaW5lZCwgc2VwYXJhdGVkIGJ5IGEgY29tbWEuCgoJCQkJCQkqJ2RlZmluZScqIConZGVmJyoKJ2RlZmluZScgJ2RlZicJCXN0cmluZwkoZGVmYXVsdCAiXlxzKiNccypkZWZpbmUiKQoJCQlnbG9iYWwgb3IgbG9jYWwgdG8gYnVmZmVyIHxnbG9iYWwtbG9jYWx8CgkJCXtub3QgaW4gVml9CglQYXR0ZXJuIHRvIGJlIHVzZWQgdG8gZmluZCBhIG1hY3JvIGRlZmluaXRpb24uICBJdCBpcyBhIHNlYXJjaAoJcGF0dGVybiwganVzdCBsaWtlIGZvciB0aGUgIi8iIGNvbW1hbmQuICBUaGlzIG9wdGlvbiBpcyB1c2VkIGZvciB0aGUKCWNvbW1hbmRzIGxpa2UgIltpIiBhbmQgIltkIiB8aW5jbHVkZS1zZWFyY2h8LiAgVGhlICdpc2lkZW50JyBvcHRpb24gaXMKCXVzZWQgdG8gcmVjb2duaXplIHRoZSBkZWZpbmVkIG5hbWUgYWZ0ZXIgdGhlIG1hdGNoOgoJCXttYXRjaCB3aXRoICdkZWZpbmUnfXtub24tSUQgY2hhcnN9e2RlZmluZWQgbmFtZX17bm9uLUlEIGNoYXJ9CglTZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0IGluc2VydGluZyBiYWNrc2xhc2hlcyB0byBpbmNsdWRlIGEgc3BhY2UKCW9yIGJhY2tzbGFzaC4KCVRoZSBkZWZhdWx0IHZhbHVlIGlzIGZvciBDIHByb2dyYW1zLiAgRm9yIEMrKyB0aGlzIHZhbHVlIHdvdWxkIGJlCgl1c2VmdWwsIHRvIGluY2x1ZGUgY29uc3QgdHlwZSBkZWNsYXJhdGlvbnM6ID4KCQleXCgjXHMqZGVmaW5lXHxbYS16XSpccypjb25zdFxzKlthLXpdKlwpCjwJV2hlbiB1c2luZyB0aGUgIjpzZXQiIGNvbW1hbmQsIHlvdSBuZWVkIHRvIGRvdWJsZSB0aGUgYmFja3NsYXNoZXMhCgoJCQkqJ2RlbGNvbWJpbmUnKiAqJ2RlY28nKiAqJ25vZGVsY29tYmluZScqIConbm9kZWNvJyoKJ2RlbGNvbWJpbmUnICdkZWNvJwlib29sZWFuIChkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbXVsdGlfYnl0ZXwKCQkJZmVhdHVyZX0KCUlmIGVkaXRpbmcgVW5pY29kZSBhbmQgdGhpcyBvcHRpb24gaXMgc2V0LCBiYWNrc3BhY2UgYW5kIE5vcm1hbCBtb2RlCgkieCIgZGVsZXRlIGVhY2ggY29tYmluaW5nIGNoYXJhY3RlciBvbiBpdHMgb3duLiAgV2hlbiBpdCBpcyBvZmYgKHRoZQoJZGVmYXVsdCkgdGhlIGNoYXJhY3RlciBhbG9uZyB3aXRoIGl0cyBjb21iaW5pbmcgY2hhcmFjdGVycyBhcmUKCWRlbGV0ZWQuCglOb3RlOiBXaGVuICdkZWxjb21iaW5lJyBpcyBzZXQgInh4IiBtYXkgd29yayBkaWZmZXJlbnQgZnJvbSAiMngiIQoKCVRoaXMgaXMgdXNlZnVsIGZvciBBcmFiaWMsIEhlYnJldyBhbmQgbWFueSBvdGhlciBsYW5ndWFnZXMgd2hlcmUgb25lCgltYXkgaGF2ZSBjb21iaW5pbmcgY2hhcmFjdGVycyBvdmVydG9wIG9mIGJhc2UgY2hhcmFjdGVycywgYW5kIHdhbnQKCXRvIHJlbW92ZSBvbmx5IHRoZSBjb21iaW5pbmcgb25lcy4KCgkJCQkJCSonZGljdGlvbmFyeScqIConZGljdCcqCidkaWN0aW9uYXJ5JyAnZGljdCcJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwgb3IgbG9jYWwgdG8gYnVmZmVyIHxnbG9iYWwtbG9jYWx8CgkJCXtub3QgaW4gVml9CglMaXN0IG9mIGZpbGUgbmFtZXMsIHNlcGFyYXRlZCBieSBjb21tYXMsIHRoYXQgYXJlIHVzZWQgdG8gbG9va3VwIHdvcmRzCglmb3Iga2V5d29yZCBjb21wbGV0aW9uIGNvbW1hbmRzIHxpX0NUUkwtWF9DVFJMLUt8LiAgRWFjaCBmaWxlIHNob3VsZAoJY29udGFpbiBhIGxpc3Qgb2Ygd29yZHMuICBUaGlzIGNhbiBiZSBvbmUgd29yZCBwZXIgbGluZSwgb3Igc2V2ZXJhbAoJd29yZHMgcGVyIGxpbmUsIHNlcGFyYXRlZCBieSBub24ta2V5d29yZCBjaGFyYWN0ZXJzICh3aGl0ZSBzcGFjZSBpcwoJcHJlZmVycmVkKS4gIE1heGltdW0gbGluZSBsZW5ndGggaXMgNTEwIGJ5dGVzLgoJVG8gaW5jbHVkZSBhIGNvbW1hIGluIGEgZmlsZSBuYW1lIHByZWNlZGUgaXQgd2l0aCBhIGJhY2tzbGFzaC4gIFNwYWNlcwoJYWZ0ZXIgYSBjb21tYSBhcmUgaWdub3JlZCwgb3RoZXJ3aXNlIHNwYWNlcyBhcmUgaW5jbHVkZWQgaW4gdGhlIGZpbGUKCW5hbWUuICBTZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0IHVzaW5nIGJhY2tzbGFzaGVzLgoJVGhpcyBoYXMgbm90aGluZyB0byBkbyB3aXRoIHRoZSB8RGljdGlvbmFyeXwgdmFyaWFibGUgdHlwZS4KCVdoZXJlIHRvIGZpbmQgYSBsaXN0IG9mIHdvcmRzPwoJLSBPbiBGcmVlQlNELCB0aGVyZSBpcyB0aGUgZmlsZSAiL3Vzci9zaGFyZS9kaWN0L3dvcmRzIi4KCS0gSW4gdGhlIFNpbXRlbCBhcmNoaXZlLCBsb29rIGluIHRoZSAibXNkb3MvbGluZ3Vpc3QiIGRpcmVjdG9yeS4KCS0gSW4gIm1pc2NmaWxlcyIgb2YgdGhlIEdOVSBjb2xsZWN0aW9uLgoJVGhlIHVzZSBvZiB8OnNldCs9fCBhbmQgfDpzZXQtPXwgaXMgcHJlZmVycmVkIHdoZW4gYWRkaW5nIG9yIHJlbW92aW5nCglkaXJlY3RvcmllcyBmcm9tIHRoZSBsaXN0LiAgVGhpcyBhdm9pZHMgcHJvYmxlbXMgd2hlbiBhIGZ1dHVyZSB2ZXJzaW9uCgl1c2VzIGFub3RoZXIgZGVmYXVsdC4KCUJhY2t0aWNrcyBjYW5ub3QgYmUgdXNlZCBpbiB0aGlzIG9wdGlvbiBmb3Igc2VjdXJpdHkgcmVhc29ucy4KCgkJCQkJCQkqJ2RpZmYnKiAqJ25vZGlmZicqCidkaWZmJwkJCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byB3aW5kb3cKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2RpZmZ8CgkJCWZlYXR1cmV9CglKb2luIHRoZSBjdXJyZW50IHdpbmRvdyBpbiB0aGUgZ3JvdXAgb2Ygd2luZG93cyB0aGF0IHNob3dzIGRpZmZlcmVuY2VzCgliZXR3ZWVuIGZpbGVzLiAgU2VlIHx2aW1kaWZmfC4KCgkJCQkJCSonZGV4JyogKidkaWZmZXhwcicqCidkaWZmZXhwcicgJ2RleCcJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2RpZmZ8CgkJCWZlYXR1cmV9CglFeHByZXNzaW9uIHdoaWNoIGlzIGV2YWx1YXRlZCB0byBvYnRhaW4gYW4gZWQtc3R5bGUgZGlmZiBmaWxlIGZyb20gdHdvCgl2ZXJzaW9ucyBvZiBhIGZpbGUuICBTZWUgfGRpZmYtZGlmZmV4cHJ8LgoJVGhpcyBvcHRpb24gY2Fubm90IGJlIHNldCBmcm9tIGEgfG1vZGVsaW5lfCBvciBpbiB0aGUgfHNhbmRib3h8LCBmb3IKCXNlY3VyaXR5IHJlYXNvbnMuCgoJCQkJCQkqJ2RpcCcqIConZGlmZm9wdCcqCidkaWZmb3B0JyAnZGlwJwkJc3RyaW5nCShkZWZhdWx0ICJmaWxsZXIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2RpZmZ8CgkJCWZlYXR1cmV9CglPcHRpb24gc2V0dGluZ3MgZm9yIGRpZmYgbW9kZS4gIEl0IGNhbiBjb25zaXN0IG9mIHRoZSBmb2xsb3dpbmcgaXRlbXMuCglBbGwgYXJlIG9wdGlvbmFsLiAgSXRlbXMgbXVzdCBiZSBzZXBhcmF0ZWQgYnkgYSBjb21tYS4KCgkJZmlsbGVyCQlTaG93IGZpbGxlciBsaW5lcywgdG8ga2VlcCB0aGUgdGV4dAoJCQkJc3luY2hyb25pemVkIHdpdGggYSB3aW5kb3cgdGhhdCBoYXMgaW5zZXJ0ZWQKCQkJCWxpbmVzIGF0IHRoZSBzYW1lIHBvc2l0aW9uLiAgTW9zdGx5IHVzZWZ1bAoJCQkJd2hlbiB3aW5kb3dzIGFyZSBzaWRlLWJ5LXNpZGUgYW5kICdzY3JvbGxiaW5kJwoJCQkJaXMgc2V0LgoKCQljb250ZXh0OntufQlVc2UgYSBjb250ZXh0IG9mIHtufSBsaW5lcyBiZXR3ZWVuIGEgY2hhbmdlCgkJCQlhbmQgYSBmb2xkIHRoYXQgY29udGFpbnMgdW5jaGFuZ2VkIGxpbmVzLgoJCQkJV2hlbiBvbWl0dGVkIGEgY29udGV4dCBvZiBzaXggbGluZXMgaXMgdXNlZC4KCQkJCVNlZSB8Zm9sZC1kaWZmfC4KCgkJaWNhc2UJCUlnbm9yZSBjaGFuZ2VzIGluIGNhc2Ugb2YgdGV4dC4gICJhIiBhbmQgIkEiCgkJCQlhcmUgY29uc2lkZXJlZCB0aGUgc2FtZS4gIEFkZHMgdGhlICItaSIgZmxhZwoJCQkJdG8gdGhlICJkaWZmIiBjb21tYW5kIGlmICdkaWZmZXhwcicgaXMgZW1wdHkuCgoJCWl3aGl0ZQkJSWdub3JlIGNoYW5nZXMgaW4gYW1vdW50IG9mIHdoaXRlIHNwYWNlLiAgQWRkcwoJCQkJdGhlICItYiIgZmxhZyB0byB0aGUgImRpZmYiIGNvbW1hbmQgaWYKCQkJCSdkaWZmZXhwcicgaXMgZW1wdHkuICBDaGVjayB0aGUgZG9jdW1lbnRhdGlvbgoJCQkJb2YgdGhlICJkaWZmIiBjb21tYW5kIGZvciB3aGF0IHRoaXMgZG9lcwoJCQkJZXhhY3RseS4gIEl0IHNob3VsZCBpZ25vcmUgYWRkaW5nIHRyYWlsaW5nCgkJCQl3aGl0ZSBzcGFjZSwgYnV0IG5vdCBsZWFkaW5nIHdoaXRlIHNwYWNlLgoKCUV4YW1wbGVzOiA+CgoJCTpzZXQgZGlmZm9wdD1maWxsZXIsY29udGV4dDo0CgkJOnNldCBkaWZmb3B0PQoJCTpzZXQgZGlmZm9wdD1maWxsZXIKPAoJCQkJICAgICAqJ2RpZ3JhcGgnKiAqJ2RnJyogKidub2RpZ3JhcGgnKiAqJ25vZGcnKgonZGlncmFwaCcgJ2RnJwkJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZGlncmFwaHN8CgkJCWZlYXR1cmV9CglFbmFibGUgdGhlIGVudGVyaW5nIG9mIGRpZ3JhcGhzIGluIEluc2VydCBtb2RlIHdpdGgge2NoYXIxfSA8QlM+Cgl7Y2hhcjJ9LiAgU2VlIHxkaWdyYXBoc3wuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyByZXNldCB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkJCQkqJ2RpcmVjdG9yeScqIConZGlyJyoKJ2RpcmVjdG9yeScgJ2RpcicJc3RyaW5nCShkZWZhdWx0IGZvciBBbWlnYTogIi4sdDoiLAoJCQkJIGZvciBNUy1ET1MgYW5kIFdpbjMyOiAiLixjOlx0bXAsYzpcdGVtcCIKCQkJCSBmb3IgVW5peDogIi4sfi90bXAsL3Zhci90bXAsL3RtcCIpCgkJCWdsb2JhbAoJTGlzdCBvZiBkaXJlY3RvcnkgbmFtZXMgZm9yIHRoZSBzd2FwIGZpbGUsIHNlcGFyYXRlZCB3aXRoIGNvbW1hcy4KCS0gVGhlIHN3YXAgZmlsZSB3aWxsIGJlIGNyZWF0ZWQgaW4gdGhlIGZpcnN0IGRpcmVjdG9yeSB3aGVyZSB0aGlzIGlzCgkgIHBvc3NpYmxlLgoJLSBFbXB0eSBtZWFucyB0aGF0IG5vIHN3YXAgZmlsZSB3aWxsIGJlIHVzZWQgKHJlY292ZXJ5IGlzCgkgIGltcG9zc2libGUhKS4KCS0gQSBkaXJlY3RvcnkgIi4iIG1lYW5zIHRvIHB1dCB0aGUgc3dhcCBmaWxlIGluIHRoZSBzYW1lIGRpcmVjdG9yeSBhcwoJICB0aGUgZWRpdGVkIGZpbGUuICBPbiBVbml4LCBhIGRvdCBpcyBwcmVwZW5kZWQgdG8gdGhlIGZpbGUgbmFtZSwgc28KCSAgaXQgZG9lc24ndCBzaG93IGluIGEgZGlyZWN0b3J5IGxpc3RpbmcuICBPbiBNUy1XaW5kb3dzIHRoZSAiaGlkZGVuIgoJICBhdHRyaWJ1dGUgaXMgc2V0IGFuZCBhIGRvdCBwcmVwZW5kZWQgaWYgcG9zc2libGUuCgktIEEgZGlyZWN0b3J5IHN0YXJ0aW5nIHdpdGggIi4vIiAob3IgIi5cIiBmb3IgTVMtRE9TIGV0IGFsLikgbWVhbnMgdG8KCSAgcHV0IHRoZSBzd2FwIGZpbGUgcmVsYXRpdmUgdG8gd2hlcmUgdGhlIGVkaXRlZCBmaWxlIGlzLiAgVGhlIGxlYWRpbmcKCSAgIi4iIGlzIHJlcGxhY2VkIHdpdGggdGhlIHBhdGggbmFtZSBvZiB0aGUgZWRpdGVkIGZpbGUuCgktIEZvciBVbml4IGFuZCBXaW4zMiwgaWYgYSBkaXJlY3RvcnkgZW5kcyBpbiB0d28gcGF0aCBzZXBhcmF0b3JzLCB0aGUKCSAgc3dhcCBmaWxlIG5hbWUgd2lsbCBiZSBidWlsdCBmcm9tIHRoZSBjb21wbGV0ZSBwYXRoIHRvIHRoZSBmaWxlCgkgIHdpdGggYWxsIHBhdGggc2VwYXJhdG9ycyBzdWJzdGl0dXRlZCB0byBwZXJjZW50ICclJyBzaWducy4gIFRoaXMgd2lsbAoJICBlbnN1cmUgZmlsZSBuYW1lIHVuaXF1ZW5lc3MgaW4gdGhlIHByZXNlcnZlIGRpcmVjdG9yeS4KCS0gU3BhY2VzIGFmdGVyIHRoZSBjb21tYSBhcmUgaWdub3JlZCwgb3RoZXIgc3BhY2VzIGFyZSBjb25zaWRlcmVkIHBhcnQKCSAgb2YgdGhlIGRpcmVjdG9yeSBuYW1lLiAgVG8gaGF2ZSBhIHNwYWNlIGF0IHRoZSBzdGFydCBvZiBhIGRpcmVjdG9yeQoJICBuYW1lLCBwcmVjZWRlIGl0IHdpdGggYSBiYWNrc2xhc2guCgktIFRvIGluY2x1ZGUgYSBjb21tYSBpbiBhIGRpcmVjdG9yeSBuYW1lIHByZWNlZGUgaXQgd2l0aCBhIGJhY2tzbGFzaC4KCS0gQSBkaXJlY3RvcnkgbmFtZSBtYXkgZW5kIGluIGFuICc6JyBvciAnLycuCgktIEVudmlyb25tZW50IHZhcmlhYmxlcyBhcmUgZXhwYW5kZWQgfDpzZXRfZW52fC4KCS0gQ2FyZWZ1bCB3aXRoICdcJyBjaGFyYWN0ZXJzLCB0eXBlIG9uZSBiZWZvcmUgYSBzcGFjZSwgdHlwZSB0d28gdG8KCSAgZ2V0IG9uZSBpbiB0aGUgb3B0aW9uIChzZWUgfG9wdGlvbi1iYWNrc2xhc2h8KSwgZm9yIGV4YW1wbGU6ID4KCSAgICA6c2V0IGRpcj1jOlxcdG1wLFwgZGlyXFwsd2l0aFxcLGNvbW1hcyxcXFwgZGlyXCB3aXRoXCBzcGFjZXMKPAktIEZvciBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eSB3aXRoIFZpbSB2ZXJzaW9uIDMuMCBhICc+JyBhdCB0aGUgc3RhcnQKCSAgb2YgdGhlIG9wdGlvbiBpcyByZW1vdmVkLgoJVXNpbmcgIi4iIGZpcnN0IGluIHRoZSBsaXN0IGlzIHJlY29tbWVuZGVkLiAgVGhpcyBtZWFucyB0aGF0IGVkaXRpbmcKCXRoZSBzYW1lIGZpbGUgdHdpY2Ugd2lsbCByZXN1bHQgaW4gYSB3YXJuaW5nLiAgVXNpbmcgIi90bXAiIG9uIFVuaXggaXMKCWRpc2NvdXJhZ2VkOiBXaGVuIHRoZSBzeXN0ZW0gY3Jhc2hlcyB5b3UgbG9zZSB0aGUgc3dhcCBmaWxlLgoJIi92YXIvdG1wIiBpcyBvZnRlbiBub3QgY2xlYXJlZCB3aGVuIHJlYm9vdGluZywgdGh1cyBpcyBhIGJldHRlcgoJY2hvaWNlIHRoYW4gIi90bXAiLiAgQnV0IGl0IGNhbiBjb250YWluIGEgbG90IG9mIGZpbGVzLCB5b3VyIHN3YXAKCWZpbGVzIGdldCBsb3N0IGluIHRoZSBjcm93ZC4gIFRoYXQgaXMgd2h5IGEgInRtcCIgZGlyZWN0b3J5IGluIHlvdXIKCWhvbWUgZGlyZWN0b3J5IGlzIHRyaWVkIGZpcnN0LgoJVGhlIHVzZSBvZiB8OnNldCs9fCBhbmQgfDpzZXQtPXwgaXMgcHJlZmVycmVkIHdoZW4gYWRkaW5nIG9yIHJlbW92aW5nCglkaXJlY3RvcmllcyBmcm9tIHRoZSBsaXN0LiAgVGhpcyBhdm9pZHMgcHJvYmxlbXMgd2hlbiBhIGZ1dHVyZSB2ZXJzaW9uCgl1c2VzIGFub3RoZXIgZGVmYXVsdC4KCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoJe1ZpOiBkaXJlY3RvcnkgdG8gcHV0IHRlbXAgZmlsZSBpbiwgZGVmYXVsdHMgdG8gIi90bXAifQoKCQkJCQkqJ2Rpc3BsYXknKiAqJ2R5JyoKJ2Rpc3BsYXknICdkeScJCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglDaGFuZ2UgdGhlIHdheSB0ZXh0IGlzIGRpc3BsYXllZC4gIFRoaXMgaXMgY29tbWEgc2VwYXJhdGVkIGxpc3Qgb2YKCWZsYWdzOgoJbGFzdGxpbmUJV2hlbiBpbmNsdWRlZCwgYXMgbXVjaCBhcyBwb3NzaWJsZSBvZiB0aGUgbGFzdCBsaW5lCgkJCWluIGEgd2luZG93IHdpbGwgYmUgZGlzcGxheWVkLiAgV2hlbiBub3QgaW5jbHVkZWQsIGEKCQkJbGFzdCBsaW5lIHRoYXQgZG9lc24ndCBmaXQgaXMgcmVwbGFjZWQgd2l0aCAiQCIgbGluZXMuCgl1aGV4CQlTaG93IHVucHJpbnRhYmxlIGNoYXJhY3RlcnMgaGV4YWRlY2ltYWwgYXMgPHh4PgoJCQlpbnN0ZWFkIG9mIHVzaW5nIF5DIGFuZCB+Qy4KCgkJCQkJCSonZWFkaXJlY3Rpb24nKiAqJ2VhZCcqCidlYWRpcmVjdGlvbicgJ2VhZCcJc3RyaW5nCShkZWZhdWx0ICJib3RoIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgK3ZlcnRzcGxpdAoJCQlmZWF0dXJlfQoJVGVsbHMgd2hlbiB0aGUgJ2VxdWFsYWx3YXlzJyBvcHRpb24gYXBwbGllczoKCQl2ZXIJdmVydGljYWxseSwgd2lkdGggb2Ygd2luZG93cyBpcyBub3QgYWZmZWN0ZWQKCQlob3IJaG9yaXpvbnRhbGx5LCBoZWlnaHQgb2Ygd2luZG93cyBpcyBub3QgYWZmZWN0ZWQKCQlib3RoCXdpZHRoIGFuZCBoZWlnaHQgb2Ygd2luZG93cyBpcyBhZmZlY3RlZAoKCQkJICAgKidlZCcqIConZWRjb21wYXRpYmxlJyogKidub2VkJyogKidub2VkY29tcGF0aWJsZScqCidlZGNvbXBhdGlibGUnICdlZCcJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJTWFrZXMgdGhlICdnJyBhbmQgJ2MnIGZsYWdzIG9mIHRoZSAiOnN1YnN0aXR1dGUiIGNvbW1hbmQgdG8gYmUKCXRvZ2dsZWQgZWFjaCB0aW1lIHRoZSBmbGFnIGlzIGdpdmVuLiAgU2VlIHxjb21wbGV4LWNoYW5nZXwuICBTZWUKCWFsc28gJ2dkZWZhdWx0JyBvcHRpb24uCglTd2l0Y2hpbmcgdGhpcyBvcHRpb24gb24gaXMgZGlzY291cmFnZWQhCgoJCQkJCSonZW5jb2RpbmcnKiAqJ2VuYycqICpFNTQzKgonZW5jb2RpbmcnICdlbmMnCXN0cmluZyAoZGVmYXVsdDogImxhdGluMSIgb3IgdmFsdWUgZnJvbSAkTEFORykKCQkJZ2xvYmFsCgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbXVsdGlfYnl0ZXwKCQkJZmVhdHVyZX0KCQkJe25vdCBpbiBWaX0KCVNldHMgdGhlIGNoYXJhY3RlciBlbmNvZGluZyB1c2VkIGluc2lkZSBWaW0uICBJdCBhcHBsaWVzIHRvIHRleHQgaW4KCXRoZSBidWZmZXJzLCByZWdpc3RlcnMsIFN0cmluZ3MgaW4gZXhwcmVzc2lvbnMsIHRleHQgc3RvcmVkIGluIHRoZQoJdmltaW5mbyBmaWxlLCBldGMuICBJdCBzZXRzIHRoZSBraW5kIG9mIGNoYXJhY3RlcnMgd2hpY2ggVmltIGNhbiB3b3JrCgl3aXRoLiAgU2VlIHxlbmNvZGluZy1uYW1lc3wgZm9yIHRoZSBwb3NzaWJsZSB2YWx1ZXMuCgoJTk9URTogQ2hhbmdpbmcgdGhpcyBvcHRpb24gd2lsbCBub3QgY2hhbmdlIHRoZSBlbmNvZGluZyBvZiB0aGUKCWV4aXN0aW5nIHRleHQgaW4gVmltLiAgSXQgbWF5IGNhdXNlIG5vbi1BU0NJSSB0ZXh0IHRvIGJlY29tZSBpbnZhbGlkLgoJSXQgc2hvdWxkIG5vcm1hbGx5IGJlIGtlcHQgYXQgaXRzIGRlZmF1bHQgdmFsdWUsIG9yIHNldCB3aGVuIFZpbQoJc3RhcnRzIHVwLiAgU2VlIHxtdWx0aWJ5dGV8LgoKCU5PVEU6IEZvciBHVEsrIDIgaXQgaXMgaGlnaGx5IHJlY29tbWVuZGVkIHRvIHNldCAnZW5jb2RpbmcnIHRvCgkidXRmLTgiLiAgQWx0aG91Z2ggY2FyZSBoYXMgYmVlbiB0YWtlbiB0byBhbGxvdyBkaWZmZXJlbnQgdmFsdWVzIG9mCgknZW5jb2RpbmcnLCAidXRmLTgiIGlzIHRoZSBuYXR1cmFsIGNob2ljZSBmb3IgdGhlIGVudmlyb25tZW50IGFuZAoJYXZvaWRzIHVubmVjZXNzYXJ5IGNvbnZlcnNpb24gb3ZlcmhlYWQuICAidXRmLTgiIGhhcyBub3QgYmVlbiBtYWRlCgl0aGUgZGVmYXVsdCB0byBwcmV2ZW50IGRpZmZlcmVudCBiZWhhdmlvciBvZiB0aGUgR1VJIGFuZCB0ZXJtaW5hbAoJdmVyc2lvbnMsIGFuZCB0byBhdm9pZCBjaGFuZ2luZyB0aGUgZW5jb2Rpbmcgb2YgbmV3bHkgY3JlYXRlZCBmaWxlcwoJd2l0aG91dCB5b3VyIGtub3dsZWRnZSAoaW4gY2FzZSAnZmlsZWVuY29kaW5ncycgaXMgZW1wdHkpLgoKCVRoZSBjaGFyYWN0ZXIgZW5jb2Rpbmcgb2YgZmlsZXMgY2FuIGJlIGRpZmZlcmVudCBmcm9tICdlbmNvZGluZycuCglUaGlzIGlzIHNwZWNpZmllZCB3aXRoICdmaWxlZW5jb2RpbmcnLiAgVGhlIGNvbnZlcnNpb24gaXMgZG9uZSB3aXRoCglpY29udigpIG9yIGFzIHNwZWNpZmllZCB3aXRoICdjaGFyY29udmVydCcuCgoJTm9ybWFsbHkgJ2VuY29kaW5nJyB3aWxsIGJlIGVxdWFsIHRvIHlvdXIgY3VycmVudCBsb2NhbGUuICBUaGlzIHdpbGwKCWJlIHRoZSBkZWZhdWx0IGlmIFZpbSByZWNvZ25pemVzIHlvdXIgZW52aXJvbm1lbnQgc2V0dGluZ3MuICBJZgoJJ2VuY29kaW5nJyBpcyBub3Qgc2V0IHRvIHRoZSBjdXJyZW50IGxvY2FsZSwgJ3Rlcm1lbmNvZGluZycgbXVzdCBiZQoJc2V0IHRvIGNvbnZlcnQgdHlwZWQgYW5kIGRpc3BsYXllZCB0ZXh0LiAgU2VlIHxlbmNvZGluZy10YWJsZXwuCgoJV2hlbiB5b3Ugc2V0IHRoaXMgb3B0aW9uLCBpdCBmaXJlcyB0aGUgfEVuY29kaW5nQ2hhbmdlZHwgYXV0b2NvbW1hbmQKCWV2ZW50IHNvIHRoYXQgeW91IGNhbiBzZXQgdXAgZm9udHMgaWYgbmVjZXNzYXJ5LgoKCVdoZW4gdGhlIG9wdGlvbiBpcyBzZXQsIHRoZSB2YWx1ZSBpcyBjb252ZXJ0ZWQgdG8gbG93ZXJjYXNlLiAgVGh1cwoJeW91IGNhbiBzZXQgaXQgd2l0aCB1cHBlcmNhc2UgdmFsdWVzIHRvby4gIFVuZGVyc2NvcmVzIGFyZSB0cmFuc2xhdGVkCgl0byAnLScgc2lnbnMuCglXaGVuIHRoZSBlbmNvZGluZyBpcyByZWNvZ25pemVkLCBpdCBpcyBjaGFuZ2VkIHRvIHRoZSBzdGFuZGFyZCBuYW1lLgoJRm9yIGV4YW1wbGUgIkxhdGluLTEiIGJlY29tZXMgImxhdGluMSIsICJJU09fODg1OTIiIGJlY29tZXMKCSJpc28tODg1OS0yIiBhbmQgInV0ZjgiIGJlY29tZXMgInV0Zi04Ii4KCglOb3RlOiAibGF0aW4xIiBpcyBhbHNvIHVzZWQgd2hlbiB0aGUgZW5jb2RpbmcgY291bGQgbm90IGJlIGRldGVjdGVkLgoJVGhpcyBvbmx5IHdvcmtzIHdoZW4gZWRpdGluZyBmaWxlcyBpbiB0aGUgc2FtZSBlbmNvZGluZyEgIFdoZW4gdGhlCglhY3R1YWwgY2hhcmFjdGVyIHNldCBpcyBub3QgbGF0aW4xLCBtYWtlIHN1cmUgJ2ZpbGVlbmNvZGluZycgYW5kCgknZmlsZWVuY29kaW5ncycgYXJlIGVtcHR5LiAgV2hlbiBjb252ZXJzaW9uIGlzIG5lZWRlZCwgc3dpdGNoIHRvIHVzaW5nCgl1dGYtOC4KCglXaGVuICJ1bmljb2RlIiwgInVjcy0yIiBvciAidWNzLTQiIGlzIHVzZWQsIFZpbSBpbnRlcm5hbGx5IHVzZXMgdXRmLTguCglZb3UgZG9uJ3Qgbm90aWNlIHRoaXMgd2hpbGUgZWRpdGluZywgYnV0IGl0IGRvZXMgbWF0dGVyIGZvciB0aGUKCXx2aW1pbmZvLWZpbGV8LiAgQW5kIFZpbSBleHBlY3RzIHRoZSB0ZXJtaW5hbCB0byB1c2UgdXRmLTggdG9vLiAgVGh1cwoJc2V0dGluZyAnZW5jb2RpbmcnIHRvIG9uZSBvZiB0aGVzZSB2YWx1ZXMgaW5zdGVhZCBvZiB1dGYtOCBvbmx5IGhhcwoJZWZmZWN0IGZvciBlbmNvZGluZyB1c2VkIGZvciBmaWxlcyB3aGVuICdmaWxlZW5jb2RpbmcnIGlzIGVtcHR5LgoKCSBXaGVuICdlbmNvZGluZycgaXMgc2V0IHRvIGEgVW5pY29kZSBlbmNvZGluZywgYW5kICdmaWxlZW5jb2RpbmdzJyB3YXMKCSBub3Qgc2V0IHlldCwgdGhlIGRlZmF1bHQgZm9yICdmaWxlZW5jb2RpbmdzJyBpcyBjaGFuZ2VkLgoKCQkJKidlbmRvZmxpbmUnKiAqJ2VvbCcqIConbm9lbmRvZmxpbmUnKiAqJ25vZW9sJyoKJ2VuZG9mbGluZScgJ2VvbCcJYm9vbGVhbgkoZGVmYXVsdCBvbikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CglXaGVuIHdyaXRpbmcgYSBmaWxlIGFuZCB0aGlzIG9wdGlvbiBpcyBvZmYgYW5kIHRoZSAnYmluYXJ5JyBvcHRpb24KCWlzIG9uLCBubyA8RU9MPiB3aWxsIGJlIHdyaXR0ZW4gZm9yIHRoZSBsYXN0IGxpbmUgaW4gdGhlIGZpbGUuICBUaGlzCglvcHRpb24gaXMgYXV0b21hdGljYWxseSBzZXQgd2hlbiBzdGFydGluZyB0byBlZGl0IGEgbmV3IGZpbGUsIHVubGVzcwoJdGhlIGZpbGUgZG9lcyBub3QgaGF2ZSBhbiA8RU9MPiBmb3IgdGhlIGxhc3QgbGluZSBpbiB0aGUgZmlsZSwgaW4KCXdoaWNoIGNhc2UgaXQgaXMgcmVzZXQuICBOb3JtYWxseSB5b3UgZG9uJ3QgaGF2ZSB0byBzZXQgb3IgcmVzZXQgdGhpcwoJb3B0aW9uLiAgV2hlbiAnYmluYXJ5JyBpcyBvZmYgdGhlIHZhbHVlIGlzIG5vdCB1c2VkIHdoZW4gd3JpdGluZyB0aGUKCWZpbGUuICBXaGVuICdiaW5hcnknIGlzIG9uIGl0IGlzIHVzZWQgdG8gcmVtZW1iZXIgdGhlIHByZXNlbmNlIG9mIGEKCTxFT0w+IGZvciB0aGUgbGFzdCBsaW5lIGluIHRoZSBmaWxlLCBzbyB0aGF0IHdoZW4geW91IHdyaXRlIHRoZSBmaWxlCgl0aGUgc2l0dWF0aW9uIGZyb20gdGhlIG9yaWdpbmFsIGZpbGUgY2FuIGJlIGtlcHQuICBCdXQgeW91IGNhbiBjaGFuZ2UKCWl0IGlmIHlvdSB3YW50IHRvLgoKCQkJICAgICAqJ2VxdWFsYWx3YXlzJyogKidlYScqIConbm9lcXVhbGFsd2F5cycqIConbm9lYScqCidlcXVhbGFsd2F5cycgJ2VhJwlib29sZWFuCShkZWZhdWx0IG9uKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVdoZW4gb24sIGFsbCB0aGUgd2luZG93cyBhcmUgYXV0b21hdGljYWxseSBtYWRlIHRoZSBzYW1lIHNpemUgYWZ0ZXIKCXNwbGl0dGluZyBvciBjbG9zaW5nIGEgd2luZG93LiAgVGhpcyBhbHNvIGhhcHBlbnMgdGhlIG1vbWVudCB0aGUKCW9wdGlvbiBpcyBzd2l0Y2hlZCBvbi4gIFdoZW4gb2ZmLCBzcGxpdHRpbmcgYSB3aW5kb3cgd2lsbCByZWR1Y2UgdGhlCglzaXplIG9mIHRoZSBjdXJyZW50IHdpbmRvdyBhbmQgbGVhdmUgdGhlIG90aGVyIHdpbmRvd3MgdGhlIHNhbWUuICBXaGVuCgljbG9zaW5nIGEgd2luZG93IHRoZSBleHRyYSBsaW5lcyBhcmUgZ2l2ZW4gdG8gdGhlIHdpbmRvdyBuZXh0IHRvIGl0CgkoZGVwZW5kaW5nIG9uICdzcGxpdGJlbG93JyBhbmQgJ3NwbGl0cmlnaHQnKS4KCVdoZW4gbWl4aW5nIHZlcnRpY2FsbHkgYW5kIGhvcml6b250YWxseSBzcGxpdCB3aW5kb3dzLCBhIG1pbmltYWwgc2l6ZQoJaXMgY29tcHV0ZWQgYW5kIHNvbWUgd2luZG93cyBtYXkgYmUgbGFyZ2VyIGlmIHRoZXJlIGlzIHJvb20uICBUaGUKCSdlYWRpcmVjdGlvbicgb3B0aW9uIHRlbGxzIGluIHdoaWNoIGRpcmVjdGlvbiB0aGUgc2l6ZSBpcyBhZmZlY3RlZC4KCUNoYW5naW5nIHRoZSBoZWlnaHQgb2YgYSB3aW5kb3cgY2FuIGJlIGF2b2lkZWQgYnkgc2V0dGluZwoJJ3dpbmZpeGhlaWdodCcuCgoJCQkJCQkqJ2VxdWFscHJnJyogKidlcCcqCidlcXVhbHByZycgJ2VwJwkJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwgb3IgbG9jYWwgdG8gYnVmZmVyIHxnbG9iYWwtbG9jYWx8CgkJCXtub3QgaW4gVml9CglFeHRlcm5hbCBwcm9ncmFtIHRvIHVzZSBmb3IgIj0iIGNvbW1hbmQuICBXaGVuIHRoaXMgb3B0aW9uIGlzIGVtcHR5Cgl0aGUgaW50ZXJuYWwgZm9ybWF0dGluZyBmdW5jdGlvbnMgYXJlIHVzZWQgKCdsaXNwJywgJ2NpbmRlbnQnIG9yCgknaW5kZW50ZXhwcicpLgoJRW52aXJvbm1lbnQgdmFyaWFibGVzIGFyZSBleHBhbmRlZCB8OnNldF9lbnZ8LiAgU2VlIHxvcHRpb24tYmFja3NsYXNofAoJYWJvdXQgaW5jbHVkaW5nIHNwYWNlcyBhbmQgYmFja3NsYXNoZXMuCglUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCgkJCSonZXJyb3JiZWxscycqIConZWInKiAqJ25vZXJyb3JiZWxscycqIConbm9lYicqCidlcnJvcmJlbGxzJyAnZWInCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCVJpbmcgdGhlIGJlbGwgKGJlZXAgb3Igc2NyZWVuIGZsYXNoKSBmb3IgZXJyb3IgbWVzc2FnZXMuICBUaGlzIG9ubHkKCW1ha2VzIGEgZGlmZmVyZW5jZSBmb3IgZXJyb3IgbWVzc2FnZXMsIHRoZSBiZWxsIHdpbGwgYmUgdXNlZCBhbHdheXMKCWZvciBhIGxvdCBvZiBlcnJvcnMgd2l0aG91dCBhIG1lc3NhZ2UgKGUuZy4sIGhpdHRpbmcgPEVzYz4gaW4gTm9ybWFsCgltb2RlKS4gIFNlZSAndmlzdWFsYmVsbCcgb24gaG93IHRvIG1ha2UgdGhlIGJlbGwgYmVoYXZlIGxpa2UgYSBiZWVwLAoJc2NyZWVuIGZsYXNoIG9yIGRvIG5vdGhpbmcuCgoJCQkJCQkqJ2Vycm9yZmlsZScqIConZWYnKgonZXJyb3JmaWxlJyAnZWYnCXN0cmluZwkoQW1pZ2EgZGVmYXVsdDogIkF6dGVjQy5FcnIiLAoJCQkJCW90aGVyczogImVycm9ycy5lcnIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3F1aWNrZml4fAoJCQlmZWF0dXJlfQoJTmFtZSBvZiB0aGUgZXJyb3JmaWxlIGZvciB0aGUgUXVpY2tGaXggbW9kZSAoc2VlIHw6Y2Z8KS4KCVdoZW4gdGhlICItcSIgY29tbWFuZC1saW5lIGFyZ3VtZW50IGlzIHVzZWQsICdlcnJvcmZpbGUnIGlzIHNldCB0byB0aGUKCWZvbGxvd2luZyBhcmd1bWVudC4gIFNlZSB8LXF8LgoJTk9UIHVzZWQgZm9yIHRoZSAiOm1ha2UiIGNvbW1hbmQuICBTZWUgJ21ha2VlZicgZm9yIHRoYXQuCglFbnZpcm9ubWVudCB2YXJpYWJsZXMgYXJlIGV4cGFuZGVkIHw6c2V0X2VudnwuCglTZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0IGluY2x1ZGluZyBzcGFjZXMgYW5kIGJhY2tzbGFzaGVzLgoJVGhpcyBvcHRpb24gY2Fubm90IGJlIHNldCBmcm9tIGEgfG1vZGVsaW5lfCBvciBpbiB0aGUgfHNhbmRib3h8LCBmb3IKCXNlY3VyaXR5IHJlYXNvbnMuCgoJCQkJCQkqJ2Vycm9yZm9ybWF0JyogKidlZm0nKgonZXJyb3Jmb3JtYXQnICdlZm0nCXN0cmluZwkoZGVmYXVsdCBpcyB2ZXJ5IGxvbmcpCgkJCWdsb2JhbCBvciBsb2NhbCB0byBidWZmZXIgfGdsb2JhbC1sb2NhbHwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3F1aWNrZml4fAoJCQlmZWF0dXJlfQoJU2NhbmYtbGlrZSBkZXNjcmlwdGlvbiBvZiB0aGUgZm9ybWF0IGZvciB0aGUgbGluZXMgaW4gdGhlIGVycm9yIGZpbGUKCShzZWUgfGVycm9yZm9ybWF0fCkuCgoJCQkJICAgICAqJ2VzY2tleXMnKiAqJ2VrJyogKidub2VzY2tleXMnKiAqJ25vZWsnKgonZXNja2V5cycgJ2VrJwkJYm9vbGVhbgkoVmltIGRlZmF1bHQ6IG9uLCBWaSBkZWZhdWx0OiBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJRnVuY3Rpb24ga2V5cyB0aGF0IHN0YXJ0IHdpdGggYW4gPEVzYz4gYXJlIHJlY29nbml6ZWQgaW4gSW5zZXJ0Cgltb2RlLiAgV2hlbiB0aGlzIG9wdGlvbiBpcyBvZmYsIHRoZSBjdXJzb3IgYW5kIGZ1bmN0aW9uIGtleXMgY2Fubm90IGJlCgl1c2VkIGluIEluc2VydCBtb2RlIGlmIHRoZXkgc3RhcnQgd2l0aCBhbiA8RXNjPi4gIFRoZSBhZHZhbnRhZ2Ugb2YKCXRoaXMgaXMgdGhhdCB0aGUgc2luZ2xlIDxFc2M+IGlzIHJlY29nbml6ZWQgaW1tZWRpYXRlbHksIGluc3RlYWQgb2YKCWFmdGVyIG9uZSBzZWNvbmQuICBJbnN0ZWFkIG9mIHJlc2V0dGluZyB0aGlzIG9wdGlvbiwgeW91IG1pZ2h0IHdhbnQgdG8KCXRyeSBjaGFuZ2luZyB0aGUgdmFsdWVzIGZvciAndGltZW91dGxlbicgYW5kICd0dGltZW91dGxlbicuICBOb3RlIHRoYXQKCXdoZW4gJ2VzY2tleXMnIGlzIG9mZiwgeW91IGNhbiBzdGlsbCBtYXAgYW55dGhpbmcsIGJ1dCB0aGUgY3Vyc29yIGtleXMKCXdvbid0IHdvcmsgYnkgZGVmYXVsdC4KCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHNldCB0byB0aGUgVmkgZGVmYXVsdCB2YWx1ZSB3aGVuICdjb21wYXRpYmxlJyBpcwoJc2V0IGFuZCB0byB0aGUgVmltIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMgcmVzZXQuCgoJCQkJCQkqJ2V2ZW50aWdub3JlJyogKidlaScqCidldmVudGlnbm9yZScgJ2VpJwlzdHJpbmcJKGRlZmF1bHQgIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrYXV0b2NtZHwKCQkJZmVhdHVyZX0KCUEgbGlzdCBvZiBhdXRvY29tbWFuZCBldmVudCBuYW1lcywgd2hpY2ggYXJlIHRvIGJlIGlnbm9yZWQuCglXaGVuIHNldCB0byAiYWxsIiwgYWxsIGF1dG9jb21tYW5kIGV2ZW50cyBhcmUgaWdub3JlZCwgYXV0b2NvbW1hbmRzCgl3aWxsIG5vdCBiZSBleGVjdXRlZC4KCU90aGVyd2lzZSB0aGlzIGlzIGEgY29tbWEgc2VwYXJhdGVkIGxpc3Qgb2YgZXZlbnQgbmFtZXMuICBFeGFtcGxlOiA+CgkgICAgOnNldCBlaT1XaW5FbnRlcixXaW5MZWF2ZQo8CgkJCQkgKidleHBhbmR0YWInKiAqJ2V0JyogKidub2V4cGFuZHRhYicqIConbm9ldCcqCidleHBhbmR0YWInICdldCcJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJSW4gSW5zZXJ0IG1vZGU6IFVzZSB0aGUgYXBwcm9wcmlhdGUgbnVtYmVyIG9mIHNwYWNlcyB0byBpbnNlcnQgYQoJPFRhYj4uICBTcGFjZXMgYXJlIHVzZWQgaW4gaW5kZW50cyB3aXRoIHRoZSAnPicgYW5kICc8JyBjb21tYW5kcyBhbmQKCXdoZW4gJ2F1dG9pbmRlbnQnIGlzIG9uLiAgVG8gaW5zZXJ0IGEgcmVhbCB0YWIgd2hlbiAnZXhwYW5kdGFiJyBpcwoJb24sIHVzZSBDVFJMLVY8VGFiPi4gIFNlZSBhbHNvIHw6cmV0YWJ8IGFuZCB8aW5zLWV4cGFuZHRhYnwuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyByZXNldCB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkJCSonZXhyYycqIConZXgnKiAqJ25vZXhyYycqIConbm9leCcqCidleHJjJyAnZXgnCQlib29sZWFuIChkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglFbmFibGVzIHRoZSByZWFkaW5nIG9mIC52aW1yYywgLmV4cmMgYW5kIC5ndmltcmMgaW4gdGhlIGN1cnJlbnQKCWRpcmVjdG9yeS4gIElmIHlvdSBzd2l0Y2ggdGhpcyBvcHRpb24gb24geW91IHNob3VsZCBhbHNvIGNvbnNpZGVyCglzZXR0aW5nIHRoZSAnc2VjdXJlJyBvcHRpb24gKHNlZSB8aW5pdGlhbGl6YXRpb258KS4gIFVzaW5nIGEgbG9jYWwKCS5leHJjLCAudmltcmMgb3IgLmd2aW1yYyBpcyBhIHBvdGVudGlhbCBzZWN1cml0eSBsZWFrLCB1c2Ugd2l0aCBjYXJlIQoJYWxzbyBzZWUgfC52aW1yY3wgYW5kIHxndWktaW5pdHwuCglUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCgkJCQkqJ2ZpbGVlbmNvZGluZycqIConZmVuYycqICpFMjEzKgonZmlsZWVuY29kaW5nJyAnZmVuYycJc3RyaW5nIChkZWZhdWx0OiAiIikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbXVsdGlfYnl0ZXwKCQkJZmVhdHVyZX0KCQkJe25vdCBpbiBWaX0KCVNldHMgdGhlIGNoYXJhY3RlciBlbmNvZGluZyBmb3IgdGhlIGZpbGUgb2YgdGhpcyBidWZmZXIuCglXaGVuICdmaWxlZW5jb2RpbmcnIGlzIGRpZmZlcmVudCBmcm9tICdlbmNvZGluZycsIGNvbnZlcnNpb24gd2lsbCBiZQoJZG9uZSB3aGVuIHJlYWRpbmcgYW5kIHdyaXRpbmcgdGhlIGZpbGUuCglXaGVuICdmaWxlZW5jb2RpbmcnIGlzIGVtcHR5LCB0aGUgc2FtZSB2YWx1ZSBhcyAnZW5jb2RpbmcnIHdpbGwgYmUKCXVzZWQgKG5vIGNvbnZlcnNpb24gd2hlbiByZWFkaW5nIG9yIHdyaXRpbmcgYSBmaWxlKS4KCQlXQVJOSU5HOiBDb252ZXJzaW9uIGNhbiBjYXVzZSBsb3NzIG9mIGluZm9ybWF0aW9uISAgV2hlbgoJCSdlbmNvZGluZycgaXMgInV0Zi04IiBjb252ZXJzaW9uIGlzIG1vc3QgbGlrZWx5IGRvbmUgaW4gYSB3YXkKCQl0aGF0IHRoZSByZXZlcnNlIGNvbnZlcnNpb24gcmVzdWx0cyBpbiB0aGUgc2FtZSB0ZXh0LiAgV2hlbgoJCSdlbmNvZGluZycgaXMgbm90ICJ1dGYtOCIgc29tZSBjaGFyYWN0ZXJzIG1heSBiZSBsb3N0IQoJU2VlICdlbmNvZGluZycgZm9yIHRoZSBwb3NzaWJsZSB2YWx1ZXMuICBBZGRpdGlvbmFsbHksIHZhbHVlcyBtYXkgYmUKCXNwZWNpZmllZCB0aGF0IGNhbiBiZSBoYW5kbGVkIGJ5IHRoZSBjb252ZXJ0ZXIsIHNlZQoJfG1ieXRlLWNvbnZlcnNpb258LgoJV2hlbiByZWFkaW5nIGEgZmlsZSAnZmlsZWVuY29kaW5nJyB3aWxsIGJlIHNldCBmcm9tICdmaWxlZW5jb2RpbmdzJy4KCVRvIHJlYWQgYSBmaWxlIGluIGEgY2VydGFpbiBlbmNvZGluZyBpdCB3b24ndCB3b3JrIGJ5IHNldHRpbmcKCSdmaWxlZW5jb2RpbmcnLCB1c2UgdGhlIHwrK2VuY3wgYXJndW1lbnQuCglQcmVwZW5kaW5nICI4Yml0LSIgYW5kICIyYnl0ZS0iIGhhcyBubyBtZWFuaW5nIGhlcmUsIHRoZXkgYXJlIGlnbm9yZWQuCglXaGVuIHRoZSBvcHRpb24gaXMgc2V0LCB0aGUgdmFsdWUgaXMgY29udmVydGVkIHRvIGxvd2VyY2FzZS4gIFRodXMKCXlvdSBjYW4gc2V0IGl0IHdpdGggdXBwZXJjYXNlIHZhbHVlcyB0b28uICAnXycgY2hhcmFjdGVycyBhcmUKCXJlcGxhY2VkIHdpdGggJy0nLiAgSWYgYSBuYW1lIGlzIHJlY29nbml6ZWQgZnJvbSB0aGUgbGlzdCBmb3IKCSdlbmNvZGluZycsIGl0IGlzIHJlcGxhY2VkIGJ5IHRoZSBzdGFuZGFyZCBuYW1lLiAgRm9yIGV4YW1wbGUKCSJJU084ODU5LTIiIGJlY29tZXMgImlzby04ODU5LTIiLgoJV2hlbiB0aGlzIG9wdGlvbiBpcyBzZXQsIGFmdGVyIHN0YXJ0aW5nIHRvIGVkaXQgYSBmaWxlLCB0aGUgJ21vZGlmaWVkJwoJb3B0aW9uIGlzIHNldCwgYmVjYXVzZSB0aGUgZmlsZSB3b3VsZCBiZSBkaWZmZXJlbnQgd2hlbiB3cml0dGVuLgoJSWYgeW91IGRvIHRoaXMgaW4gYSBtb2RlbGluZSwgeW91IG1pZ2h0IHdhbnQgdG8gc2V0ICdub21vZGlmaWVkJyB0bwoJYXZvaWQgdGhpcy4KCVRoaXMgb3B0aW9uIGNhbiBub3QgYmUgY2hhbmdlZCB3aGVuICdtb2RpZmlhYmxlJyBpcyBvZmYuCgoJCQkJCQkJKidmZScqCglOT1RFOiBCZWZvcmUgdmVyc2lvbiA2LjAgdGhpcyBvcHRpb24gc3BlY2lmaWVkIHRoZSBlbmNvZGluZyBmb3IgdGhlCgl3aG9sZSBvZiBWaW0sIHRoaXMgd2FzIGEgbWlzdGFrZS4gIE5vdyB1c2UgJ2VuY29kaW5nJyBpbnN0ZWFkLiAgVGhlCglvbGQgc2hvcnQgbmFtZSB3YXMgJ2ZlJywgd2hpY2ggaXMgbm8gbG9uZ2VyIHVzZWQuCgoJCQkJCSonZmlsZWVuY29kaW5ncycqIConZmVuY3MnKgonZmlsZWVuY29kaW5ncycgJ2ZlbmNzJwlzdHJpbmcgKGRlZmF1bHQ6ICJ1Y3MtYm9tIiwKCQkJCSAgICAidWNzLWJvbSx1dGYtOCxkZWZhdWx0LGxhdGluMSIgd2hlbgoJCQkJICAgICdlbmNvZGluZycgaXMgc2V0IHRvIGEgVW5pY29kZSB2YWx1ZSkKCQkJZ2xvYmFsCgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbXVsdGlfYnl0ZXwKCQkJZmVhdHVyZX0KCQkJe25vdCBpbiBWaX0KCVRoaXMgaXMgYSBsaXN0IG9mIGNoYXJhY3RlciBlbmNvZGluZ3MgY29uc2lkZXJlZCB3aGVuIHN0YXJ0aW5nIHRvIGVkaXQKCWFuIGV4aXN0aW5nIGZpbGUuICBXaGVuIGEgZmlsZSBpcyByZWFkLCBWaW0gdHJpZXMgdG8gdXNlIHRoZSBmaXJzdAoJbWVudGlvbmVkIGNoYXJhY3RlciBlbmNvZGluZy4gIElmIGFuIGVycm9yIGlzIGRldGVjdGVkLCB0aGUgbmV4dCBvbmUKCWluIHRoZSBsaXN0IGlzIHRyaWVkLiAgV2hlbiBhbiBlbmNvZGluZyBpcyBmb3VuZCB0aGF0IHdvcmtzLAoJJ2ZpbGVlbmNvZGluZycgaXMgc2V0IHRvIGl0LiAgSWYgYWxsIGZhaWwsICdmaWxlZW5jb2RpbmcnIGlzIHNldCB0bwoJYW4gZW1wdHkgc3RyaW5nLCB3aGljaCBtZWFucyB0aGUgdmFsdWUgb2YgJ2VuY29kaW5nJyBpcyB1c2VkLgoJCVdBUk5JTkc6IENvbnZlcnNpb24gY2FuIGNhdXNlIGxvc3Mgb2YgaW5mb3JtYXRpb24hICBXaGVuCgkJJ2VuY29kaW5nJyBpcyAidXRmLTgiIChvciBvbmUgb2YgdGhlIG90aGVyIFVuaWNvZGUgdmFyaWFudHMpCgkJY29udmVyc2lvbiBpcyBtb3N0IGxpa2VseSBkb25lIGluIGEgd2F5IHRoYXQgdGhlIHJldmVyc2UKCQljb252ZXJzaW9uIHJlc3VsdHMgaW4gdGhlIHNhbWUgdGV4dC4gIFdoZW4gJ2VuY29kaW5nJyBpcyBub3QKCQkidXRmLTgiIHNwZWNpYWwgY2hhcmFjdGVycyBtYXkgYmUgbG9zdCEKCUZvciBhbiBlbXB0eSBmaWxlIG9yIGEgZmlsZSB3aXRoIG9ubHkgQVNDSUkgY2hhcmFjdGVycyBtb3N0IGVuY29kaW5ncwoJd2lsbCB3b3JrIGFuZCB0aGUgZmlyc3QgZW50cnkgb2YgJ2ZpbGVlbmNvZGluZ3MnIHdpbGwgYmUgdXNlZCAoZXhjZXB0CgkidWNzLWJvbSIsIHdoaWNoIHJlcXVpcmVzIHRoZSBCT00gdG8gYmUgcHJlc2VudCkuICBJZiB5b3UgcHJlZmVyCglhbm90aGVyIGVuY29kaW5nIHVzZSBhbiBCdWZSZWFkUG9zdCBhdXRvY29tbWFuZCBldmVudCB0byB0ZXN0IGlmIHlvdXIKCXByZWZlcnJlZCBlbmNvZGluZyBpcyB0byBiZSB1c2VkLiAgRXhhbXBsZTogPgoJCWF1IEJ1ZlJlYWRQb3N0ICogaWYgc2VhcmNoKCdcUycsICd3JykgPT0gMCB8CgkJCVwgc2V0IGZlbmM9aXNvLTIwMjItanAgfCBlbmRpZgo8CVRoaXMgc2V0cyAnZmlsZWVuY29kaW5nJyB0byAiaXNvLTIwMjItanAiIGlmIHRoZSBmaWxlIGRvZXMgbm90IGNvbnRhaW4KCW5vbi1ibGFuayBjaGFyYWN0ZXJzLgoJTm90ZSB0aGF0ICdmaWxlZW5jb2RpbmdzJyBpcyBub3QgdXNlZCBmb3IgYW4gbmV3IGZpbGUsICdmaWxlZW5jb2RpbmcnCglpcyBhbHdheXMgZW1wdHkgdGhlbi4gIFRoaXMgbWVhbnMgdGhhdCBhIG5vbi1leGlzdGluZyBmaWxlIG1heSBnZXQgYQoJZGlmZmVyZW50IGVuY29kaW5nIHRoYW4gYW4gZW1wdHkgZmlsZS4KCVRoZSBzcGVjaWFsIHZhbHVlICJ1Y3MtYm9tIiBjYW4gYmUgdXNlZCB0byBjaGVjayBmb3IgYSBVbmljb2RlIEJPTQoJKEJ5dGUgT3JkZXIgTWFyaykgYXQgdGhlIHN0YXJ0IG9mIHRoZSBmaWxlLiAgSXQgbXVzdCBub3QgYmUgcHJlY2VkZWQKCWJ5ICJ1dGYtOCIgb3IgYW5vdGhlciBVbmljb2RlIGVuY29kaW5nIGZvciB0aGlzIHRvIHdvcmsgcHJvcGVybHkuCglBbiBlbnRyeSBmb3IgYW4gOC1iaXQgZW5jb2RpbmcgKGUuZy4sICJsYXRpbjEiKSBzaG91bGQgYmUgdGhlIGxhc3QsCgliZWNhdXNlIFZpbSBjYW5ub3QgZGV0ZWN0IGFuIGVycm9yLCB0aHVzIHRoZSBlbmNvZGluZyBpcyBhbHdheXMKCWFjY2VwdGVkLgoJVGhlIHNwZWNpYWwgdmFsdWUgImRlZmF1bHQiIGNhbiBiZSB1c2VkIGZvciB0aGUgZW5jb2RpbmcgZnJvbSB0aGUKCWVudmlyb25tZW50LiAgVGhpcyBpcyB0aGUgZGVmYXVsdCB2YWx1ZSBmb3IgJ2VuY29kaW5nJy4gIEl0IGlzIHVzZWZ1bAoJd2hlbiAnZW5jb2RpbmcnIGlzIHNldCB0byAidXRmLTgiIGFuZCB5b3VyIGVudmlyb25tZW50IHVzZXMgYQoJbm9uLWxhdGluMSBlbmNvZGluZywgc3VjaCBhcyBSdXNzaWFuLgoJV1JPTkcgVkFMVUVTOgkJCVdIQVQnUyBXUk9ORzoKCQlsYXRpbjEsdXRmLTgJCSJsYXRpbjEiIHdpbGwgYWx3YXlzIGJlIHVzZWQKCQl1dGYtOCx1Y3MtYm9tLGxhdGluMQlCT00gd29uJ3QgYmUgcmVjb2duaXplZCBpbiBhbiB1dGYtOAoJCQkJCWZpbGUKCQljcDEyNTAsbGF0aW4xCQkiY3AxMjUwIiB3aWxsIGFsd2F5cyBiZSB1c2VkCglJZiAnZmlsZWVuY29kaW5ncycgaXMgZW1wdHksICdmaWxlZW5jb2RpbmcnIGlzIG5vdCBtb2RpZmllZC4KCVNlZSAnZmlsZWVuY29kaW5nJyBmb3IgdGhlIHBvc3NpYmxlIHZhbHVlcy4KCVNldHRpbmcgdGhpcyBvcHRpb24gZG9lcyBub3QgaGF2ZSBhbiBlZmZlY3QgdW50aWwgdGhlIG5leHQgdGltZSBhIGZpbGUKCWlzIHJlYWQuCgoJCQkJCSonZmlsZWZvcm1hdCcqIConZmYnKgonZmlsZWZvcm1hdCcgJ2ZmJwlzdHJpbmcgKE1TLURPUywgTVMtV2luZG93cywgT1MvMiBkZWZhdWx0OiAiZG9zIiwKCQkJCVVuaXggZGVmYXVsdDogInVuaXgiLAoJCQkJTWFjaW50b3NoIGRlZmF1bHQ6ICJtYWMiKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCVRoaXMgZ2l2ZXMgdGhlIDxFT0w+IG9mIHRoZSBjdXJyZW50IGJ1ZmZlciwgd2hpY2ggaXMgdXNlZCBmb3IKCXJlYWRpbmcvd3JpdGluZyB0aGUgYnVmZmVyIGZyb20vdG8gYSBmaWxlOgoJICAgIGRvcwkgICAgPENSPiA8Tkw+CgkgICAgdW5peCAgICA8Tkw+CgkgICAgbWFjCSAgICA8Q1I+CglXaGVuICJkb3MiIGlzIHVzZWQsIENUUkwtWiBhdCB0aGUgZW5kIG9mIGEgZmlsZSBpcyBpZ25vcmVkLgoJU2VlIHxmaWxlLWZvcm1hdHN8IGFuZCB8ZmlsZS1yZWFkfC4KCUZvciB0aGUgY2hhcmFjdGVyIGVuY29kaW5nIG9mIHRoZSBmaWxlIHNlZSAnZmlsZWVuY29kaW5nJy4KCVdoZW4gJ2JpbmFyeScgaXMgc2V0LCB0aGUgdmFsdWUgb2YgJ2ZpbGVmb3JtYXQnIGlzIGlnbm9yZWQsIGZpbGUgSS9PCgl3b3JrcyBsaWtlIGl0IHdhcyBzZXQgdG8gInVuaXgnLgoJVGhpcyBvcHRpb24gaXMgc2V0IGF1dG9tYXRpY2FsbHkgd2hlbiBzdGFydGluZyB0byBlZGl0IGEgZmlsZSBhbmQKCSdmaWxlZm9ybWF0cycgaXMgbm90IGVtcHR5IGFuZCAnYmluYXJ5JyBpcyBvZmYuCglXaGVuIHRoaXMgb3B0aW9uIGlzIHNldCwgYWZ0ZXIgc3RhcnRpbmcgdG8gZWRpdCBhIGZpbGUsIHRoZSAnbW9kaWZpZWQnCglvcHRpb24gaXMgc2V0LCBiZWNhdXNlIHRoZSBmaWxlIHdvdWxkIGJlIGRpZmZlcmVudCB3aGVuIHdyaXR0ZW4uCglUaGlzIG9wdGlvbiBjYW4gbm90IGJlIGNoYW5nZWQgd2hlbiAnbW9kaWZpYWJsZScgaXMgb2ZmLgoJRm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5OiBXaGVuIHRoaXMgb3B0aW9uIGlzIHNldCB0byAiZG9zIiwKCSd0ZXh0bW9kZScgaXMgc2V0LCBvdGhlcndpc2UgJ3RleHRtb2RlJyBpcyByZXNldC4KCgkJCQkJKidmaWxlZm9ybWF0cycqIConZmZzJyoKJ2ZpbGVmb3JtYXRzJyAnZmZzJwlzdHJpbmcgKGRlZmF1bHQ6CgkJCQlWaW0rVmkJTVMtRE9TLCBNUy1XaW5kb3dzIE9TLzI6ICJkb3MsdW5peCIsCgkJCQlWaW0JVW5peDogInVuaXgsZG9zIiwKCQkJCVZpbQlNYWM6ICJtYWMsdW5peCxkb3MiLAoJCQkJVmkJQ3lnd2luOiAidW5peCxkb3MiLAoJCQkJVmkJb3RoZXJzOiAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglUaGlzIGdpdmVzIHRoZSBlbmQtb2YtbGluZSAoPEVPTD4pIGZvcm1hdHMgdGhhdCB3aWxsIGJlIHRyaWVkIHdoZW4KCXN0YXJ0aW5nIHRvIGVkaXQgYSBuZXcgYnVmZmVyIGFuZCB3aGVuIHJlYWRpbmcgYSBmaWxlIGludG8gYW4gZXhpc3RpbmcKCWJ1ZmZlcjoKCS0gV2hlbiBlbXB0eSwgdGhlIGZvcm1hdCBkZWZpbmVkIHdpdGggJ2ZpbGVmb3JtYXQnIHdpbGwgYmUgdXNlZAoJICBhbHdheXMuICBJdCBpcyBub3Qgc2V0IGF1dG9tYXRpY2FsbHkuCgktIFdoZW4gc2V0IHRvIG9uZSBuYW1lLCB0aGF0IGZvcm1hdCB3aWxsIGJlIHVzZWQgd2hlbmV2ZXIgYSBuZXcgYnVmZmVyCgkgIGlzIG9wZW5lZC4gICdmaWxlZm9ybWF0JyBpcyBzZXQgYWNjb3JkaW5nbHkgZm9yIHRoYXQgYnVmZmVyLiAgVGhlCgkgICdmaWxlZm9ybWF0cycgbmFtZSB3aWxsIGJlIHVzZWQgd2hlbiBhIGZpbGUgaXMgcmVhZCBpbnRvIGFuIGV4aXN0aW5nCgkgIGJ1ZmZlciwgbm8gbWF0dGVyIHdoYXQgJ2ZpbGVmb3JtYXQnIGZvciB0aGF0IGJ1ZmZlciBpcyBzZXQgdG8uCgktIFdoZW4gbW9yZSB0aGFuIG9uZSBuYW1lIGlzIHByZXNlbnQsIHNlcGFyYXRlZCBieSBjb21tYXMsIGF1dG9tYXRpYwoJICA8RU9MPiBkZXRlY3Rpb24gd2lsbCBiZSBkb25lIHdoZW4gcmVhZGluZyBhIGZpbGUuICBXaGVuIHN0YXJ0aW5nIHRvCgkgIGVkaXQgYSBmaWxlLCBhIGNoZWNrIGlzIGRvbmUgZm9yIHRoZSA8RU9MPjoKCSAgMS4gSWYgYWxsIGxpbmVzIGVuZCBpbiA8Q1I+PE5MPiwgYW5kICdmaWxlZm9ybWF0cycgaW5jbHVkZXMgImRvcyIsCgkgICAgICdmaWxlZm9ybWF0JyBpcyBzZXQgdG8gImRvcyIuCgkgIDIuIElmIGEgPE5MPiBpcyBmb3VuZCBhbmQgJ2ZpbGVmb3JtYXRzJyBpbmNsdWRlcyAidW5peCIsICdmaWxlZm9ybWF0JwoJICAgICBpcyBzZXQgdG8gInVuaXgiLiAgTm90ZSB0aGF0IHdoZW4gYSA8Tkw+IGlzIGZvdW5kIHdpdGhvdXQgYQoJICAgICBwcmVjZWRpbmcgPENSPiwgInVuaXgiIGlzIHByZWZlcnJlZCBvdmVyICJkb3MiLgoJICAzLiBJZiAnZmlsZWZvcm1hdHMnIGluY2x1ZGVzICJtYWMiLCAnZmlsZWZvcm1hdCcgaXMgc2V0IHRvICJtYWMiLgoJICAgICBUaGlzIG1lYW5zIHRoYXQgIm1hYyIgaXMgb25seSBjaG9zZW4gd2hlbiAidW5peCIgaXMgbm90IHByZXNlbnQsCgkgICAgIG9yIHdoZW4gbm8gPE5MPiBpcyBmb3VuZCBpbiB0aGUgZmlsZSwgYW5kIHdoZW4gImRvcyIgaXMgbm90CgkgICAgIHByZXNlbnQsIG9yIG5vIDxDUj48Tkw+IGlzIHByZXNlbnQgaW4gdGhlIGZpbGUuCgkgICAgIEFsc28gaWYgInVuaXgiIHdhcyBmaXJzdCBjaG9zZW4sIGJ1dCB0aGUgZmlyc3QgPENSPiBpcyBiZWZvcmUKCSAgICAgdGhlIGZpcnN0IDxOTD4gYW5kIHRoZXJlIGFwcGVhcnMgdG8gYmUgbW9yZSA8Q1I+J3MgdGhhbiA8Tkw+J3MgaW4KCSAgICAgdGhlIGZpbGUsIHRoZW4gJ2ZpbGVmb3JtYXQnIGlzIHNldCB0byAibWFjIi4KCSAgNC4gSWYgJ2ZpbGVmb3JtYXQnIGlzIHN0aWxsIG5vdCBzZXQsIHRoZSBmaXJzdCBuYW1lIGZyb20KCSAgICAgJ2ZpbGVmb3JtYXRzJyBpcyB1c2VkLgoJICBXaGVuIHJlYWRpbmcgYSBmaWxlIGludG8gYW4gZXhpc3RpbmcgYnVmZmVyLCB0aGUgc2FtZSBpcyBkb25lLCBidXQKCSAgdGhpcyBoYXBwZW5zIGxpa2UgJ2ZpbGVmb3JtYXQnIGhhcyBiZWVuIHNldCBhcHByb3ByaWF0ZWx5IGZvciB0aGF0CgkgIGZpbGUgb25seSwgdGhlIG9wdGlvbiBpcyBub3QgY2hhbmdlZC4KCVdoZW4gJ2JpbmFyeScgaXMgc2V0LCB0aGUgdmFsdWUgb2YgJ2ZpbGVmb3JtYXRzJyBpcyBub3QgdXNlZC4KCglGb3Igc3lzdGVtcyB3aXRoIGEgRG9zLWxpa2UgPEVPTD4gKDxDUj48Tkw+KSwgd2hlbiByZWFkaW5nIGZpbGVzIHRoYXQKCWFyZSAiOnNvdXJjZSJlZCBhbmQgZm9yIHZpbXJjIGZpbGVzLCBhdXRvbWF0aWMgPEVPTD4gZGV0ZWN0aW9uIG1heSBiZQoJZG9uZToKCS0gV2hlbiAnZmlsZWZvcm1hdHMnIGlzIGVtcHR5LCB0aGVyZSBpcyBubyBhdXRvbWF0aWMgZGV0ZWN0aW9uLiAgRG9zCgkgIGZvcm1hdCB3aWxsIGJlIHVzZWQuCgktIFdoZW4gJ2ZpbGVmb3JtYXRzJyBpcyBzZXQgdG8gb25lIG9yIG1vcmUgbmFtZXMsIGF1dG9tYXRpYyBkZXRlY3Rpb24KCSAgaXMgZG9uZS4gIFRoaXMgaXMgYmFzZWQgb24gdGhlIGZpcnN0IDxOTD4gaW4gdGhlIGZpbGU6IElmIHRoZXJlIGlzIGEKCSAgPENSPiBpbiBmcm9udCBvZiBpdCwgRG9zIGZvcm1hdCBpcyB1c2VkLCBvdGhlcndpc2UgVW5peCBmb3JtYXQgaXMKCSAgdXNlZC4KCUFsc28gc2VlIHxmaWxlLWZvcm1hdHN8LgoJRm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5OiBXaGVuIHRoaXMgb3B0aW9uIGlzIHNldCB0byBhbiBlbXB0eQoJc3RyaW5nIG9yIG9uZSBmb3JtYXQgKG5vIGNvbW1hIGlzIGluY2x1ZGVkKSwgJ3RleHRhdXRvJyBpcyByZXNldCwKCW90aGVyd2lzZSAndGV4dGF1dG8nIGlzIHNldC4KCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHNldCB0byB0aGUgVmkgZGVmYXVsdCB2YWx1ZSB3aGVuICdjb21wYXRpYmxlJyBpcwoJc2V0IGFuZCB0byB0aGUgVmltIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMgcmVzZXQuCgoJCQkJCSonZmlsZXR5cGUnKiAqJ2Z0JyoKJ2ZpbGV0eXBlJyAnZnQnCQlzdHJpbmcgKGRlZmF1bHQ6ICIiKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2F1dG9jbWR8CgkJCWZlYXR1cmV9CglXaGVuIHRoaXMgb3B0aW9uIGlzIHNldCwgdGhlIEZpbGVUeXBlIGF1dG9jb21tYW5kIGV2ZW50IGlzIHRyaWdnZXJlZC4KCUFsbCBhdXRvY29tbWFuZHMgdGhhdCBtYXRjaCB3aXRoIHRoZSB2YWx1ZSBvZiB0aGlzIG9wdGlvbiB3aWxsIGJlCglleGVjdXRlZC4gIFRodXMgdGhlIHZhbHVlIG9mICdmaWxldHlwZScgaXMgdXNlZCBpbiBwbGFjZSBvZiB0aGUgZmlsZQoJbmFtZS4KCU90aGVyd2lzZSB0aGlzIG9wdGlvbiBkb2VzIG5vdCBhbHdheXMgcmVmbGVjdCB0aGUgY3VycmVudCBmaWxlIHR5cGUuCglUaGlzIG9wdGlvbiBpcyBub3JtYWxseSBzZXQgd2hlbiB0aGUgZmlsZSB0eXBlIGlzIGRldGVjdGVkLiAgVG8gZW5hYmxlCgl0aGlzIHVzZSB0aGUgIjpmaWxldHlwZSBvbiIgY29tbWFuZC4gfDpmaWxldHlwZXwKCVNldHRpbmcgdGhpcyBvcHRpb24gdG8gYSBkaWZmZXJlbnQgdmFsdWUgaXMgbW9zdCB1c2VmdWwgaW4gYSBtb2RlbGluZSwKCWZvciBhIGZpbGUgZm9yIHdoaWNoIHRoZSBmaWxlIHR5cGUgaXMgbm90IGF1dG9tYXRpY2FsbHkgcmVjb2duaXplZC4KCUV4YW1wbGUsIGZvciBpbiBhbiBJREwgZmlsZTogPgoJCS8qIHZpbTogc2V0IGZpbGV0eXBlPWlkbCA6ICovCjwJfEZpbGVUeXBlfCB8ZmlsZXR5cGVzfAoJRG8gbm90IGNvbmZ1c2UgdGhpcyBvcHRpb24gd2l0aCAnb3NmaWxldHlwZScsIHdoaWNoIGlzIGZvciB0aGUgZmlsZQoJdHlwZSB0aGF0IGlzIGFjdHVhbGx5IHN0b3JlZCB3aXRoIHRoZSBmaWxlLgoJVGhpcyBvcHRpb24gaXMgbm90IGNvcGllZCB0byBhbm90aGVyIGJ1ZmZlciwgaW5kZXBlbmRlbnQgb2YgdGhlICdzJyBvcgoJJ1MnIGZsYWcgaW4gJ2Nwb3B0aW9ucycuCglPbmx5IG5vcm1hbCBmaWxlIG5hbWUgY2hhcmFjdGVycyBjYW4gYmUgdXNlZCwgIi9cKj9bfDw+IiBhcmUgaWxsZWdhbC4KCgkJCQkJCSonZmlsbGNoYXJzJyogKidmY3MnKgonZmlsbGNoYXJzJyAnZmNzJwlzdHJpbmcJKGRlZmF1bHQgInZlcnQ6fCxmb2xkOi0iKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3dpbmRvd3N8CgkJCWFuZCB8K2ZvbGRpbmd8IGZlYXR1cmVzfQoJQ2hhcmFjdGVycyB0byBmaWxsIHRoZSBzdGF0dXNsaW5lcyBhbmQgdmVydGljYWwgc2VwYXJhdG9ycy4KCUl0IGlzIGEgY29tbWEgc2VwYXJhdGVkIGxpc3Qgb2YgaXRlbXM6CgoJICBpdGVtCQlkZWZhdWx0CQlVc2VkIGZvciB+CgkgIHN0bDpjCQknICcgb3IgJ14nCXN0YXR1c2xpbmUgb2YgdGhlIGN1cnJlbnQgd2luZG93CgkgIHN0bG5jOmMJJyAnIG9yICctJwlzdGF0dXNsaW5lIG9mIHRoZSBub24tY3VycmVudCB3aW5kb3dzCgkgIHZlcnQ6YwknfCcJCXZlcnRpY2FsIHNlcGFyYXRvcnMgfDp2c3BsaXR8CgkgIGZvbGQ6YwknLScJCWZpbGxpbmcgJ2ZvbGR0ZXh0JwoJICBkaWZmOmMJJy0nCQlkZWxldGVkIGxpbmVzIG9mIHRoZSAnZGlmZicgb3B0aW9uCgoJQW55IG9uZSB0aGF0IGlzIG9taXR0ZWQgd2lsbCBmYWxsIGJhY2sgdG8gdGhlIGRlZmF1bHQuICBGb3IgInN0bCIgYW5kCgkic3RsbmMiIHRoZSBzcGFjZSB3aWxsIGJlIHVzZWQgd2hlbiB0aGVyZSBpcyBoaWdobGlnaHRpbmcsICdeJyBvciAnLScKCW90aGVyd2lzZS4KCglFeGFtcGxlOiA+CgkgICAgOnNldCBmaWxsY2hhcnM9c3RsOl4sc3RsbmM6LSx2ZXJ0Olx8LGZvbGQ6LSxkaWZmOi0KPAlUaGlzIGlzIHNpbWlsYXIgdG8gdGhlIGRlZmF1bHQsIGV4Y2VwdCB0aGF0IHRoZXNlIGNoYXJhY3RlcnMgd2lsbCBhbHNvCgliZSB1c2VkIHdoZW4gdGhlcmUgaXMgaGlnaGxpZ2h0aW5nLgoKCVRoZSBoaWdobGlnaHRpbmcgdXNlZCBmb3IgdGhlc2UgaXRlbXM6CgkgIGl0ZW0JCWhpZ2hsaWdodCBncm91cCB+CgkgIHN0bDpjCQlTdGF0dXNMaW5lCQl8aGwtU3RhdHVzTGluZXwKCSAgc3RsbmM6YwlTdGF0dXNMaW5lTkMJCXxobC1TdGF0dXNMaW5lTkN8CgkgIHZlcnQ6YwlWZXJ0U3BsaXQJCXxobC1WZXJ0U3BsaXR8CgkgIGZvbGQ6YwlGb2xkZWQJCQl8aGwtRm9sZGVkfAoJICBkaWZmOmMJRGlmZkRlbGV0ZQkJfGhsLURpZmZEZWxldGV8CgoJCQkJCSonZmttYXAnKiAqJ2ZrJyogKidub2ZrbWFwJyogKidub2ZrJyoKJ2ZrbWFwJyAnZmsnCQlib29sZWFuIChkZWZhdWx0IG9mZikJCQkqRTE5OCoKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmlnaHRsZWZ0fAoJCQlmZWF0dXJlfQoJV2hlbiBvbiwgdGhlIGtleWJvYXJkIGlzIG1hcHBlZCBmb3IgdGhlIEZhcnNpIGNoYXJhY3RlciBzZXQuCglOb3JtYWxseSB5b3Ugd291bGQgc2V0ICdhbGxvd3JldmlucycgYW5kIHVzZSBDVFJMLV8gaW4gaW5zZXJ0IG1vZGUgdG8KCXRvZ2dsZSB0aGlzIG9wdGlvbiB8aV9DVFJMLV98LiAgU2VlIHxmYXJzaS50eHR8LgoKCQkJCQkJKidmb2xkY2xvc2UnKiAqJ2ZjbCcqCidmb2xkY2xvc2UnICdmY2wnCXN0cmluZyAoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCtmb2xkaW5nfAoJCQlmZWF0dXJlfQoJV2hlbiBzZXQgdG8gImFsbCIsIGEgZm9sZCBpcyBjbG9zZWQgd2hlbiB0aGUgY3Vyc29yIGlzbid0IGluIGl0IGFuZAoJaXRzIGxldmVsIGlzIGhpZ2hlciB0aGFuICdmb2xkbGV2ZWwnLiAgVXNlZnVsIGlmIHlvdSB3YW50IGZvbGRzIHRvCglhdXRvbWF0aWNhbGx5IGNsb3NlIHdoZW4gbW92aW5nIG91dCBvZiB0aGVtLgoKCQkJCQkJKidmb2xkY29sdW1uJyogKidmZGMnKgonZm9sZGNvbHVtbicgJ2ZkYycJbnVtYmVyIChkZWZhdWx0IDApCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wKCQkJZmVhdHVyZX0KCVdoZW4gbm9uLXplcm8sIGEgY29sdW1uIHdpdGggdGhlIHNwZWNpZmllZCB3aWR0aCBpcyBzaG93biBhdCB0aGUgc2lkZQoJb2YgdGhlIHdpbmRvdyB3aGljaCBpbmRpY2F0ZXMgb3BlbiBhbmQgY2xvc2VkIGZvbGRzLiAgVGhlIG1heGltdW0KCXZhbHVlIGlzIDEyLgoJU2VlIHxmb2xkaW5nfC4KCgkJCSonZm9sZGVuYWJsZScqIConZmVuJyogKidub2ZvbGRlbmFibGUnKiAqJ25vZmVuJyoKJ2ZvbGRlbmFibGUnICdmZW4nCWJvb2xlYW4gKGRlZmF1bHQgb24pCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wKCQkJZmVhdHVyZX0KCVdoZW4gb2ZmLCBhbGwgZm9sZHMgYXJlIG9wZW4uICBUaGlzIG9wdGlvbiBjYW4gYmUgdXNlZCB0byBxdWlja2x5Cglzd2l0Y2ggYmV0d2VlbiBzaG93aW5nIGFsbCB0ZXh0IHVuZm9sZGVkIGFuZCB2aWV3aW5nIHRoZSB0ZXh0IHdpdGgKCWZvbGRzIChpbmNsdWRpbmcgbWFudWFsbHkgb3BlbmVkIG9yIGNsb3NlZCBmb2xkcykuICBJdCBjYW4gYmUgdG9nZ2xlZAoJd2l0aCB0aGUgfHppfCBjb21tYW5kLiAgVGhlICdmb2xkY29sdW1uJyB3aWxsIHJlbWFpbiBibGFuayB3aGVuCgknZm9sZGVuYWJsZScgaXMgb2ZmLgoJVGhpcyBvcHRpb24gaXMgc2V0IGJ5IGNvbW1hbmRzIHRoYXQgY3JlYXRlIGEgbmV3IGZvbGQgb3IgY2xvc2UgYSBmb2xkLgoJU2VlIHxmb2xkaW5nfC4KCgkJCQkJCSonZm9sZGV4cHInKiAqJ2ZkZScqCidmb2xkZXhwcicgJ2ZkZScJc3RyaW5nIChkZWZhdWx0OiAiMCIpCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wKCQkJb3IgfCtldmFsfCBmZWF0dXJlfQoJVGhlIGV4cHJlc3Npb24gdXNlZCBmb3Igd2hlbiAnZm9sZG1ldGhvZCcgaXMgImV4cHIiLiAgSXQgaXMgZXZhbHVhdGVkCglmb3IgZWFjaCBsaW5lIHRvIG9idGFpbiBpdHMgZm9sZCBsZXZlbC4gIFNlZSB8Zm9sZC1leHByfC4gIEFsc28gc2VlCgl8ZXZhbC1zYW5kYm94fC4KCgkJCQkJCSonZm9sZGlnbm9yZScqIConZmRpJyoKJ2ZvbGRpZ25vcmUnICdmZGknCXN0cmluZyAoZGVmYXVsdDogIiMiKQoJCQlsb2NhbCB0byB3aW5kb3cKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2ZvbGRpbmd8CgkJCWZlYXR1cmV9CglVc2VkIG9ubHkgd2hlbiAnZm9sZG1ldGhvZCcgaXMgImluZGVudCIuICBMaW5lcyBzdGFydGluZyB3aXRoCgljaGFyYWN0ZXJzIGluICdmb2xkaWdub3JlJyB3aWxsIGdldCB0aGVpciBmb2xkIGxldmVsIGZyb20gc3Vycm91bmRpbmcKCWxpbmVzLiAgV2hpdGUgc3BhY2UgaXMgc2tpcHBlZCBiZWZvcmUgY2hlY2tpbmcgZm9yIHRoaXMgY2hhcmFjdGVyLgoJVGhlIGRlZmF1bHQgIiMiIHdvcmtzIHdlbGwgZm9yIEMgcHJvZ3JhbXMuICBTZWUgfGZvbGQtaW5kZW50fC4KCgkJCQkJCSonZm9sZGxldmVsJyogKidmZGwnKgonZm9sZGxldmVsJyAnZmRsJwludW1iZXIgKGRlZmF1bHQ6IDApCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wKCQkJZmVhdHVyZX0KCVNldHMgdGhlIGZvbGQgbGV2ZWw6IEZvbGRzIHdpdGggYSBoaWdoZXIgbGV2ZWwgd2lsbCBiZSBjbG9zZWQuCglTZXR0aW5nIHRoaXMgb3B0aW9uIHRvIHplcm8gd2lsbCBjbG9zZSBhbGwgZm9sZHMuICBIaWdoZXIgbnVtYmVycyB3aWxsCgljbG9zZSBmZXdlciBmb2xkcy4KCVRoaXMgb3B0aW9uIGlzIHNldCBieSBjb21tYW5kcyBsaWtlIHx6bXwsIHx6TXwgYW5kIHx6UnwuCglTZWUgfGZvbGQtZm9sZGxldmVsfC4KCgkJCQkJCSonZm9sZGxldmVsc3RhcnQnKiAqJ2ZkbHMnKgonZm9sZGxldmVsc3RhcnQnICdmZGxzJwludW1iZXIgKGRlZmF1bHQ6IC0xKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2ZvbGRpbmd8CgkJCWZlYXR1cmV9CglTZXRzICdmb2xkbGV2ZWwnIHdoZW4gc3RhcnRpbmcgdG8gZWRpdCBhbm90aGVyIGJ1ZmZlciBpbiBhIHdpbmRvdy4KCVVzZWZ1bCB0byBhbHdheXMgc3RhcnQgZWRpdGluZyB3aXRoIGFsbCBmb2xkcyBjbG9zZWQgKHZhbHVlIHplcm8pLAoJc29tZSBmb2xkcyBjbG9zZWQgKG9uZSkgb3Igbm8gZm9sZHMgY2xvc2VkICg5OSkuCglUaGlzIGlzIGRvbmUgYmVmb3JlIHJlYWRpbmcgYW55IG1vZGVsaW5lLCB0aHVzIGEgc2V0dGluZyBpbiBhIG1vZGVsaW5lCglvdmVycnVsZXMgdGhpcyBvcHRpb24uICBTdGFydGluZyB0byBlZGl0IGEgZmlsZSBmb3IgfGRpZmYtbW9kZXwgYWxzbwoJaWdub3JlcyB0aGlzIG9wdGlvbiBhbmQgY2xvc2VzIGFsbCBmb2xkcy4KCUl0IGlzIGFsc28gZG9uZSBiZWZvcmUgQnVmUmVhZFByZSBhdXRvY29tbWFuZHMsIHRvIGFsbG93IGFuIGF1dG9jbWQgdG8KCW92ZXJydWxlIHRoZSAnZm9sZGxldmVsJyB2YWx1ZSBmb3Igc3BlY2lmaWMgZmlsZXMuCglXaGVuIHRoZSB2YWx1ZSBpcyBuZWdhdGl2ZSwgaXQgaXMgbm90IHVzZWQuCgoJCQkJCQkqJ2ZvbGRtYXJrZXInKiAqJ2ZtcicqICpFNTM2KgonZm9sZG1hcmtlcicgJ2ZtcicJc3RyaW5nIChkZWZhdWx0OiAie3t7LH19fSIpCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wKCQkJZmVhdHVyZX0KCVRoZSBzdGFydCBhbmQgZW5kIG1hcmtlciB1c2VkIHdoZW4gJ2ZvbGRtZXRob2QnIGlzICJtYXJrZXIiLiAgVGhlcmUKCW11c3QgYmUgb25lIGNvbW1hLCB3aGljaCBzZXBhcmF0ZXMgdGhlIHN0YXJ0IGFuZCBlbmQgbWFya2VyLiAgVGhlCgltYXJrZXIgaXMgYSBsaXRlcmFsIHN0cmluZyAoYSByZWd1bGFyIGV4cHJlc3Npb24gd291bGQgYmUgdG9vIHNsb3cpLgoJU2VlIHxmb2xkLW1hcmtlcnwuCgoJCQkJCQkqJ2ZvbGRtZXRob2QnKiAqJ2ZkbScqCidmb2xkbWV0aG9kJyAnZmRtJwlzdHJpbmcgKGRlZmF1bHQ6ICJtYW51YWwiKQoJCQlsb2NhbCB0byB3aW5kb3cKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2ZvbGRpbmd8CgkJCWZlYXR1cmV9CglUaGUga2luZCBvZiBmb2xkaW5nIHVzZWQgZm9yIHRoZSBjdXJyZW50IHdpbmRvdy4gIFBvc3NpYmxlIHZhbHVlczoKCXxmb2xkLW1hbnVhbHwJbWFudWFsCSAgICBGb2xkcyBhcmUgY3JlYXRlZCBtYW51YWxseS4KCXxmb2xkLWluZGVudHwJaW5kZW50CSAgICBMaW5lcyB3aXRoIGVxdWFsIGluZGVudCBmb3JtIGEgZm9sZC4KCXxmb2xkLWV4cHJ8CWV4cHIJICAgICdmb2xkZXhwcicgZ2l2ZXMgdGhlIGZvbGQgbGV2ZWwgb2YgYSBsaW5lLgoJfGZvbGQtbWFya2VyfAltYXJrZXIJICAgIE1hcmtlcnMgYXJlIHVzZWQgdG8gc3BlY2lmeSBmb2xkcy4KCXxmb2xkLXN5bnRheHwJc3ludGF4CSAgICBTeW50YXggaGlnaGxpZ2h0aW5nIGl0ZW1zIHNwZWNpZnkgZm9sZHMuCgl8Zm9sZC1kaWZmfAlkaWZmCSAgICBGb2xkIHRleHQgdGhhdCBpcyBub3QgY2hhbmdlZC4KCgkJCQkJCSonZm9sZG1pbmxpbmVzJyogKidmbWwnKgonZm9sZG1pbmxpbmVzJyAnZm1sJwludW1iZXIgKGRlZmF1bHQ6IDEpCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wKCQkJZmVhdHVyZX0KCVNldHMgdGhlIG1pbmltdW0gbnVtYmVyIG9mIHNjcmVlbiBsaW5lcyBmb3IgYSBmb2xkIHRvIGJlIGRpc3BsYXllZAoJY2xvc2VkLiAgQWxzbyBmb3IgbWFudWFsbHkgY2xvc2VkIGZvbGRzLgoJTm90ZSB0aGF0IHRoaXMgb25seSBoYXMgYW4gZWZmZWN0IG9mIHdoYXQgaXMgZGlzcGxheWVkLiAgQWZ0ZXIgdXNpbmcKCSJ6YyIgdG8gY2xvc2UgYSBmb2xkLCB3aGljaCBpcyBkaXNwbGF5ZWQgb3BlbiBiZWNhdXNlIGl0J3Mgc21hbGxlcgoJdGhhbiAnZm9sZG1pbmxpbmVzJywgYSBmb2xsb3dpbmcgInpjIiBtYXkgY2xvc2UgYSBjb250YWluaW5nIGZvbGQuCgoJCQkJCQkqJ2ZvbGRuZXN0bWF4JyogKidmZG4nKgonZm9sZG5lc3RtYXgnICdmZG4nCW51bWJlciAoZGVmYXVsdDogMjApCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wKCQkJZmVhdHVyZX0KCVNldHMgdGhlIG1heGltdW0gbmVzdGluZyBvZiBmb2xkcyBmb3IgdGhlICJpbmRlbnQiIGFuZCAic3ludGF4IgoJbWV0aG9kcy4gIFRoaXMgYXZvaWRzIHRoYXQgdG9vIG1hbnkgZm9sZHMgd2lsbCBiZSBjcmVhdGVkLiAgVXNpbmcgbW9yZQoJdGhhbiAyMCBkb2Vzbid0IHdvcmssIGJlY2F1c2UgdGhlIGludGVybmFsIGxpbWl0IGlzIDIwLgoKCQkJCQkJKidmb2xkb3BlbicqIConZmRvJyoKJ2ZvbGRvcGVuJyAnZmRvJwlzdHJpbmcgKGRlZmF1bHQ6ICJibG9jayxob3IsbWFyayxwZXJjZW50LHF1aWNrZml4LAoJCQkJCQkJICAgICBzZWFyY2gsdGFnLHVuZG8iKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2ZvbGRpbmd8CgkJCWZlYXR1cmV9CglTcGVjaWZpZXMgZm9yIHdoaWNoIHR5cGUgb2YgY29tbWFuZHMgZm9sZHMgd2lsbCBiZSBvcGVuZWQsIGlmIHRoZQoJY29tbWFuZCBtb3ZlcyB0aGUgY3Vyc29yIGludG8gYSBjbG9zZWQgZm9sZC4gIEl0IGlzIGEgY29tbWEgc2VwYXJhdGVkCglsaXN0IG9mIGl0ZW1zLgoJCWl0ZW0JCWNvbW1hbmRzIH4KCQlhbGwJCWFueQoJCWJsb2NrCQkiKCIsICJ7IiwgIltbIiwgIlt7IiwgZXRjLgoJCWhvcgkJaG9yaXpvbnRhbCBtb3ZlbWVudHM6ICJsIiwgInciLCAiZngiLCBldGMuCgkJaW5zZXJ0CQlhbnkgY29tbWFuZCBpbiBJbnNlcnQgbW9kZQoJCWp1bXAJCWZhciBqdW1wczogIkciLCAiZ2ciLCBldGMuCgkJbWFyawkJanVtcGluZyB0byBhIG1hcms6ICInbSIsIENUUkwtTywgZXRjLgoJCXBlcmNlbnQJCSIlIgoJCXF1aWNrZml4CSI6Y24iLCAiOmNyZXciLCAiOm1ha2UiLCBldGMuCgkJc2VhcmNoCQlzZWFyY2ggZm9yIGEgcGF0dGVybjogIi8iLCAibiIsICIqIiwgImdkIiwgZXRjLgoJCQkJKG5vdCBmb3IgYSBzZWFyY2ggcGF0dGVybiBpbiBhICI6IiBjb21tYW5kKQoJCXRhZwkJanVtcGluZyB0byBhIHRhZzogIjp0YSIsIENUUkwtVCwgZXRjLgoJCXVuZG8JCXVuZG8gb3IgcmVkbzogInUiIGFuZCBDVFJMLVIKCVdoZW4gdGhlIGNvbW1hbmQgaXMgcGFydCBvZiBhIG1hcHBpbmcgdGhpcyBvcHRpb24gaXMgbm90IHVzZWQuICBBZGQKCXRoZSB8enZ8IGNvbW1hbmQgdG8gdGhlIG1hcHBpbmcgdG8gZ2V0IHRoZSBzYW1lIGVmZmVjdC4KCVdoZW4gYSBtb3ZlbWVudCBjb21tYW5kIGlzIHVzZWQgZm9yIGFuIG9wZXJhdG9yIChlLmcuLCAiZGwiIG9yICJ5JSIpCgl0aGlzIG9wdGlvbiBpcyBub3QgdXNlZC4gIFRoaXMgbWVhbnMgdGhlIG9wZXJhdG9yIHdpbGwgaW5jbHVkZSB0aGUKCXdob2xlIGNsb3NlZCBmb2xkLgoJTm90ZSB0aGF0IHZlcnRpY2FsIG1vdmVtZW50cyBhcmUgbm90IGhlcmUsIGJlY2F1c2UgaXQgd291bGQgbWFrZSBpdAoJdmVyeSBkaWZmaWN1bHQgdG8gbW92ZSBvbnRvIGEgY2xvc2VkIGZvbGQuCglJbiBpbnNlcnQgbW9kZSB0aGUgZm9sZHMgY29udGFpbmluZyB0aGUgY3Vyc29yIHdpbGwgYWx3YXlzIGJlIG9wZW4KCXdoZW4gdGV4dCBpcyBpbnNlcnRlZC4KCVRvIGNsb3NlIGZvbGRzIHlvdSBjYW4gcmUtYXBwbHkgJ2ZvbGRsZXZlbCcgd2l0aCB0aGUgfHp4fCBjb21tYW5kIG9yCglzZXQgdGhlICdmb2xkY2xvc2UnIG9wdGlvbiB0byAiYWxsIi4KCgkJCQkJCSonZm9sZHRleHQnKiAqJ2ZkdCcqCidmb2xkdGV4dCcgJ2ZkdCcJc3RyaW5nIChkZWZhdWx0OiAiZm9sZHRleHQoKSIpCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrZm9sZGluZ3wKCQkJZmVhdHVyZX0KCUFuIGV4cHJlc3Npb24gd2hpY2ggaXMgdXNlZCB0byBzcGVjaWZ5IHRoZSB0ZXh0IGRpc3BsYXllZCBmb3IgYSBjbG9zZWQKCWZvbGQuICBTZWUgfGZvbGQtZm9sZHRleHR8LgoKCQkJCQkqJ2Zvcm1hdG9wdGlvbnMnKiAqJ2ZvJyoKJ2Zvcm1hdG9wdGlvbnMnICdmbycJc3RyaW5nIChWaW0gZGVmYXVsdDogInRjcSIsIFZpIGRlZmF1bHQ6ICJ2dCIpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJVGhpcyBpcyBhIHNlcXVlbmNlIG9mIGxldHRlcnMgd2hpY2ggZGVzY3JpYmVzIGhvdyBhdXRvbWF0aWMKCWZvcm1hdHRpbmcgaXMgdG8gYmUgZG9uZS4gIFNlZSB8Zm8tdGFibGV8LiAgV2hlbiB0aGUgJ3Bhc3RlJyBvcHRpb24gaXMKCW9uLCBubyBmb3JtYXR0aW5nIGlzIGRvbmUgKGxpa2UgJ2Zvcm1hdG9wdGlvbnMnIGlzIGVtcHR5KS4gIENvbW1hcyBjYW4KCWJlIGluc2VydGVkIGZvciByZWFkYWJpbGl0eS4KCVRvIGF2b2lkIHByb2JsZW1zIHdpdGggZmxhZ3MgdGhhdCBhcmUgYWRkZWQgaW4gdGhlIGZ1dHVyZSwgdXNlIHRoZQoJIis9IiBhbmQgIi09IiBmZWF0dXJlIG9mICI6c2V0IiB8YWRkLW9wdGlvbi1mbGFnc3wuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyBzZXQgdG8gdGhlIFZpIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMKCXNldCBhbmQgdG8gdGhlIFZpbSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzIHJlc2V0LgoKCQkJCQkqJ2Zvcm1hdGxpc3RwYXQnKiAqJ2ZscCcqCidmb3JtYXRsaXN0cGF0JyAnZmxwJwlzdHJpbmcgKGRlZmF1bHQ6ICJeXHMqXGRcK1tcXTouKX1cdCBdXHMqIikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CglBIHBhdHRlcm4gdGhhdCBpcyB1c2VkIHRvIHJlY29nbml6ZSBhIGxpc3QgaGVhZGVyLiAgVGhpcyBpcyB1c2VkIGZvcgoJdGhlICJuIiBmbGFnIGluICdmb3JtYXRvcHRpb25zJy4KCVRoZSBwYXR0ZXJuIG11c3QgbWF0Y2ggZXhhY3RseSB0aGUgdGV4dCB0aGF0IHdpbGwgYmUgdGhlIGluZGVudCBmb3IKCXRoZSBsaW5lIGJlbG93IGl0LiAgWW91IGNhbiB1c2UgfC9cemV8IHRvIG1hcmsgdGhlIGVuZCBvZiB0aGUgbWF0Y2gKCXdoaWxlIHN0aWxsIGNoZWNraW5nIG1vcmUgY2hhcmFjdGVycy4gIFRoZXJlIG11c3QgYmUgYSBjaGFyYWN0ZXIKCWZvbGxvd2luZyB0aGUgcGF0dGVybiwgd2hlbiBpdCBtYXRjaGVzIHRoZSB3aG9sZSBsaW5lIGl0IGlzIGhhbmRsZWQKCWxpa2UgdGhlcmUgaXMgbm8gbWF0Y2guCglUaGUgZGVmYXVsdCByZWNvZ25pemVzIGEgbnVtYmVyLCBmb2xsb3dlZCBieSBhbiBvcHRpb25hbCBwdW5jdHVhdGlvbgoJY2hhcmFjdGVyIGFuZCB3aGl0ZSBzcGFjZS4KCgkJCQkJCSonZm9ybWF0cHJnJyogKidmcCcqCidmb3JtYXRwcmcnICdmcCcJc3RyaW5nIChkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVRoZSBuYW1lIG9mIGFuIGV4dGVybmFsIHByb2dyYW0gdGhhdCB3aWxsIGJlIHVzZWQgdG8gZm9ybWF0IHRoZSBsaW5lcwoJc2VsZWN0ZWQgd2l0aCB0aGUgImdxIiBjb21tYW5kLiAgVGhlIHByb2dyYW0gbXVzdCB0YWtlIHRoZSBpbnB1dCBvbgoJc3RkaW4gYW5kIHByb2R1Y2UgdGhlIG91dHB1dCBvbiBzdGRvdXQuICBUaGUgVW5peCBwcm9ncmFtICJmbXQiIGlzCglzdWNoIGEgcHJvZ3JhbS4gIElmIHRoaXMgb3B0aW9uIGlzIGFuIGVtcHR5IHN0cmluZywgdGhlIGludGVybmFsCglmb3JtYXQgZnVuY3Rpb24gd2lsbCBiZSB1c2VkIHxDLWluZGVudGluZ3wuICBFbnZpcm9ubWVudCB2YXJpYWJsZXMgYXJlCglleHBhbmRlZCB8OnNldF9lbnZ8LiAgU2VlIHxvcHRpb24tYmFja3NsYXNofCBhYm91dCBpbmNsdWRpbmcgc3BhY2VzCglhbmQgYmFja3NsYXNoZXMuCglUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCgkJCQkJCQkqJ2ZzeW5jJyogKidmcycqCidmc3luYycgJ2ZzJwkJYm9vbGVhbgkoZGVmYXVsdCBvbikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglXaGVuIG9uLCB0aGUgbGlicmFyeSBmdW5jdGlvbiBmc3luYygpIHdpbGwgYmUgY2FsbGVkIGFmdGVyIHdyaXRpbmcgYQoJZmlsZS4gIFRoaXMgd2lsbCBmbHVzaCBhIGZpbGUgdG8gZGlzaywgZW5zdXJpbmcgdGhhdCBpdCBpcyBzYWZlbHkKCXdyaXR0ZW4gZXZlbiBvbiBmaWxlc3lzdGVtcyB3aGljaCBkbyBtZXRhZGF0YS1vbmx5IGpvdXJuYWxpbmcuICBUaGlzCgl3aWxsIGZvcmNlIHRoZSBoYXJkZHJpdmUgdG8gc3BpbiB1cCBvbiBMaW51eCBzeXN0ZW1zIHJ1bm5pbmcgaW4gbGFwdG9wCgltb2RlLCBzbyBpdCBtYXkgYmUgdW5kZXNpcmFibGUgaW4gc29tZSBzaXR1YXRpb25zLiAgQmUgd2FybmVkIHRoYXQKCXR1cm5pbmcgdGhpcyBvZmYgaW5jcmVhc2VzIHRoZSBjaGFuY2VzIG9mIGRhdGEgbG9zcyBhZnRlciBhIGNyYXNoLiAgT24KCXN5c3RlbXMgd2l0aG91dCBhbiBmc3luYygpIGltcGxlbWVudGF0aW9uLCB0aGlzIHZhcmlhYmxlIGlzIGFsd2F5cwoJb2ZmLgoJQWxzbyBzZWUgJ3N3YXBzeW5jJyBmb3IgY29udHJvbGxpbmcgZnN5bmMoKSBvbiBzd2FwIGZpbGVzLgoKCQkJCSAgIConZ2RlZmF1bHQnKiAqJ2dkJyogKidub2dkZWZhdWx0JyogKidub2dkJyoKJ2dkZWZhdWx0JyAnZ2QnCQlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglXaGVuIG9uLCB0aGUgIjpzdWJzdGl0dXRlIiBmbGFnICdnJyBpcyBkZWZhdWx0IG9uLiAgVGhpcyBtZWFucyB0aGF0CglhbGwgbWF0Y2hlcyBpbiBhIGxpbmUgYXJlIHN1YnN0aXR1dGVkIGluc3RlYWQgb2Ygb25lLiAgV2hlbiBhICdnJyBmbGFnCglpcyBnaXZlbiB0byBhICI6c3Vic3RpdHV0ZSIgY29tbWFuZCwgdGhpcyB3aWxsIHRvZ2dsZSB0aGUgc3Vic3RpdHV0aW9uCglvZiBhbGwgb3Igb25lIG1hdGNoLiAgU2VlIHxjb21wbGV4LWNoYW5nZXwuCgoJCWNvbW1hbmQJCSdnZGVmYXVsdCcgb24JJ2dkZWZhdWx0JyBvZmYJfgoJCTpzLy8vCQkgIHN1YnN0LiBhbGwJICBzdWJzdC4gb25lCgkJOnMvLy9nCQkgIHN1YnN0LiBvbmUJICBzdWJzdC4gYWxsCgkJOnMvLy9nZwkJICBzdWJzdC4gYWxsCSAgc3Vic3QuIG9uZQoKCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHJlc2V0IHdoZW4gJ2NvbXBhdGlibGUnIGlzIHNldC4KCgkJCQkJCSonZ3JlcGZvcm1hdCcqIConZ2ZtJyoKJ2dyZXBmb3JtYXQnICdnZm0nCXN0cmluZwkoZGVmYXVsdCAiJWY6JWwlbSwlZiAgJWwlbSIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJRm9ybWF0IHRvIHJlY29nbml6ZSBmb3IgdGhlICI6Z3JlcCIgY29tbWFuZCBvdXRwdXQuCglUaGlzIGlzIGEgc2NhbmYtbGlrZSBzdHJpbmcgdGhhdCB1c2VzIHRoZSBzYW1lIGZvcm1hdCBhcyB0aGUKCSdlcnJvcmZvcm1hdCcgb3B0aW9uOiBzZWUgfGVycm9yZm9ybWF0fC4KCgkJCQkJCSonZ3JlcHByZycqIConZ3AnKgonZ3JlcHByZycgJ2dwJwkJc3RyaW5nCShkZWZhdWx0ICJncmVwIC1uICIsCgkJCQkJVW5peDogImdyZXAgLW4gJCogL2Rldi9udWxsIiwKCQkJCQlXaW4zMjogImZpbmRzdHIgL24iIG9yICJncmVwIC1uIiwKCQkJCQkJICAgICAgVk1TOiAiU0VBUkNIL05VTUJFUlMgIikKCQkJZ2xvYmFsIG9yIGxvY2FsIHRvIGJ1ZmZlciB8Z2xvYmFsLWxvY2FsfAoJCQl7bm90IGluIFZpfQoJUHJvZ3JhbSB0byB1c2UgZm9yIHRoZSB8OmdyZXB8IGNvbW1hbmQuICBUaGlzIG9wdGlvbiBtYXkgY29udGFpbiAnJScKCWFuZCAnIycgY2hhcmFjdGVycywgd2hpY2ggYXJlIGV4cGFuZGVkIGxpa2Ugd2hlbiB1c2VkIGluIGEgY29tbWFuZC0KCWxpbmUuICBUaGUgcGxhY2Vob2xkZXIgIiQqIiBpcyBhbGxvd2VkIHRvIHNwZWNpZnkgd2hlcmUgdGhlIGFyZ3VtZW50cwoJd2lsbCBiZSBpbmNsdWRlZC4gIEVudmlyb25tZW50IHZhcmlhYmxlcyBhcmUgZXhwYW5kZWQgfDpzZXRfZW52fC4gIFNlZQoJfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0IGluY2x1ZGluZyBzcGFjZXMgYW5kIGJhY2tzbGFzaGVzLgoJV2hlbiB5b3VyICJncmVwIiBhY2NlcHRzIHRoZSAiLUgiIGFyZ3VtZW50LCB1c2UgdGhpcyB0byBtYWtlICI6Z3JlcCIKCWFsc28gd29yayB3ZWxsIHdpdGggYSBzaW5nbGUgZmlsZTogPgoJCTpzZXQgZ3JlcHByZz1ncmVwXCAtbkgKPAlTcGVjaWFsIHZhbHVlOiBXaGVuICdncmVwcHJnJyBpcyBzZXQgdG8gImludGVybmFsIiB0aGUgfDpncmVwfCBjb21tYW5kCgl3b3JrcyBsaWtlIHw6dmltZ3JlcHwgYW5kIHw6Z3JlcGFkZHwgbGlrZSB8OnZpbWdyZXBhZGR8LgoJU2VlIGFsc28gdGhlIHNlY3Rpb24gfDptYWtlX21ha2Vwcmd8LCBzaW5jZSBtb3N0IG9mIHRoZSBjb21tZW50cyB0aGVyZQoJYXBwbHkgZXF1YWxseSB0byAnZ3JlcHByZycuCglGb3IgV2luMzIsIHRoZSBkZWZhdWx0IGlzICJmaW5kc3RyIC9uIiBpZiAiZmluZHN0ci5leGUiIGNhbiBiZSBmb3VuZCwKCW90aGVyd2lzZSBpdCdzICJncmVwIC1uIi4KCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJKidndWljdXJzb3InKiAqJ2djcicqICpFNTQ1KiAqRTU0NiogKkU1NDgqICpFNTQ5KgonZ3VpY3Vyc29yJyAnZ2NyJwlzdHJpbmcJKGRlZmF1bHQgIm4tdi1jOmJsb2NrLUN1cnNvci9sQ3Vyc29yLAoJCQkJCXZlOnZlcjM1LUN1cnNvciwKCQkJCQlvOmhvcjUwLUN1cnNvciwKCQkJCQlpLWNpOnZlcjI1LUN1cnNvci9sQ3Vyc29yLAoJCQkJCXItY3I6aG9yMjAtQ3Vyc29yL2xDdXJzb3IsCgkJCQkJc206YmxvY2stQ3Vyc29yCgkJCQkJLWJsaW5rd2FpdDE3NS1ibGlua29mZjE1MC1ibGlua29uMTc1IiwKCQkJCWZvciBNUy1ET1MgYW5kIFdpbjMyIGNvbnNvbGU6CgkJCQkJIm4tdi1jOmJsb2NrLG86aG9yNTAsaS1jaTpob3IxNSwKCQkJCQlyLWNyOmhvcjMwLHNtOmJsb2NrIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggR1VJIGVuYWJsZWQsIGFuZAoJCQlmb3IgTVMtRE9TIGFuZCBXaW4zMiBjb25zb2xlfQoJVGhpcyBvcHRpb24gdGVsbHMgVmltIHdoYXQgdGhlIGN1cnNvciBzaG91bGQgbG9vayBsaWtlIGluIGRpZmZlcmVudAoJbW9kZXMuICBJdCBmdWxseSB3b3JrcyBpbiB0aGUgR1VJLiAgSW4gYW4gTVNET1Mgb3IgV2luMzIgY29uc29sZSwgb25seQoJdGhlIGhlaWdodCBvZiB0aGUgY3Vyc29yIGNhbiBiZSBjaGFuZ2VkLiAgVGhpcyBjYW4gYmUgZG9uZSBieQoJc3BlY2lmeWluZyBhIGJsb2NrIGN1cnNvciwgb3IgYSBwZXJjZW50YWdlIGZvciBhIHZlcnRpY2FsIG9yCglob3Jpem9udGFsIGN1cnNvci4KCUZvciBhIGNvbnNvbGUgdGhlICd0X1NJJyBhbmQgJ3RfRUknIGVzY2FwZSBzZXF1ZW5jZXMgYXJlIHVzZWQuCgoJVGhlIG9wdGlvbiBpcyBhIGNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIHBhcnRzLiAgRWFjaCBwYXJ0IGNvbnNpc3Qgb2YgYQoJbW9kZS1saXN0IGFuZCBhbiBhcmd1bWVudC1saXN0OgoJCW1vZGUtbGlzdDphcmd1bWVudC1saXN0LG1vZGUtbGlzdDphcmd1bWVudC1saXN0LC4uCglUaGUgbW9kZS1saXN0IGlzIGEgZGFzaCBzZXBhcmF0ZWQgbGlzdCBvZiB0aGVzZSBtb2RlczoKCQluCU5vcm1hbCBtb2RlCgkJdglWaXN1YWwgbW9kZQoJCXZlCVZpc3VhbCBtb2RlIHdpdGggJ3NlbGVjdGlvbicgImV4Y2x1c2l2ZSIgKHNhbWUgYXMgJ3YnLAoJCQlpZiBub3Qgc3BlY2lmaWVkKQoJCW8JT3BlcmF0b3ItcGVuZGluZyBtb2RlCgkJaQlJbnNlcnQgbW9kZQoJCXIJUmVwbGFjZSBtb2RlCgkJYwlDb21tYW5kLWxpbmUgTm9ybWFsIChhcHBlbmQpIG1vZGUKCQljaQlDb21tYW5kLWxpbmUgSW5zZXJ0IG1vZGUKCQljcglDb21tYW5kLWxpbmUgUmVwbGFjZSBtb2RlCgkJc20Jc2hvd21hdGNoIGluIEluc2VydCBtb2RlCgkJYQlhbGwgbW9kZXMKCVRoZSBhcmd1bWVudC1saXN0IGlzIGEgZGFzaCBzZXBhcmF0ZWQgbGlzdCBvZiB0aGVzZSBhcmd1bWVudHM6CgkJaG9ye059CWhvcml6b250YWwgYmFyLCB7Tn0gcGVyY2VudCBvZiB0aGUgY2hhcmFjdGVyIGhlaWdodAoJCXZlcntOfQl2ZXJ0aWNhbCBiYXIsIHtOfSBwZXJjZW50IG9mIHRoZSBjaGFyYWN0ZXIgd2lkdGgKCQlibG9jawlibG9jayBjdXJzb3IsIGZpbGxzIHRoZSB3aG9sZSBjaGFyYWN0ZXIKCQkJW29ubHkgb25lIG9mIHRoZSBhYm92ZSB0aHJlZSBzaG91bGQgYmUgcHJlc2VudF0KCQlibGlua3dhaXR7Tn0JCQkJKmN1cnNvci1ibGlua2luZyoKCQlibGlua29ue059CgkJYmxpbmtvZmZ7Tn0KCQkJYmxpbmsgdGltZXMgZm9yIGN1cnNvcjogYmxpbmt3YWl0IGlzIHRoZSBkZWxheSBiZWZvcmUKCQkJdGhlIGN1cnNvciBzdGFydHMgYmxpbmtpbmcsIGJsaW5rb24gaXMgdGhlIHRpbWUgdGhhdAoJCQl0aGUgY3Vyc29yIGlzIHNob3duIGFuZCBibGlua29mZiBpcyB0aGUgdGltZSB0aGF0IHRoZQoJCQljdXJzb3IgaXMgbm90IHNob3duLiAgVGhlIHRpbWVzIGFyZSBpbiBtc2VjLiAgV2hlbiBvbmUKCQkJb2YgdGhlIG51bWJlcnMgaXMgemVybywgdGhlcmUgaXMgbm8gYmxpbmtpbmcuICBUaGUKCQkJZGVmYXVsdCBpczogImJsaW5rd2FpdDcwMC1ibGlua29uNDAwLWJsaW5rb2ZmMjUwIi4KCQkJVGhlc2UgbnVtYmVycyBhcmUgdXNlZCBmb3IgYSBtaXNzaW5nIGVudHJ5LiAgVGhpcwoJCQltZWFucyB0aGF0IGJsaW5raW5nIGlzIGVuYWJsZWQgYnkgZGVmYXVsdC4gIFRvIHN3aXRjaAoJCQlibGlua2luZyBvZmYgeW91IGNhbiB1c2UgImJsaW5rb24wIi4gIFRoZSBjdXJzb3Igb25seQoJCQlibGlua3Mgd2hlbiBWaW0gaXMgd2FpdGluZyBmb3IgaW5wdXQsIG5vdCB3aGlsZQoJCQlleGVjdXRpbmcgYSBjb21tYW5kLgoJCQlUbyBtYWtlIHRoZSBjdXJzb3IgYmxpbmsgaW4gYW4geHRlcm0sIHNlZQoJCQl8eHRlcm0tYmxpbmt8LgoJCXtncm91cC1uYW1lfQoJCQlhIGhpZ2hsaWdodCBncm91cCBuYW1lLCB0aGF0IHNldHMgdGhlIGNvbG9yIGFuZCBmb250CgkJCWZvciB0aGUgY3Vyc29yCgkJe2dyb3VwLW5hbWV9L3tncm91cC1uYW1lfQoJCQlUd28gaGlnaGxpZ2h0IGdyb3VwIG5hbWVzLCB0aGUgZmlyc3QgaXMgdXNlZCB3aGVuCgkJCW5vIGxhbmd1YWdlIG1hcHBpbmdzIGFyZSB1c2VkLCB0aGUgb3RoZXIgd2hlbiB0aGV5CgkJCWFyZS4gfGxhbmd1YWdlLW1hcHBpbmd8CgoJRXhhbXBsZXMgb2YgcGFydHM6CgkgICBuLWMtdjpibG9jay1uQ3Vyc29yCWluIE5vcm1hbCwgQ29tbWFuZC1saW5lIGFuZCBWaXN1YWwgbW9kZSwgdXNlIGEKCQkJCWJsb2NrIGN1cnNvciB3aXRoIGNvbG9ycyBmcm9tIHRoZSAibkN1cnNvciIKCQkJCWhpZ2hsaWdodCBncm91cAoJICAgaS1jaTp2ZXIzMC1pQ3Vyc29yLWJsaW5rd2FpdDMwMC1ibGlua29uMjAwLWJsaW5rb2ZmMTUwCgkJCQlJbiBJbnNlcnQgYW5kIENvbW1hbmQtbGluZSBJbnNlcnQgbW9kZSwgdXNlIGEKCQkJCTMwJSB2ZXJ0aWNhbCBiYXIgY3Vyc29yIHdpdGggY29sb3JzIGZyb20gdGhlCgkJCQkiaUN1cnNvciIgaGlnaGxpZ2h0IGdyb3VwLiAgQmxpbmsgYSBiaXQKCQkJCWZhc3Rlci4KCglUaGUgJ2EnIG1vZGUgaXMgZGlmZmVyZW50LiAgSXQgd2lsbCBzZXQgdGhlIGdpdmVuIGFyZ3VtZW50LWxpc3QgZm9yCglhbGwgbW9kZXMuICBJdCBkb2VzIG5vdCByZXNldCBhbnl0aGluZyB0byBkZWZhdWx0cy4gIFRoaXMgY2FuIGJlIHVzZWQKCXRvIGRvIGEgY29tbW9uIHNldHRpbmcgZm9yIGFsbCBtb2Rlcy4gIEZvciBleGFtcGxlLCB0byBzd2l0Y2ggb2ZmCglibGlua2luZzogImE6YmxpbmtvbjAiCgoJRXhhbXBsZXMgb2YgY3Vyc29yIGhpZ2hsaWdodGluZzogPgoJICAgIDpoaWdobGlnaHQgQ3Vyc29yIGd1aT1yZXZlcnNlIGd1aWZnPU5PTkUgZ3VpYmc9Tk9ORQoJICAgIDpoaWdobGlnaHQgQ3Vyc29yIGd1aT1OT05FIGd1aWZnPWJnIGd1aWJnPWZnCjwKCQkJCQkqJ2d1aWZvbnQnKiAqJ2dmbicqCgkJCQkJCSAgICpFMjM1KiAqRTU5NiogKkU2MTAqICpFNjExKgonZ3VpZm9udCcgJ2dmbicJCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggR1VJIGVuYWJsZWR9CglUaGlzIGlzIGEgbGlzdCBvZiBmb250cyB3aGljaCB3aWxsIGJlIHVzZWQgZm9yIHRoZSBHVUkgdmVyc2lvbiBvZiBWaW0uCglJbiBpdHMgc2ltcGxlc3QgZm9ybSB0aGUgdmFsdWUgaXMganVzdCBvbmUgZm9udCBuYW1lLiAgV2hlbgoJdGhlIGZvbnQgY2Fubm90IGJlIGZvdW5kIHlvdSB3aWxsIGdldCBhbiBlcnJvciBtZXNzYWdlLiAgVG8gdHJ5IG90aGVyCglmb250IG5hbWVzIGEgbGlzdCBjYW4gYmUgc3BlY2lmaWVkLCBmb250IG5hbWVzIHNlcGFyYXRlZCB3aXRoIGNvbW1hcy4KCVRoZSBmaXJzdCB2YWxpZCBmb250IGlzIHVzZWQuCgoJT24gc3lzdGVtcyB3aGVyZSAnZ3VpZm9udHNldCcgaXMgc3VwcG9ydGVkIChYMTEpIGFuZCAnZ3VpZm9udHNldCcgaXMKCW5vdCBlbXB0eSwgdGhlbiAnZ3VpZm9udCcgaXMgbm90IHVzZWQuCgoJU3BhY2VzIGFmdGVyIGEgY29tbWEgYXJlIGlnbm9yZWQuICBUbyBpbmNsdWRlIGEgY29tbWEgaW4gYSBmb250IG5hbWUKCXByZWNlZGUgaXQgd2l0aCBhIGJhY2tzbGFzaC4gIFNldHRpbmcgYW4gb3B0aW9uIHJlcXVpcmVzIGFuIGV4dHJhCgliYWNrc2xhc2ggYmVmb3JlIGEgc3BhY2UgYW5kIGEgYmFja3NsYXNoLiAgU2VlIGFsc28KCXxvcHRpb24tYmFja3NsYXNofC4gIEZvciBleGFtcGxlOiA+CgkgICAgOnNldCBndWlmb250PVNjcmVlbjE1LFwgN3gxMyxmb250XFwsd2l0aFxcLGNvbW1hcwo8CXdpbGwgbWFrZSBWaW0gdHJ5IHRvIHVzZSB0aGUgZm9udCAiU2NyZWVuMTUiIGZpcnN0LCBhbmQgaWYgaXQgZmFpbHMgaXQKCXdpbGwgdHJ5IHRvIHVzZSAiN3gxMyIgYW5kIHRoZW4gImZvbnQsd2l0aCxjb21tYXMiIGluc3RlYWQuCgoJSWYgbm9uZSBvZiB0aGUgZm9udHMgY2FuIGJlIGxvYWRlZCwgVmltIHdpbGwga2VlcCB0aGUgY3VycmVudCBzZXR0aW5nLgoJSWYgYW4gZW1wdHkgZm9udCBsaXN0IGlzIGdpdmVuLCBWaW0gd2lsbCB0cnkgdXNpbmcgb3RoZXIgcmVzb3VyY2UKCXNldHRpbmdzIChmb3IgWCwgaXQgd2lsbCB1c2UgdGhlIFZpbS5mb250IHJlc291cmNlKSwgYW5kIGZpbmFsbHkgaXQKCXdpbGwgdHJ5IHNvbWUgYnVpbHRpbiBkZWZhdWx0IHdoaWNoIHNob3VsZCBhbHdheXMgYmUgdGhlcmUgKCI3eDEzIiBpbgoJdGhlIGNhc2Ugb2YgWCkuICBUaGUgZm9udCBuYW1lcyBnaXZlbiBzaG91bGQgYmUgIm5vcm1hbCIgZm9udHMuICBWaW0KCXdpbGwgdHJ5IHRvIGZpbmQgdGhlIHJlbGF0ZWQgYm9sZCBhbmQgaXRhbGljIGZvbnRzLgoKCUZvciBXaW4zMiwgR1RLLCBNYWMgT1MgYW5kIFBob3RvbjogPgoJICAgIDpzZXQgZ3VpZm9udD0qCjwJd2lsbCBicmluZyB1cCBhIGZvbnQgcmVxdWVzdGVyLCB3aGVyZSB5b3UgY2FuIHBpY2sgdGhlIGZvbnQgeW91IHdhbnQuCgoJVGhlIGZvbnQgbmFtZSBkZXBlbmRzIG9uIHRoZSBHVUkgdXNlZC4gIFNlZSB8c2V0dGluZy1ndWlmb250fCBmb3IgYQoJd2F5IHRvIHNldCAnZ3VpZm9udCcgZm9yIHZhcmlvdXMgc3lzdGVtcy4KCglGb3IgdGhlIEdUSysgMiBHVUkgdGhlIGZvbnQgbmFtZSBsb29rcyBsaWtlIHRoaXM6ID4KCSAgICA6c2V0IGd1aWZvbnQ9QW5kYWxlXCBNb25vXCAxMQo8CVRoYXQncyBhbGwuICBYTEZEcyBhcmUgbm8gbG9uZ2VyIGFjY2VwdGVkLgoKCUZvciBNYWMgT1NYIHlvdSBjYW4gdXNlIHNvbWV0aGluZyBsaWtlIHRoaXM6ID4KCSAgICA6c2V0IGd1aWZvbnQ9TW9uYWNvOmgxMAo8CQkJCQkJCQkqRTIzNioKCU5vdGUgdGhhdCB0aGUgZm9udHMgbXVzdCBiZSBtb25vLXNwYWNlZCAoYWxsIGNoYXJhY3RlcnMgaGF2ZSB0aGUgc2FtZQoJd2lkdGgpLiAgQW4gZXhjZXB0aW9uIGlzIEdUSyAyOiBhbGwgZm9udHMgYXJlIGFjY2VwdGVkLCBidXQKCW1vbm8tc3BhY2VkIGZvbnRzIGxvb2sgYmVzdC4KCglUbyBwcmV2aWV3IGEgZm9udCBvbiBYMTEsIHlvdSBtaWdodCBiZSBhYmxlIHRvIHVzZSB0aGUgInhmb250c2VsIgoJcHJvZ3JhbS4gIFRoZSAieGxzZm9udHMiIHByb2dyYW0gZ2l2ZXMgYSBsaXN0IG9mIGFsbCBhdmFpbGFibGUgZm9udHMuCgoJRm9yIHRoZSBXaW4zMiBHVUkJCQkJCSpFMjQ0KiAqRTI0NSoKCS0gdGFrZXMgdGhlc2Ugb3B0aW9ucyBpbiB0aGUgZm9udCBuYW1lOgoJCWhYWCAtIGhlaWdodCBpcyBYWCAocG9pbnRzLCBjYW4gYmUgZmxvYXRpbmctcG9pbnQpCgkJd1hYIC0gd2lkdGggaXMgWFggKHBvaW50cywgY2FuIGJlIGZsb2F0aW5nLXBvaW50KQoJCWIgICAtIGJvbGQKCQlpICAgLSBpdGFsaWMKCQl1ICAgLSB1bmRlcmxpbmUKCQlzICAgLSBzdHJpa2VvdXQKCQljWFggLSBjaGFyYWN0ZXIgc2V0IFhYLiAgVmFsaWQgY2hhcnNldHMgYXJlOiBBTlNJLCBBUkFCSUMsCgkJICAgICAgQkFMVElDLCBDSElORVNFQklHNSwgREVGQVVMVCwgRUFTVEVVUk9QRSwgR0IyMzEyLCBHUkVFSywKCQkgICAgICBIQU5HRVVMLCBIRUJSRVcsIEpPSEFCLCBNQUMsIE9FTSwgUlVTU0lBTiwgU0hJRlRKSVMsCgkJICAgICAgU1lNQk9MLCBUSEFJLCBUVVJLSVNILCBWSUVUTkFNRVNFIEFOU0kgYW5kIEJBTFRJQy4KCQkgICAgICBOb3JtYWxseSB5b3Ugd291bGQgdXNlICJjREVGQVVMVCIuCgoJICBVc2UgYSAnOicgdG8gc2VwYXJhdGUgdGhlIG9wdGlvbnMuCgktIEEgJ18nIGNhbiBiZSB1c2VkIGluIHRoZSBwbGFjZSBvZiBhIHNwYWNlLCBzbyB5b3UgZG9uJ3QgbmVlZCB0byB1c2UKCSAgYmFja3NsYXNoZXMgdG8gZXNjYXBlIHRoZSBzcGFjZXMuCgktIEV4YW1wbGVzOiA+CgkgICAgOnNldCBndWlmb250PWNvdXJpZXJfbmV3OmgxMjp3NTpiOmNSVVNTSUFOCgkgICAgOnNldCBndWlmb250PUFuZGFsZV9Nb25vOmg3LjU6dzQuNQo8CVNlZSBhbHNvIHxmb250LXNpemVzfC4KCgkJCQkJKidndWlmb250c2V0JyogKidnZnMnKgoJCQkJCSpFMjUwKiAqRTI1MiogKkUyMzQqICpFNTk3KiAqRTU5OCoKJ2d1aWZvbnRzZXQnICdnZnMnCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggR1VJIGVuYWJsZWQgYW5kCgkJCXdpdGggdGhlIHwreGZvbnRzZXR8IGZlYXR1cmV9CgkJCXtub3QgYXZhaWxhYmxlIGluIHRoZSBHVEsrIDIgR1VJfQoJV2hlbiBub3QgZW1wdHksIHNwZWNpZmllcyB0d28gKG9yIG1vcmUpIGZvbnRzIHRvIGJlIHVzZWQuICBUaGUgZmlyc3QKCW9uZSBmb3Igbm9ybWFsIEVuZ2xpc2gsIHRoZSBzZWNvbmQgb25lIGZvciB5b3VyIHNwZWNpYWwgbGFuZ3VhZ2UuICBTZWUKCXx4Zm9udHNldHwuCglTZXR0aW5nIHRoaXMgb3B0aW9uIGFsc28gbWVhbnMgdGhhdCBhbGwgZm9udCBuYW1lcyB3aWxsIGJlIGhhbmRsZWQgYXMKCWEgZm9udHNldCBuYW1lLiAgQWxzbyB0aGUgb25lcyB1c2VkIGZvciB0aGUgImZvbnQiIGFyZ3VtZW50IG9mIHRoZQoJfDpoaWdobGlnaHR8IGNvbW1hbmQuCglUaGUgZm9udHMgbXVzdCBtYXRjaCB3aXRoIHRoZSBjdXJyZW50IGxvY2FsZS4gIElmIGZvbnRzIGZvciB0aGUKCWNoYXJhY3RlciBzZXRzIHRoYXQgdGhlIGN1cnJlbnQgbG9jYWxlIHVzZXMgYXJlIG5vdCBpbmNsdWRlZCwgc2V0dGluZwoJJ2d1aWZvbnRzZXQnIHdpbGwgZmFpbC4KCU5vdGUgdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiAnZ3VpZm9udCcgYW5kICdndWlmb250c2V0JzogSW4gJ2d1aWZvbnQnCgl0aGUgY29tbWEtc2VwYXJhdGVkIG5hbWVzIGFyZSBhbHRlcm5hdGl2ZSBuYW1lcywgb25lIG9mIHdoaWNoIHdpbGwgYmUKCXVzZWQuICBJbiAnZ3VpZm9udHNldCcgdGhlIHdob2xlIHN0cmluZyBpcyBvbmUgZm9udHNldCBuYW1lLAoJaW5jbHVkaW5nIHRoZSBjb21tYXMuICBJdCBpcyBub3QgcG9zc2libGUgdG8gc3BlY2lmeSBhbHRlcm5hdGl2ZQoJZm9udHNldCBuYW1lcy4KCVRoaXMgZXhhbXBsZSB3b3JrcyBvbiBtYW55IFgxMSBzeXN0ZW1zOiA+CgkJOnNldCBndWlmb250c2V0PS0qLSotbWVkaXVtLXItbm9ybWFsLS0xNi0qLSotKi1jLSotKi0qCjwKCQkJCSonZ3VpZm9udHdpZGUnKiAqJ2dmdycqICpFMjMxKiAqRTUzMyogKkU1MzQqCidndWlmb250d2lkZScgJ2dmdycJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCBHVUkgZW5hYmxlZH0KCVdoZW4gbm90IGVtcHR5LCBzcGVjaWZpZXMgYSBjb21tYS1zZXBhcmF0ZWQgbGlzdCBvZiBmb250cyB0byBiZSB1c2VkCglmb3IgZG91YmxlLXdpZHRoIGNoYXJhY3RlcnMuICBUaGUgZmlyc3QgZm9udCB0aGF0IGNhbiBiZSBsb2FkZWQgaXMKCXVzZWQuCglOb3RlOiBUaGUgc2l6ZSBvZiB0aGVzZSBmb250cyBtdXN0IGJlIGV4YWN0bHkgdHdpY2UgYXMgd2lkZSBhcyB0aGUgb25lCglzcGVjaWZpZWQgd2l0aCAnZ3VpZm9udCcgYW5kIHRoZSBzYW1lIGhlaWdodC4KCglBbGwgR1VJIHZlcnNpb25zIGJ1dCBHVEsrIDI6CgoJJ2d1aWZvbnR3aWRlJyBpcyBvbmx5IHVzZWQgd2hlbiAnZW5jb2RpbmcnIGlzIHNldCB0byAidXRmLTgiIGFuZAoJJ2d1aWZvbnRzZXQnIGlzIGVtcHR5IG9yIGludmFsaWQuCglXaGVuICdndWlmb250JyBpcyBzZXQgYW5kIGEgdmFsaWQgZm9udCBpcyBmb3VuZCBpbiBpdCBhbmQKCSdndWlmb250d2lkZScgaXMgZW1wdHkgVmltIHdpbGwgYXR0ZW1wdCB0byBmaW5kIGEgbWF0Y2hpbmcKCWRvdWJsZS13aWR0aCBmb250IGFuZCBzZXQgJ2d1aWZvbnR3aWRlJyB0byBpdC4KCglHVEsrIDIgR1VJIG9ubHk6CQkJKmd1aWZvbnR3aWRlX2d0azIqCgoJSWYgc2V0IGFuZCB2YWxpZCwgJ2d1aWZvbnR3aWRlJyBpcyBhbHdheXMgdXNlZCBmb3IgZG91YmxlIHdpZHRoCgljaGFyYWN0ZXJzLCBldmVuIGlmICdlbmNvZGluZycgaXMgbm90IHNldCB0byAidXRmLTgiLgoJVmltIGRvZXMgbm90IGF0dGVtcHQgdG8gZmluZCBhbiBhcHByb3ByaWF0ZSB2YWx1ZSBmb3IgJ2d1aWZvbnR3aWRlJwoJYXV0b21hdGljYWxseS4gIElmICdndWlmb250d2lkZScgaXMgZW1wdHkgUGFuZ28vWGZ0IHdpbGwgY2hvb3NlIHRoZQoJZm9udCBmb3IgY2hhcmFjdGVycyBub3QgYXZhaWxhYmxlIGluICdndWlmb250Jy4gIFRodXMgeW91IGRvIG5vdCBuZWVkCgl0byBzZXQgJ2d1aWZvbnR3aWRlJyBhdCBhbGwgdW5sZXNzIHlvdSB3YW50IHRvIG92ZXJyaWRlIHRoZSBjaG9pY2UKCW1hZGUgYnkgUGFuZ28vWGZ0LgoKCQkJCQkJKidndWloZWFkcm9vbScqIConZ2hyJyoKJ2d1aWhlYWRyb29tJyAnZ2hyJwludW1iZXIJKGRlZmF1bHQgNTApCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfSB7b25seSBmb3IgR1RLIGFuZCBYMTEgR1VJfQoJVGhlIG51bWJlciBvZiBwaXhlbHMgc3VidHJhY3RlZCBmcm9tIHRoZSBzY3JlZW4gaGVpZ2h0IHdoZW4gZml0dGluZwoJdGhlIEdVSSB3aW5kb3cgb24gdGhlIHNjcmVlbi4gIFNldCB0aGlzIGJlZm9yZSB0aGUgR1VJIGlzIHN0YXJ0ZWQsCgllLmcuLCBpbiB5b3VyIHxndmltcmN8IGZpbGUuICBXaGVuIHplcm8sIHRoZSB3aG9sZSBzY3JlZW4gaGVpZ2h0IHdpbGwKCWJlIHVzZWQgYnkgdGhlIHdpbmRvdy4gIFdoZW4gcG9zaXRpdmUsIHRoZSBzcGVjaWZpZWQgbnVtYmVyIG9mIHBpeGVsCglsaW5lcyB3aWxsIGJlIGxlZnQgZm9yIHdpbmRvdyBkZWNvcmF0aW9ucyBhbmQgb3RoZXIgaXRlbXMgb24gdGhlCglzY3JlZW4uICBTZXQgaXQgdG8gYSBuZWdhdGl2ZSB2YWx1ZSB0byBhbGxvdyB3aW5kb3dzIHRhbGxlciB0aGFuIHRoZQoJc2NyZWVuLgoKCQkJCQkJKidndWlvcHRpb25zJyogKidnbycqCidndWlvcHRpb25zJyAnZ28nCXN0cmluZwkoZGVmYXVsdCAiZ21yTHRUIiAgIChNUy1XaW5kb3dzKSwKCQkJCQkgImFnaW1yTHRUIiAoR1RLLCBNb3RpZiBhbmQgQXRoZW5hKSkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggR1VJIGVuYWJsZWR9CglUaGlzIG9wdGlvbiBvbmx5IGhhcyBhbiBlZmZlY3QgaW4gdGhlIEdVSSB2ZXJzaW9uIG9mIFZpbS4gIEl0IGlzIGEKCXNlcXVlbmNlIG9mIGxldHRlcnMgd2hpY2ggZGVzY3JpYmVzIHdoYXQgY29tcG9uZW50cyBhbmQgb3B0aW9ucyBvZiB0aGUKCUdVSSBzaG91bGQgYmUgdXNlZC4KCVRvIGF2b2lkIHByb2JsZW1zIHdpdGggZmxhZ3MgdGhhdCBhcmUgYWRkZWQgaW4gdGhlIGZ1dHVyZSwgdXNlIHRoZQoJIis9IiBhbmQgIi09IiBmZWF0dXJlIG9mICI6c2V0IiB8YWRkLW9wdGlvbi1mbGFnc3wuCgoJVmFsaWQgbGV0dGVycyBhcmUgYXMgZm9sbG93czoKCQkJCQkJCSpndWlvcHRpb25zX2EqCgkgICdhJwlBdXRvc2VsZWN0OiAgSWYgcHJlc2VudCwgdGhlbiB3aGVuZXZlciBWSVNVQUwgbW9kZSBpcyBzdGFydGVkLAoJCW9yIHRoZSBWaXN1YWwgYXJlYSBleHRlbmRlZCwgVmltIHRyaWVzIHRvIGJlY29tZSB0aGUgb3duZXIgb2YKCQl0aGUgd2luZG93aW5nIHN5c3RlbSdzIGdsb2JhbCBzZWxlY3Rpb24uICBUaGlzIG1lYW5zIHRoYXQgdGhlCgkJVmlzdWFsbHkgaGlnaGxpZ2h0ZWQgdGV4dCBpcyBhdmFpbGFibGUgZm9yIHBhc3RpbmcgaW50byBvdGhlcgoJCWFwcGxpY2F0aW9ucyBhcyB3ZWxsIGFzIGludG8gVmltIGl0c2VsZi4gIFdoZW4gdGhlIFZpc3VhbCBtb2RlCgkJZW5kcywgcG9zc2libHkgZHVlIHRvIGFuIG9wZXJhdGlvbiBvbiB0aGUgdGV4dCwgb3Igd2hlbiBhbgoJCWFwcGxpY2F0aW9uIHdhbnRzIHRvIHBhc3RlIHRoZSBzZWxlY3Rpb24sIHRoZSBoaWdobGlnaHRlZCB0ZXh0CgkJaXMgYXV0b21hdGljYWxseSB5YW5rZWQgaW50byB0aGUgIiogc2VsZWN0aW9uIHJlZ2lzdGVyLgoJCVRodXMgdGhlIHNlbGVjdGlvbiBpcyBzdGlsbCBhdmFpbGFibGUgZm9yIHBhc3RpbmcgaW50byBvdGhlcgoJCWFwcGxpY2F0aW9ucyBhZnRlciB0aGUgVklTVUFMIG1vZGUgaGFzIGVuZGVkLgoJCSAgICBJZiBub3QgcHJlc2VudCwgdGhlbiBWaW0gd29uJ3QgYmVjb21lIHRoZSBvd25lciBvZiB0aGUKCQl3aW5kb3dpbmcgc3lzdGVtJ3MgZ2xvYmFsIHNlbGVjdGlvbiB1bmxlc3MgZXhwbGljaXRseSB0b2xkIHRvCgkJYnkgYSB5YW5rIG9yIGRlbGV0ZSBvcGVyYXRpb24gZm9yIHRoZSAiKiByZWdpc3Rlci4KCQlUaGUgc2FtZSBhcHBsaWVzIHRvIHRoZSBtb2RlbGVzcyBzZWxlY3Rpb24uCgoJICAnQScJQXV0b3NlbGVjdCBmb3IgdGhlIG1vZGVsZXNzIHNlbGVjdGlvbi4gIExpa2UgJ2EnLCBidXQgb25seQoJCWFwcGxpZXMgdG8gdGhlIG1vZGVsZXNzIHNlbGVjdGlvbi4KCgkJICAgICdndWlvcHRpb25zJyAgIGF1dG9zZWxlY3QgVmlzdWFsICBhdXRvc2VsZWN0IG1vZGVsZXNzIH4KCQkJICIiCQkgLQkJCSAtCgkJCSAiYSIJCXllcwkJCXllcwoJCQkgIkEiCQkgLQkJCXllcwoJCQkgImFBIgkJeWVzCQkJeWVzCgoJICAnYycJVXNlIGNvbnNvbGUgZGlhbG9ncyBpbnN0ZWFkIG9mIHBvcHVwIGRpYWxvZ3MgZm9yIHNpbXBsZQoJCWNob2ljZXMuCgoJICAnZicJRm9yZWdyb3VuZDogRG9uJ3QgdXNlIGZvcmsoKSB0byBkZXRhY2ggdGhlIEdVSSBmcm9tIHRoZSBzaGVsbAoJCXdoZXJlIGl0IHdhcyBzdGFydGVkLiAgVXNlIHRoaXMgZm9yIHByb2dyYW1zIHRoYXQgd2FpdCBmb3IgdGhlCgkJZWRpdG9yIHRvIGZpbmlzaCAoZS5nLiwgYW4gZS1tYWlsIHByb2dyYW0pLiAgQWx0ZXJuYXRpdmVseSB5b3UKCQljYW4gdXNlICJndmltIC1mIiBvciAiOmd1aSAtZiIgdG8gc3RhcnQgdGhlIEdVSSBpbiB0aGUKCQlmb3JlZ3JvdW5kLiAgfGd1aS1mb3JrfAoJCU5vdGU6IFNldCB0aGlzIG9wdGlvbiBpbiB0aGUgdmltcmMgZmlsZS4gIFRoZSBmb3JraW5nIG1heSBoYXZlCgkJaGFwcGVuZWQgYWxyZWFkeSB3aGVuIHRoZSBndmltcmMgZmlsZSBpcyByZWFkLgoKCSAgJ2knCVVzZSBhIFZpbSBpY29uLiAgRm9yIEdUSyB3aXRoIEtERSBpdCBpcyB1c2VkIGluIHRoZSBsZWZ0LXVwcGVyCgkJY29ybmVyIG9mIHRoZSB3aW5kb3cuICBJdCdzIGJsYWNrJndoaXRlIG9uIG5vbi1HVEssIGJlY2F1c2Ugb2YKCQlsaW1pdGF0aW9ucyBvZiBYMTEuICBGb3IgYSBjb2xvciBpY29uLCBzZWUgfFgxMS1pY29ufC4KCgkgICdtJwlNZW51IGJhciBpcyBwcmVzZW50LgoJICAnTScJVGhlIHN5c3RlbSBtZW51ICIkVklNUlVOVElNRS9tZW51LnZpbSIgaXMgbm90IHNvdXJjZWQuICBOb3RlCgkJdGhhdCB0aGlzIGZsYWcgbXVzdCBiZSBhZGRlZCBpbiB0aGUgLnZpbXJjIGZpbGUsIGJlZm9yZQoJCXN3aXRjaGluZyBvbiBzeW50YXggb3IgZmlsZXR5cGUgcmVjb2duaXRpb24gKHdoZW4gdGhlIC5ndmltcmMKCQlmaWxlIGlzIHNvdXJjZWQgdGhlIHN5c3RlbSBtZW51IGhhcyBhbHJlYWR5IGJlZW4gbG9hZGVkOyB0aGUKCQkiOnN5bnRheCBvbiIgYW5kICI6ZmlsZXR5cGUgb24iIGNvbW1hbmRzIGxvYWQgdGhlIG1lbnUgdG9vKS4KCSAgJ2cnCUdyZXkgbWVudSBpdGVtczogTWFrZSBtZW51IGl0ZW1zIHRoYXQgYXJlIG5vdCBhY3RpdmUgZ3JleS4gIElmCgkJJ2cnIGlzIG5vdCBpbmNsdWRlZCBpbmFjdGl2ZSBtZW51IGl0ZW1zIGFyZSBub3Qgc2hvd24gYXQgYWxsLgoJCUV4Y2VwdGlvbjogQXRoZW5hIHdpbGwgYWx3YXlzIHVzZSBncmV5IG1lbnUgaXRlbXMuCgoJICAndCcJSW5jbHVkZSB0ZWFyb2ZmIG1lbnUgaXRlbXMuICBDdXJyZW50bHkgb25seSB3b3JrcyBmb3IgV2luMzIsCgkJR1RLKywgYW5kIE1vdGlmIDEuMiBHVUkuCgkgICdUJwlJbmNsdWRlIFRvb2xiYXIuICBDdXJyZW50bHkgb25seSBpbiBXaW4zMiwgR1RLKywgTW90aWYsIFBob3RvbgoJICAgICAgICBhbmQgQXRoZW5hIEdVSXMuCgoJICAncicJUmlnaHQtaGFuZCBzY3JvbGxiYXIgaXMgYWx3YXlzIHByZXNlbnQuCgkgICdSJwlSaWdodC1oYW5kIHNjcm9sbGJhciBpcyBwcmVzZW50IHdoZW4gdGhlcmUgaXMgYSB2ZXJ0aWNhbGx5CgkJc3BsaXQgd2luZG93LgoJICAnbCcJTGVmdC1oYW5kIHNjcm9sbGJhciBpcyBhbHdheXMgcHJlc2VudC4KCSAgJ0wnCUxlZnQtaGFuZCBzY3JvbGxiYXIgaXMgcHJlc2VudCB3aGVuIHRoZXJlIGlzIGEgdmVydGljYWxseQoJCXNwbGl0IHdpbmRvdy4KCSAgJ2InCUJvdHRvbSAoaG9yaXpvbnRhbCkgc2Nyb2xsYmFyIGlzIHByZXNlbnQuICBJdHMgc2l6ZSBkZXBlbmRzIG9uCgkJdGhlIGxvbmdlc3QgdmlzaWJsZSBsaW5lLCBvciBvbiB0aGUgY3Vyc29yIGxpbmUgaWYgdGhlICdoJwoJCWZsYWcgaXMgaW5jbHVkZWQuIHxndWktaG9yaXotc2Nyb2xsfAoJICAnaCcJTGltaXQgaG9yaXpvbnRhbCBzY3JvbGxiYXIgc2l6ZSB0byB0aGUgbGVuZ3RoIG9mIHRoZSBjdXJzb3IKCQlsaW5lLiAgUmVkdWNlcyBjb21wdXRhdGlvbnMuIHxndWktaG9yaXotc2Nyb2xsfAoKCUFuZCB5ZXMsIHlvdSBtYXkgZXZlbiBoYXZlIHNjcm9sbGJhcnMgb24gdGhlIGxlZnQgQU5EIHRoZSByaWdodCBpZgoJeW91IHJlYWxseSB3YW50IHRvIDotKS4gIFNlZSB8Z3VpLXNjcm9sbGJhcnN8IGZvciBtb3JlIGluZm9ybWF0aW9uLgoKCSAgJ3YnCVVzZSBhIHZlcnRpY2FsIGJ1dHRvbiBsYXlvdXQgZm9yIGRpYWxvZ3MuICBXaGVuIG5vdCBpbmNsdWRlZCwKCQlhIGhvcml6b250YWwgbGF5b3V0IGlzIHByZWZlcnJlZCwgYnV0IHdoZW4gaXQgZG9lc24ndCBmaXQgYQoJCXZlcnRpY2FsIGxheW91dCBpcyB1c2VkIGFueXdheS4KCSAgJ3AnCVVzZSBQb2ludGVyIGNhbGxiYWNrcyBmb3IgWDExIEdVSS4gIFRoaXMgaXMgcmVxdWlyZWQgZm9yIHNvbWUKCQl3aW5kb3cgbWFuYWdlcnMuICBJZiB0aGUgY3Vyc29yIGlzIG5vdCBibGlua2luZyBvciBob2xsb3cgYXQKCQl0aGUgcmlnaHQgbW9tZW50LCB0cnkgYWRkaW5nIHRoaXMgZmxhZy4gIFRoaXMgbXVzdCBiZSBkb25lCgkJYmVmb3JlIHN0YXJ0aW5nIHRoZSBHVUkuICBTZXQgaXQgaW4geW91ciBndmltcmMuICBBZGRpbmcgb3IKCQlyZW1vdmluZyBpdCBhZnRlciB0aGUgR1VJIGhhcyBzdGFydGVkIGhhcyBubyBlZmZlY3QuCgkgICdGJwlBZGQgYSBmb290ZXIuICBPbmx5IGZvciBNb3RpZi4gIFNlZSB8Z3VpLWZvb3RlcnwuCgoJCQkJCQkqJ2d1aXB0eScqIConbm9ndWlwdHknKgonZ3VpcHR5JwkJYm9vbGVhbgkoZGVmYXVsdCBvbikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggR1VJIGVuYWJsZWR9CglPbmx5IGluIHRoZSBHVUk6IElmIG9uLCBhbiBhdHRlbXB0IGlzIG1hZGUgdG8gb3BlbiBhIHBzZXVkby10dHkgZm9yCglJL08gdG8vZnJvbSBzaGVsbCBjb21tYW5kcy4gIFNlZSB8Z3VpLXB0eXwuCgoJCQkJCQkqJ2hlbHBmaWxlJyogKidoZicqCidoZWxwZmlsZScgJ2hmJwkJc3RyaW5nCShkZWZhdWx0IChNU0RPUykgICIkVklNUlVOVElNRVxkb2NcaGVscC50eHQiCgkJCQkJIChvdGhlcnMpICIkVklNUlVOVElNRS9kb2MvaGVscC50eHQiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCU5hbWUgb2YgdGhlIG1haW4gaGVscCBmaWxlLiAgQWxsIGRpc3RyaWJ1dGVkIGhlbHAgZmlsZXMgc2hvdWxkIGJlCglwbGFjZWQgdG9nZXRoZXIgaW4gb25lIGRpcmVjdG9yeS4gIEFkZGl0aW9uYWxseSwgYWxsICJkb2MiIGRpcmVjdG9yaWVzCglpbiAncnVudGltZXBhdGgnIHdpbGwgYmUgdXNlZC4KCUVudmlyb25tZW50IHZhcmlhYmxlcyBhcmUgZXhwYW5kZWQgfDpzZXRfZW52fC4gIEZvciBleGFtcGxlOgoJIiRWSU1SVU5USU1FL2RvYy9oZWxwLnR4dCIuICBJZiAkVklNUlVOVElNRSBpcyBub3Qgc2V0LCAkVklNIGlzIGFsc28KCXRyaWVkLiAgQWxzbyBzZWUgfCRWSU1SVU5USU1FfCBhbmQgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0IGluY2x1ZGluZwoJc3BhY2VzIGFuZCBiYWNrc2xhc2hlcy4KCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJCQkJKidoZWxwaGVpZ2h0JyogKidoaCcqCidoZWxwaGVpZ2h0JyAnaGgnCW51bWJlcgkoZGVmYXVsdCAyMCkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgK3dpbmRvd3MKCQkJZmVhdHVyZX0KCU1pbmltYWwgaW5pdGlhbCBoZWlnaHQgb2YgdGhlIGhlbHAgd2luZG93IHdoZW4gaXQgaXMgb3BlbmVkIHdpdGggdGhlCgkiOmhlbHAiIGNvbW1hbmQuICBUaGUgaW5pdGlhbCBoZWlnaHQgb2YgdGhlIGhlbHAgd2luZG93IGlzIGhhbGYgb2YgdGhlCgljdXJyZW50IHdpbmRvdywgb3IgKHdoZW4gdGhlICdlYScgb3B0aW9uIGlzIG9uKSB0aGUgc2FtZSBhcyBvdGhlcgoJd2luZG93cy4gIFdoZW4gdGhlIGhlaWdodCBpcyBsZXNzIHRoYW4gJ2hlbHBoZWlnaHQnLCB0aGUgaGVpZ2h0IGlzCglzZXQgdG8gJ2hlbHBoZWlnaHQnLiAgU2V0IHRvIHplcm8gdG8gZGlzYWJsZS4KCgkJCQkJCSonaGVscGxhbmcnKiAqJ2hsZycqCidoZWxwbGFuZycgJ2hsZycJc3RyaW5nCShkZWZhdWx0OiBtZXNzYWdlcyBsYW5ndWFnZSBvciBlbXB0eSkKCQkJZ2xvYmFsCgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbXVsdGlfbGFuZ3wKCQkJZmVhdHVyZX0KCQkJe25vdCBpbiBWaX0KCUNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIGxhbmd1YWdlcy4gIFZpbSB3aWxsIHVzZSB0aGUgZmlyc3QgbGFuZ3VhZ2UKCWZvciB3aGljaCB0aGUgZGVzaXJlZCBoZWxwIGNhbiBiZSBmb3VuZC4gIFRoZSBFbmdsaXNoIGhlbHAgd2lsbCBhbHdheXMKCWJlIHVzZWQgYXMgYSBsYXN0IHJlc29ydC4gIFlvdSBjYW4gYWRkICJlbiIgdG8gcHJlZmVyIEVuZ2xpc2ggb3ZlcgoJYW5vdGhlciBsYW5ndWFnZSwgYnV0IHRoYXQgd2lsbCBvbmx5IGZpbmQgdGFncyB0aGF0IGV4aXN0IGluIHRoYXQKCWxhbmd1YWdlIGFuZCBub3QgaW4gdGhlIEVuZ2xpc2ggaGVscC4KCUV4YW1wbGU6ID4KCQk6c2V0IGhlbHBsYW5nPWRlLGl0CjwJVGhpcyB3aWxsIGZpcnN0IHNlYXJjaCBHZXJtYW4sIHRoZW4gSXRhbGlhbiBhbmQgZmluYWxseSBFbmdsaXNoIGhlbHAKCWZpbGVzLgoJV2hlbiB1c2luZyB8Q1RSTC1dfCBhbmQgIjpoZWxwISIgaW4gYSBub24tRW5nbGlzaCBoZWxwIGZpbGUgVmltIHdpbGwKCXRyeSB0byBmaW5kIHRoZSB0YWcgaW4gdGhlIGN1cnJlbnQgbGFuZ3VhZ2UgYmVmb3JlIHVzaW5nIHRoaXMgb3B0aW9uLgoJU2VlIHxoZWxwLXRyYW5zbGF0ZWR8LgoKCQkJCSAgICAgKidoaWRkZW4nKiAqJ2hpZCcqIConbm9oaWRkZW4nKiAqJ25vaGlkJyoKJ2hpZGRlbicgJ2hpZCcJCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVdoZW4gb2ZmIGEgYnVmZmVyIGlzIHVubG9hZGVkIHdoZW4gaXQgaXMgfGFiYW5kb258ZWQuICBXaGVuIG9uIGEKCWJ1ZmZlciBiZWNvbWVzIGhpZGRlbiB3aGVuIGl0IGlzIHxhYmFuZG9ufGVkLiAgSWYgdGhlIGJ1ZmZlciBpcyBzdGlsbAoJZGlzcGxheWVkIGluIGFub3RoZXIgd2luZG93LCBpdCBkb2VzIG5vdCBiZWNvbWUgaGlkZGVuLCBvZiBjb3Vyc2UuCglUaGUgY29tbWFuZHMgdGhhdCBtb3ZlIHRocm91Z2ggdGhlIGJ1ZmZlciBsaXN0IHNvbWV0aW1lcyBtYWtlIGEgYnVmZmVyCgloaWRkZW4gYWx0aG91Z2ggdGhlICdoaWRkZW4nIG9wdGlvbiBpcyBvZmY6IFdoZW4gdGhlIGJ1ZmZlciBpcwoJbW9kaWZpZWQsICdhdXRvd3JpdGUnIGlzIG9mZiBvciB3cml0aW5nIGlzIG5vdCBwb3NzaWJsZSwgYW5kIHRoZSAnIScKCWZsYWcgd2FzIHVzZWQuICBTZWUgYWxzbyB8d2luZG93cy50eHR8LgoJVG8gb25seSBtYWtlIG9uZSBidWZmZXIgaGlkZGVuIHVzZSB0aGUgJ2J1ZmhpZGRlbicgb3B0aW9uLgoJVGhpcyBvcHRpb24gaXMgc2V0IGZvciBvbmUgY29tbWFuZCB3aXRoICI6aGlkZSB7Y29tbWFuZH0iIHw6aGlkZXwuCglXQVJOSU5HOiBJdCdzIGVhc3kgdG8gZm9yZ2V0IHRoYXQgeW91IGhhdmUgY2hhbmdlcyBpbiBoaWRkZW4gYnVmZmVycy4KCVRoaW5rIHR3aWNlIHdoZW4gdXNpbmcgIjpxISIgb3IgIjpxYSEiLgoKCQkJCQkJKidoaWdobGlnaHQnKiAqJ2hsJyoKJ2hpZ2hsaWdodCcgJ2hsJwlzdHJpbmcJKGRlZmF1bHQgKGFzIGEgc2luZ2xlIHN0cmluZyk6CgkJCQkgICAgICI4OlNwZWNpYWxLZXksQDpOb25UZXh0LGQ6RGlyZWN0b3J5LAoJCQkJICAgICBlOkVycm9yTXNnLGk6SW5jU2VhcmNoLGw6U2VhcmNoLG06TW9yZU1zZywKCQkJCSAgICAgTTpNb2RlTXNnLG46TGluZU5yLHI6UXVlc3Rpb24sCgkJCQkgICAgIHM6U3RhdHVzTGluZSxTOlN0YXR1c0xpbmVOQyxjOlZlcnRTcGxpdAoJCQkJICAgICB0OlRpdGxlLHY6VmlzdWFsLHc6V2FybmluZ01zZyxXOldpbGRNZW51LAoJCQkJICAgICBmOkZvbGRlZCxGOkZvbGRDb2x1bW4sQTpEaWZmQWRkLAoJCQkJICAgICBDOkRpZmZDaGFuZ2UsRDpEaWZmRGVsZXRlLFQ6RGlmZlRleHQsCgkJCQkgICAgID46U2lnbkNvbHVtbixCOlNwZWxsQmFkLFA6U3BlbGxDYXAsCgkJCQkgICAgIFI6U3BlbGxSYXJlLEw6U3BlbGxMb2NhbCIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJVGhpcyBvcHRpb24gY2FuIGJlIHVzZWQgdG8gc2V0IGhpZ2hsaWdodGluZyBtb2RlIGZvciB2YXJpb3VzCglvY2Nhc2lvbnMuICBJdCBpcyBhIGNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIGNoYXJhY3RlciBwYWlycy4gIFRoZQoJZmlyc3QgY2hhcmFjdGVyIGluIGEgcGFpciBnaXZlcyB0aGUgb2NjYXNpb24sIHRoZSBzZWNvbmQgdGhlIG1vZGUgdG8KCXVzZSBmb3IgdGhhdCBvY2Nhc2lvbi4gIFRoZSBvY2Nhc2lvbnMgYXJlOgoJfGhsLVNwZWNpYWxLZXl8CSA4ICBNZXRhIGFuZCBzcGVjaWFsIGtleXMgbGlzdGVkIHdpdGggIjptYXAiCgl8aGwtTm9uVGV4dHwJIEAgICd+JyBhbmQgJ0AnIGF0IHRoZSBlbmQgb2YgdGhlIHdpbmRvdyBhbmQKCQkJICAgIGNoYXJhY3RlcnMgZnJvbSAnc2hvd2JyZWFrJwoJfGhsLURpcmVjdG9yeXwJIGQgIGRpcmVjdG9yaWVzIGluIENUUkwtRCBsaXN0aW5nIGFuZCBvdGhlciBzcGVjaWFsCgkJCSAgICB0aGluZ3MgaW4gbGlzdGluZ3MKCXxobC1FcnJvck1zZ3wJIGUgIGVycm9yIG1lc3NhZ2VzCgkJCSBoICAob2Jzb2xldGUsIGlnbm9yZWQpCgl8aGwtSW5jU2VhcmNofAkgaSAgJ2luY3NlYXJjaCcgaGlnaGxpZ2h0aW5nCgl8aGwtU2VhcmNofAkgbCAgbGFzdCBzZWFyY2ggcGF0dGVybiBoaWdobGlnaHRpbmcgKHNlZSAnaGxzZWFyY2gnKQoJfGhsLU1vcmVNc2d8CSBtICB8bW9yZS1wcm9tcHR8Cgl8aGwtTW9kZU1zZ3wJIE0gIE1vZGUgKGUuZy4sICItLSBJTlNFUlQgLS0iKQoJfGhsLUxpbmVOcnwJIG4gIGxpbmUgbnVtYmVyIGZvciAiOm51bWJlciIgYW5kICI6IyIgY29tbWFuZHMKCXxobC1RdWVzdGlvbnwJIHIgIHxoaXQtZW50ZXJ8IHByb21wdCBhbmQgeWVzL25vIHF1ZXN0aW9ucwoJfGhsLVN0YXR1c0xpbmV8CSBzICBzdGF0dXMgbGluZSBvZiBjdXJyZW50IHdpbmRvdyB8c3RhdHVzLWxpbmV8Cgl8aGwtU3RhdHVzTGluZU5DfCBTICBzdGF0dXMgbGluZXMgb2Ygbm90LWN1cnJlbnQgd2luZG93cwoJfGhsLVRpdGxlfAkgdCAgVGl0bGVzIGZvciBvdXRwdXQgZnJvbSAiOnNldCBhbGwiLCAiOmF1dG9jbWQiIGV0Yy4KCXxobC1WZXJ0U3BsaXR8CSBjICBjb2x1bW4gdXNlZCB0byBzZXBhcmF0ZSB2ZXJ0aWNhbGx5IHNwbGl0IHdpbmRvd3MKCXxobC1WaXN1YWx8CSB2ICBWaXN1YWwgbW9kZQoJfGhsLVZpc3VhbE5PU3wJIFYgIFZpc3VhbCBtb2RlIHdoZW4gVmltIGRvZXMgaXMgIk5vdCBPd25pbmcgdGhlCgkJCSAgICBTZWxlY3Rpb24iIE9ubHkgWDExIEd1aSdzIHxndWkteDExfCBhbmQKCQkJICAgIHx4dGVybS1jbGlwYm9hcmR8LgoJfGhsLVdhcm5pbmdNc2d8CSB3ICB3YXJuaW5nIG1lc3NhZ2VzCgl8aGwtV2lsZE1lbnV8CSBXICB3aWxkY2FyZCBtYXRjaGVzIGRpc3BsYXllZCBmb3IgJ3dpbGRtZW51JwoJfGhsLUZvbGRlZHwJIGYgIGxpbmUgdXNlZCBmb3IgY2xvc2VkIGZvbGRzCgl8aGwtRm9sZENvbHVtbnwJIEYgICdmb2xkY29sdW1uJwoJfGhsLURpZmZBZGR8CSBBICBhZGRlZCBsaW5lIGluIGRpZmYgbW9kZQoJfGhsLURpZmZDaGFuZ2V8CSBDICBjaGFuZ2VkIGxpbmUgaW4gZGlmZiBtb2RlCgl8aGwtRGlmZkRlbGV0ZXwJIEQgIGRlbGV0ZWQgbGluZSBpbiBkaWZmIG1vZGUKCXxobC1EaWZmVGV4dHwJIFQgIGluc2VydGVkIHRleHQgaW4gZGlmZiBtb2RlCgl8aGwtU2lnbkNvbHVtbnwJID4gIGNvbHVtbiB1c2VkIGZvciB8c2lnbnN8Cgl8aGwtU3BlbGxCYWR8CSBCICBtaXNzcGVsbGVkIHdvcmQgfHNwZWxsfAoJfGhsLVNwZWxsQ2FwfAkgUCAgd29yZCB0aGF0IHNob3VsZCBzdGFydCB3aXRoIGNhcGl0YWx8c3BlbGx8Cgl8aGwtU3BlbGxSYXJlfAkgUiAgcmFyZSB3b3JkIHxzcGVsbHwKCXxobC1TcGVsbExvY2FsfAkgTCAgd29yZCBmcm9tIG90aGVyIHJlZ2lvbiB8c3BlbGx8CgoJVGhlIGRpc3BsYXkgbW9kZXMgYXJlOgoJCXIJcmV2ZXJzZQkJKHRlcm1jYXAgZW50cnkgIm1yIiBhbmQgIm1lIikKCQlpCWl0YWxpYwkJKHRlcm1jYXAgZW50cnkgIlpIIiBhbmQgIlpSIikKCQliCWJvbGQJCSh0ZXJtY2FwIGVudHJ5ICJtZCIgYW5kICJtZSIpCgkJcwlzdGFuZG91dAkodGVybWNhcCBlbnRyeSAic28iIGFuZCAic2UiKQoJCXUJdW5kZXJsaW5lCSh0ZXJtY2FwIGVudHJ5ICJ1cyIgYW5kICJ1ZSIpCgkJYwl1bmRlcmN1cmwJKHRlcm1jYXAgZW50cnkgIkNzIiBhbmQgIkNlIikKCQluCW5vIGhpZ2hsaWdodGluZwoJCS0Jbm8gaGlnaGxpZ2h0aW5nCgkJOgl1c2UgYSBoaWdobGlnaHQgZ3JvdXAKCVRoZSBkZWZhdWx0IGlzIHVzZWQgZm9yIG9jY2FzaW9ucyB0aGF0IGFyZSBub3QgaW5jbHVkZWQuCglJZiB5b3Ugd2FudCB0byBjaGFuZ2Ugd2hhdCB0aGUgZGlzcGxheSBtb2RlcyBkbywgc2VlIHxkb3MtY29sb3JzfAoJZm9yIGFuIGV4YW1wbGUuCglXaGVuIHVzaW5nIHRoZSAnOicgZGlzcGxheSBtb2RlLCB0aGlzIG11c3QgYmUgZm9sbG93ZWQgYnkgdGhlIG5hbWUgb2YKCWEgaGlnaGxpZ2h0IGdyb3VwLiAgQSBoaWdobGlnaHQgZ3JvdXAgY2FuIGJlIHVzZWQgdG8gZGVmaW5lIGFueSB0eXBlCglvZiBoaWdobGlnaHRpbmcsIGluY2x1ZGluZyB1c2luZyBjb2xvci4gIFNlZSB8OmhpZ2hsaWdodHwgb24gaG93IHRvCglkZWZpbmUgb25lLiAgVGhlIGRlZmF1bHQgdXNlcyBhIGRpZmZlcmVudCBncm91cCBmb3IgZWFjaCBvY2Nhc2lvbi4KCVNlZSB8aGlnaGxpZ2h0LWRlZmF1bHR8IGZvciB0aGUgZGVmYXVsdCBoaWdobGlnaHQgZ3JvdXBzLgoKCQkJCSAqJ2hsc2VhcmNoJyogKidobHMnKiAqJ25vaGxzZWFyY2gnKiAqJ25vaGxzJyoKJ2hsc2VhcmNoJyAnaGxzJwlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUKCQkJfCtleHRyYV9zZWFyY2h8IGZlYXR1cmV9CglXaGVuIHRoZXJlIGlzIGEgcHJldmlvdXMgc2VhcmNoIHBhdHRlcm4sIGhpZ2hsaWdodCBhbGwgaXRzIG1hdGNoZXMuCglUaGUgdHlwZSBvZiBoaWdobGlnaHRpbmcgdXNlZCBjYW4gYmUgc2V0IHdpdGggdGhlICdsJyBvY2Nhc2lvbiBpbiB0aGUKCSdoaWdobGlnaHQnIG9wdGlvbi4gIFRoaXMgdXNlcyB0aGUgIlNlYXJjaCIgaGlnaGxpZ2h0IGdyb3VwIGJ5CglkZWZhdWx0LiAgTm90ZSB0aGF0IG9ubHkgdGhlIG1hdGNoaW5nIHRleHQgaXMgaGlnaGxpZ2h0ZWQsIGFueSBvZmZzZXRzCglhcmUgbm90IGFwcGxpZWQuCglTZWUgYWxzbzogJ2luY3NlYXJjaCcgYW5kIHw6bWF0Y2h8LgoJV2hlbiB5b3UgZ2V0IGJvcmVkIGxvb2tpbmcgYXQgdGhlIGhpZ2hsaWdodGVkIG1hdGNoZXMsIHlvdSBjYW4gdHVybiBpdAoJb2ZmIHdpdGggfDpub2hsc2VhcmNofC4gIEFzIHNvb24gYXMgeW91IHVzZSBhIHNlYXJjaCBjb21tYW5kLCB0aGUKCWhpZ2hsaWdodGluZyBjb21lcyBiYWNrLgoJV2hlbiB0aGUgc2VhcmNoIHBhdHRlcm4gY2FuIG1hdGNoIGFuIGVuZC1vZi1saW5lLCBWaW0gd2lsbCB0cnkgdG8KCWhpZ2hsaWdodCBhbGwgb2YgdGhlIG1hdGNoZWQgdGV4dC4gIEhvd2V2ZXIsIHRoaXMgZGVwZW5kcyBvbiB3aGVyZSB0aGUKCXNlYXJjaCBzdGFydHMuICBUaGlzIHdpbGwgYmUgdGhlIGZpcnN0IGxpbmUgaW4gdGhlIHdpbmRvdyBvciB0aGUgZmlyc3QKCWxpbmUgYmVsb3cgYSBjbG9zZWQgZm9sZC4gIEEgbWF0Y2ggaW4gYSBwcmV2aW91cyBsaW5lIHdoaWNoIGlzIG5vdAoJZHJhd24gbWF5IG5vdCBjb250aW51ZSBpbiBhbiBuZXdseSBkcmF3biBsaW5lLgoJTk9URTogVGhpcyBvcHRpb24gaXMgcmVzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJKidoaXN0b3J5JyogKidoaScqCidoaXN0b3J5JyAnaGknCQludW1iZXIJKFZpbSBkZWZhdWx0OiAyMCwgVmkgZGVmYXVsdDogMCkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglBIGhpc3Rvcnkgb2YgIjoiIGNvbW1hbmRzLCBhbmQgYSBoaXN0b3J5IG9mIHByZXZpb3VzIHNlYXJjaCBwYXR0ZXJucwoJYXJlIHJlbWVtYmVyZWQuICBUaGlzIG9wdGlvbiBkZWNpZGVzIGhvdyBtYW55IGVudHJpZXMgbWF5IGJlIHN0b3JlZCBpbgoJZWFjaCBvZiB0aGVzZSBoaXN0b3JpZXMgKHNlZSB8Y21kbGluZS1lZGl0aW5nfCkuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyBzZXQgdG8gdGhlIFZpIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMKCXNldCBhbmQgdG8gdGhlIFZpbSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzIHJlc2V0LgoKCQkJCQkgKidoa21hcCcqIConaGsnKiAqJ25vaGttYXAnKiAqJ25vaGsnKgonaGttYXAnICdoaycJCWJvb2xlYW4gKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtyaWdodGxlZnR8CgkJCWZlYXR1cmV9CglXaGVuIG9uLCB0aGUga2V5Ym9hcmQgaXMgbWFwcGVkIGZvciB0aGUgSGVicmV3IGNoYXJhY3RlciBzZXQuCglOb3JtYWxseSB5b3Ugd291bGQgc2V0ICdhbGxvd3JldmlucycgYW5kIHVzZSBDVFJMLV8gaW4gaW5zZXJ0IG1vZGUgdG8KCXRvZ2dsZSB0aGlzIG9wdGlvbi4gIFNlZSB8cmlsZWZ0LnR4dHwuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyByZXNldCB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkJIConaGttYXBwJyogKidoa3AnKiAqJ25vaGttYXBwJyogKidub2hrcCcqCidoa21hcHAnICdoa3AnCQlib29sZWFuIChkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmlnaHRsZWZ0fAoJCQlmZWF0dXJlfQoJV2hlbiBvbiwgcGhvbmV0aWMga2V5Ym9hcmQgbWFwcGluZyBpcyB1c2VkLiAgJ2hrbWFwJyBtdXN0IGFsc28gYmUgb24uCglUaGlzIGlzIHVzZWZ1bCBpZiB5b3UgaGF2ZSBhIG5vbi1IZWJyZXcga2V5Ym9hcmQuCglTZWUgfHJpbGVmdC50eHR8LgoJTk9URTogVGhpcyBvcHRpb24gaXMgcmVzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJKidpY29uJyogKidub2ljb24nKgonaWNvbicJCQlib29sZWFuCShkZWZhdWx0IG9mZiwgb24gd2hlbiB0aXRsZSBjYW4gYmUgcmVzdG9yZWQpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrdGl0bGV8CgkJCWZlYXR1cmV9CglXaGVuIG9uLCB0aGUgaWNvbiB0ZXh0IG9mIHRoZSB3aW5kb3cgd2lsbCBiZSBzZXQgdG8gdGhlIHZhbHVlIG9mCgknaWNvbnN0cmluZycgKGlmIGl0IGlzIG5vdCBlbXB0eSksIG9yIHRvIHRoZSBuYW1lIG9mIHRoZSBmaWxlCgljdXJyZW50bHkgYmVpbmcgZWRpdGVkLiAgT25seSB0aGUgbGFzdCBwYXJ0IG9mIHRoZSBuYW1lIGlzIHVzZWQuCglPdmVycmlkZGVuIGJ5IHRoZSAnaWNvbnN0cmluZycgb3B0aW9uLgoJT25seSB3b3JrcyBpZiB0aGUgdGVybWluYWwgc3VwcG9ydHMgc2V0dGluZyB3aW5kb3cgaWNvbnMgKGN1cnJlbnRseQoJb25seSBYMTEgR1VJIGFuZCB0ZXJtaW5hbHMgd2l0aCBhIG5vbi1lbXB0eSAndF9JUycgb3B0aW9uIC0gdGhlc2UgYXJlCglVbml4IHh0ZXJtIGFuZCBpcmlzLWFuc2kgYnkgZGVmYXVsdCwgd2hlcmUgJ3RfSVMnIGlzIHRha2VuIGZyb20gdGhlCglidWlsdGluIHRlcm1jYXApLgoJV2hlbiBWaW0gd2FzIGNvbXBpbGVkIHdpdGggSEFWRV9YMTEgZGVmaW5lZCwgdGhlIG9yaWdpbmFsIGljb24gd2lsbCBiZQoJcmVzdG9yZWQgaWYgcG9zc2libGUgfFgxMXwuICBTZWUgfFgxMS1pY29ufCBmb3IgY2hhbmdpbmcgdGhlIGljb24gb24KCVgxMS4KCgkJCQkJCSonaWNvbnN0cmluZycqCidpY29uc3RyaW5nJwkJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3RpdGxlfAoJCQlmZWF0dXJlfQoJV2hlbiB0aGlzIG9wdGlvbiBpcyBub3QgZW1wdHksIGl0IHdpbGwgYmUgdXNlZCBmb3IgdGhlIGljb24gdGV4dCBvZgoJdGhlIHdpbmRvdy4gIFRoaXMgaGFwcGVucyBvbmx5IHdoZW4gdGhlICdpY29uJyBvcHRpb24gaXMgb24uCglPbmx5IHdvcmtzIGlmIHRoZSB0ZXJtaW5hbCBzdXBwb3J0cyBzZXR0aW5nIHdpbmRvdyBpY29uIHRleHQKCShjdXJyZW50bHkgb25seSBYMTEgR1VJIGFuZCB0ZXJtaW5hbHMgd2l0aCBhIG5vbi1lbXB0eSAndF9JUycgb3B0aW9uKS4KCURvZXMgbm90IHdvcmsgZm9yIE1TIFdpbmRvd3MuCglXaGVuIFZpbSB3YXMgY29tcGlsZWQgd2l0aCBIQVZFX1gxMSBkZWZpbmVkLCB0aGUgb3JpZ2luYWwgaWNvbiB3aWxsIGJlCglyZXN0b3JlZCBpZiBwb3NzaWJsZSB8WDExfC4KCVdoZW4gdGhpcyBvcHRpb24gY29udGFpbnMgcHJpbnRmLXN0eWxlICclJyBpdGVtcywgdGhleSB3aWxsIGJlCglleHBhbmRlZCBhY2NvcmRpbmcgdG8gdGhlIHJ1bGVzIHVzZWQgZm9yICdzdGF0dXNsaW5lJy4gIFNlZQoJJ3RpdGxlc3RyaW5nJyBmb3IgZXhhbXBsZSBzZXR0aW5ncy4KCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCtzdGF0dXNsaW5lfCBmZWF0dXJlfQoKCQkJKidpZ25vcmVjYXNlJyogKidpYycqIConbm9pZ25vcmVjYXNlJyogKidub2ljJyoKJ2lnbm9yZWNhc2UnICdpYycJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJSWdub3JlIGNhc2UgaW4gc2VhcmNoIHBhdHRlcm5zLiAgQWxzbyB1c2VkIHdoZW4gc2VhcmNoaW5nIGluIHRoZSB0YWdzCglmaWxlLgoJQWxzbyBzZWUgJ3NtYXJ0Y2FzZScuCglDYW4gYmUgb3ZlcnJ1bGVkIGJ5IHVzaW5nICJcYyIgb3IgIlxDIiBpbiB0aGUgcGF0dGVybiwgc2VlCgl8L2lnbm9yZWNhc2V8LgoKCQkJCQkJKidpbWFjdGl2YXRla2V5JyogKidpbWFrJyoKJ2ltYWN0aXZhdGVrZXknICdpbWFrJwlzdHJpbmcgKGRlZmF1bHQgIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHwreGltfCBhbmQKCQkJfCtHVUlfR1RLfH0KCVNwZWNpZmllcyB0aGUga2V5IHRoYXQgeW91ciBJbnB1dCBNZXRob2QgaW4gWC1XaW5kb3dzIHVzZXMgZm9yCglhY3RpdmF0aW9uLiAgV2hlbiB0aGlzIGlzIHNwZWNpZmllZCBjb3JyZWN0bHksIHZpbSBjYW4gZnVsbHkgY29udHJvbAoJSU0gd2l0aCAnaW1jbWRsaW5lJywgJ2ltaW5zZXJ0JyBhbmQgJ2ltc2VhcmNoJy4KCVlvdSBjYW4ndCB1c2UgdGhpcyBvcHRpb24gdG8gY2hhbmdlIHRoZSBhY3RpdmF0aW9uIGtleSwgdGhlIG9wdGlvbgoJdGVsbHMgVmltIHdoYXQgdGhlIGtleSBpcy4KCUZvcm1hdDoKCQlbTU9ESUZJRVJfRkxBRy1dS0VZX1NUUklORwoKCVRoZXNlIGNoYXJhY3RlcnMgY2FuIGJlIHVzZWQgZm9yIE1PRElGSUVSX0ZMQUcgKGNhc2UgaXMgaWdub3JlZCk6CgkJUwkgICAgU2hpZnQga2V5CgkJTAkgICAgTG9jayBrZXkKCQlDCSAgICBDb250cm9sIGtleQoJCTEJICAgIE1vZDEga2V5CgkJMgkgICAgTW9kMiBrZXkKCQkzCSAgICBNb2QzIGtleQoJCTQJICAgIE1vZDQga2V5CgkJNQkgICAgTW9kNSBrZXkKCUNvbWJpbmF0aW9ucyBhcmUgYWxsb3dlZCwgZm9yIGV4YW1wbGUgIlMtQy1zcGFjZSIgb3IgIlNDLXNwYWNlIiBhcmUKCWJvdGggc2hpZnQrY3RybCtzcGFjZS4KCVNlZSA8WDExL2tleXN5bWRlZi5oPiBhbmQgWFN0cmluZ1RvS2V5c3ltIGZvciBLRVlfU1RSSU5HLgoKCUV4YW1wbGU6ID4KCQk6c2V0IGltYWN0aXZhdGVrZXk9Uy1zcGFjZQo8CSJTLXNwYWNlIiBtZWFucyBzaGlmdCtzcGFjZS4gIFRoaXMgaXMgdGhlIGFjdGl2YXRpb24ga2V5IGZvciBraW5wdXQyICsKCWNhbm5hIChKYXBhbmVzZSksIGFuZCBhbWkgKEtvcmVhbikuCgoJCQkJKidpbWNtZGxpbmUnKiAqJ2ltYycqIConbm9pbWNtZGxpbmUnKiAqJ25vaW1jJyoKJ2ltY21kbGluZScgJ2ltYycJYm9vbGVhbiAoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3hpbXwKCQkJfCttdWx0aV9ieXRlX2ltZXwgb3IgfGdsb2JhbC1pbWV8IGZlYXR1cmV9CglXaGVuIHNldCB0aGUgSW5wdXQgTWV0aG9kIGlzIGFsd2F5cyBvbiB3aGVuIHN0YXJ0aW5nIHRvIGVkaXQgYSBjb21tYW5kCglsaW5lLCB1bmxlc3MgZW50ZXJpbmcgYSBzZWFyY2ggcGF0dGVybiAoc2VlICdpbXNlYXJjaCcgZm9yIHRoYXQpLgoJU2V0dGluZyB0aGlzIG9wdGlvbiBpcyB1c2VmdWwgd2hlbiB5b3VyIGlucHV0IG1ldGhvZCBhbGxvd3MgZW50ZXJpbmcKCUVuZ2xpc2ggY2hhcmFjdGVycyBkaXJlY3RseSwgZS5nLiwgd2hlbiBpdCdzIHVzZWQgdG8gdHlwZSBhY2NlbnRlZAoJY2hhcmFjdGVycyB3aXRoIGRlYWQga2V5cy4KCgkJCQkqJ2ltZGlzYWJsZScqIConaW1kJyogKidub2Rpc2FibGUnKiAqJ25vaW1kJyoKJ2ltZGlzYWJsZScgJ2ltZCcJYm9vbGVhbiAoZGVmYXVsdCBvZmYsIG9uIGZvciBzb21lIHN5c3RlbXMgKFNHSSkpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3hpbXwKCQkJfCttdWx0aV9ieXRlX2ltZXwgb3IgfGdsb2JhbC1pbWV8IGZlYXR1cmV9CglXaGVuIHNldCB0aGUgSW5wdXQgTWV0aG9kIGlzIG5ldmVyIHVzZWQuICBUaGlzIGlzIHVzZWZ1bCB0byBkaXNhYmxlCgl0aGUgSU0gd2hlbiBpdCBkb2Vzbid0IHdvcmsgcHJvcGVybHkuCglDdXJyZW50bHkgdGhpcyBvcHRpb24gaXMgb24gYnkgZGVmYXVsdCBmb3IgU0dJL0lSSVggbWFjaGluZXMuICBUaGlzCgltYXkgY2hhbmdlIGluIGxhdGVyIHJlbGVhc2VzLgoKCQkJCQkJKidpbWluc2VydCcqIConaW1pJyoKJ2ltaW5zZXJ0JyAnaW1pJwludW1iZXIgKGRlZmF1bHQgMCwgMiB3aGVuIGFuIGlucHV0IG1ldGhvZCBpcyBzdXBwb3J0ZWQpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJU3BlY2lmaWVzIHdoZXRoZXIgOmxtYXAgb3IgYW4gSW5wdXQgTWV0aG9kIChJTSkgaXMgdG8gYmUgdXNlZCBpbgoJSW5zZXJ0IG1vZGUuICBWYWxpZCB2YWx1ZXM6CgkJMAk6bG1hcCBpcyBvZmYgYW5kIElNIGlzIG9mZgoJCTEJOmxtYXAgaXMgT04gYW5kIElNIGlzIG9mZgoJCTIJOmxtYXAgaXMgb2ZmIGFuZCBJTSBpcyBPTgoJMiBpcyBhdmFpbGFibGUgb25seSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbXVsdGlfYnl0ZV9pbWV8LCB8K3hpbXwKCW9yIHxnbG9iYWwtaW1lfC4KCVRvIGFsd2F5cyByZXNldCB0aGUgb3B0aW9uIHRvIHplcm8gd2hlbiBsZWF2aW5nIEluc2VydCBtb2RlIHdpdGggPEVzYz4KCXRoaXMgY2FuIGJlIHVzZWQ6ID4KCQk6aW5vcmVtYXAgPEVTQz4gPEVTQz46c2V0IGltaW5zZXJ0PTA8Q1I+CjwJVGhpcyBtYWtlcyA6bG1hcCBhbmQgSU0gdHVybiBvZmYgYXV0b21hdGljYWxseSB3aGVuIGxlYXZpbmcgSW5zZXJ0Cgltb2RlLgoJTm90ZSB0aGF0IHRoaXMgb3B0aW9uIGNoYW5nZXMgd2hlbiB1c2luZyBDVFJMLV4gaW4gSW5zZXJ0IG1vZGUKCXxpX0NUUkwtXnwuCglUaGUgdmFsdWUgaXMgc2V0IHRvIDEgd2hlbiBzZXR0aW5nICdrZXltYXAnIHRvIGEgdmFsaWQga2V5bWFwIG5hbWUuCglJdCBpcyBhbHNvIHVzZWQgZm9yIHRoZSBhcmd1bWVudCBvZiBjb21tYW5kcyBsaWtlICJyIiBhbmQgImYiLgoJVGhlIHZhbHVlIDAgbWF5IG5vdCB3b3JrIGNvcnJlY3RseSB3aXRoIEF0aGVuYSBhbmQgTW90aWYgd2l0aCBzb21lIFhJTQoJbWV0aG9kcy4gIFVzZSAnaW1kaXNhYmxlJyB0byBkaXNhYmxlIFhJTSB0aGVuLgoKCQkJCQkJKidpbXNlYXJjaCcqIConaW1zJyoKJ2ltc2VhcmNoJyAnaW1zJwludW1iZXIgKGRlZmF1bHQgMCwgMiB3aGVuIGFuIGlucHV0IG1ldGhvZCBpcyBzdXBwb3J0ZWQpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJU3BlY2lmaWVzIHdoZXRoZXIgOmxtYXAgb3IgYW4gSW5wdXQgTWV0aG9kIChJTSkgaXMgdG8gYmUgdXNlZCB3aGVuCgllbnRlcmluZyBhIHNlYXJjaCBwYXR0ZXJuLiAgVmFsaWQgdmFsdWVzOgoJCS0xCXRoZSB2YWx1ZSBvZiAnaW1pbnNlcnQnIGlzIHVzZWQsIG1ha2VzIGl0IGxvb2sgbGlrZQoJCQknaW1pbnNlcnQnIGlzIGFsc28gdXNlZCB3aGVuIHR5cGluZyBhIHNlYXJjaCBwYXR0ZXJuCgkJMAk6bG1hcCBpcyBvZmYgYW5kIElNIGlzIG9mZgoJCTEJOmxtYXAgaXMgT04gYW5kIElNIGlzIG9mZgoJCTIJOmxtYXAgaXMgb2ZmIGFuZCBJTSBpcyBPTgoJTm90ZSB0aGF0IHRoaXMgb3B0aW9uIGNoYW5nZXMgd2hlbiB1c2luZyBDVFJMLV4gaW4gQ29tbWFuZC1saW5lIG1vZGUKCXxjX0NUUkwtXnwuCglUaGUgdmFsdWUgaXMgc2V0IHRvIDEgd2hlbiBpdCBpcyBub3QgLTEgYW5kIHNldHRpbmcgdGhlICdrZXltYXAnCglvcHRpb24gdG8gYSB2YWxpZCBrZXltYXAgbmFtZS4KCVRoZSB2YWx1ZSAwIG1heSBub3Qgd29yayBjb3JyZWN0bHkgd2l0aCBBdGhlbmEgYW5kIE1vdGlmIHdpdGggc29tZSBYSU0KCW1ldGhvZHMuICBVc2UgJ2ltZGlzYWJsZScgdG8gZGlzYWJsZSBYSU0gdGhlbi4KCgkJCQkJCSonaW5jbHVkZScqIConaW5jJyoKJ2luY2x1ZGUnICdpbmMnCQlzdHJpbmcJKGRlZmF1bHQgIl5ccyojXHMqaW5jbHVkZSIpCgkJCWdsb2JhbCBvciBsb2NhbCB0byBidWZmZXIgfGdsb2JhbC1sb2NhbHwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZQoJCQl8K2ZpbmRfaW5fcGF0aHwgZmVhdHVyZX0KCVBhdHRlcm4gdG8gYmUgdXNlZCB0byBmaW5kIGFuIGluY2x1ZGUgY29tbWFuZC4gIEl0IGlzIGEgc2VhcmNoCglwYXR0ZXJuLCBqdXN0IGxpa2UgZm9yIHRoZSAiLyIgY29tbWFuZCAoU2VlIHxwYXR0ZXJufCkuICBUaGUgZGVmYXVsdAoJdmFsdWUgaXMgZm9yIEMgcHJvZ3JhbXMuICBUaGlzIG9wdGlvbiBpcyB1c2VkIGZvciB0aGUgY29tbWFuZHMgIltpIiwKCSJdSSIsICJbZCIsIGV0Yy4gIFRoZSAnaXNmbmFtZScgb3B0aW9uIGlzIHVzZWQgdG8gcmVjb2duaXplIHRoZSBmaWxlCgluYW1lIHRoYXQgY29tZXMgYWZ0ZXIgdGhlIG1hdGNoZWQgcGF0dGVybi4gIFNlZSB8b3B0aW9uLWJhY2tzbGFzaHwKCWFib3V0IGluY2x1ZGluZyBzcGFjZXMgYW5kIGJhY2tzbGFzaGVzLgoKCQkJCQkJKidpbmNsdWRlZXhwcicqIConaW5leCcqCidpbmNsdWRlZXhwcicgJ2luZXgnCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUKCQkJfCtmaW5kX2luX3BhdGh8IG9yIHwrZXZhbHwgZmVhdHVyZX0KCUV4cHJlc3Npb24gdG8gYmUgdXNlZCB0byB0cmFuc2Zvcm0gdGhlIHN0cmluZyBmb3VuZCB3aXRoIHRoZSAnaW5jbHVkZScKCW9wdGlvbiB0byBhIGZpbGUgbmFtZS4gIE1vc3RseSB1c2VmdWwgdG8gY2hhbmdlICIuIiB0byAiLyIgZm9yIEphdmE6ID4KCQk6c2V0IGluY2x1ZGVleHByPXN1YnN0aXR1dGUodjpmbmFtZSwnXFwuJywnLycsJ2cnKQo8CVRoZSAidjpmbmFtZSIgdmFyaWFibGUgd2lsbCBiZSBzZXQgdG8gdGhlIGZpbGUgbmFtZSB0aGF0IHdhcyBkZXRlY3RlZC4KCUV2YWx1YXRlZCBpbiB0aGUgfHNhbmRib3h8LgoJQWxzbyB1c2VkIGZvciB0aGUgfGdmfCBjb21tYW5kIGlmIGFuIHVubW9kaWZpZWQgZmlsZSBuYW1lIGNhbid0IGJlCglmb3VuZC4gIEFsbG93cyBkb2luZyAiZ2YiIG9uIHRoZSBuYW1lIGFmdGVyIGFuICdpbmNsdWRlJyBzdGF0ZW1lbnQuCglBbHNvIHVzZWQgZm9yIHw8Y2ZpbGU+fC4KCgkJCQkgKidpbmNzZWFyY2gnKiAqJ2lzJyogKidub2luY3NlYXJjaCcqIConbm9pcycqCidpbmNzZWFyY2gnICdpcycJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlCgkJCXwrZXh0cmFfc2VhcmNofCBmZWF0dXJlfQoJV2hpbGUgdHlwaW5nIGEgc2VhcmNoIGNvbW1hbmQsIHNob3cgd2hlcmUgdGhlIHBhdHRlcm4sIGFzIGl0IHdhcyB0eXBlZAoJc28gZmFyLCBtYXRjaGVzLiAgVGhlIG1hdGNoZWQgc3RyaW5nIGlzIGhpZ2hsaWdodGVkLiAgSWYgdGhlIHBhdHRlcm4KCWlzIGludmFsaWQgb3Igbm90IGZvdW5kLCBub3RoaW5nIGlzIHNob3duLiAgVGhlIHNjcmVlbiB3aWxsIGJlIHVwZGF0ZWQKCW9mdGVuLCB0aGlzIGlzIG9ubHkgdXNlZnVsIG9uIGZhc3QgdGVybWluYWxzLgoJTm90ZSB0aGF0IHRoZSBtYXRjaCB3aWxsIGJlIHNob3duLCBidXQgdGhlIGN1cnNvciB3aWxsIHJldHVybiB0byBpdHMKCW9yaWdpbmFsIHBvc2l0aW9uIHdoZW4gbm8gbWF0Y2ggaXMgZm91bmQgYW5kIHdoZW4gcHJlc3NpbmcgPEVzYz4uICBZb3UKCXN0aWxsIG5lZWQgdG8gZmluaXNoIHRoZSBzZWFyY2ggY29tbWFuZCB3aXRoIDxFbnRlcj4gdG8gbW92ZSB0aGUKCWN1cnNvciB0byB0aGUgbWF0Y2guCglUaGUgaGlnaGxpZ2h0aW5nIGNhbiBiZSBzZXQgd2l0aCB0aGUgJ2knIGZsYWcgaW4gJ2hpZ2hsaWdodCcuCglTZWUgYWxzbzogJ2hsc2VhcmNoJy4KCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHJlc2V0IHdoZW4gJ2NvbXBhdGlibGUnIGlzIHNldC4KCgkJCQkJCSonaW5kZW50ZXhwcicqIConaW5kZScqCidpbmRlbnRleHByJyAnaW5kZScJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2NpbmRlbnR8CgkJCW9yIHwrZXZhbHwgZmVhdHVyZXN9CglFeHByZXNzaW9uIHdoaWNoIGlzIGV2YWx1YXRlZCB0byBvYnRhaW4gdGhlIHByb3BlciBpbmRlbnQgZm9yIGEgbGluZS4KCUl0IGlzIHVzZWQgd2hlbiBhIG5ldyBsaW5lIGlzIGNyZWF0ZWQsIGZvciB0aGUgfD18IG9wZXJhdG9yIGFuZAoJaW4gSW5zZXJ0IG1vZGUgYXMgc3BlY2lmaWVkIHdpdGggdGhlICdpbmRlbnRrZXlzJyBvcHRpb24uCglXaGVuIHRoaXMgb3B0aW9uIGlzIG5vdCBlbXB0eSwgaXQgb3ZlcnJ1bGVzIHRoZSAnY2luZGVudCcgYW5kCgknc21hcnRpbmRlbnQnIGluZGVudGluZy4KCVdoZW4gJ3Bhc3RlJyBpcyBzZXQgdGhpcyBvcHRpb24gaXMgbm90IHVzZWQgZm9yIGluZGVudGluZy4KCVRoZSBleHByZXNzaW9uIGlzIGV2YWx1YXRlZCB3aXRoIHx2OmxudW18IHNldCB0byB0aGUgbGluZSBudW1iZXIgZm9yCgl3aGljaCB0aGUgaW5kZW50IGlzIHRvIGJlIGNvbXB1dGVkLiAgVGhlIGN1cnNvciBpcyBhbHNvIGFzIHRoaXMgbGluZQoJd2hlbiB0aGUgZXhwcmVzc2lvbiBpcyBldmFsdWF0ZWQgKGJ1dCBpdCBtYXkgYmUgbW92ZWQgYXJvdW5kKS4KCVRoZSBleHByZXNzaW9uIG11c3QgcmV0dXJuIHRoZSBudW1iZXIgb2Ygc3BhY2VzIHdvcnRoIG9mIGluZGVudC4gIEl0CgljYW4gcmV0dXJuICItMSIgdG8ga2VlcCB0aGUgY3VycmVudCBpbmRlbnQgKHRoaXMgbWVhbnMgJ2F1dG9pbmRlbnQnIGlzCgl1c2VkIGZvciB0aGUgaW5kZW50KS4KCUZ1bmN0aW9ucyB1c2VmdWwgZm9yIGNvbXB1dGluZyB0aGUgaW5kZW50IGFyZSB8aW5kZW50KCl8LCB8Y2luZGVudCgpfAoJYW5kIHxsaXNwaW5kZW50KCl8LgoJVGhlIGV2YWx1YXRpb24gb2YgdGhlIGV4cHJlc3Npb24gbXVzdCBub3QgaGF2ZSBzaWRlIGVmZmVjdHMhICBJdCBtdXN0Cglub3QgY2hhbmdlIHRoZSB0ZXh0LCBqdW1wIHRvIGFub3RoZXIgd2luZG93LCBldGMuICBBZnRlcndhcmRzIHRoZQoJY3Vyc29yIHBvc2l0aW9uIGlzIGFsd2F5cyByZXN0b3JlZCwgdGh1cyB0aGUgY3Vyc29yIG1heSBiZSBtb3ZlZC4KCU5vcm1hbGx5IHRoaXMgb3B0aW9uIHdvdWxkIGJlIHNldCB0byBjYWxsIGEgZnVuY3Rpb246ID4KCQk6c2V0IGluZGVudGV4cHI9R2V0TXlJbmRlbnQoKQo8CUVycm9yIG1lc3NhZ2VzIHdpbGwgYmUgc3VwcHJlc3NlZCwgdW5sZXNzIHRoZSAnZGVidWcnIG9wdGlvbiBjb250YWlucwoJIm1zZyIuCglTZWUgfGluZGVudC1leHByZXNzaW9ufC4gIEFsc28gc2VlIHxldmFsLXNhbmRib3h8LgoJTk9URTogVGhpcyBvcHRpb24gaXMgbWFkZSBlbXB0eSB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkJCQkqJ2luZGVudGtleXMnKiAqJ2luZGsnKgonaW5kZW50a2V5cycgJ2luZGsnCXN0cmluZwkoZGVmYXVsdCAiMHssMH0sOiwwIywhXkYsbyxPLGUiKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2NpbmRlbnR8CgkJCWZlYXR1cmV9CglBIGxpc3Qgb2Yga2V5cyB0aGF0LCB3aGVuIHR5cGVkIGluIEluc2VydCBtb2RlLCBjYXVzZSByZWluZGVudGluZyBvZgoJdGhlIGN1cnJlbnQgbGluZS4gIE9ubHkgaGFwcGVucyBpZiAnaW5kZW50ZXhwcicgaXNuJ3QgZW1wdHkuCglUaGUgZm9ybWF0IGlzIGlkZW50aWNhbCB0byAnY2lua2V5cycsIHNlZSB8aW5kZW50a2V5cy1mb3JtYXR8LgoJU2VlIHxDLWluZGVudGluZ3wgYW5kIHxpbmRlbnQtZXhwcmVzc2lvbnwuCgoJCQkqJ2luZmVyY2FzZScqIConaW5mJyogKidub2luZmVyY2FzZScqIConbm9pbmYnKgonaW5mZXJjYXNlJyAnaW5mJwlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CglXaGVuIGRvaW5nIGtleXdvcmQgY29tcGxldGlvbiBpbiBpbnNlcnQgbW9kZSB8aW5zLWNvbXBsZXRpb258LCBhbmQKCSdpZ25vcmVjYXNlJyBpcyBhbHNvIG9uLCB0aGUgY2FzZSBvZiB0aGUgbWF0Y2ggaXMgYWRqdXN0ZWQuICBJZiB0aGUKCXR5cGVkIHRleHQgY29udGFpbnMgYSBsb3dlcmNhc2UgbGV0dGVyIHdoZXJlIHRoZSBtYXRjaCBoYXMgYW4gdXBwZXIKCWNhc2UgbGV0dGVyLCB0aGUgY29tcGxldGVkIHBhcnQgaXMgbWFkZSBsb3dlcmNhc2UuICBJZiB0aGUgdHlwZWQgdGV4dAoJaGFzIG5vIGxvd2VyY2FzZSBsZXR0ZXJzIGFuZCB0aGUgbWF0Y2ggaGFzIGEgbG93ZXJjYXNlIGxldHRlciB3aGVyZQoJdGhlIHR5cGVkIHRleHQgaGFzIGFuIHVwcGVyY2FzZSBsZXR0ZXIsIGFuZCB0aGVyZSBpcyBhIGxldHRlciBiZWZvcmUKCWl0LCB0aGUgY29tcGxldGVkIHBhcnQgaXMgbWFkZSB1cHBlcmNhc2UuCgoJCQkqJ2luc2VydG1vZGUnKiAqJ2ltJyogKidub2luc2VydG1vZGUnKiAqJ25vaW0nKgonaW5zZXJ0bW9kZScgJ2ltJwlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglNYWtlcyBWaW0gd29yayBpbiBhIHdheSB0aGF0IEluc2VydCBtb2RlIGlzIHRoZSBkZWZhdWx0IG1vZGUuICBVc2VmdWwKCWlmIHlvdSB3YW50IHRvIHVzZSBWaW0gYXMgYSBtb2RlbGVzcyBlZGl0b3IuICBVc2VkIGZvciB8ZXZpbXwuCglUaGVzZSBJbnNlcnQgbW9kZSBjb21tYW5kcyB3aWxsIGJlIHVzZWZ1bDoKCS0gVXNlIHRoZSBjdXJzb3Iga2V5cyB0byBtb3ZlIGFyb3VuZC4KCS0gVXNlIENUUkwtTyB0byBleGVjdXRlIG9uZSBOb3JtYWwgbW9kZSBjb21tYW5kIHxpX0NUUkwtT3wpLiAgV2hlbgoJICB0aGlzIGlzIGEgbWFwcGluZywgaXQgaXMgZXhlY3V0ZWQgYXMgaWYgJ2luc2VydG1vZGUnIHdhcyBvZmYuCgkgIE5vcm1hbCBtb2RlIHJlbWFpbnMgYWN0aXZlIHVudGlsIHRoZSBtYXBwaW5nIGlzIGZpbmlzaGVkLgoJCQkJCQkJCSppX0NUUkwtTCoKCS0gVXNlIENUUkwtTCB0byBleGVjdXRlIGEgbnVtYmVyIG9mIE5vcm1hbCBtb2RlIGNvbW1hbmRzLCB0aGVuIHVzZQoJICA8RXNjPiB0byBnZXQgYmFjayB0byBJbnNlcnQgbW9kZS4KCglUaGVzZSBpdGVtcyBjaGFuZ2Ugd2hlbiAnaW5zZXJ0bW9kZScgaXMgc2V0OgoJLSB3aGVuIHN0YXJ0aW5nIHRvIGVkaXQgb2YgYSBmaWxlLCBWaW0gZ29lcyB0byBJbnNlcnQgbW9kZS4KCS0gPEVzYz4gaW4gSW5zZXJ0IG1vZGUgaXMgYSBuby1vcCBhbmQgYmVlcHMuCgktIDxFc2M+IGluIE5vcm1hbCBtb2RlIG1ha2VzIFZpbSBnbyB0byBJbnNlcnQgbW9kZS4KCS0gQ1RSTC1MIGluIEluc2VydCBtb2RlIGlzIGEgY29tbWFuZCwgaXQgaXMgbm90IGluc2VydGVkLgoJLSBDVFJMLVogaW4gSW5zZXJ0IG1vZGUgc3VzcGVuZHMgVmltLCBzZWUgfENUUkwtWnwuCSppX0NUUkwtWioKCUhvd2V2ZXIsIHdoZW4gPEVzYz4gaXMgdXNlZCBpbnNpZGUgYSBtYXBwaW5nLCBpdCBiZWhhdmVzIGxpa2UKCSdpbnNlcnRtb2RlJyB3YXMgbm90IHNldC4gIFRoaXMgd2FzIGRvbmUgdG8gYmUgYWJsZSB0byB1c2UgdGhlIHNhbWUKCW1hcHBpbmdzIHdpdGggJ2luc2VydG1vZGUnIHNldCBvciBub3Qgc2V0LgoJV2hlbiBleGVjdXRpbmcgY29tbWFuZHMgd2l0aCB8Om5vcm1hbHwgJ2luc2VydG1vZGUnIGlzIG5vdCB1c2VkLgoKCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHJlc2V0IHdoZW4gJ2NvbXBhdGlibGUnIGlzIHNldC4KCgkJCQkJCSonaXNmbmFtZScqIConaXNmJyoKJ2lzZm5hbWUnICdpc2YnCQlzdHJpbmcJKGRlZmF1bHQgZm9yIE1TLURPUywgV2luMzIgYW5kIE9TLzI6CgkJCSAgICAgIkAsNDgtNTcsLyxcLC4sLSxfLCssLCwjLCQsJSx7LH0sWyxdLDosQC1ALCEsfiw9IgoJCQkgICAgZm9yIEFNSUdBOiAiQCw0OC01NywvLC4sLSxfLCssLCwkLDoiCgkJCSAgICBmb3IgVk1TOiAiQCw0OC01NywvLC4sLSxfLCssLCwjLCQsJSw8LD4sWyxdLDosOyx+IgoJCQkgICAgZm9yIE9TLzM5MDogIkAsMjQwLTI0OSwvLC4sLSxfLCssLCwjLCQsJSx+LD0iCgkJCSAgICBvdGhlcndpc2U6ICJALDQ4LTU3LC8sLiwtLF8sKywsLCMsJCwlLH4sPSIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJVGhlIGNoYXJhY3RlcnMgc3BlY2lmaWVkIGJ5IHRoaXMgb3B0aW9uIGFyZSBpbmNsdWRlZCBpbiBmaWxlIG5hbWVzIGFuZAoJcGF0aCBuYW1lcy4gIEZpbGVuYW1lcyBhcmUgdXNlZCBmb3IgY29tbWFuZHMgbGlrZSAiZ2YiLCAiW2kiIGFuZCBpbgoJdGhlIHRhZ3MgZmlsZS4gIEl0IGlzIGFsc28gdXNlZCBmb3IgIlxmIiBpbiBhIHxwYXR0ZXJufC4KCU11bHRpLWJ5dGUgY2hhcmFjdGVycyAyNTYgYW5kIGFib3ZlIGFyZSBhbHdheXMgaW5jbHVkZWQsIG9ubHkgdGhlCgljaGFyYWN0ZXJzIHVwIHRvIDI1NSBhcmUgc3BlY2lmaWVkIHdpdGggdGhpcyBvcHRpb24uCglGb3IgVVRGLTggdGhlIGNoYXJhY3RlcnMgMHhhMCB0byAweGZmIGFyZSBpbmNsdWRlZCBhcyB3ZWxsLgoKCU5vdGUgdGhhdCBvbiBzeXN0ZW1zIHVzaW5nIGEgYmFja3NsYXNoIGFzIHBhdGggc2VwYXJhdG9yLCBWaW0gdHJpZXMgdG8KCWRvIGl0cyBiZXN0IHRvIG1ha2UgaXQgd29yayBhcyB5b3Ugd291bGQgZXhwZWN0LiAgVGhhdCBpcyBhIGJpdAoJdHJpY2t5LCBzaW5jZSBWaSBvcmlnaW5hbGx5IHVzZWQgdGhlIGJhY2tzbGFzaCB0byBlc2NhcGUgc3BlY2lhbAoJY2hhcmFjdGVycy4gIFZpbSB3aWxsIG5vdCByZW1vdmUgYSBiYWNrc2xhc2ggaW4gZnJvbnQgb2YgYSBub3JtYWwgZmlsZQoJbmFtZSBjaGFyYWN0ZXIgb24gdGhlc2Ugc3lzdGVtcywgYnV0IGl0IHdpbGwgb24gVW5peCBhbmQgYWxpa2VzLiAgVGhlCgknJicgYW5kICdeJyBhcmUgbm90IGluY2x1ZGVkIGJ5IGRlZmF1bHQsIGJlY2F1c2UgdGhlc2UgYXJlIHNwZWNpYWwgZm9yCgljbWQuZXhlLgoKCVRoZSBmb3JtYXQgb2YgdGhpcyBvcHRpb24gaXMgYSBsaXN0IG9mIHBhcnRzLCBzZXBhcmF0ZWQgd2l0aCBjb21tYXMuCglFYWNoIHBhcnQgY2FuIGJlIGEgc2luZ2xlIGNoYXJhY3RlciBudW1iZXIgb3IgYSByYW5nZS4gIEEgcmFuZ2UgaXMgdHdvCgljaGFyYWN0ZXIgbnVtYmVycyB3aXRoICctJyBpbiBiZXR3ZWVuLiAgQSBjaGFyYWN0ZXIgbnVtYmVyIGNhbiBiZSBhCglkZWNpbWFsIG51bWJlciBiZXR3ZWVuIDAgYW5kIDI1NSBvciB0aGUgQVNDSUkgY2hhcmFjdGVyIGl0c2VsZiAoZG9lcwoJbm90IHdvcmsgZm9yIGRpZ2l0cykuICBFeGFtcGxlOgoJCSJfLC0sMTI4LTE0MCwjLTQzIgkoaW5jbHVkZSAnXycgYW5kICctJyBhbmQgdGhlIHJhbmdlCgkJCQkJMTI4IHRvIDE0MCBhbmQgJyMnIHRvIDQzKQoJSWYgYSBwYXJ0IHN0YXJ0cyB3aXRoICdeJywgdGhlIGZvbGxvd2luZyBjaGFyYWN0ZXIgbnVtYmVyIG9yIHJhbmdlCgl3aWxsIGJlIGV4Y2x1ZGVkIGZyb20gdGhlIG9wdGlvbi4gIFRoZSBvcHRpb24gaXMgaW50ZXJwcmV0ZWQgZnJvbSBsZWZ0Cgl0byByaWdodC4gIFB1dCB0aGUgZXhjbHVkZWQgY2hhcmFjdGVyIGFmdGVyIHRoZSByYW5nZSB3aGVyZSBpdCBpcwoJaW5jbHVkZWQuICBUbyBpbmNsdWRlICdeJyBpdHNlbGYgdXNlIGl0IGFzIHRoZSBsYXN0IGNoYXJhY3RlciBvZiB0aGUKCW9wdGlvbiBvciB0aGUgZW5kIG9mIGEgcmFuZ2UuICBFeGFtcGxlOgoJCSJeYS16LCMsXiIJKGV4Y2x1ZGUgJ2EnIHRvICd6JywgaW5jbHVkZSAnIycgYW5kICdeJykKCUlmIHRoZSBjaGFyYWN0ZXIgaXMgJ0AnLCBhbGwgY2hhcmFjdGVycyB3aGVyZSBpc2FscGhhKCkgcmV0dXJucyBUUlVFCglhcmUgaW5jbHVkZWQuICBOb3JtYWxseSB0aGVzZSBhcmUgdGhlIGNoYXJhY3RlcnMgYSB0byB6IGFuZCBBIHRvIFosCglwbHVzIGFjY2VudGVkIGNoYXJhY3RlcnMuICBUbyBpbmNsdWRlICdAJyBpdHNlbGYgdXNlICJALUAiLiAgRXhhbXBsZXM6CgkJIkAsXmEteiIJQWxsIGFscGhhYmV0aWMgY2hhcmFjdGVycywgZXhjbHVkaW5nIGxvd2VyCgkJCQljYXNlIGxldHRlcnMuCgkJImEteixBLVosQC1AIglBbGwgbGV0dGVycyBwbHVzIHRoZSAnQCcgY2hhcmFjdGVyLgoJQSBjb21tYSBjYW4gYmUgaW5jbHVkZWQgYnkgdXNpbmcgaXQgd2hlcmUgYSBjaGFyYWN0ZXIgbnVtYmVyIGlzCglleHBlY3RlZC4gIEV4YW1wbGU6CgkJIjQ4LTU3LCwsXyIJRGlnaXRzLCBjb21tYSBhbmQgdW5kZXJzY29yZS4KCUEgY29tbWEgY2FuIGJlIGV4Y2x1ZGVkIGJ5IHByZXBlbmRpbmcgYSAnXicuICBFeGFtcGxlOgoJCSIgLX4sXiwsOSIJQWxsIGNoYXJhY3RlcnMgZnJvbSBzcGFjZSB0byAnficsIGV4Y2x1ZGluZwoJCQkJY29tbWEsIHBsdXMgPFRhYj4uCglTZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0IGluY2x1ZGluZyBzcGFjZXMgYW5kIGJhY2tzbGFzaGVzLgoKCQkJCQkJKidpc2lkZW50JyogKidpc2knKgonaXNpZGVudCcgJ2lzaScJCXN0cmluZwkoZGVmYXVsdCBmb3IgTVMtRE9TLCBXaW4zMiBhbmQgT1MvMjoKCQkJCQkgICAiQCw0OC01NyxfLDEyOC0xNjcsMjI0LTIzNSIKCQkJCW90aGVyd2lzZTogIkAsNDgtNTcsXywxOTItMjU1IikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglUaGUgY2hhcmFjdGVycyBnaXZlbiBieSB0aGlzIG9wdGlvbiBhcmUgaW5jbHVkZWQgaW4gaWRlbnRpZmllcnMuCglJZGVudGlmaWVycyBhcmUgdXNlZCBpbiByZWNvZ25pemluZyBlbnZpcm9ubWVudCB2YXJpYWJsZXMgYW5kIGFmdGVyIGEKCW1hdGNoIG9mIHRoZSAnZGVmaW5lJyBvcHRpb24uICBJdCBpcyBhbHNvIHVzZWQgZm9yICJcaSIgaW4gYQoJfHBhdHRlcm58LiAgU2VlICdpc2ZuYW1lJyBmb3IgYSBkZXNjcmlwdGlvbiBvZiB0aGUgZm9ybWF0IG9mIHRoaXMKCW9wdGlvbi4KCUNhcmVmdWw6IElmIHlvdSBjaGFuZ2UgdGhpcyBvcHRpb24sIGl0IG1pZ2h0IGJyZWFrIGV4cGFuZGluZwoJZW52aXJvbm1lbnQgdmFyaWFibGVzLiAgRS5nLiwgd2hlbiAnLycgaXMgaW5jbHVkZWQgYW5kIFZpbSB0cmllcyB0bwoJZXhwYW5kICIkSE9NRS8udmltaW5mbyIuICBNYXliZSB5b3Ugc2hvdWxkIGNoYW5nZSAnaXNrZXl3b3JkJyBpbnN0ZWFkLgoKCQkJCQkJKidpc2tleXdvcmQnKiAqJ2lzaycqCidpc2tleXdvcmQnICdpc2snCXN0cmluZyAoVmltIGRlZmF1bHQgZm9yIE1TLURPUyBhbmQgV2luMzI6CgkJCQkJICAgICJALDQ4LTU3LF8sMTI4LTE2NywyMjQtMjM1IgoJCQkJICAgb3RoZXJ3aXNlOiAgIkAsNDgtNTcsXywxOTItMjU1IgoJCQkJVmkgZGVmYXVsdDogIkAsNDgtNTcsXyIpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJS2V5d29yZHMgYXJlIHVzZWQgaW4gc2VhcmNoaW5nIGFuZCByZWNvZ25pemluZyB3aXRoIG1hbnkgY29tbWFuZHM6CgkidyIsICIqIiwgIltpIiwgZXRjLiAgSXQgaXMgYWxzbyB1c2VkIGZvciAiXGsiIGluIGEgfHBhdHRlcm58LiAgU2VlCgknaXNmbmFtZScgZm9yIGEgZGVzY3JpcHRpb24gb2YgdGhlIGZvcm1hdCBvZiB0aGlzIG9wdGlvbi4gIEZvciBDCglwcm9ncmFtcyB5b3UgY291bGQgdXNlICJhLXosQS1aLDQ4LTU3LF8sLiwtLD4iLgoJRm9yIGEgaGVscCBmaWxlIGl0IGlzIHNldCB0byBhbGwgbm9uLWJsYW5rIHByaW50YWJsZSBjaGFyYWN0ZXJzIGV4Y2VwdAoJJyonLCAnIicgYW5kICd8JyAoc28gdGhhdCBDVFJMLV0gb24gYSBjb21tYW5kIGZpbmRzIHRoZSBoZWxwIGZvciB0aGF0Cgljb21tYW5kKS4KCVdoZW4gdGhlICdsaXNwJyBvcHRpb24gaXMgb24gdGhlICctJyBjaGFyYWN0ZXIgaXMgYWx3YXlzIGluY2x1ZGVkLgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIHRoZSBWaSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzCglzZXQgYW5kIHRvIHRoZSBWaW0gZGVmYXVsdCB2YWx1ZSB3aGVuICdjb21wYXRpYmxlJyBpcyByZXNldC4KCgkJCQkJCSonaXNwcmludCcqIConaXNwJyoKJ2lzcHJpbnQnICdpc3AnCXN0cmluZwkoZGVmYXVsdCBmb3IgTVMtRE9TLCBXaW4zMiwgT1MvMiBhbmQgTWFjaW50b3NoOgoJCQkJIkAsfi0yNTUiOyBvdGhlcndpc2U6ICJALDE2MS0yNTUiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVRoZSBjaGFyYWN0ZXJzIGdpdmVuIGJ5IHRoaXMgb3B0aW9uIGFyZSBkaXNwbGF5ZWQgZGlyZWN0bHkgb24gdGhlCglzY3JlZW4uICBJdCBpcyBhbHNvIHVzZWQgZm9yICJccCIgaW4gYSB8cGF0dGVybnwuICBUaGUgY2hhcmFjdGVycyBmcm9tCglzcGFjZSAoQVNDSUkgMzIpIHRvICd+JyAoQVNDSUkgMTI2KSBhcmUgYWx3YXlzIGRpc3BsYXllZCBkaXJlY3RseSwKCWV2ZW4gd2hlbiB0aGV5IGFyZSBub3QgaW5jbHVkZWQgaW4gJ2lzcHJpbnQnIG9yIGV4Y2x1ZGVkLiAgU2VlCgknaXNmbmFtZScgZm9yIGEgZGVzY3JpcHRpb24gb2YgdGhlIGZvcm1hdCBvZiB0aGlzIG9wdGlvbi4KCglOb24tcHJpbnRhYmxlIGNoYXJhY3RlcnMgYXJlIGRpc3BsYXllZCB3aXRoIHR3byBjaGFyYWN0ZXJzOgoJCSAgMCAtICAzMQkiXkAiIC0gIl5fIgoJCSAzMiAtIDEyNglhbHdheXMgc2luZ2xlIGNoYXJhY3RlcnMKCQkgICAxMjcJCSJePyIKCQkxMjggLSAxNTkJIn5AIiAtICJ+XyIKCQkxNjAgLSAyNTQJInwgIiAtICJ8fiIKCQkgICAyNTUJCSJ+PyIKCVdoZW4gJ2VuY29kaW5nJyBpcyBhIFVuaWNvZGUgb25lLCBpbGxlZ2FsIGJ5dGVzIGZyb20gMTI4IHRvIDI1NSBhcmUKCWRpc3BsYXllZCBhcyA8eHg+LCB3aXRoIHRoZSBoZXhhZGVjaW1hbCB2YWx1ZSBvZiB0aGUgYnl0ZS4KCVdoZW4gJ2Rpc3BsYXknIGNvbnRhaW5zICJ1aGV4IiBhbGwgdW5wcmludGFibGUgY2hhcmFjdGVycyBhcmUKCWRpc3BsYXllZCBhcyA8eHg+LgoJVGhlIE5vblRleHQgaGlnaGxpZ2h0aW5nIHdpbGwgYmUgdXNlZCBmb3IgdW5wcmludGFibGUgY2hhcmFjdGVycy4KCXxobC1Ob25UZXh0fAoKCU11bHRpLWJ5dGUgY2hhcmFjdGVycyAyNTYgYW5kIGFib3ZlIGFyZSBhbHdheXMgaW5jbHVkZWQsIG9ubHkgdGhlCgljaGFyYWN0ZXJzIHVwIHRvIDI1NSBhcmUgc3BlY2lmaWVkIHdpdGggdGhpcyBvcHRpb24uICBXaGVuIGEgY2hhcmFjdGVyCglpcyBwcmludGFibGUgYnV0IGl0IGlzIG5vdCBhdmFpbGFibGUgaW4gdGhlIGN1cnJlbnQgZm9udCwgYQoJcmVwbGFjZW1lbnQgY2hhcmFjdGVyIHdpbGwgYmUgc2hvd24uCglVbnByaW50YWJsZSBhbmQgemVyby13aWR0aCBVbmljb2RlIGNoYXJhY3RlcnMgYXJlIGRpc3BsYXllZCBhcyA8eHh4eD4uCglUaGVyZSBpcyBubyBvcHRpb24gdG8gc3BlY2lmeSB0aGVzZSBjaGFyYWN0ZXJzLgoKCQkJKidqb2luc3BhY2VzJyogKidqcycqIConbm9qb2luc3BhY2VzJyogKidub2pzJyoKJ2pvaW5zcGFjZXMnICdqcycJYm9vbGVhbgkoZGVmYXVsdCBvbikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglJbnNlcnQgdHdvIHNwYWNlcyBhZnRlciBhICcuJywgJz8nIGFuZCAnIScgd2l0aCBhIGpvaW4gY29tbWFuZC4KCVdoZW4gJ2Nwb3B0aW9ucycgaW5jbHVkZXMgdGhlICdqJyBmbGFnLCBvbmx5IGRvIHRoaXMgYWZ0ZXIgYSAnLicuCglPdGhlcndpc2Ugb25seSBvbmUgc3BhY2UgaXMgaW5zZXJ0ZWQuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyBzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJCSona2V5JyoKJ2tleScJCQlzdHJpbmcJKGRlZmF1bHQgIiIpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJVGhlIGtleSB0aGF0IGlzIHVzZWQgZm9yIGVuY3J5cHRpbmcgYW5kIGRlY3J5cHRpbmcgdGhlIGN1cnJlbnQgYnVmZmVyLgoJU2VlIHxlbmNyeXB0aW9ufC4KCUNhcmVmdWw6IERvIG5vdCBzZXQgdGhlIGtleSB2YWx1ZSBieSBoYW5kLCBzb21lb25lIG1pZ2h0IHNlZSB0aGUgdHlwZWQKCWtleS4gIFVzZSB0aGUgfDpYfCBjb21tYW5kLiAgQnV0IHlvdSBjYW4gbWFrZSAna2V5JyBlbXB0eTogPgoJCTpzZXQga2V5PQo8CUl0IGlzIG5vdCBwb3NzaWJsZSB0byBnZXQgdGhlIHZhbHVlIG9mIHRoaXMgb3B0aW9uIHdpdGggIjpzZXQga2V5IiBvcgoJImVjaG8gJmtleSIuICBUaGlzIGlzIHRvIGF2b2lkIHNob3dpbmcgaXQgdG8gc29tZW9uZSB3aG8gc2hvdWxkbid0Cglrbm93LiAgSXQgYWxzbyBtZWFucyB5b3UgY2Fubm90IHNlZSBpdCB5b3Vyc2VsZiBvbmNlIHlvdSBoYXZlIHNldCBpdCwKCWJlIGNhcmVmdWwgbm90IHRvIG1ha2UgYSB0eXBpbmcgZXJyb3IhCgoJCQkJCSona2V5bWFwJyogKidrbXAnKiAqRTU0NCoKJ2tleW1hcCcgJ2ttcCcJCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwra2V5bWFwfAoJCQlmZWF0dXJlfQoJTmFtZSBvZiBhIGtleWJvYXJkIG1hcHBpbmcuICBTZWUgfG1ieXRlLWtleW1hcHwuCglTZXR0aW5nIHRoaXMgb3B0aW9uIHRvIGEgdmFsaWQga2V5bWFwIG5hbWUgaGFzIHRoZSBzaWRlIGVmZmVjdCBvZgoJc2V0dGluZyAnaW1pbnNlcnQnIHRvIG9uZSwgc28gdGhhdCB0aGUga2V5bWFwIGJlY29tZXMgZWZmZWN0aXZlLgoJJ2ltc2VhcmNoJyBpcyBhbHNvIHNldCB0byBvbmUsIHVubGVzcyBpdCB3YXMgLTEKCU9ubHkgbm9ybWFsIGZpbGUgbmFtZSBjaGFyYWN0ZXJzIGNhbiBiZSB1c2VkLCAiL1wqP1t8PD4iIGFyZSBpbGxlZ2FsLgoKCQkJCQkqJ2tleW1vZGVsJyogKidrbScqCidrZXltb2RlbCcgJ2ttJwkJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCUxpc3Qgb2YgY29tbWEgc2VwYXJhdGVkIHdvcmRzLCB3aGljaCBlbmFibGUgc3BlY2lhbCB0aGluZ3MgdGhhdCBrZXlzCgljYW4gZG8uICBUaGVzZSB2YWx1ZXMgY2FuIGJlIHVzZWQ6CgkgICBzdGFydHNlbAlVc2luZyBhIHNoaWZ0ZWQgc3BlY2lhbCBrZXkgc3RhcnRzIHNlbGVjdGlvbiAoZWl0aGVyCgkJCVNlbGVjdCBtb2RlIG9yIFZpc3VhbCBtb2RlLCBkZXBlbmRpbmcgb24gImtleSIgYmVpbmcKCQkJcHJlc2VudCBpbiAnc2VsZWN0bW9kZScpLgoJICAgc3RvcHNlbAlVc2luZyBhIG5vdC1zaGlmdGVkIHNwZWNpYWwga2V5IHN0b3BzIHNlbGVjdGlvbi4KCVNwZWNpYWwga2V5cyBpbiB0aGlzIGNvbnRleHQgYXJlIHRoZSBjdXJzb3Iga2V5cywgPEVuZD4sIDxIb21lPiwKCTxQYWdlVXA+IGFuZCA8UGFnZURvd24+LgoJVGhlICdrZXltb2RlbCcgb3B0aW9uIGlzIHNldCBieSB0aGUgfDpiZWhhdmV8IGNvbW1hbmQuCgoJCQkJCSona2V5d29yZHByZycqICona3AnKgona2V5d29yZHByZycgJ2twJwlzdHJpbmcJKGRlZmF1bHQgIm1hbiIgb3IgIm1hbiAtcyIsICBET1M6ICI6aGVscCIsCgkJCQkJCU9TLzI6ICJ2aWV3IC8iLCBWTVM6ICJoZWxwIikKCQkJZ2xvYmFsIG9yIGxvY2FsIHRvIGJ1ZmZlciB8Z2xvYmFsLWxvY2FsfAoJCQl7bm90IGluIFZpfQoJUHJvZ3JhbSB0byB1c2UgZm9yIHRoZSB8S3wgY29tbWFuZC4gIEVudmlyb25tZW50IHZhcmlhYmxlcyBhcmUKCWV4cGFuZGVkIHw6c2V0X2VudnwuICAiOmhlbHAiIG1heSBiZSB1c2VkIHRvIGFjY2VzcyB0aGUgVmltIGludGVybmFsCgloZWxwLiAgKE5vdGUgdGhhdCBwcmV2aW91c2x5IHNldHRpbmcgdGhlIGdsb2JhbCBvcHRpb24gdG8gdGhlIGVtcHR5Cgl2YWx1ZSBkaWQgdGhpcywgd2hpY2ggaXMgbm93IGRlcHJlY2F0ZWQuKQoJV2hlbiAibWFuIiBpcyB1c2VkLCBWaW0gd2lsbCBhdXRvbWF0aWNhbGx5IHRyYW5zbGF0ZSBhIGNvdW50IGZvciB0aGUKCSJLIiBjb21tYW5kIHRvIGEgc2VjdGlvbiBudW1iZXIuICBBbHNvIGZvciAibWFuIC1zIiwgaW4gd2hpY2ggY2FzZSB0aGUKCSItcyIgaXMgcmVtb3ZlZCB3aGVuIHRoZXJlIGlzIG5vIGNvdW50LgoJU2VlIHxvcHRpb24tYmFja3NsYXNofCBhYm91dCBpbmNsdWRpbmcgc3BhY2VzIGFuZCBiYWNrc2xhc2hlcy4KCUV4YW1wbGU6ID4KCQk6c2V0IGtleXdvcmRwcmc9bWFuXCAtcwo8CVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJCQkqJ2xhbmdtYXAnKiAqJ2xtYXAnKiAqRTM1NyogKkUzNTgqCidsYW5nbWFwJyAnbG1hcCcJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtsYW5nbWFwfAoJCQlmZWF0dXJlfQoJVGhpcyBvcHRpb24gYWxsb3dzIHN3aXRjaGluZyB5b3VyIGtleWJvYXJkIGludG8gYSBzcGVjaWFsIGxhbmd1YWdlCgltb2RlLiAgV2hlbiB5b3UgYXJlIHR5cGluZyB0ZXh0IGluIEluc2VydCBtb2RlIHRoZSBjaGFyYWN0ZXJzIGFyZQoJaW5zZXJ0ZWQgZGlyZWN0bHkuICBXaGVuIGluIGNvbW1hbmQgbW9kZSB0aGUgJ2xhbmdtYXAnIG9wdGlvbiB0YWtlcwoJY2FyZSBvZiB0cmFuc2xhdGluZyB0aGVzZSBzcGVjaWFsIGNoYXJhY3RlcnMgdG8gdGhlIG9yaWdpbmFsIG1lYW5pbmcKCW9mIHRoZSBrZXkuICBUaGlzIG1lYW5zIHlvdSBkb24ndCBoYXZlIHRvIGNoYW5nZSB0aGUga2V5Ym9hcmQgbW9kZSB0bwoJYmUgYWJsZSB0byBleGVjdXRlIE5vcm1hbCBtb2RlIGNvbW1hbmRzLgoJVGhpcyBpcyB0aGUgb3Bwb3NpdGUgb2YgdGhlICdrZXltYXAnIG9wdGlvbiwgd2hlcmUgY2hhcmFjdGVycyBhcmUKCW1hcHBlZCBpbiBJbnNlcnQgbW9kZS4KCVRoaXMgb25seSB3b3JrcyBmb3IgOC1iaXQgY2hhcmFjdGVycy4gIFRoZSB2YWx1ZSBvZiAnbGFuZ21hcCcgbWF5IGJlCglzcGVjaWZpZWQgd2l0aCBtdWx0aS1ieXRlIGNoYXJhY3RlcnMgKGUuZy4sIFVURi04KSwgYnV0IG9ubHkgdGhlIGxvd2VyCgk4IGJpdHMgb2YgZWFjaCBjaGFyYWN0ZXIgd2lsbCBiZSB1c2VkLgoKCUV4YW1wbGUgKGZvciBHcmVlayk6CQkJCQkqZ3JlZWsqICA+CgkgICAgOnNldCBsYW5nbWFwPcFBLMJCLNhDLMRELMVFLNZGLMNHLMdILMlJLM5KLMpLLMtMLMxNLM1OLM9PLNBQLFFRLNFSLNNTLNRULMhVLNlWLFdXLNdYLNVZLMZaLOFhLOJiLPhjLORkLOVlLPZmLONnLOdoLOlpLO5qLOprLOtsLOxtLO1uLO9vLPBwLHFxLPFyLPNzLPR0LOh1LPl2LPJ3LPd4LPV5LOZ6CjwJRXhhbXBsZSAoZXhjaGFuZ2VzIG1lYW5pbmcgb2YgeiBhbmQgeSBmb3IgY29tbWFuZHMpOiA+CgkgICAgOnNldCBsYW5nbWFwPXp5LHl6LFpZLFlaCjwKCVRoZSAnbGFuZ21hcCcgb3B0aW9uIGlzIGEgbGlzdCBvZiBwYXJ0cywgc2VwYXJhdGVkIHdpdGggY29tbWFzLiAgRWFjaAoJcGFydCBjYW4gYmUgaW4gb25lIG9mIHR3byBmb3JtczoKCTEuICBBIGxpc3Qgb2YgcGFpcnMuICBFYWNoIHBhaXIgaXMgYSAiZnJvbSIgY2hhcmFjdGVyIGltbWVkaWF0ZWx5CgkgICAgZm9sbG93ZWQgYnkgdGhlICJ0byIgY2hhcmFjdGVyLiAgRXhhbXBsZXM6ICJhQSIsICJhQWJCY0MiLgoJMi4gIEEgbGlzdCBvZiAiZnJvbSIgY2hhcmFjdGVycywgYSBzZW1pLWNvbG9uIGFuZCBhIGxpc3Qgb2YgInRvIgoJICAgIGNoYXJhY3RlcnMuICBFeGFtcGxlOiAiYWJjO0FCQyIKCUV4YW1wbGU6ICJhQSxmZ2g7RkdILGNDZERlRSIKCVNwZWNpYWwgY2hhcmFjdGVycyBuZWVkIHRvIGJlIHByZWNlZGVkIHdpdGggYSBiYWNrc2xhc2guICBUaGVzZSBhcmUKCSI7IiwgJywnIGFuZCBiYWNrc2xhc2ggaXRzZWxmLgoKCVRoaXMgd2lsbCBhbGxvdyB5b3UgdG8gYWN0aXZhdGUgdmltIGFjdGlvbnMgd2l0aG91dCBoYXZpbmcgdG8gc3dpdGNoCgliYWNrIGFuZCBmb3J0aCBiZXR3ZWVuIHRoZSBsYW5ndWFnZXMuICBZb3VyIGxhbmd1YWdlIGNoYXJhY3RlcnMgd2lsbAoJYmUgdW5kZXJzdG9vZCBhcyBub3JtYWwgdmltIEVuZ2xpc2ggY2hhcmFjdGVycyAoYWNjb3JkaW5nIHRvIHRoZQoJbGFuZ21hcCBtYXBwaW5ncykgaW4gdGhlIGZvbGxvd2luZyBjYXNlczoKCSBvIE5vcm1hbC9WaXN1YWwgbW9kZSAoY29tbWFuZHMsIGJ1ZmZlci9yZWdpc3RlciBuYW1lcywgdXNlciBtYXBwaW5ncykKCSBvIEluc2VydC9SZXBsYWNlIE1vZGU6IFJlZ2lzdGVyIG5hbWVzIGFmdGVyIENUUkwtUgoJIG8gSW5zZXJ0L1JlcGxhY2UgTW9kZTogTWFwcGluZ3MKCUNoYXJhY3RlcnMgZW50ZXJlZCBpbiBDb21tYW5kLWxpbmUgbW9kZSB3aWxsIE5PVCBiZSBhZmZlY3RlZCBieQoJdGhpcyBvcHRpb24uICAgTm90ZSB0aGF0IHRoaXMgb3B0aW9uIGNhbiBiZSBjaGFuZ2VkIGF0IGFueSB0aW1lCglhbGxvd2luZyB0byBzd2l0Y2ggYmV0d2VlbiBtYXBwaW5ncyBmb3IgZGlmZmVyZW50IGxhbmd1YWdlcy9lbmNvZGluZ3MuCglVc2UgYSBtYXBwaW5nIHRvIGF2b2lkIGhhdmluZyB0byB0eXBlIGl0IGVhY2ggdGltZSEKCgkJCQkJKidsYW5nbWVudScqIConbG0nKgonbGFuZ21lbnUnICdsbScJCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbWVudXwgYW5kCgkJCXwrbXVsdGlfbGFuZ3wgZmVhdHVyZXN9CglMYW5ndWFnZSB0byB1c2UgZm9yIG1lbnUgdHJhbnNsYXRpb24uICBUZWxscyB3aGljaCBmaWxlIGlzIGxvYWRlZAoJZnJvbSB0aGUgImxhbmciIGRpcmVjdG9yeSBpbiAncnVudGltZXBhdGgnOiA+CgkJImxhbmcvbWVudV8iIC4gJmxhbmdtZW51IC4gIi52aW0iCjwJKHdpdGhvdXQgdGhlIHNwYWNlcykuICBGb3IgZXhhbXBsZSwgdG8gYWx3YXlzIHVzZSB0aGUgRHV0Y2ggbWVudXMsIG5vCgltYXR0ZXIgd2hhdCAkTEFORyBpcyBzZXQgdG86ID4KCQk6c2V0IGxhbmdtZW51PW5sX05MLklTT184ODU5LTEKPAlXaGVuICdsYW5nbWVudScgaXMgZW1wdHksIHx2Omxhbmd8IGlzIHVzZWQuCglPbmx5IG5vcm1hbCBmaWxlIG5hbWUgY2hhcmFjdGVycyBjYW4gYmUgdXNlZCwgIi9cKj9bfDw+IiBhcmUgaWxsZWdhbC4KCUlmIHlvdXIgJExBTkcgaXMgc2V0IHRvIGEgbm9uLUVuZ2xpc2ggbGFuZ3VhZ2UgYnV0IHlvdSBkbyB3YW50IHRvIHVzZQoJdGhlIEVuZ2xpc2ggbWVudXM6ID4KCQk6c2V0IGxhbmdtZW51PW5vbmUKPAlUaGlzIG9wdGlvbiBtdXN0IGJlIHNldCBiZWZvcmUgbG9hZGluZyBtZW51cywgc3dpdGNoaW5nIG9uIGZpbGV0eXBlCglkZXRlY3Rpb24gb3Igc3ludGF4IGhpZ2hsaWdodGluZy4gIE9uY2UgdGhlIG1lbnVzIGFyZSBkZWZpbmVkIHNldHRpbmcKCXRoaXMgb3B0aW9uIGhhcyBubyBlZmZlY3QuICBCdXQgeW91IGNvdWxkIGRvIHRoaXM6ID4KCQk6c291cmNlICRWSU1SVU5USU1FL2RlbG1lbnUudmltCgkJOnNldCBsYW5nbWVudT1kZV9ERS5JU09fODg1OS0xCgkJOnNvdXJjZSAkVklNUlVOVElNRS9tZW51LnZpbQo8CVdhcm5pbmc6IFRoaXMgZGVsZXRlcyBhbGwgbWVudXMgdGhhdCB5b3UgZGVmaW5lZCB5b3Vyc2VsZiEKCgkJCQkJKidsYXN0c3RhdHVzJyogKidscycqCidsYXN0c3RhdHVzJyAnbHMnCW51bWJlcgkoZGVmYXVsdCAxKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVRoZSB2YWx1ZSBvZiB0aGlzIG9wdGlvbiBpbmZsdWVuY2VzIHdoZW4gdGhlIGxhc3Qgd2luZG93IHdpbGwgaGF2ZSBhCglzdGF0dXMgbGluZToKCQkwOiBuZXZlcgoJCTE6IG9ubHkgaWYgdGhlcmUgYXJlIGF0IGxlYXN0IHR3byB3aW5kb3dzCgkJMjogYWx3YXlzCglUaGUgc2NyZWVuIGxvb2tzIG5pY2VyIHdpdGggYSBzdGF0dXMgbGluZSBpZiB5b3UgaGF2ZSBzZXZlcmFsCgl3aW5kb3dzLCBidXQgaXQgdGFrZXMgYW5vdGhlciBzY3JlZW4gbGluZS4gfHN0YXR1cy1saW5lfAoKCQkJKidsYXp5cmVkcmF3JyogKidseicqIConbm9sYXp5cmVkcmF3JyogKidub2x6JyoKJ2xhenlyZWRyYXcnICdseicJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiB0aGlzIG9wdGlvbiBpcyBzZXQsIHRoZSBzY3JlZW4gd2lsbCBub3QgYmUgcmVkcmF3biB3aGlsZQoJZXhlY3V0aW5nIG1hY3JvcywgcmVnaXN0ZXJzIGFuZCBvdGhlciBjb21tYW5kcyB0aGF0IGhhdmUgbm90IGJlZW4KCXR5cGVkLiAgQWxzbywgdXBkYXRpbmcgdGhlIHdpbmRvdyB0aXRsZSBpcyBwb3N0cG9uZWQuICBUbyBmb3JjZSBhbgoJdXBkYXRlIHVzZSB8OnJlZHJhd3wuCgoJCQkqJ2xpbmVicmVhaycqIConbGJyJyogKidub2xpbmVicmVhaycqIConbm9sYnInKgonbGluZWJyZWFrJyAnbGJyJwlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJbG9jYWwgdG8gd2luZG93CgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgIHwrbGluZWJyZWFrfAoJCQlmZWF0dXJlfQoJSWYgb24gVmltIHdpbGwgd3JhcCBsb25nIGxpbmVzIGF0IGEgY2hhcmFjdGVyIGluICdicmVha2F0JyByYXRoZXIKCXRoYW4gYXQgdGhlIGxhc3QgY2hhcmFjdGVyIHRoYXQgZml0cyBvbiB0aGUgc2NyZWVuLiAgVW5saWtlCgknd3JhcG1hcmdpbicgYW5kICd0ZXh0d2lkdGgnLCB0aGlzIGRvZXMgbm90IGluc2VydCA8RU9MPnMgaW4gdGhlIGZpbGUsCglpdCBvbmx5IGFmZmVjdHMgdGhlIHdheSB0aGUgZmlsZSBpcyBkaXNwbGF5ZWQsIG5vdCBpdHMgY29udGVudHMuICBUaGUKCXZhbHVlIG9mICdzaG93YnJlYWsnIGlzIHVzZWQgdG8gcHV0IGluIGZyb250IG9mIHdyYXBwZWQgbGluZXMuCglUaGlzIG9wdGlvbiBpcyBub3QgdXNlZCB3aGVuIHRoZSAnd3JhcCcgb3B0aW9uIGlzIG9mZiBvciAnbGlzdCcgaXMgb24uCglOb3RlIHRoYXQgPFRhYj4gY2hhcmFjdGVycyBhZnRlciBhbiA8RU9MPiBhcmUgbW9zdGx5IG5vdCBkaXNwbGF5ZWQKCXdpdGggdGhlIHJpZ2h0IGFtb3VudCBvZiB3aGl0ZSBzcGFjZS4KCgkJCQkJCSonbGluZXMnKiAqRTU5MyoKJ2xpbmVzJwkJCW51bWJlcgkoZGVmYXVsdCAyNCBvciB0ZXJtaW5hbCBoZWlnaHQpCgkJCWdsb2JhbAoJTnVtYmVyIG9mIGxpbmVzIG9mIHRoZSBWaW0gd2luZG93LgoJTm9ybWFsbHkgeW91IGRvbid0IG5lZWQgdG8gc2V0IHRoaXMuICBJdCBpcyBkb25lIGF1dG9tYXRpY2FsbHkgYnkgdGhlCgl0ZXJtaW5hbCBpbml0aWFsaXphdGlvbiBjb2RlLiAgQWxzbyBzZWUgfHBvc2l4LXNjcmVlbi1zaXplfC4KCVdoZW4gVmltIGlzIHJ1bm5pbmcgaW4gdGhlIEdVSSBvciBpbiBhIHJlc2l6YWJsZSB3aW5kb3csIHNldHRpbmcgdGhpcwoJb3B0aW9uIHdpbGwgY2F1c2UgdGhlIHdpbmRvdyBzaXplIHRvIGJlIGNoYW5nZWQuICBXaGVuIHlvdSBvbmx5IHdhbnQKCXRvIHVzZSB0aGUgc2l6ZSBmb3IgdGhlIEdVSSwgcHV0IHRoZSBjb21tYW5kIGluIHlvdXIgfGd2aW1yY3wgZmlsZS4KCVZpbSBsaW1pdHMgdGhlIG51bWJlciBvZiBsaW5lcyB0byB3aGF0IGZpdHMgb24gdGhlIHNjcmVlbi4gIFlvdSBjYW4KCXVzZSB0aGlzIGNvbW1hbmQgdG8gZ2V0IHRoZSB0YWxsZXN0IHdpbmRvdyBwb3NzaWJsZTogPgoJCTpzZXQgbGluZXM9OTk5CjwJSWYgeW91IGdldCBsZXNzIGxpbmVzIHRoYW4gZXhwZWN0ZWQsIGNoZWNrIHRoZSAnZ3VpaGVhZHJvb20nIG9wdGlvbi4KCVdoZW4geW91IHNldCB0aGlzIG9wdGlvbiBhbmQgVmltIGlzIHVuYWJsZSB0byBjaGFuZ2UgdGhlIHBoeXNpY2FsCgludW1iZXIgb2YgbGluZXMgb2YgdGhlIGRpc3BsYXksIHRoZSBkaXNwbGF5IG1heSBiZSBtZXNzZWQgdXAuCgoJCQkJCQkqJ2xpbmVzcGFjZScqIConbHNwJyoKJ2xpbmVzcGFjZScgJ2xzcCcJbnVtYmVyCShkZWZhdWx0IDAsIDEgZm9yIFdpbjMyIEdVSSkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGluIHRoZSBHVUl9CglOdW1iZXIgb2YgcGl4ZWwgbGluZXMgaW5zZXJ0ZWQgYmV0d2VlbiBjaGFyYWN0ZXJzLiAgVXNlZnVsIGlmIHRoZSBmb250Cgl1c2VzIHRoZSBmdWxsIGNoYXJhY3RlciBjZWxsIGhlaWdodCwgbWFraW5nIGxpbmVzIHRvdWNoIGVhY2ggb3RoZXIuCglXaGVuIG5vbi16ZXJvIHRoZXJlIGlzIHJvb20gZm9yIHVuZGVybGluaW5nLgoJV2l0aCBzb21lIGZvbnRzIHRoZXJlIGNhbiBiZSB0b28gbXVjaCByb29tIGJldHdlZW4gbGluZXMgKHRvIGhhdmUKCXNwYWNlIGZvciBhc2NlbnRzIGFuZCBkZXNjZW50cykuICBUaGVuIGl0IG1ha2VzIHNlbnNlIHRvIHNldAoJJ2xpbmVzcGFjZScgdG8gYSBuZWdhdGl2ZSB2YWx1ZS4gIFRoaXMgbWF5IGNhdXNlIGRpc3BsYXkgcHJvYmxlbXMKCXRob3VnaCEKCgkJCQkJCSonbGlzcCcqIConbm9saXNwJyoKJ2xpc3AnCQkJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrbGlzcGluZGVudHwKCQkJZmVhdHVyZX0KCUxpc3AgbW9kZTogV2hlbiA8RW50ZXI+IGlzIHR5cGVkIGluIGluc2VydCBtb2RlIHNldCB0aGUgaW5kZW50IGZvcgoJdGhlIG5leHQgbGluZSB0byBMaXNwIHN0YW5kYXJkcyAod2VsbCwgc29ydCBvZikuICBBbHNvIGhhcHBlbnMgd2l0aAoJImNjIiBvciAiUyIuICAnYXV0b2luZGVudCcgbXVzdCBhbHNvIGJlIG9uIGZvciB0aGlzIHRvIHdvcmsuICBUaGUgJ3AnCglmbGFnIGluICdjcG9wdGlvbnMnIGNoYW5nZXMgdGhlIG1ldGhvZCBvZiBpbmRlbnRpbmc6IFZpIGNvbXBhdGlibGUgb3IKCWJldHRlci4gIEFsc28gc2VlICdsaXNwd29yZHMnLgoJVGhlICctJyBjaGFyYWN0ZXIgaXMgaW5jbHVkZWQgaW4ga2V5d29yZCBjaGFyYWN0ZXJzLiAgUmVkZWZpbmVzIHRoZQoJIj0iIG9wZXJhdG9yIHRvIHVzZSB0aGlzIHNhbWUgaW5kZW50YXRpb24gYWxnb3JpdGhtIHJhdGhlciB0aGFuCgljYWxsaW5nIGFuIGV4dGVybmFsIHByb2dyYW0gaWYgJ2VxdWFscHJnJyBpcyBlbXB0eS4KCVRoaXMgb3B0aW9uIGlzIG5vdCB1c2VkIHdoZW4gJ3Bhc3RlJyBpcyBzZXQuCgl7Vmk6IERvZXMgaXQgYSBsaXR0bGUgYml0IGRpZmZlcmVudGx5fQoKCQkJCQkJKidsaXNwd29yZHMnKiAqJ2x3JyoKJ2xpc3B3b3JkcycgJ2x3JwlzdHJpbmcJKGRlZmF1bHQgaXMgdmVyeSBsb25nKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2xpc3BpbmRlbnR8CgkJCWZlYXR1cmV9CglDb21tYSBzZXBhcmF0ZWQgbGlzdCBvZiB3b3JkcyB0aGF0IGluZmx1ZW5jZSB0aGUgTGlzcCBpbmRlbnRpbmcuCgl8J2xpc3AnfAoKCQkJCQkJKidsaXN0JyogKidub2xpc3QnKgonbGlzdCcJCQlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJbG9jYWwgdG8gd2luZG93CglMaXN0IG1vZGU6IFNob3cgdGFicyBhcyBDVFJMLUksIHNob3cgZW5kIG9mIGxpbmUgd2l0aCAkLiAgVXNlZnVsIHRvCglzZWUgdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB0YWJzIGFuZCBzcGFjZXMgYW5kIGZvciB0cmFpbGluZyBibGFua3MuCglOb3RlIHRoYXQgdGhpcyB3aWxsIGFsc28gYWZmZWN0IGZvcm1hdHRpbmcgKHNldCB3aXRoICd0ZXh0d2lkdGgnIG9yCgknd3JhcG1hcmdpbicpIHdoZW4gJ2Nwb3B0aW9ucycgaW5jbHVkZXMgJ0wnLiAgU2VlICdsaXN0Y2hhcnMnIGZvcgoJY2hhbmdpbmcgdGhlIHdheSB0YWJzIGFyZSBkaXNwbGF5ZWQuCgoJCQkJCQkqJ2xpc3RjaGFycycqIConbGNzJyoKJ2xpc3RjaGFycycgJ2xjcycJc3RyaW5nCShkZWZhdWx0ICJlb2w6JCIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJU3RyaW5ncyB0byB1c2UgaW4gJ2xpc3QnIG1vZGUuICBJdCBpcyBhIGNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIHN0cmluZwoJc2V0dGluZ3MuCgkgIGVvbDpjCQlDaGFyYWN0ZXIgdG8gc2hvdyBhdCB0aGUgZW5kIG9mIGVhY2ggbGluZS4gIFdoZW4KCQkJb21pdHRlZCwgdGhlcmUgaXMgbm8gZXh0cmEgY2hhcmFjdGVyIGF0IHRoZSBlbmQgb2YgdGhlCgkJCWxpbmUuCgkgIHRhYjp4eQlUd28gY2hhcmFjdGVycyB0byBiZSB1c2VkIHRvIHNob3cgYSBUYWIuICBUaGUgZmlyc3QKCQkJY2hhciBpcyB1c2VkIG9uY2UuICBUaGUgc2Vjb25kIGNoYXIgaXMgcmVwZWF0ZWQgdG8KCQkJZmlsbCB0aGUgc3BhY2UgdGhhdCB0aGUgVGFiIG5vcm1hbGx5IG9jY3VwaWVzLgoJCQkidGFiOj4tIiB3aWxsIHNob3cgYSBUYWIgdGhhdCB0YWtlcyBmb3VyIHNwYWNlcyBhcwoJCQkiPi0tLSIuICBXaGVuIG9taXR0ZWQsIGEgVGFiIGlzIHNob3cgYXMgXkkuCgkgIHRyYWlsOmMJQ2hhcmFjdGVyIHRvIHNob3cgZm9yIHRyYWlsaW5nIHNwYWNlcy4gIFdoZW4gb21pdHRlZCwKCQkJdHJhaWxpbmcgc3BhY2VzIGFyZSBibGFuay4KCSAgZXh0ZW5kczpjCUNoYXJhY3RlciB0byBzaG93IGluIHRoZSBsYXN0IGNvbHVtbiwgd2hlbiAnd3JhcCcgaXMKCQkJb2ZmIGFuZCB0aGUgbGluZSBjb250aW51ZXMgYmV5b25kIHRoZSByaWdodCBvZiB0aGUKCQkJc2NyZWVuLgoJICBwcmVjZWRlczpjCUNoYXJhY3RlciB0byBzaG93IGluIHRoZSBmaXJzdCBjb2x1bW4sIHdoZW4gJ3dyYXAnCgkJCWlzIG9mZiBhbmQgdGhlcmUgaXMgdGV4dCBwcmVjZWRpbmcgdGhlIGNoYXJhY3RlcgoJCQl2aXNpYmxlIGluIHRoZSBmaXJzdCBjb2x1bW4uCgkgIG5ic3A6YwlDaGFyYWN0ZXIgdG8gc2hvdyBmb3IgYSBub24tYnJlYWthYmxlIHNwYWNlIChjaGFyYWN0ZXIKCSAgCQkweEEwLCAxNjApLiAgTGVmdCBibGFuayB3aGVuIG9taXR0ZWQuCgoJVGhlIGNoYXJhY3RlcnMgJzonIGFuZCAnLCcgc2hvdWxkIG5vdCBiZSB1c2VkLiAgVVRGLTggY2hhcmFjdGVycyBjYW4KCWJlIHVzZWQgd2hlbiAnZW5jb2RpbmcnIGlzICJ1dGYtOCIsIG90aGVyd2lzZSBvbmx5IHByaW50YWJsZQoJY2hhcmFjdGVycyBhcmUgYWxsb3dlZC4KCglFeGFtcGxlczogPgoJICAgIDpzZXQgbGNzPXRhYjo+LSx0cmFpbDotCgkgICAgOnNldCBsY3M9dGFiOj4tLGVvbDo8LG5ic3A6JQoJICAgIDpzZXQgbGNzPWV4dGVuZHM6PixwcmVjZWRlczo8CjwJVGhlICJOb25UZXh0IiBoaWdobGlnaHRpbmcgd2lsbCBiZSB1c2VkIGZvciAiZW9sIiwgImV4dGVuZHMiIGFuZAoJInByZWNlZGVzIi4gICJTcGVjaWFsS2V5IiBmb3IgIm5ic3AiLCAidGFiIiBhbmQgInRyYWlsIi4KCgkJCSonbHBsJyogKidub2xwbCcqIConbG9hZHBsdWdpbnMnKiAqJ25vbG9hZHBsdWdpbnMnKgonbG9hZHBsdWdpbnMnICdscGwnCWJvb2xlYW4JKGRlZmF1bHQgb24pCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiBvbiB0aGUgcGx1Z2luIHNjcmlwdHMgYXJlIGxvYWRlZCB3aGVuIHN0YXJ0aW5nIHVwIHxsb2FkLXBsdWdpbnN8LgoJVGhpcyBvcHRpb24gY2FuIGJlIHJlc2V0IGluIHlvdXIgfHZpbXJjfCBmaWxlIHRvIGRpc2FibGUgdGhlIGxvYWRpbmcKCW9mIHBsdWdpbnMuCglOb3RlIHRoYXQgdXNpbmcgdGhlICItdSBOT05FIiBhbmQgIi0tbm9wbHVnaW4iIGNvbW1hbmQgbGluZSBhcmd1bWVudHMKCXJlc2V0IHRoaXMgb3B0aW9uLiB8LXV8IHwtLW5vcGx1Z2lufAoKCQkJCQkJKidtYWdpYycqIConbm9tYWdpYycqCidtYWdpYycJCQlib29sZWFuCShkZWZhdWx0IG9uKQoJCQlnbG9iYWwKCUNoYW5nZXMgdGhlIHNwZWNpYWwgY2hhcmFjdGVycyB0aGF0IGNhbiBiZSB1c2VkIGluIHNlYXJjaCBwYXR0ZXJucy4KCVNlZSB8cGF0dGVybnwuCglOT1RFOiBUbyBhdm9pZCBwb3J0YWJpbGl0eSBwcm9ibGVtcyB3aXRoIHVzaW5nIHBhdHRlcm5zLCBhbHdheXMga2VlcAoJdGhpcyBvcHRpb24gYXQgdGhlIGRlZmF1bHQgIm9uIi4gIE9ubHkgc3dpdGNoIGl0IG9mZiB3aGVuIHdvcmtpbmcgd2l0aAoJb2xkIFZpIHNjcmlwdHMuICBJbiBhbnkgb3RoZXIgc2l0dWF0aW9uIHdyaXRlIHBhdHRlcm5zIHRoYXQgd29yayB3aGVuCgknbWFnaWMnIGlzIG9uLiAgSW5jbHVkZSAiXE0iIHdoZW4geW91IHdhbnQgdG8gfC9cTXwuCgoJCQkJCQkqJ21ha2VlZicqIConbWVmJyoKJ21ha2VlZicgJ21lZicJCXN0cmluZwkoZGVmYXVsdDogIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrcXVpY2tmaXh8CgkJCWZlYXR1cmV9CglOYW1lIG9mIHRoZSBlcnJvcmZpbGUgZm9yIHRoZSB8Om1ha2V8IGNvbW1hbmQgKHNlZSB8Om1ha2VfbWFrZXByZ3wpCglhbmQgdGhlIHw6Z3JlcHwgY29tbWFuZC4KCVdoZW4gaXQgaXMgZW1wdHksIGFuIGludGVybmFsbHkgZ2VuZXJhdGVkIHRlbXAgZmlsZSB3aWxsIGJlIHVzZWQuCglXaGVuICIjIyIgaXMgaW5jbHVkZWQsIGl0IGlzIHJlcGxhY2VkIGJ5IGEgbnVtYmVyIHRvIG1ha2UgdGhlIG5hbWUKCXVuaXF1ZS4gIFRoaXMgbWFrZXMgc3VyZSB0aGF0IHRoZSAiOm1ha2UiIGNvbW1hbmQgZG9lc24ndCBvdmVyd3JpdGUgYW4KCWV4aXN0aW5nIGZpbGUuCglOT1QgdXNlZCBmb3IgdGhlICI6Y2YiIGNvbW1hbmQuICBTZWUgJ2Vycm9yZmlsZScgZm9yIHRoYXQuCglFbnZpcm9ubWVudCB2YXJpYWJsZXMgYXJlIGV4cGFuZGVkIHw6c2V0X2VudnwuCglTZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0IGluY2x1ZGluZyBzcGFjZXMgYW5kIGJhY2tzbGFzaGVzLgoJVGhpcyBvcHRpb24gY2Fubm90IGJlIHNldCBmcm9tIGEgfG1vZGVsaW5lfCBvciBpbiB0aGUgfHNhbmRib3h8LCBmb3IKCXNlY3VyaXR5IHJlYXNvbnMuCgoJCQkJCQkqJ21ha2VwcmcnKiAqJ21wJyoKJ21ha2VwcmcnICdtcCcJCXN0cmluZwkoZGVmYXVsdCAibWFrZSIsIFZNUzogIk1NUyIpCgkJCWdsb2JhbCBvciBsb2NhbCB0byBidWZmZXIgfGdsb2JhbC1sb2NhbHwKCQkJe25vdCBpbiBWaX0KCVByb2dyYW0gdG8gdXNlIGZvciB0aGUgIjptYWtlIiBjb21tYW5kLiAgU2VlIHw6bWFrZV9tYWtlcHJnfC4gIFRoaXMKCW9wdGlvbiBtYXkgY29udGFpbiAnJScgYW5kICcjJyBjaGFyYWN0ZXJzLCB3aGljaCBhcmUgZXhwYW5kZWQgbGlrZQoJd2hlbiB1c2VkIGluIGEgY29tbWFuZC1saW5lLiAgRW52aXJvbm1lbnQgdmFyaWFibGVzIGFyZSBleHBhbmRlZAoJfDpzZXRfZW52fC4gIFNlZSB8b3B0aW9uLWJhY2tzbGFzaHwgYWJvdXQgaW5jbHVkaW5nIHNwYWNlcyBhbmQKCWJhY2tzbGFzaGVzLiAgTm90ZSB0aGF0IGEgJ3wnIG11c3QgYmUgZXNjYXBlZCB0d2ljZTogb25jZSBmb3IgIjpzZXQiCglhbmQgb25jZSBmb3IgdGhlIGludGVycHJldGF0aW9uIG9mIGEgY29tbWFuZC4gIFdoZW4geW91IHVzZSBhIGZpbHRlcgoJY2FsbGVkICJteWZpbHRlciIgZG8gaXQgbGlrZSB0aGlzOiA+CgkgICAgOnNldCBtYWtlcHJnPWdtYWtlXCBcXFx8XCBteWZpbHRlcgo8CVRoZSBwbGFjZWhvbGRlciAiJCoiIGNhbiBiZSBnaXZlbiAoZXZlbiBtdWx0aXBsZSB0aW1lcykgdG8gc3BlY2lmeQoJd2hlcmUgdGhlIGFyZ3VtZW50cyB3aWxsIGJlIGluY2x1ZGVkLCBmb3IgZXhhbXBsZTogPgoJICAgIDpzZXQgbWFrZXByZz1sYXRleFwgXFxcXG5vbnN0b3Btb2RlXCBcXFxcaW5wdXRcXHskKn0KPAlUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCgkJCQkJCSonbWF0Y2hwYWlycycqIConbXBzJyoKJ21hdGNocGFpcnMnICdtcHMnCXN0cmluZwkoZGVmYXVsdCAiKDopLHs6fSxbOl0iKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCUNoYXJhY3RlcnMgdGhhdCBmb3JtIHBhaXJzLiAgVGhlIHwlfCBjb21tYW5kIGp1bXBzIGZyb20gb25lIHRvIHRoZQoJb3RoZXIuICBDdXJyZW50bHkgb25seSBzaW5nbGUgY2hhcmFjdGVyIHBhaXJzIGFyZSBhbGxvd2VkLCBhbmQgdGhleQoJbXVzdCBiZSBkaWZmZXJlbnQuICBUaGUgY2hhcmFjdGVycyBtdXN0IGJlIHNlcGFyYXRlZCBieSBhIGNvbG9uLiAgVGhlCglwYWlycyBtdXN0IGJlIHNlcGFyYXRlZCBieSBhIGNvbW1hLiAgRXhhbXBsZSBmb3IgaW5jbHVkaW5nICc8JyBhbmQgJz4nCgkoSFRNTCk6ID4KCQk6c2V0IG1wcys9PDo+Cgo8CUEgbW9yZSBleG90aWMgZXhhbXBsZSwgdG8ganVtcCBiZXR3ZWVuIHRoZSAnPScgYW5kICc7JyBpbiBhbgoJYXNzaWdubWVudCwgdXNlZnVsIGZvciBsYW5ndWFnZXMgbGlrZSBDIGFuZCBKYXZhOiA+CgkJOmF1IEZpbGVUeXBlIGMsY3BwLGphdmEgc2V0IG1wcys9PTo7Cgo8CUZvciBhIG1vcmUgYWR2YW5jZWQgd2F5IG9mIHVzaW5nICIlIiwgc2VlIHRoZSBtYXRjaGl0LnZpbSBwbHVnaW4gaW4KCXRoZSAkVklNUlVOVElNRS9tYWNyb3MgZGlyZWN0b3J5LiB8YWRkLWxvY2FsLWhlbHB8CgoJCQkJCQkqJ21hdGNodGltZScqIConbWF0JyoKJ21hdGNodGltZScgJ21hdCcJbnVtYmVyCShkZWZhdWx0IDUpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfXtpbiBOdml9CglUZW50aHMgb2YgYSBzZWNvbmQgdG8gc2hvdyB0aGUgbWF0Y2hpbmcgcGFyZW4sIHdoZW4gJ3Nob3dtYXRjaCcgaXMKCXNldC4gIE5vdGUgdGhhdCB0aGlzIGlzIG5vdCBpbiBtaWxsaXNlY29uZHMsIGxpa2Ugb3RoZXIgb3B0aW9ucyB0aGF0CglzZXQgYSB0aW1lLiAgVGhpcyBpcyB0byBiZSBjb21wYXRpYmxlIHdpdGggTnZpLgoKCQkJCQkJKidtYXhmdW5jZGVwdGgnKiAqJ21mZCcqCidtYXhmdW5jZGVwdGgnICdtZmQnCW51bWJlcgkoZGVmYXVsdCAxMDApCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJTWF4aW11bSBkZXB0aCBvZiBmdW5jdGlvbiBjYWxscyBmb3IgdXNlciBmdW5jdGlvbnMuICBUaGlzIG5vcm1hbGx5CgljYXRjaGVzIGVuZGxlc3MgcmVjdXJzaW9uLiAgV2hlbiB1c2luZyBhIHJlY3Vyc2l2ZSBmdW5jdGlvbiB3aXRoCgltb3JlIGRlcHRoLCBzZXQgJ21heGZ1bmNkZXB0aCcgdG8gYSBiaWdnZXIgbnVtYmVyLiAgQnV0IHRoaXMgd2lsbCB1c2UKCW1vcmUgbWVtb3J5LCB0aGVyZSBpcyB0aGUgZGFuZ2VyIG9mIGZhaWxpbmcgd2hlbiBtZW1vcnkgaXMgZXhoYXVzdGVkLgoJU2VlIGFsc28gfDpmdW5jdGlvbnwuCgoJCQkJCQkqJ21heG1hcGRlcHRoJyogKidtbWQnKiAqRTIyMyoKJ21heG1hcGRlcHRoJyAnbW1kJwludW1iZXIJKGRlZmF1bHQgMTAwMCkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglNYXhpbXVtIG51bWJlciBvZiB0aW1lcyBhIG1hcHBpbmcgaXMgZG9uZSB3aXRob3V0IHJlc3VsdGluZyBpbiBhCgljaGFyYWN0ZXIgdG8gYmUgdXNlZC4gIFRoaXMgbm9ybWFsbHkgY2F0Y2hlcyBlbmRsZXNzIG1hcHBpbmdzLCBsaWtlCgkiOm1hcCB4IHkiIHdpdGggIjptYXAgeSB4Ii4gIEl0IHN0aWxsIGRvZXMgbm90IGNhdGNoICI6bWFwIGcgd2ciLAoJYmVjYXVzZSB0aGUgJ3cnIGlzIHVzZWQgYmVmb3JlIHRoZSBuZXh0IG1hcHBpbmcgaXMgZG9uZS4gIFNlZSBhbHNvCgl8a2V5LW1hcHBpbmd8LgoKCQkJCQkJKidtYXhtZW0nKiAqJ21tJyoKJ21heG1lbScgJ21tJwkJbnVtYmVyCShkZWZhdWx0IGJldHdlZW4gMjU2IHRvIDUxMjAgKHN5c3RlbQoJCQkJIGRlcGVuZGVudCkgb3IgaGFsZiB0aGUgYW1vdW50IG9mIG1lbW9yeQoJCQkJIGF2YWlsYWJsZSkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglNYXhpbXVtIGFtb3VudCBvZiBtZW1vcnkgKGluIEtieXRlKSB0byB1c2UgZm9yIG9uZSBidWZmZXIuICBXaGVuIHRoaXMKCWxpbWl0IGlzIHJlYWNoZWQgYWxsb2NhdGluZyBleHRyYSBtZW1vcnkgZm9yIGEgYnVmZmVyIHdpbGwgY2F1c2UKCW90aGVyIG1lbW9yeSB0byBiZSBmcmVlZC4gIE1heGltdW0gdmFsdWUgMjAwMDAwMC4gIFVzZSB0aGlzIHRvIHdvcmsKCXdpdGhvdXQgYSBsaW1pdC4gIEFsc28gc2VlICdtYXhtZW10b3QnLgoKCQkJCQkJKidtYXhtZW1wYXR0ZXJuJyogKidtbXAnKgonbWF4bWVtcGF0dGVybicgJ21tcCcJbnVtYmVyCShkZWZhdWx0IDEwMDApCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJTWF4aW11bSBhbW91bnQgb2YgbWVtb3J5IChpbiBLYnl0ZSkgdG8gdXNlIGZvciBwYXR0ZXJuIG1hdGNoaW5nLgoJTWF4aW11bSB2YWx1ZSAyMDAwMDAwLiAgVXNlIHRoaXMgdG8gd29yayB3aXRob3V0IGEgbGltaXQuCgkJCQkJCQkqRTM2MyoKCVdoZW4gVmltIHJ1bnMgaW50byB0aGUgbGltaXQgaXQgZ2l2ZXMgYW4gZXJyb3IgbWVzc2FnZSBtb3N0bHkgYmVoYXZlcwoJbGlrZSBDVFJMLUMgd2FzIHR5cGVkLgoJUnVubmluZyBpbnRvIHRoZSBsaW1pdCBvZnRlbiBtZWFucyB0aGF0IHRoZSBwYXR0ZXJuIGlzIHZlcnkKCWluZWZmaWNpZW50IG9yIHRvbyBjb21wbGV4LiAgVGhpcyBtYXkgYWxyZWFkeSBoYXBwZW4gd2l0aCB0aGUgcGF0dGVybgoJIlwoLlwpKiIgb24gYSB2ZXJ5IGxvbmcgbGluZS4gICIuKiIgd29ya3MgbXVjaCBiZXR0ZXIuCglWaW0gbWF5IHJ1biBvdXQgb2YgbWVtb3J5IGJlZm9yZSBoaXR0aW5nIHRoZSAnbWF4bWVtcGF0dGVybicgbGltaXQuCgoJCQkJCQkqJ21heG1lbXRvdCcqIConbW10JyoKJ21heG1lbXRvdCcgJ21tdCcJbnVtYmVyCShkZWZhdWx0IGJldHdlZW4gMjA0OCBhbmQgMTAyNDAgKHN5c3RlbQoJCQkJIGRlcGVuZGVudCkgb3IgaGFsZiB0aGUgYW1vdW50IG9mIG1lbW9yeQoJCQkJIGF2YWlsYWJsZSkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglNYXhpbXVtIGFtb3VudCBvZiBtZW1vcnkgKGluIEtieXRlKSB0byB1c2UgZm9yIGFsbCBidWZmZXJzIHRvZ2V0aGVyLgoJTWF4aW11bSB2YWx1ZSAyMDAwMDAwLiAgVXNlIHRoaXMgdG8gd29yayB3aXRob3V0IGEgbGltaXQuICBBbHNvIHNlZQoJJ21heG1lbScuCgoJCQkJCQkqJ21lbnVpdGVtcycqIConbWlzJyoKJ21lbnVpdGVtcycgJ21pcycJbnVtYmVyCShkZWZhdWx0IDI1KQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K21lbnV8CgkJCWZlYXR1cmV9CglNYXhpbXVtIG51bWJlciBvZiBpdGVtcyB0byB1c2UgaW4gYSBtZW51LiAgVXNlZCBmb3IgbWVudXMgdGhhdCBhcmUKCWdlbmVyYXRlZCBmcm9tIGEgbGlzdCBvZiBpdGVtcywgZS5nLiwgdGhlIEJ1ZmZlcnMgbWVudS4gIENoYW5naW5nIHRoaXMKCW9wdGlvbiBoYXMgbm8gZGlyZWN0IGVmZmVjdCwgdGhlIG1lbnUgbXVzdCBiZSByZWZyZXNoZWQgZmlyc3QuCgoJCQkJICAgKidtb2RlbGluZScqIConbWwnKiAqJ25vbW9kZWxpbmUnKiAqJ25vbWwnKgonbW9kZWxpbmUnICdtbCcJCWJvb2xlYW4JKFZpbSBkZWZhdWx0OiBvbiwgVmkgZGVmYXVsdDogb2ZmKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJCQkJKidtb2RlbGluZXMnKiAqJ21scycqCidtb2RlbGluZXMnICdtbHMnCW51bWJlcgkoZGVmYXVsdCA1KQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCUlmICdtb2RlbGluZScgaXMgb24gJ21vZGVsaW5lcycgZ2l2ZXMgdGhlIG51bWJlciBvZiBsaW5lcyB0aGF0IGlzCgljaGVja2VkIGZvciBzZXQgY29tbWFuZHMuICBJZiAnbW9kZWxpbmUnIGlzIG9mZiBvciAnbW9kZWxpbmVzJyBpcyB6ZXJvCglubyBsaW5lcyBhcmUgY2hlY2tlZC4gIFNlZSB8bW9kZWxpbmV8LgoJTk9URTogJ21vZGVsaW5lJyBpcyBzZXQgdG8gdGhlIFZpIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMKCXNldCBhbmQgdG8gdGhlIFZpbSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzIHJlc2V0LgoKCQkJCSonbW9kaWZpYWJsZScqIConbWEnKiAqJ25vbW9kaWZpYWJsZScqIConbm9tYScqCidtb2RpZmlhYmxlJyAnbWEnCWJvb2xlYW4JKGRlZmF1bHQgb24pCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQkJKkUyMSoKCVdoZW4gb2ZmIHRoZSBidWZmZXIgY29udGVudHMgY2Fubm90IGJlIGNoYW5nZWQuICBUaGUgJ2ZpbGVmb3JtYXQnIGFuZAoJJ2ZpbGVlbmNvZGluZycgb3B0aW9ucyBhbHNvIGNhbid0IGJlIGNoYW5nZWQuCglDYW4gYmUgcmVzZXQgd2l0aCB0aGUgfC1NfCBjb21tYW5kIGxpbmUgYXJndW1lbnQuCgoJCQkJKidtb2RpZmllZCcqIConbW9kJyogKidub21vZGlmaWVkJyogKidub21vZCcqCidtb2RpZmllZCcgJ21vZCcJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJV2hlbiBvbiwgdGhlIGJ1ZmZlciBpcyBjb25zaWRlcmVkIHRvIGJlIG1vZGlmaWVkLiAgVGhpcyBvcHRpb24gaXMgc2V0Cgl3aGVuOgoJMS4gQSBjaGFuZ2Ugd2FzIG1hZGUgdG8gdGhlIHRleHQgc2luY2UgaXQgd2FzIGxhc3Qgd3JpdHRlbi4gIFVzaW5nIHRoZQoJICAgfHVuZG98IGNvbW1hbmQgdG8gZ28gYmFjayB0byB0aGUgb3JpZ2luYWwgdGV4dCB3aWxsIHJlc2V0IHRoZQoJICAgb3B0aW9uLiAgQnV0IHVuZG9pbmcgY2hhbmdlcyB0aGF0IHdlcmUgbWFkZSBiZWZvcmUgd3JpdGluZyB0aGUKCSAgIGJ1ZmZlciB3aWxsIHNldCB0aGUgb3B0aW9uIGFnYWluLCBzaW5jZSB0aGUgdGV4dCBpcyBkaWZmZXJlbnQgZnJvbQoJICAgd2hlbiBpdCB3YXMgd3JpdHRlbi4KCTIuICdmaWxlZm9ybWF0JyBvciAnZmlsZWVuY29kaW5nJyBpcyBkaWZmZXJlbnQgZnJvbSBpdHMgb3JpZ2luYWwKCSAgIHZhbHVlLiAgVGhlIG9yaWdpbmFsIHZhbHVlIGlzIHNldCB3aGVuIHRoZSBidWZmZXIgaXMgcmVhZCBvcgoJICAgd3JpdHRlbi4gIEEgIjpzZXQgbm9tb2RpZmllZCIgY29tbWFuZCBhbHNvIHJlc2V0cyB0aGUgb3JpZ2luYWwKCSAgIHZhbHVlcyB0byB0aGUgY3VycmVudCB2YWx1ZXMgYW5kIHRoZSAnbW9kaWZpZWQnIG9wdGlvbiB3aWxsIGJlCgkgICByZXNldC4KCVdoZW4gJ2J1ZnR5cGUnIGlzICJub3dyaXRlIiBvciAibm9maWxlIiB0aGlzIG9wdGlvbiBtYXkgYmUgc2V0LCBidXQKCXdpbGwgYmUgaWdub3JlZC4KCgkJCQkJCSonbW9yZScqIConbm9tb3JlJyoKJ21vcmUnCQkJYm9vbGVhbgkoVmltIGRlZmF1bHQ6IG9uLCBWaSBkZWZhdWx0OiBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiBvbiwgbGlzdGluZ3MgcGF1c2Ugd2hlbiB0aGUgd2hvbGUgc2NyZWVuIGlzIGZpbGxlZC4gIFlvdSB3aWxsIGdldAoJdGhlIHxtb3JlLXByb21wdHwuICBXaGVuIHRoaXMgb3B0aW9uIGlzIG9mZiB0aGVyZSBhcmUgbm8gcGF1c2VzLCB0aGUKCWxpc3RpbmcgY29udGludWVzIHVudGlsIGZpbmlzaGVkLgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIHRoZSBWaSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzCglzZXQgYW5kIHRvIHRoZSBWaW0gZGVmYXVsdCB2YWx1ZSB3aGVuICdjb21wYXRpYmxlJyBpcyByZXNldC4KCgkJCQkJCSonbW91c2UnKiAqRTUzOCoKJ21vdXNlJwkJCXN0cmluZwkoZGVmYXVsdCAiIiwgImEiIGZvciBHVUksIE1TLURPUyBhbmQgV2luMzIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJRW5hYmxlIHRoZSB1c2Ugb2YgdGhlIG1vdXNlLiAgT25seSB3b3JrcyBmb3IgY2VydGFpbiB0ZXJtaW5hbHMKCSh4dGVybSwgTVMtRE9TLCBXaW4zMiB8d2luMzItbW91c2V8LCBRTlggcHRlcm0sIGFuZCBMaW51eCBjb25zb2xlCgl3aXRoIGdwbSkuICBGb3IgdXNpbmcgdGhlIG1vdXNlIGluIHRoZSBHVUksIHNlZSB8Z3VpLW1vdXNlfC4KCVRoZSBtb3VzZSBjYW4gYmUgZW5hYmxlZCBmb3IgZGlmZmVyZW50IG1vZGVzOgoJCW4JTm9ybWFsIG1vZGUKCQl2CVZpc3VhbCBtb2RlCgkJaQlJbnNlcnQgbW9kZQoJCWMJQ29tbWFuZC1saW5lIG1vZGUKCQloCWFsbCBwcmV2aW91cyBtb2RlcyB3aGVuIGVkaXRpbmcgYSBoZWxwIGZpbGUKCQlhCWFsbCBwcmV2aW91cyBtb2RlcwoJCXIJZm9yIHxoaXQtZW50ZXJ8IGFuZCB8bW9yZS1wcm9tcHR8IHByb21wdAoJTm9ybWFsbHkgeW91IHdvdWxkIGVuYWJsZSB0aGUgbW91c2UgaW4gYWxsIGZvdXIgbW9kZXMgd2l0aDogPgoJCTpzZXQgbW91c2U9YQo8CVdoZW4gdGhlIG1vdXNlIGlzIG5vdCBlbmFibGVkLCB0aGUgR1VJIHdpbGwgc3RpbGwgdXNlIHRoZSBtb3VzZSBmb3IKCW1vZGVsZXNzIHNlbGVjdGlvbi4gIFRoaXMgZG9lc24ndCBtb3ZlIHRoZSB0ZXh0IGN1cnNvci4KCglTZWUgfG1vdXNlLXVzaW5nfC4gIEFsc28gc2VlIHwnY2xpcGJvYXJkJ3wuCgoJTm90ZTogV2hlbiBlbmFibGluZyB0aGUgbW91c2UgaW4gYSB0ZXJtaW5hbCwgY29weS9wYXN0ZSB3aWxsIHVzZSB0aGUKCSIqIHJlZ2lzdGVyIGlmIHRoZXJlIGlzIGFjY2VzcyB0byBhbiBYLXNlcnZlci4gIFRoZSB4dGVybSBoYW5kbGluZyBvZgoJdGhlIG1vdXNlIGJ1dHRvbnMgY2FuIHN0aWxsIGJlIHVzZWQgYnkga2VlcGluZyB0aGUgc2hpZnQga2V5IHByZXNzZWQuCglBbHNvIHNlZSB0aGUgJ2NsaXBib2FyZCcgb3B0aW9uLgoKCQkJKidtb3VzZWZvY3VzJyogKidtb3VzZWYnKiAqJ25vbW91c2Vmb2N1cycqIConbm9tb3VzZWYnKgonbW91c2Vmb2N1cycgJ21vdXNlZicJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSB3b3JrcyBpbiB0aGUgR1VJfQoJVGhlIHdpbmRvdyB0aGF0IHRoZSBtb3VzZSBwb2ludGVyIGlzIG9uIGlzIGF1dG9tYXRpY2FsbHkgYWN0aXZhdGVkLgoJV2hlbiBjaGFuZ2luZyB0aGUgd2luZG93IGxheW91dCBvciB3aW5kb3cgZm9jdXMgaW4gYW5vdGhlciB3YXksIHRoZQoJbW91c2UgcG9pbnRlciBpcyBtb3ZlZCB0byB0aGUgd2luZG93IHdpdGgga2V5Ym9hcmQgZm9jdXMuICBPZmYgaXMgdGhlCglkZWZhdWx0IGJlY2F1c2UgaXQgbWFrZXMgdXNpbmcgdGhlIHB1bGwgZG93biBtZW51cyBhIGxpdHRsZSBnb29meSwgYXMKCWEgcG9pbnRlciB0cmFuc2l0IG1heSBhY3RpdmF0ZSBhIHdpbmRvdyB1bmludGVudGlvbmFsbHkuCgoJCQkqJ21vdXNlaGlkZScqIConbWgnKiAqJ25vbW91c2VoaWRlJyogKidub21oJyoKJ21vdXNlaGlkZScgJ21oJwlib29sZWFuCShkZWZhdWx0IG9uKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgd29ya3MgaW4gdGhlIEdVSX0KCVdoZW4gb24sIHRoZSBtb3VzZSBwb2ludGVyIGlzIGhpZGRlbiB3aGVuIGNoYXJhY3RlcnMgYXJlIHR5cGVkLgoJVGhlIG1vdXNlIHBvaW50ZXIgaXMgcmVzdG9yZWQgd2hlbiB0aGUgbW91c2UgaXMgbW92ZWQuCgoJCQkJCQkqJ21vdXNlbW9kZWwnKiAqJ21vdXNlbScqCidtb3VzZW1vZGVsJyAnbW91c2VtJwlzdHJpbmcJKGRlZmF1bHQgImV4dGVuZCIsICJwb3B1cCIgZm9yIE1TLURPUyBhbmQgV2luMzIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJU2V0cyB0aGUgbW9kZWwgdG8gdXNlIGZvciB0aGUgbW91c2UuICBUaGUgbmFtZSBtb3N0bHkgc3BlY2lmaWVzIHdoYXQKCXRoZSByaWdodCBtb3VzZSBidXR0b24gaXMgdXNlZCBmb3I6CgkgICBleHRlbmQJUmlnaHQgbW91c2UgYnV0dG9uIGV4dGVuZHMgYSBzZWxlY3Rpb24uICBUaGlzIHdvcmtzCgkJCWxpa2UgaW4gYW4geHRlcm0uCgkgICBwb3B1cAlSaWdodCBtb3VzZSBidXR0b24gcG9wcyB1cCBhIG1lbnUuICBUaGUgc2hpZnRlZCBsZWZ0CgkJCW1vdXNlIGJ1dHRvbiBleHRlbmRzIGEgc2VsZWN0aW9uLiAgVGhpcyB3b3JrcyBsaWtlCgkJCXdpdGggTWljcm9zb2Z0IFdpbmRvd3MuCgkgICBwb3B1cF9zZXRwb3MgTGlrZSAicG9wdXAiLCBidXQgdGhlIGN1cnNvciB3aWxsIGJlIG1vdmVkIHRvIHRoZQoJCQlwb3NpdGlvbiB3aGVyZSB0aGUgbW91c2Ugd2FzIGNsaWNrZWQsIGFuZCB0aHVzIHRoZQoJCQlzZWxlY3RlZCBvcGVyYXRpb24gd2lsbCBhY3QgdXBvbiB0aGUgY2xpY2tlZCBvYmplY3QuCgkJCUlmIGNsaWNraW5nIGluc2lkZSBhIHNlbGVjdGlvbiwgdGhhdCBzZWxlY3Rpb24gd2lsbAoJCQliZSBhY3RlZCB1cG9uLCBpLmUuIG5vIGN1cnNvciBtb3ZlLiAgVGhpcyBpbXBsaWVzIG9mCgkJCWNvdXJzZSwgdGhhdCByaWdodCBjbGlja2luZyBvdXRzaWRlIGEgc2VsZWN0aW9uIHdpbGwKCQkJZW5kIFZpc3VhbCBtb2RlLgoJT3ZlcnZpZXcgb2Ygd2hhdCBidXR0b24gZG9lcyB3aGF0IGZvciBlYWNoIG1vZGVsOgoJbW91c2UJCSAgICBleHRlbmQJCXBvcHVwKF9zZXRwb3MpIH4KCWxlZnQgY2xpY2sJICAgIHBsYWNlIGN1cnNvcglwbGFjZSBjdXJzb3IKCWxlZnQgZHJhZwkgICAgc3RhcnQgc2VsZWN0aW9uCXN0YXJ0IHNlbGVjdGlvbgoJc2hpZnQtbGVmdAkgICAgc2VhcmNoIHdvcmQJCWV4dGVuZCBzZWxlY3Rpb24KCXJpZ2h0IGNsaWNrCSAgICBleHRlbmQgc2VsZWN0aW9uCXBvcHVwIG1lbnUgKHBsYWNlIGN1cnNvcikKCXJpZ2h0IGRyYWcJICAgIGV4dGVuZCBzZWxlY3Rpb24JLQoJbWlkZGxlIGNsaWNrCSAgICBwYXN0ZQkJcGFzdGUKCglJbiB0aGUgInBvcHVwIiBtb2RlbCB0aGUgcmlnaHQgbW91c2UgYnV0dG9uIHByb2R1Y2VzIGEgcG9wLXVwIG1lbnUuCglZb3UgbmVlZCB0byBkZWZpbmUgdGhpcyBmaXJzdCwgc2VlIHxwb3B1cC1tZW51fC4KCglOb3RlIHRoYXQgeW91IGNhbiBmdXJ0aGVyIHJlZmluZSB0aGUgbWVhbmluZyBvZiBidXR0b25zIHdpdGggbWFwcGluZ3MuCglTZWUgfGd1aS1tb3VzZS1tYXBwaW5nfC4gIEJ1dCBtYXBwaW5ncyBhcmUgTk9UIHVzZWQgZm9yIG1vZGVsZXNzCglzZWxlY3Rpb24gKGJlY2F1c2UgdGhhdCdzIGhhbmRsZWQgaW4gdGhlIEdVSSBjb2RlIGRpcmVjdGx5KS4KCglUaGUgJ21vdXNlbW9kZWwnIG9wdGlvbiBpcyBzZXQgYnkgdGhlIHw6YmVoYXZlfCBjb21tYW5kLgoKCQkJCQkqJ21vdXNlc2hhcGUnKiAqJ21vdXNlcycqICpFNTQ3KgonbW91c2VzaGFwZScgJ21vdXNlcycJc3RyaW5nCShkZWZhdWx0ICJpOmJlYW0scjpiZWFtLHM6dXBkb3duLHNkOmNyb3NzLAoJCQkJCW06bm8sbWw6dXAtYXJyb3csdjpyaWdodHVwLWFycm93IikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbW91c2VzaGFwZXwKCQkJZmVhdHVyZX0KCVRoaXMgb3B0aW9uIHRlbGxzIFZpbSB3aGF0IHRoZSBtb3VzZSBwb2ludGVyIHNob3VsZCBsb29rIGxpa2UgaW4KCWRpZmZlcmVudCBtb2Rlcy4gIFRoZSBvcHRpb24gaXMgYSBjb21tYSBzZXBhcmF0ZWQgbGlzdCBvZiBwYXJ0cywgbXVjaAoJbGlrZSB1c2VkIGZvciAnZ3VpY3Vyc29yJy4gIEVhY2ggcGFydCBjb25zaXN0IG9mIGEgbW9kZS9sb2NhdGlvbi1saXN0CglhbmQgYW4gYXJndW1lbnQtbGlzdDoKCQltb2RlLWxpc3Q6c2hhcGUsbW9kZS1saXN0OnNoYXBlLC4uCglUaGUgbW9kZS1saXN0IGlzIGEgZGFzaCBzZXBhcmF0ZWQgbGlzdCBvZiB0aGVzZSBtb2Rlcy9sb2NhdGlvbnM6CgkJCUluIGEgbm9ybWFsIHdpbmRvdzogfgoJCW4JTm9ybWFsIG1vZGUKCQl2CVZpc3VhbCBtb2RlCgkJdmUJVmlzdWFsIG1vZGUgd2l0aCAnc2VsZWN0aW9uJyAiZXhjbHVzaXZlIiAoc2FtZSBhcyAndicsCgkJCWlmIG5vdCBzcGVjaWZpZWQpCgkJbwlPcGVyYXRvci1wZW5kaW5nIG1vZGUKCQlpCUluc2VydCBtb2RlCgkJcglSZXBsYWNlIG1vZGUKCgkJCU90aGVyczogfgoJCWMJYXBwZW5kaW5nIHRvIHRoZSBjb21tYW5kLWxpbmUKCQljaQlpbnNlcnRpbmcgaW4gdGhlIGNvbW1hbmQtbGluZQoJCWNyCXJlcGxhY2luZyBpbiB0aGUgY29tbWFuZC1saW5lCgkJbQlhdCB0aGUgJ0hpdCBFTlRFUicgb3IgJ01vcmUnIHByb21wdHMKCQltbAlpZGVtLCBidXQgY3Vyc29yIGluIHRoZSBsYXN0IGxpbmUKCQllCWFueSBtb2RlLCBwb2ludGVyIGJlbG93IGxhc3Qgd2luZG93CgkJcwlhbnkgbW9kZSwgcG9pbnRlciBvbiBhIHN0YXR1cyBsaW5lCgkJc2QJYW55IG1vZGUsIHdoaWxlIGRyYWdnaW5nIGEgc3RhdHVzIGxpbmUKCQl2cwlhbnkgbW9kZSwgcG9pbnRlciBvbiBhIHZlcnRpY2FsIHNlcGFyYXRvciBsaW5lCgkJdmQJYW55IG1vZGUsIHdoaWxlIGRyYWdnaW5nIGEgdmVydGljYWwgc2VwYXJhdG9yIGxpbmUKCQlhCWV2ZXJ5d2hlcmUKCglUaGUgc2hhcGUgaXMgb25lIG9mIHRoZSBmb2xsb3dpbmc6CglhdmFpbAluYW1lCQlsb29rcyBsaWtlIH4KCXcgeAlhcnJvdwkJTm9ybWFsIG1vdXNlIHBvaW50ZXIKCXcgeAlibGFuawkJbm8gcG9pbnRlciBhdCBhbGwgKHVzZSB3aXRoIGNhcmUhKQoJdyB4CWJlYW0JCUktYmVhbQoJdyB4CXVwZG93bgkJdXAtZG93biBzaXppbmcgYXJyb3dzCgl3IHgJbGVmdHJpZ2h0CWxlZnQtcmlnaHQgc2l6aW5nIGFycm93cwoJdyB4CWJ1c3kJCVRoZSBzeXN0ZW0ncyB1c3VhbCBidXN5IHBvaW50ZXIKCXcgeAlubwkJVGhlIHN5c3RlbSdzIHVzdWFsICdubyBpbnB1dCcgcG9pbnRlcgoJICB4CXVkc2l6aW5nCWluZGljYXRlcyB1cC1kb3duIHJlc2l6aW5nCgkgIHgJbHJzaXppbmcJaW5kaWNhdGVzIGxlZnQtcmlnaHQgcmVzaXppbmcKCSAgeAljcm9zc2hhaXIJbGlrZSBhIGJpZyB0aGluICsKCSAgeAloYW5kMQkJYmxhY2sgaGFuZAoJICB4CWhhbmQyCQl3aGl0ZSBoYW5kCgkgIHgJcGVuY2lsCQl3aGF0IHlvdSB3cml0ZSB3aXRoCgkgIHgJcXVlc3Rpb24JYmlnID8KCSAgeAlyaWdodHVwLWFycm93CWFycm93IHBvaW50aW5nIHJpZ2h0LXVwCgl3IHgJdXAtYXJyb3cJYXJyb3cgcG9pbnRpbmcgdXAKCSAgeAk8bnVtYmVyPglhbnkgWDExIHBvaW50ZXIgbnVtYmVyIChzZWUgWDExL2N1cnNvcmZvbnQuaCkKCglUaGUgImF2YWlsIiBjb2x1bW4gY29udGFpbnMgYSAndycgaWYgdGhlIHNoYXBlIGlzIGF2YWlsYWJsZSBmb3IgV2luMzIsCgl4IGZvciBYMTEuCglBbnkgbW9kZXMgbm90IHNwZWNpZmllZCBvciBzaGFwZXMgbm90IGF2YWlsYWJsZSB1c2UgdGhlIG5vcm1hbCBtb3VzZQoJcG9pbnRlci4KCglFeGFtcGxlOiA+CgkJOnNldCBtb3VzZXNoYXBlPXM6dWRzaXppbmcsbTpubwo8CXdpbGwgbWFrZSB0aGUgbW91c2UgdHVybiB0byBhIHNpemluZyBhcnJvdyBvdmVyIHRoZSBzdGF0dXMgbGluZXMgYW5kCglpbmRpY2F0ZSBubyBpbnB1dCB3aGVuIHRoZSBoaXQtZW50ZXIgcHJvbXB0IGlzIGRpc3BsYXllZCAoc2luY2UKCWNsaWNraW5nIHRoZSBtb3VzZSBoYXMgbm8gZWZmZWN0IGluIHRoaXMgc3RhdGUuKQoKCQkJCQkJKidtb3VzZXRpbWUnKiAqJ21vdXNldCcqCidtb3VzZXRpbWUnICdtb3VzZXQnCW51bWJlcgkoZGVmYXVsdCA1MDApCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJT25seSBmb3IgR1VJLCBNUy1ET1MsIFdpbjMyIGFuZCBVbml4IHdpdGggeHRlcm0uICBEZWZpbmVzIHRoZSBtYXhpbXVtCgl0aW1lIGluIG1zZWMgYmV0d2VlbiB0d28gbW91c2UgY2xpY2tzIGZvciB0aGUgc2Vjb25kIGNsaWNrIHRvIGJlCglyZWNvZ25pemVkIGFzIGEgbXVsdGkgY2xpY2suCgoJCQkJCQkgICAgKidtenF1YW50dW0nKiAqJ216cScqCidtenF1YW50dW0nICdtenEnCW51bWJlcgkoZGVmYXVsdCAxMDApCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrbXpzY2hlbWV8CgkJCWZlYXR1cmV9CglUaGUgbnVtYmVyIG9mIG1pbGxpc2Vjb25kcyBiZXR3ZWVuIHBvbGxzIGZvciBNelNjaGVtZSB0aHJlYWRzLgoJTmVnYXRpdmUgb3IgemVybyB2YWx1ZSBtZWFucyBubyB0aHJlYWQgc2NoZWR1bGluZy4KCgkJCQkJCQkqJ25yZm9ybWF0cycqIConbmYnKgonbnJmb3JtYXRzJyAnbmYnCXN0cmluZwkoZGVmYXVsdCAib2N0YWwsaGV4IikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CglUaGlzIGRlZmluZXMgd2hhdCBiYXNlcyBWaW0gd2lsbCBjb25zaWRlciBmb3IgbnVtYmVycyB3aGVuIHVzaW5nIHRoZQoJQ1RSTC1BIGFuZCBDVFJMLVggY29tbWFuZHMgZm9yIGFkZGluZyB0byBhbmQgc3VidHJhY3RpbmcgZnJvbSBhIG51bWJlcgoJcmVzcGVjdGl2ZWx5OyBzZWUgfENUUkwtQXwgZm9yIG1vcmUgaW5mbyBvbiB0aGVzZSBjb21tYW5kcy4KCWFscGhhCWlmIGluY2x1ZGVkLCBzaW5nbGUgYWxwaGFiZXRpY2FsIGNoYXJhY3RlcnMgd2lsbCBiZQoJCWluY3JlbWVudGVkIG9yIGRlY3JlbWVudGVkLiAgVGhpcyBpcyB1c2VmdWwgZm9yIGEgbGlzdCB3aXRoIGEKCQlsZXR0ZXIgaW5kZXggYSksIGIpLCBldGMuCglvY3RhbAlpZiBpbmNsdWRlZCwgbnVtYmVycyB0aGF0IHN0YXJ0IHdpdGggYSB6ZXJvIHdpbGwgYmUgY29uc2lkZXJlZAoJCXRvIGJlIG9jdGFsLiAgRXhhbXBsZTogVXNpbmcgQ1RSTC1BIG9uICIwMDciIHJlc3VsdHMgaW4gIjAxMCIuCgloZXgJaWYgaW5jbHVkZWQsIG51bWJlcnMgc3RhcnRpbmcgd2l0aCAiMHgiIG9yICIwWCIgd2lsbCBiZQoJCWNvbnNpZGVyZWQgdG8gYmUgaGV4YWRlY2ltYWwuICBFeGFtcGxlOiBVc2luZyBDVFJMLVggb24KCQkiMHgxMDAiIHJlc3VsdHMgaW4gIjB4MGZmIi4KCU51bWJlcnMgd2hpY2ggc2ltcGx5IGJlZ2luIHdpdGggYSBkaWdpdCBpbiB0aGUgcmFuZ2UgMS05IGFyZSBhbHdheXMKCWNvbnNpZGVyZWQgZGVjaW1hbC4gIFRoaXMgYWxzbyBoYXBwZW5zIGZvciBudW1iZXJzIHRoYXQgYXJlIG5vdAoJcmVjb2duaXplZCBhcyBvY3RhbCBvciBoZXguCgoJCQkJKidudW1iZXInKiAqJ251JyogKidub251bWJlcicqIConbm9udScqCidudW1iZXInICdudScJCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byB3aW5kb3cKCVByaW50IHRoZSBsaW5lIG51bWJlciBpbiBmcm9udCBvZiBlYWNoIGxpbmUuICBXaGVuIHRoZSAnbicgb3B0aW9uIGlzCglleGNsdWRlZCBmcm9tICdjcG9wdGlvbnMnIGEgd3JhcHBlZCBsaW5lIHdpbGwgbm90IHVzZSB0aGUgY29sdW1uIG9mCglsaW5lIG51bWJlcnMgKHRoaXMgaXMgdGhlIGRlZmF1bHQgd2hlbiAnY29tcGF0aWJsZScgaXNuJ3Qgc2V0KS4KCVRoZSAnbnVtYmVyd2lkdGgnIG9wdGlvbiBjYW4gYmUgdXNlZCB0byBzZXQgdGhlIHJvb20gdXNlZCBmb3IgdGhlIGxpbmUKCW51bWJlci4KCVdoZW4gYSBsb25nLCB3cmFwcGVkIGxpbmUgZG9lc24ndCBzdGFydCB3aXRoIHRoZSBmaXJzdCBjaGFyYWN0ZXIsICctJwoJY2hhcmFjdGVycyBhcmUgcHV0IGJlZm9yZSB0aGUgbnVtYmVyLgoJU2VlIHxobC1MaW5lTnJ8IGZvciB0aGUgaGlnaGxpZ2h0aW5nIHVzZWQgZm9yIHRoZSBudW1iZXIuCgoJCQkJCQkqJ251bWJlcndpZHRoJyogKidudXcnKgonbnVtYmVyd2lkdGgnICdudXcnCW51bWJlcgkoVmltIGRlZmF1bHQ6IDQgIFZpIGRlZmF1bHQ6IDgpCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2xpbmVicmVha3wKCQkJZmVhdHVyZX0KCU1pbmltYWwgbnVtYmVyIG9mIGNvbHVtbnMgdG8gdXNlIGZvciB0aGUgbGluZSBudW1iZXIuICBPbmx5IHJlbGV2YW50Cgl3aGVuIHRoZSAnbnVtYmVyJyBvcHRpb24gaXMgc2V0LgoJU2luY2Ugb25lIHNwYWNlIGlzIGFsd2F5cyBiZXR3ZWVuIHRoZSBudW1iZXIgYW5kIHRoZSB0ZXh0LCB0aGVyZSBpcwoJb25lIGxlc3MgY2hhcmFjdGVyIGZvciB0aGUgbnVtYmVyIGl0c2VsZi4KCVRoZSB2YWx1ZSBpcyB0aGUgbWluaW11bSB3aWR0aC4gIEEgYmlnZ2VyIHdpZHRoIGlzIHVzZWQgd2hlbiBuZWVkZWQgdG8KCWZpdCB0aGUgaGlnaGVzdCBsaW5lIG51bWJlciBpbiB0aGUgYnVmZmVyLiAgVGh1cyB3aXRoIHRoZSBWaW0gZGVmYXVsdAoJb2YgNCB0aGVyZSBpcyByb29tIGZvciBhIGxpbmUgbnVtYmVyIHVwIHRvIDk5OS4gIFdoZW4gdGhlIGJ1ZmZlciBoYXMKCTEwMDAgbGluZXMgZml2ZSBjb2x1bW5zIHdpbGwgYmUgdXNlZC4KCVRoZSBtaW5pbXVtIHZhbHVlIGlzIDEsIHRoZSBtYXhpbXVtIHZhbHVlIGlzIDEwLgoJTk9URTogJ251bWJlcndpZHRoJyBpcyByZXNldCB0byA4IHdoZW4gJ2NvbXBhdGlibGUnIGlzIHNldC4KCgkJCQkJKidvc2ZpbGV0eXBlJyogKidvZnQnKiAqRTM2NioKJ29zZmlsZXR5cGUnICdvZnQnCXN0cmluZyAoUklTQy1PUyBkZWZhdWx0OiAiVGV4dCIsCgkJCQlvdGhlcnMgZGVmYXVsdDogIiIpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K29zZmlsZXR5cGV8CgkJCWZlYXR1cmV9CglTb21lIG9wZXJhdGluZyBzeXN0ZW1zIHN0b3JlIGV4dHJhIGluZm9ybWF0aW9uIGFib3V0IGZpbGVzIGJlc2lkZXMKCW5hbWUsIGRhdGVzdGFtcCBhbmQgcGVybWlzc2lvbnMuICBUaGlzIG9wdGlvbiBjb250YWlucyB0aGUgZXh0cmEKCWluZm9ybWF0aW9uLCB0aGUgbmF0dXJlIG9mIHdoaWNoIHdpbGwgdmFyeSBiZXR3ZWVuIHN5c3RlbXMuCglUaGUgdmFsdWUgb2YgdGhpcyBvcHRpb24gaXMgdXN1YWxseSBzZXQgd2hlbiB0aGUgZmlsZSBpcyBsb2FkZWQsIGFuZAoJdXNlIHRvIHNldCB0aGUgZmlsZSB0eXBlIHdoZW4gZmlsZSBpcyB3cml0dGVuLgoJSXQgY2FuIGFmZmVjdCB0aGUgcGF0dGVybiBtYXRjaGluZyBvZiB0aGUgYXV0b21hdGljIGNvbW1hbmRzLgoJfGF1dG9jbWQtb3NmaWxldHlwZXN8CgoJCQkJCQkqJ3BhcmFncmFwaHMnKiAqJ3BhcmEnKgoncGFyYWdyYXBocycgJ3BhcmEnCXN0cmluZwkoZGVmYXVsdCAiSVBMUFBQUVBQIExJcHBscGlwYnAiKQoJCQlnbG9iYWwKCVNwZWNpZmllcyB0aGUgbnJvZmYgbWFjcm9zIHRoYXQgc2VwYXJhdGUgcGFyYWdyYXBocy4gIFRoZXNlIGFyZSBwYWlycwoJb2YgdHdvIGxldHRlcnMgKHNlZSB8b2JqZWN0LW1vdGlvbnN8KS4KCgkJCQkJCSoncGFzdGUnKiAqJ25vcGFzdGUnKgoncGFzdGUnCQkJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJUHV0IFZpbSBpbiBQYXN0ZSBtb2RlLiAgVGhpcyBpcyB1c2VmdWwgaWYgeW91IHdhbnQgdG8gY3V0IG9yIGNvcHkKCXNvbWUgdGV4dCBmcm9tIG9uZSB3aW5kb3cgYW5kIHBhc3RlIGl0IGluIFZpbS4gIFRoaXMgd2lsbCBhdm9pZAoJdW5leHBlY3RlZCBlZmZlY3RzLgoJU2V0dGluZyB0aGlzIG9wdGlvbiBpcyB1c2VmdWwgd2hlbiB1c2luZyBWaW0gaW4gYSB0ZXJtaW5hbCwgd2hlcmUgVmltCgljYW5ub3QgZGlzdGluZ3Vpc2ggYmV0d2VlbiB0eXBlZCB0ZXh0IGFuZCBwYXN0ZWQgdGV4dC4gIEluIHRoZSBHVUksIFZpbQoJa25vd3MgYWJvdXQgcGFzdGluZyBhbmQgd2lsbCBtb3N0bHkgZG8gdGhlIHJpZ2h0IHRoaW5nIHdpdGhvdXQgJ3Bhc3RlJwoJYmVpbmcgc2V0LiAgVGhlIHNhbWUgaXMgdHJ1ZSBmb3IgYSB0ZXJtaW5hbCB3aGVyZSBWaW0gaGFuZGxlcyB0aGUKCW1vdXNlIGNsaWNrcyBpdHNlbGYuCglUaGlzIG9wdGlvbiBpcyByZXNldCB3aGVuIHN0YXJ0aW5nIHRoZSBHVUkuICBUaHVzIGlmIHlvdSBzZXQgaXQgaW4KCXlvdXIgLnZpbXJjIGl0IHdpbGwgd29yayBpbiBhIHRlcm1pbmFsLCBidXQgbm90IGluIHRoZSBHVUkuICBTZXR0aW5nCgkncGFzdGUnIGluIHRoZSBHVUkgaGFzIHNpZGUgZWZmZWN0czogZS5nLiwgdGhlIFBhc3RlIHRvb2xiYXIgYnV0dG9uCgl3aWxsIG5vIGxvbmdlciB3b3JrIGluIEluc2VydCBtb2RlLCBiZWNhdXNlIGl0IHVzZXMgYSBtYXBwaW5nLgoJV2hlbiB0aGUgJ3Bhc3RlJyBvcHRpb24gaXMgc3dpdGNoZWQgb24gKGFsc28gd2hlbiBpdCB3YXMgYWxyZWFkeSBvbik6CgkJLSBtYXBwaW5nIGluIEluc2VydCBtb2RlIGFuZCBDb21tYW5kLWxpbmUgbW9kZSBpcyBkaXNhYmxlZAoJCS0gYWJicmV2aWF0aW9ucyBhcmUgZGlzYWJsZWQKCQktICd0ZXh0d2lkdGgnIGlzIHNldCB0byAwCgkJLSAnd3JhcG1hcmdpbicgaXMgc2V0IHRvIDAKCQktICdhdXRvaW5kZW50JyBpcyByZXNldAoJCS0gJ3NtYXJ0aW5kZW50JyBpcyByZXNldAoJCS0gJ3NvZnR0YWJzdG9wJyBpcyBzZXQgdG8gMAoJCS0gJ3JldmlucycgaXMgcmVzZXQKCQktICdydWxlcicgaXMgcmVzZXQKCQktICdzaG93bWF0Y2gnIGlzIHJlc2V0CgkJLSAnZm9ybWF0b3B0aW9ucycgaXMgdXNlZCBsaWtlIGl0IGlzIGVtcHR5CglUaGVzZSBvcHRpb25zIGtlZXAgdGhlaXIgdmFsdWUsIGJ1dCB0aGVpciBlZmZlY3QgaXMgZGlzYWJsZWQ6CgkJLSAnbGlzcCcKCQktICdpbmRlbnRleHByJwoJCS0gJ2NpbmRlbnQnCglOT1RFOiBXaGVuIHlvdSBzdGFydCBlZGl0aW5nIGFub3RoZXIgZmlsZSB3aGlsZSB0aGUgJ3Bhc3RlJyBvcHRpb24gaXMKCW9uLCBzZXR0aW5ncyBmcm9tIHRoZSBtb2RlbGluZXMgb3IgYXV0b2NvbW1hbmRzIG1heSBjaGFuZ2UgdGhlCglzZXR0aW5ncyBhZ2FpbiwgY2F1c2luZyB0cm91YmxlIHdoZW4gcGFzdGluZyB0ZXh0LiAgWW91IG1pZ2h0IHdhbnQgdG8KCXNldCB0aGUgJ3Bhc3RlJyBvcHRpb24gYWdhaW4uCglXaGVuIHRoZSAncGFzdGUnIG9wdGlvbiBpcyByZXNldCB0aGUgbWVudGlvbmVkIG9wdGlvbnMgYXJlIHJlc3RvcmVkIHRvCgl0aGUgdmFsdWUgYmVmb3JlIHRoZSBtb21lbnQgJ3Bhc3RlJyB3YXMgc3dpdGNoZWQgZnJvbSBvZmYgdG8gb24uCglSZXNldHRpbmcgJ3Bhc3RlJyBiZWZvcmUgZXZlciBzZXR0aW5nIGl0IGRvZXMgbm90IGhhdmUgYW55IGVmZmVjdC4KCVNpbmNlIG1hcHBpbmcgZG9lc24ndCB3b3JrIHdoaWxlICdwYXN0ZScgaXMgYWN0aXZlLCB5b3UgbmVlZCB0byB1c2UKCXRoZSAncGFzdGV0b2dnbGUnIG9wdGlvbiB0byB0b2dnbGUgdGhlICdwYXN0ZScgb3B0aW9uIHdpdGggc29tZSBrZXkuCgoJCQkJCQkqJ3Bhc3RldG9nZ2xlJyogKidwdCcqCidwYXN0ZXRvZ2dsZScgJ3B0JwlzdHJpbmcJKGRlZmF1bHQgIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiBub24tZW1wdHksIHNwZWNpZmllcyB0aGUga2V5IHNlcXVlbmNlIHRoYXQgdG9nZ2xlcyB0aGUgJ3Bhc3RlJwoJb3B0aW9uLiAgVGhpcyBpcyBsaWtlIHNwZWNpZnlpbmcgYSBtYXBwaW5nOiA+CgkgICAgOm1hcCB7a2V5c30gOnNldCBpbnZwYXN0ZTxDUj4KPAlXaGVyZSB7a2V5c30gaXMgdGhlIHZhbHVlIG9mICdwYXN0ZXRvZ2dsZScuCglUaGUgZGlmZmVyZW5jZSBpcyB0aGF0IGl0IHdpbGwgd29yayBldmVuIHdoZW4gJ3Bhc3RlJyBpcyBzZXQuCgkncGFzdGV0b2dnbGUnIHdvcmtzIGluIEluc2VydCBtb2RlIGFuZCBOb3JtYWwgbW9kZSwgYnV0IG5vdCBpbgoJQ29tbWFuZC1saW5lIG1vZGUuCglNYXBwaW5ncyBhcmUgY2hlY2tlZCBmaXJzdCwgdGh1cyBvdmVycnVsZSAncGFzdGV0b2dnbGUnLiAgSG93ZXZlciwKCXdoZW4gJ3Bhc3RlJyBpcyBvbiBtYXBwaW5ncyBhcmUgaWdub3JlZCBpbiBJbnNlcnQgbW9kZSwgdGh1cyB5b3UgY2FuIGRvCgl0aGlzOiA+CgkgICAgOm1hcCA8RjEwPiA6c2V0IHBhc3RlPENSPgoJICAgIDptYXAgPEYxMT4gOnNldCBub3Bhc3RlPENSPgoJICAgIDppbWFwIDxGMTA+IDxDLU8+OnNldCBwYXN0ZTxDUj4KCSAgICA6aW1hcCA8RjExPiA8bm9wPgoJICAgIDpzZXQgcGFzdGV0b2dnbGU9PEYxMT4KPAlUaGlzIHdpbGwgbWFrZSA8RjEwPiBzdGFydCBwYXN0ZSBtb2RlIGFuZCA8RjExPiBzdG9wIHBhc3RlIG1vZGUuCglOb3RlIHRoYXQgdHlwaW5nIDxGMTA+IGluIHBhc3RlIG1vZGUgaW5zZXJ0cyAiPEYxMD4iLCBzaW5jZSBpbiBwYXN0ZQoJbW9kZSBldmVyeXRoaW5nIGlzIGluc2VydGVkIGxpdGVyYWxseSwgZXhjZXB0IHRoZSAncGFzdGV0b2dnbGUnIGtleQoJc2VxdWVuY2UuCgoJCQkJCQkqJ3BleCcqIConcGF0Y2hleHByJyoKJ3BhdGNoZXhwcicgJ3BleCcJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K2RpZmZ8CgkJCWZlYXR1cmV9CglFeHByZXNzaW9uIHdoaWNoIGlzIGV2YWx1YXRlZCB0byBhcHBseSBhIHBhdGNoIHRvIGEgZmlsZSBhbmQgZ2VuZXJhdGUKCXRoZSByZXN1bHRpbmcgbmV3IHZlcnNpb24gb2YgdGhlIGZpbGUuICBTZWUgfGRpZmYtcGF0Y2hleHByfC4KCgkJCQkJCSoncGF0Y2htb2RlJyogKidwbScqICpFMjA2KgoncGF0Y2htb2RlJyAncG0nCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglXaGVuIG5vbi1lbXB0eSB0aGUgb2xkZXN0IHZlcnNpb24gb2YgYSBmaWxlIGlzIGtlcHQuICBUaGlzIGNhbiBiZSB1c2VkCgl0byBrZWVwIHRoZSBvcmlnaW5hbCB2ZXJzaW9uIG9mIGEgZmlsZSBpZiB5b3UgYXJlIGNoYW5naW5nIGZpbGVzIGluIGEKCXNvdXJjZSBkaXN0cmlidXRpb24uICBPbmx5IHRoZSBmaXJzdCB0aW1lIHRoYXQgYSBmaWxlIGlzIHdyaXR0ZW4gYQoJY29weSBvZiB0aGUgb3JpZ2luYWwgZmlsZSB3aWxsIGJlIGtlcHQuICBUaGUgbmFtZSBvZiB0aGUgY29weSBpcyB0aGUKCW5hbWUgb2YgdGhlIG9yaWdpbmFsIGZpbGUgd2l0aCB0aGUgc3RyaW5nIGluIHRoZSAncGF0Y2htb2RlJyBvcHRpb24KCWFwcGVuZGVkLiAgVGhpcyBvcHRpb24gc2hvdWxkIHN0YXJ0IHdpdGggYSBkb3QuICBVc2UgYSBzdHJpbmcgbGlrZQoJIi5vcmciLiAgJ2JhY2t1cGRpcicgbXVzdCBub3QgYmUgZW1wdHkgZm9yIHRoaXMgdG8gd29yayAoRGV0YWlsOiBUaGUKCWJhY2t1cCBmaWxlIGlzIHJlbmFtZWQgdG8gdGhlIHBhdGNobW9kZSBmaWxlIGFmdGVyIHRoZSBuZXcgZmlsZSBoYXMKCWJlZW4gc3VjY2Vzc2Z1bGx5IHdyaXR0ZW4sIHRoYXQncyB3aHkgaXQgbXVzdCBiZSBwb3NzaWJsZSB0byB3cml0ZSBhCgliYWNrdXAgZmlsZSkuICBJZiB0aGVyZSB3YXMgbm8gZmlsZSB0byBiZSBiYWNrZWQgdXAsIGFuIGVtcHR5IGZpbGUgaXMKCWNyZWF0ZWQuCglXaGVuIHRoZSAnYmFja3Vwc2tpcCcgcGF0dGVybiBtYXRjaGVzLCBhIHBhdGNobW9kZSBmaWxlIGlzIG5vdCBtYWRlLgoJVXNpbmcgJ3BhdGNobW9kZScgZm9yIGNvbXByZXNzZWQgZmlsZXMgYXBwZW5kcyB0aGUgZXh0ZW5zaW9uIGF0IHRoZQoJZW5kIChlLmcuLCAiZmlsZS5nei5vcmlnIiksIHRodXMgdGhlIHJlc3VsdGluZyBuYW1lIGlzbid0IGFsd2F5cwoJcmVjb2duaXplZCBhcyBhIGNvbXByZXNzZWQgZmlsZS4KCU9ubHkgbm9ybWFsIGZpbGUgbmFtZSBjaGFyYWN0ZXJzIGNhbiBiZSB1c2VkLCAiL1wqP1t8PD4iIGFyZSBpbGxlZ2FsLgoKCQkJCQkqJ3BhdGgnKiAqJ3BhJyogKkUzNDMqICpFMzQ1KiAqRTM0NyoKJ3BhdGgnICdwYScJCXN0cmluZwkoZGVmYXVsdCBvbiBVbml4OiAiLiwvdXNyL2luY2x1ZGUsLCIKCQkJCSAgIG9uIE9TLzI6CSAgIi4sL2VteC9pbmNsdWRlLCwiCgkJCQkgICBvdGhlciBzeXN0ZW1zOiAiLiwsIikKCQkJZ2xvYmFsIG9yIGxvY2FsIHRvIGJ1ZmZlciB8Z2xvYmFsLWxvY2FsfAoJCQl7bm90IGluIFZpfQoJVGhpcyBpcyBhIGxpc3Qgb2YgZGlyZWN0b3JpZXMgd2hpY2ggd2lsbCBiZSBzZWFyY2hlZCB3aGVuIHVzaW5nIHRoZQoJfGdmfCwgW2YsIF1mLCBeV2YsIHw6ZmluZHwgYW5kIG90aGVyIGNvbW1hbmRzLCBwcm92aWRlZCB0aGF0IHRoZSBmaWxlCgliZWluZyBzZWFyY2hlZCBmb3IgaGFzIGEgcmVsYXRpdmUgcGF0aCAobm90IHN0YXJ0aW5nIHdpdGggJy8nKS4gIFRoZQoJZGlyZWN0b3JpZXMgaW4gdGhlICdwYXRoJyBvcHRpb24gbWF5IGJlIHJlbGF0aXZlIG9yIGFic29sdXRlLgoJLSBVc2UgY29tbWFzIHRvIHNlcGFyYXRlIGRpcmVjdG9yeSBuYW1lczogPgoJCTpzZXQgcGF0aD0uLC91c3IvbG9jYWwvaW5jbHVkZSwvdXNyL2luY2x1ZGUKPAktIFNwYWNlcyBjYW4gYWxzbyBiZSB1c2VkIHRvIHNlcGFyYXRlIGRpcmVjdG9yeSBuYW1lcyAoZm9yIGJhY2t3YXJkcwoJICBjb21wYXRpYmlsaXR5IHdpdGggdmVyc2lvbiAzLjApLiAgVG8gaGF2ZSBhIHNwYWNlIGluIGEgZGlyZWN0b3J5CgkgIG5hbWUsIHByZWNlZGUgaXQgd2l0aCBhbiBleHRyYSBiYWNrc2xhc2gsIGFuZCBlc2NhcGUgdGhlIHNwYWNlOiA+CgkJOnNldCBwYXRoPS4sL2Rpci93aXRoXFxcIHNwYWNlCjwJLSBUbyBpbmNsdWRlIGEgY29tbWEgaW4gYSBkaXJlY3RvcnkgbmFtZSBwcmVjZWRlIGl0IHdpdGggYW4gZXh0cmEKCSAgYmFja3NsYXNoOiA+CgkJOnNldCBwYXRoPS4sL2Rpci93aXRoXFwsY29tbWEKPAktIFRvIHNlYXJjaCByZWxhdGl2ZSB0byB0aGUgZGlyZWN0b3J5IG9mIHRoZSBjdXJyZW50IGZpbGUsIHVzZTogPgoJCTpzZXQgcGF0aD0uCjwJLSBUbyBzZWFyY2ggaW4gdGhlIGN1cnJlbnQgZGlyZWN0b3J5IHVzZSBhbiBlbXB0eSBzdHJpbmcgYmV0d2VlbiB0d28KCSAgY29tbWFzOiA+CgkJOnNldCBwYXRoPSwsCjwJLSBBIGRpcmVjdG9yeSBuYW1lIG1heSBlbmQgaW4gYSAnOicgb3IgJy8nLgoJLSBFbnZpcm9ubWVudCB2YXJpYWJsZXMgYXJlIGV4cGFuZGVkIHw6c2V0X2VudnwuCgktIFdoZW4gdXNpbmcgfG5ldHJ3LnZpbXwgVVJMcyBjYW4gYmUgdXNlZC4gIEZvciBleGFtcGxlLCBhZGRpbmcKCSAgImh0dHA6Ly93d3cudmltLm9yZyIgd2lsbCBtYWtlICI6ZmluZCBpbmRleC5odG1sIiB3b3JrLgoJLSBTZWFyY2ggdXB3YXJkcyBhbmQgZG93bndhcmRzIGluIGEgZGlyZWN0b3J5IHRyZWU6CgkgIDEpICIqIiBtYXRjaGVzIGEgc2VxdWVuY2Ugb2YgY2hhcmFjdGVycywgZS5nLjogPgoJCTpzZXQgcGF0aD0vdXNyL2luY2x1ZGUvKgo8CSAgICAgbWVhbnMgYWxsIHN1YmRpcmVjdG9yaWVzIGluIC91c3IvaW5jbHVkZSAoYnV0IG5vdCAvdXNyL2luY2x1ZGUKCSAgICAgaXRzZWxmKS4gPgoJCTpzZXQgcGF0aD0vdXNyLypjCjwJICAgICBtYXRjaGVzIC91c3IvZG9jIGFuZCAvdXNyL3NyYy4KCSAgMikgIioqIiBtYXRjaGVzIGEgc3VidHJlZSwgdXAgdG8gMTAwIGRpcmVjdG9yaWVzIGRlZXAuICBFeGFtcGxlOiA+CgkJOnNldCBwYXRoPS9ob21lL3VzZXJfeC9zcmMvKioKPAkgICAgIG1lYW5zIHNlYXJjaCBpbiB0aGUgd2hvbGUgc3VidHJlZSB1bmRlciAiL2hvbWUvdXNyX3gvc3JjIi4KCSAgMykgSWYgdGhlIHBhdGggZW5kcyB3aXRoIGEgJzsnLCB0aGlzIHBhdGggaXMgdGhlIHN0YXJ0cG9pbnQKCSAgICAgZm9yIHVwd2FyZCBzZWFyY2guCgkgIFNlZSB8ZmlsZS1zZWFyY2hpbmd8IGZvciBtb3JlIGluZm8gYW5kIGV4YWN0IHN5bnRheC4KCSAge25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3BhdGhfZXh0cmF8IGZlYXR1cmV9CgktIENhcmVmdWwgd2l0aCAnXCcgY2hhcmFjdGVycywgdHlwZSB0d28gdG8gZ2V0IG9uZSBpbiB0aGUgb3B0aW9uOiA+CgkJOnNldCBwYXRoPS4sYzpcXGluY2x1ZGUKPAkgIE9yIGp1c3QgdXNlICcvJyBpbnN0ZWFkOiA+CgkJOnNldCBwYXRoPS4sYzovaW5jbHVkZQo8CURvbid0IGZvcmdldCAiLiIgb3IgZmlsZXMgd29uJ3QgZXZlbiBiZSBmb3VuZCBpbiB0aGUgc2FtZSBkaXJlY3RvcnkgYXMKCXRoZSBmaWxlIQoJVGhlIG1heGltdW0gbGVuZ3RoIGlzIGxpbWl0ZWQuICBIb3cgbXVjaCBkZXBlbmRzIG9uIHRoZSBzeXN0ZW0sIG1vc3RseQoJaXQgaXMgc29tZXRoaW5nIGxpa2UgMjU2IG9yIDEwMjQgY2hhcmFjdGVycy4KCVlvdSBjYW4gY2hlY2sgaWYgYWxsIHRoZSBpbmNsdWRlIGZpbGVzIGFyZSBmb3VuZCwgdXNpbmcgdGhlIHZhbHVlIG9mCgkncGF0aCcsIHNlZSB8OmNoZWNrcGF0aHwuCglUaGUgdXNlIG9mIHw6c2V0Kz18IGFuZCB8OnNldC09fCBpcyBwcmVmZXJyZWQgd2hlbiBhZGRpbmcgb3IgcmVtb3ZpbmcKCWRpcmVjdG9yaWVzIGZyb20gdGhlIGxpc3QuICBUaGlzIGF2b2lkcyBwcm9ibGVtcyB3aGVuIGEgZnV0dXJlIHZlcnNpb24KCXVzZXMgYW5vdGhlciBkZWZhdWx0LiAgVG8gcmVtb3ZlIHRoZSBjdXJyZW50IGRpcmVjdG9yeSB1c2U6ID4KCQk6c2V0IHBhdGgtPQo8CVRvIGFkZCB0aGUgY3VycmVudCBkaXJlY3RvcnkgdXNlOiA+CgkJOnNldCBwYXRoKz0KPAlUbyB1c2UgYW4gZW52aXJvbm1lbnQgdmFyaWFibGUsIHlvdSBwcm9iYWJseSBuZWVkIHRvIHJlcGxhY2UgdGhlCglzZXBhcmF0b3IuICBIZXJlIGlzIGFuIGV4YW1wbGUgdG8gYXBwZW5kICRJTkNMLCBpbiB3aGljaCBkaXJlY3RvcnkKCW5hbWVzIGFyZSBzZXBhcmF0ZWQgd2l0aCBhIHNlbWktY29sb246ID4KCQk6bGV0ICZwYXRoID0gJnBhdGggLiAiLCIgLiBzdWJzdGl0dXRlKCRJTkNMLCAnOycsICcsJywgJ2cnKQo8CVJlcGxhY2UgdGhlICc7JyB3aXRoIGEgJzonIG9yIHdoYXRldmVyIHNlcGFyYXRvciBpcyB1c2VkLiAgTm90ZSB0aGF0Cgl0aGlzIGRvZXNuJ3Qgd29yayB3aGVuICRJTkNMIGNvbnRhaW5zIGEgY29tbWEgb3Igd2hpdGUgc3BhY2UuCgoJCQkqJ3ByZXNlcnZlaW5kZW50JyogKidwaScqIConbm9wcmVzZXJ2ZWluZGVudCcqIConbm9waScqCidwcmVzZXJ2ZWluZGVudCcgJ3BpJwlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CglXaGVuIGNoYW5naW5nIHRoZSBpbmRlbnQgb2YgdGhlIGN1cnJlbnQgbGluZSwgcHJlc2VydmUgYXMgbXVjaCBvZiB0aGUKCWluZGVudCBzdHJ1Y3R1cmUgYXMgcG9zc2libGUuICBOb3JtYWxseSB0aGUgaW5kZW50IGlzIHJlcGxhY2VkIGJ5IGEKCXNlcmllcyBvZiB0YWJzIGZvbGxvd2VkIGJ5IHNwYWNlcyBhcyByZXF1aXJlZCAodW5sZXNzIHwnZXhwYW5kdGFiJ3wgaXMKCWVuYWJsZWQsIGluIHdoaWNoIGNhc2Ugb25seSBzcGFjZXMgYXJlIHVzZWQpLiAgRW5hYmxpbmcgdGhpcyBvcHRpb24KCW1lYW5zIHRoZSBpbmRlbnQgd2lsbCBwcmVzZXJ2ZSBhcyBtYW55IGV4aXN0aW5nIGNoYXJhY3RlcnMgYXMgcG9zc2libGUKCWZvciBpbmRlbnRpbmcsIGFuZCBvbmx5IGFkZCBhZGRpdGlvbmFsIHRhYnMgb3Igc3BhY2VzIGFzIHJlcXVpcmVkLgoJTk9URTogV2hlbiB1c2luZyAiPj4iIG11bHRpcGxlIHRpbWVzIHRoZSByZXN1bHRpbmcgaW5kZW50IGlzIGEgbWl4IG9mCgl0YWJzIGFuZCBzcGFjZXMuICBZb3UgbWlnaHQgbm90IGxpa2UgdGhpcy4KCU5PVEU6ICdwcmVzZXJ2ZWluZGVudCcgaXMgcmVzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoJQWxzbyBzZWUgJ2NvcHlpbmRlbnQnLgoJVXNlIHw6cmV0YWJ8IHRvIGNsZWFuIHVwIHdoaXRlIHNwYWNlLgoKCQkJCQkqJ3ByZXZpZXdoZWlnaHQnKiAqJ3B2aCcqCidwcmV2aWV3aGVpZ2h0JyAncHZoJwludW1iZXIgKGRlZmF1bHQgMTIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrd2luZG93c3wgb3IKCQkJfCtxdWlja2ZpeHwgZmVhdHVyZX0KCURlZmF1bHQgaGVpZ2h0IGZvciBhIHByZXZpZXcgd2luZG93LiAgVXNlZCBmb3IgfDpwdGFnfCBhbmQgYXNzb2NpYXRlZAoJY29tbWFuZHMuICBVc2VkIGZvciB8Q1RSTC1XX318IHdoZW4gbm8gY291bnQgaXMgZ2l2ZW4uCgoJCQkJCSoncHJldmlld3dpbmRvdycqIConbm9wcmV2aWV3d2luZG93JyoKCQkJCQkqJ3B2dycqIConbm9wdncnKiAqRTU5MCoKJ3ByZXZpZXd3aW5kb3cnICdwdncnCWJvb2xlYW4gKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byB3aW5kb3cKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3dpbmRvd3N8IG9yCgkJCXwrcXVpY2tmaXh8IGZlYXR1cmV9CglJZGVudGlmaWVzIHRoZSBwcmV2aWV3IHdpbmRvdy4gIE9ubHkgb25lIHdpbmRvdyBjYW4gaGF2ZSB0aGlzIG9wdGlvbgoJc2V0LiAgSXQncyBub3JtYWxseSBub3Qgc2V0IGRpcmVjdGx5LCBidXQgYnkgdXNpbmcgb25lIG9mIHRoZSBjb21tYW5kcwoJfDpwdGFnfCwgfDpwZWRpdHwsIGV0Yy4KCgkJCQkJCSoncHJpbnRkZXZpY2UnKiAqJ3BkZXYnKgoncHJpbnRkZXZpY2UnICdwZGV2JwlzdHJpbmcJKGRlZmF1bHQgZW1wdHkpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3ByaW50ZXJ8CgkJCWZlYXR1cmV9CglUaGUgbmFtZSBvZiB0aGUgcHJpbnRlciB0byBiZSB1c2VkIGZvciB8OmhhcmRjb3B5fC4KCVNlZSB8cGRldi1vcHRpb258LgoJVGhpcyBvcHRpb24gY2Fubm90IGJlIHNldCBmcm9tIGEgfG1vZGVsaW5lfCBvciBpbiB0aGUgfHNhbmRib3h8LCBmb3IKCXNlY3VyaXR5IHJlYXNvbnMuCgoJCQkJCQkqJ3ByaW50ZW5jb2RpbmcnKiAqJ3BlbmMnKgoncHJpbnRlbmNvZGluZycgJ3BlbmMnCVN0cmluZwkoZGVmYXVsdCBlbXB0eSwgZXhjZXB0IGZvciBzb21lIHN5c3RlbXMpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3ByaW50ZXJ8CgkJCWFuZCB8K3Bvc3RzY3JpcHR8IGZlYXR1cmVzfQoJU2V0cyB0aGUgY2hhcmFjdGVyIGVuY29kaW5nIHVzZWQgd2hlbiBwcmludGluZy4KCVNlZSB8cGVuYy1vcHRpb258LgoKCQkJCQkJKidwcmludGV4cHInKiAqJ3BleHByJyoKJ3ByaW50ZXhwcicgJ3BleHByJwlTdHJpbmcJKGRlZmF1bHQ6IHNlZSBiZWxvdykKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcHJpbnRlcnwKCQkJYW5kIHwrcG9zdHNjcmlwdHwgZmVhdHVyZXN9CglFeHByZXNzaW9uIHVzZWQgdG8gcHJpbnQgdGhlIFBvc3RTY3JpcHQgcHJvZHVjZWQgd2l0aCB8OmhhcmRjb3B5fC4KCVNlZSB8cGV4cHItb3B0aW9ufC4KCgkJCQkJCSoncHJpbnRmb250JyogKidwZm4nKgoncHJpbnRmb250JyAncGZuJwlzdHJpbmcJKGRlZmF1bHQgImNvdXJpZXIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtwcmludGVyfAoJCQlmZWF0dXJlfQoJVGhlIG5hbWUgb2YgdGhlIGZvbnQgdGhhdCB3aWxsIGJlIHVzZWQgZm9yIHw6aGFyZGNvcHl8LgoJU2VlIHxwZm4tb3B0aW9ufC4KCgkJCQkJCSoncHJpbnRoZWFkZXInKiAqJ3BoZWFkZXInKgoncHJpbnRoZWFkZXInICdwaGVhZGVyJyAgc3RyaW5nICAoZGVmYXVsdCAiJTwlZiVoJW0lPVBhZ2UgJU4iKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtwcmludGVyfAoJCQlmZWF0dXJlfQoJVGhlIGZvcm1hdCBvZiB0aGUgaGVhZGVyIHByb2R1Y2VkIGluIHw6aGFyZGNvcHl8IG91dHB1dC4KCVNlZSB8cGhlYWRlci1vcHRpb258LgoKCQkJCQkJKidwcmludG1iY2hhcnNldCcqIConcG1iY3MnKgoncHJpbnRtYmNoYXJzZXQnICdwbWJjcycgIHN0cmluZyAoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcHJpbnRlcnwsCgkJCXwrcG9zdHNjcmlwdHwgYW5kIHwrbXVsdGlfYnl0ZXwgZmVhdHVyZXN9CglUaGUgQ0pLIGNoYXJhY3RlciBzZXQgdG8gYmUgdXNlZCBmb3IgQ0pLIG91dHB1dCBmcm9tIHw6aGFyZGNvcHl8LgoJU2VlIHxwbWJjcy1vcHRpb258LgoKCQkJCQkJKidwcmludG1iZm9udCcqIConcG1iZm4nKgoncHJpbnRtYmZvbnQnICdwbWJmbicJc3RyaW5nIChkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aCB0aGUgfCtwcmludGVyfCwKCQkJfCtwb3N0c2NyaXB0fCBhbmQgfCttdWx0aV9ieXRlfCBmZWF0dXJlc30KCUxpc3Qgb2YgZm9udCBuYW1lcyB0byBiZSB1c2VkIGZvciBDSksgb3V0cHV0IGZyb20gfDpoYXJkY29weXwuCglTZWUgfHBtYmZuLW9wdGlvbnwuCgoJCQkJCQkqJ3ByaW50b3B0aW9ucycqIConcG9wdCcqCidwcmludG9wdGlvbnMnICdwb3B0JyBzdHJpbmcgKGRlZmF1bHQgIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHwrcHJpbnRlcnwgZmVhdHVyZX0KCUxpc3Qgb2YgaXRlbXMgdGhhdCBjb250cm9sIHRoZSBmb3JtYXQgb2YgdGhlIG91dHB1dCBvZiB8OmhhcmRjb3B5fC4KCVNlZSB8cG9wdC1vcHRpb258LgoKCQkJCQkJKidwcm9tcHQnKiAqJ25vcHJvbXB0JyoKJ3Byb21wdCcJCWJvb2xlYW4JKGRlZmF1bHQgb24pCgkJCWdsb2JhbAoJV2hlbiBvbiBhICI6IiBwcm9tcHQgaXMgdXNlZCBpbiBFeCBtb2RlLgoKCQkJCQkJKidxdW90ZWVzY2FwZScqIConcWUnKgoncXVvdGVlc2NhcGUnICdxZScJc3RyaW5nCShkZWZhdWx0ICJcIikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CglUaGUgY2hhcmFjdGVycyB0aGF0IGFyZSB1c2VkIHRvIGVzY2FwZSBxdW90ZXMgaW4gYSBzdHJpbmcuICBVc2VkIGZvcgoJb2JqZWN0cyBsaWtlIGEnLCBhIiBhbmQgYWAgfGEnfC4KCVdoZW4gb25lIG9mIHRoZSBjaGFyYWN0ZXJzIGluIHRoaXMgb3B0aW9uIGlzIGZvdW5kIGluc2lkZSBhIHN0cmluZywKCXRoZSBmb2xsb3dpbmcgY2hhcmFjdGVyIHdpbGwgYmUgc2tpcHBlZC4gIFRoZSBkZWZhdWx0IHZhbHVlIG1ha2VzIHRoZQoJdGV4dCAiZm9vXCJiYXJcXCIgY29uc2lkZXJlZCB0byBiZSBvbmUgc3RyaW5nLgoKCQkJCSAgIConcmVhZG9ubHknKiAqJ3JvJyogKidub3JlYWRvbmx5JyogKidub3JvJyoKJ3JlYWRvbmx5JyAncm8nCQlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJbG9jYWwgdG8gYnVmZmVyCglJZiBvbiwgd3JpdGVzIGZhaWwgdW5sZXNzIHlvdSB1c2UgYSAnIScuICBQcm90ZWN0cyB5b3UgZnJvbQoJYWNjaWRlbnRhbGx5IG92ZXJ3cml0aW5nIGEgZmlsZS4gIERlZmF1bHQgb24gd2hlbiBWaW0gaXMgc3RhcnRlZAoJaW4gcmVhZC1vbmx5IG1vZGUgKCJ2aW0gLVIiKSBvciB3aGVuIHRoZSBleGVjdXRhYmxlIGlzIGNhbGxlZCAidmlldyIuCglXaGVuIHVzaW5nICI6dyEiIHRoZSAncmVhZG9ubHknIG9wdGlvbiBpcyByZXNldCBmb3IgdGhlIGN1cnJlbnQKCWJ1ZmZlciwgdW5sZXNzIHRoZSAnWicgZmxhZyBpcyBpbiAnY3BvcHRpb25zJy4KCXtub3QgaW4gVmk6fSAgV2hlbiB1c2luZyB0aGUgIjp2aWV3IiBjb21tYW5kIHRoZSAncmVhZG9ubHknIG9wdGlvbiBpcwoJc2V0IGZvciB0aGUgbmV3bHkgZWRpdGVkIGJ1ZmZlci4KCgkJCQkJCSoncmVtYXAnKiAqJ25vcmVtYXAnKgoncmVtYXAnCQkJYm9vbGVhbgkoZGVmYXVsdCBvbikKCQkJZ2xvYmFsCglBbGxvd3MgZm9yIG1hcHBpbmdzIHRvIHdvcmsgcmVjdXJzaXZlbHkuICBJZiB5b3UgZG8gbm90IHdhbnQgdGhpcyBmb3IKCWEgc2luZ2xlIGVudHJ5LCB1c2UgdGhlIDpub3JlbWFwWyFdIGNvbW1hbmQuCgoJCQkJCQkqJ3JlcG9ydCcqCidyZXBvcnQnCQludW1iZXIJKGRlZmF1bHQgMikKCQkJZ2xvYmFsCglUaHJlc2hvbGQgZm9yIHJlcG9ydGluZyBudW1iZXIgb2YgbGluZXMgY2hhbmdlZC4gIFdoZW4gdGhlIG51bWJlciBvZgoJY2hhbmdlZCBsaW5lcyBpcyBtb3JlIHRoYW4gJ3JlcG9ydCcgYSBtZXNzYWdlIHdpbGwgYmUgZ2l2ZW4gZm9yIG1vc3QKCSI6IiBjb21tYW5kcy4gIElmIHlvdSB3YW50IGl0IGFsd2F5cywgc2V0ICdyZXBvcnQnIHRvIDAuCglGb3IgdGhlICI6c3Vic3RpdHV0ZSIgY29tbWFuZCB0aGUgbnVtYmVyIG9mIHN1YnN0aXR1dGlvbnMgaXMgdXNlZAoJaW5zdGVhZCBvZiB0aGUgbnVtYmVyIG9mIGxpbmVzLgoKCQkJIConcmVzdG9yZXNjcmVlbicqIConcnMnKiAqJ25vcmVzdG9yZXNjcmVlbicqIConbm9ycycqCidyZXN0b3Jlc2NyZWVuJyAncnMnCWJvb2xlYW4JKGRlZmF1bHQgb24pCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfSAge29ubHkgaW4gV2luZG93cyA5NS9OVCBjb25zb2xlIHZlcnNpb259CglXaGVuIHNldCwgdGhlIHNjcmVlbiBjb250ZW50cyBpcyByZXN0b3JlZCB3aGVuIGV4aXRpbmcgVmltLiAgVGhpcyBhbHNvCgloYXBwZW5zIHdoZW4gZXhlY3V0aW5nIGV4dGVybmFsIGNvbW1hbmRzLgoKCUZvciBub24tV2luZG93cyBWaW06IFlvdSBjYW4gc2V0IG9yIHJlc2V0IHRoZSAndF90aScgYW5kICd0X3RlJwoJb3B0aW9ucyBpbiB5b3VyIC52aW1yYy4gIFRvIGRpc2FibGUgcmVzdG9yaW5nOgoJCXNldCB0X3RpPSB0X3RlPQoJVG8gZW5hYmxlIHJlc3RvcmluZyAoZm9yIGFuIHh0ZXJtKToKCQlzZXQgdF90aT1eWzdeW1tyXltbPzQ3aCB0X3RlPV5bWz80N2xeWzgKCShXaGVyZSBeWyBpcyBhbiA8RXNjPiwgdHlwZSBDVFJMLVYgPEVzYz4gdG8gaW5zZXJ0IGl0KQoKCQkJCSoncmV2aW5zJyogKidyaScqIConbm9yZXZpbnMnKiAqJ25vcmknKgoncmV2aW5zJyAncmknCQlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrcmlnaHRsZWZ0fAoJCQlmZWF0dXJlfQoJSW5zZXJ0aW5nIGNoYXJhY3RlcnMgaW4gSW5zZXJ0IG1vZGUgd2lsbCB3b3JrIGJhY2t3YXJkcy4gIFNlZSAidHlwaW5nCgliYWNrd2FyZHMiIHxpbnMtcmV2ZXJzZXwuICBUaGlzIG9wdGlvbiBjYW4gYmUgdG9nZ2xlZCB3aXRoIHRoZSBDVFJMLV8KCWNvbW1hbmQgaW4gSW5zZXJ0IG1vZGUsIHdoZW4gJ2FsbG93cmV2aW5zJyBpcyBzZXQuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyByZXNldCB3aGVuICdjb21wYXRpYmxlJyBvciAncGFzdGUnIGlzIHNldC4KCgkJCQkgKidyaWdodGxlZnQnKiAqJ3JsJyogKidub3JpZ2h0bGVmdCcqIConbm9ybCcqCidyaWdodGxlZnQnICdybCcJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3JpZ2h0bGVmdHwKCQkJZmVhdHVyZX0KCVdoZW4gb24sIGRpc3BsYXkgb3JpZW50YXRpb24gYmVjb21lcyByaWdodC10by1sZWZ0LCBpLmUuLCBjaGFyYWN0ZXJzCgl0aGF0IGFyZSBzdG9yZWQgaW4gdGhlIGZpbGUgYXBwZWFyIGZyb20gdGhlIHJpZ2h0IHRvIHRoZSBsZWZ0LgoJVXNpbmcgdGhpcyBvcHRpb24sIGl0IGlzIHBvc3NpYmxlIHRvIGVkaXQgZmlsZXMgZm9yIGxhbmd1YWdlcyB0aGF0CglhcmUgd3JpdHRlbiBmcm9tIHRoZSByaWdodCB0byB0aGUgbGVmdCBzdWNoIGFzIEhlYnJldyBhbmQgQXJhYmljLgoJVGhpcyBvcHRpb24gaXMgcGVyIHdpbmRvdywgc28gaXQgaXMgcG9zc2libGUgdG8gZWRpdCBtaXhlZCBmaWxlcwoJc2ltdWx0YW5lb3VzbHksIG9yIHRvIHZpZXcgdGhlIHNhbWUgZmlsZSBpbiBib3RoIHdheXMgKHRoaXMgaXMKCXVzZWZ1bCB3aGVuZXZlciB5b3UgaGF2ZSBhIG1peGVkIHRleHQgZmlsZSB3aXRoIGJvdGggcmlnaHQtdG8tbGVmdAoJYW5kIGxlZnQtdG8tcmlnaHQgc3RyaW5ncyBzbyB0aGF0IGJvdGggc2V0cyBhcmUgZGlzcGxheWVkIHByb3Blcmx5CglpbiBkaWZmZXJlbnQgd2luZG93cykuICBBbHNvIHNlZSB8cmlsZWZ0LnR4dHwuCgoJCQkqJ3JpZ2h0bGVmdGNtZCcqIConcmxjJyogKidub3JpZ2h0bGVmdGNtZCcqIConbm9ybGMnKgoncmlnaHRsZWZ0Y21kJyAncmxjJwlzdHJpbmcJKGRlZmF1bHQgInNlYXJjaCIpCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3JpZ2h0bGVmdHwKCQkJZmVhdHVyZX0KCUVhY2ggd29yZCBpbiB0aGlzIG9wdGlvbiBlbmFibGVzIHRoZSBjb21tYW5kIGxpbmUgZWRpdGluZyB0byB3b3JrIGluCglyaWdodC10by1sZWZ0IG1vZGUgZm9yIGEgZ3JvdXAgb2YgY29tbWFuZHM6CgoJCXNlYXJjaAkJIi8iIGFuZCAiPyIgY29tbWFuZHMKCglUaGlzIGlzIHVzZWZ1bCBmb3IgbGFuZ3VhZ2VzIHN1Y2ggYXMgSGVicmV3LCBBcmFiaWMgYW5kIEZhcnNpLgoJVGhlICdyaWdodGxlZnQnIG9wdGlvbiBtdXN0IGJlIHNldCBmb3IgJ3JpZ2h0bGVmdGNtZCcgdG8gdGFrZSBlZmZlY3QuCgoJCQkJCSAqJ3J1bGVyJyogKidydScqIConbm9ydWxlcicqIConbm9ydScqCidydWxlcicgJ3J1JwkJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlCgkJCXwrY21kbGluZV9pbmZvfCBmZWF0dXJlfQoJU2hvdyB0aGUgbGluZSBhbmQgY29sdW1uIG51bWJlciBvZiB0aGUgY3Vyc29yIHBvc2l0aW9uLCBzZXBhcmF0ZWQgYnkgYQoJY29tbWEuICBXaGVuIHRoZXJlIGlzIHJvb20sIHRoZSByZWxhdGl2ZSBwb3NpdGlvbiBvZiB0aGUgZGlzcGxheWVkCgl0ZXh0IGluIHRoZSBmaWxlIGlzIHNob3duIG9uIHRoZSBmYXIgcmlnaHQ6CgkJVG9wCWZpcnN0IGxpbmUgaXMgdmlzaWJsZQoJCUJvdAlsYXN0IGxpbmUgaXMgdmlzaWJsZQoJCUFsbAlmaXJzdCBhbmQgbGFzdCBsaW5lIGFyZSB2aXNpYmxlCgkJNDUlCXJlbGF0aXZlIHBvc2l0aW9uIGluIHRoZSBmaWxlCglJZiAncnVsZXJmb3JtYXQnIGlzIHNldCwgaXQgd2lsbCBkZXRlcm1pbmUgdGhlIGNvbnRlbnRzIG9mIHRoZSBydWxlci4KCUVhY2ggd2luZG93IGhhcyBpdHMgb3duIHJ1bGVyLiAgSWYgYSB3aW5kb3cgaGFzIGEgc3RhdHVzIGxpbmUsIHRoZQoJcnVsZXIgaXMgc2hvd24gdGhlcmUuICBPdGhlcndpc2UgaXQgaXMgc2hvd24gaW4gdGhlIGxhc3QgbGluZSBvZiB0aGUKCXNjcmVlbi4gIElmIHRoZSBzdGF0dXNsaW5lIGlzIGdpdmVuIGJ5ICdzdGF0dXNsaW5lJyAoaS5lLiBub3QgZW1wdHkpLAoJdGhpcyBvcHRpb24gdGFrZXMgcHJlY2VkZW5jZSBvdmVyICdydWxlcicgYW5kICdydWxlcmZvcm1hdCcKCUlmIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyBkaXNwbGF5ZWQgaXMgZGlmZmVyZW50IGZyb20gdGhlIG51bWJlciBvZgoJYnl0ZXMgaW4gdGhlIHRleHQgKGUuZy4sIGZvciBhIFRBQiBvciBhIG11bHRpLWJ5dGUgY2hhcmFjdGVyKSwgYm90aAoJdGhlIHRleHQgY29sdW1uIChieXRlIG51bWJlcikgYW5kIHRoZSBzY3JlZW4gY29sdW1uIGFyZSBzaG93biwKCXNlcGFyYXRlZCB3aXRoIGEgZGFzaC4KCUZvciBhbiBlbXB0eSBsaW5lICIwLTEiIGlzIHNob3duLgoJRm9yIGFuIGVtcHR5IGJ1ZmZlciB0aGUgbGluZSBudW1iZXIgd2lsbCBhbHNvIGJlIHplcm86ICIwLDAtMSIuCglUaGlzIG9wdGlvbiBpcyByZXNldCB3aGVuIHRoZSAncGFzdGUnIG9wdGlvbiBpcyBzZXQuCglJZiB5b3UgZG9uJ3Qgd2FudCB0byBzZWUgdGhlIHJ1bGVyIGFsbCB0aGUgdGltZSBidXQgd2FudCB0byBrbm93IHdoZXJlCgl5b3UgYXJlLCB1c2UgImcgQ1RSTC1HIiB8Z19DVFJMLUd8LgoJTk9URTogVGhpcyBvcHRpb24gaXMgcmVzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJKidydWxlcmZvcm1hdCcqIConcnVmJyoKJ3J1bGVyZm9ybWF0JyAncnVmJwlzdHJpbmcJKGRlZmF1bHQgZW1wdHkpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrc3RhdHVzbGluZXwKCQkJZmVhdHVyZX0KCVdoZW4gdGhpcyBvcHRpb24gaXMgbm90IGVtcHR5LCBpdCBkZXRlcm1pbmVzIHRoZSBjb250ZW50IG9mIHRoZSBydWxlcgoJc3RyaW5nLCBhcyBkaXNwbGF5ZWQgZm9yIHRoZSAncnVsZXInIG9wdGlvbi4KCVRoZSBmb3JtYXQgb2YgdGhpcyBvcHRpb24sIGlzIGxpa2UgdGhhdCBvZiAnc3RhdHVzbGluZScuCglUaGUgZGVmYXVsdCBydWxlciB3aWR0aCBpcyAxNyBjaGFyYWN0ZXJzLiAgVG8gbWFrZSB0aGUgcnVsZXIgMTUKCWNoYXJhY3RlcnMgd2lkZSwgcHV0ICIlMTUoIiBhdCB0aGUgc3RhcnQgYW5kICIlKSIgYXQgdGhlIGVuZC4KCUV4YW1wbGU6ID4KCQk6c2V0IHJ1bGVyZm9ybWF0PSUxNSglYyVWXCAlcCUlJSkKPAoJCQkJKidydW50aW1lcGF0aCcqIConcnRwJyogKnZpbWZpbGVzKgoncnVudGltZXBhdGgnICdydHAnCXN0cmluZwkoZGVmYXVsdDoKCQkJCQlVbml4OiAiJEhPTUUvLnZpbSwKCQkJCQkJJFZJTS92aW1maWxlcywKCQkJCQkJJFZJTVJVTlRJTUUsCgkJCQkJCSRWSU0vdmltZmlsZXMvYWZ0ZXIsCgkJCQkJCSRIT01FLy52aW0vYWZ0ZXIiCgkJCQkJQW1pZ2E6ICJob21lOnZpbWZpbGVzLAoJCQkJCQkkVklNL3ZpbWZpbGVzLAoJCQkJCQkkVklNUlVOVElNRSwKCQkJCQkJJFZJTS92aW1maWxlcy9hZnRlciwKCQkJCQkJaG9tZTp2aW1maWxlcy9hZnRlciIKCQkJCQlQQywgT1MvMjogIiRIT01FL3ZpbWZpbGVzLAoJCQkJCQkkVklNL3ZpbWZpbGVzLAoJCQkJCQkkVklNUlVOVElNRSwKCQkJCQkJJFZJTS92aW1maWxlcy9hZnRlciwKCQkJCQkJJEhPTUUvdmltZmlsZXMvYWZ0ZXIiCgkJCQkJTWFjaW50b3NoOiAiJFZJTTp2aW1maWxlcywKCQkJCQkJJFZJTVJVTlRJTUUsCgkJCQkJCSRWSU06dmltZmlsZXM6YWZ0ZXIiCgkJCQkJUklTQy1PUzogIkNob2ljZXM6dmltZmlsZXMsCgkJCQkJCSRWSU1SVU5USU1FLAoJCQkJCQlDaG9pY2VzOnZpbWZpbGVzL2FmdGVyIgoJCQkJCVZNUzogInN5cyRsb2dpbjp2aW1maWxlcywKCQkJCQkJJFZJTS92aW1maWxlcywKCQkJCQkJJFZJTVJVTlRJTUUsCgkJCQkJCSRWSU0vdmltZmlsZXMvYWZ0ZXIsCgkJCQkJCXN5cyRsb2dpbjp2aW1maWxlcy9hZnRlciIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJVGhpcyBpcyBhIGxpc3Qgb2YgZGlyZWN0b3JpZXMgd2hpY2ggd2lsbCBiZSBzZWFyY2hlZCBmb3IgcnVudGltZQoJZmlsZXM6CgkgIGZpbGV0eXBlLnZpbQlmaWxldHlwZXMgYnkgZmlsZSBuYW1lIHxuZXctZmlsZXR5cGV8CgkgIHNjcmlwdHMudmltCWZpbGV0eXBlcyBieSBmaWxlIGNvbnRlbnRzIHxuZXctZmlsZXR5cGUtc2NyaXB0c3wKCSAgYXV0b2xvYWQvCWF1dG9tYXRpY2FsbHkgbG9hZGVkIHNjcmlwdHMgfGF1dG9sb2FkLWZ1bmN0aW9uc3wKCSAgY29sb3JzLwljb2xvciBzY2hlbWUgZmlsZXMgfDpjb2xvcnNjaGVtZXwKCSAgY29tcGlsZXIvCWNvbXBpbGVyIGZpbGVzIHw6Y29tcGlsZXJ8CgkgIGRvYy8JCWRvY3VtZW50YXRpb24gfHdyaXRlLWxvY2FsLWhlbHB8CgkgIGZ0cGx1Z2luLwlmaWxldHlwZSBwbHVnaW5zIHx3cml0ZS1maWxldHlwZS1wbHVnaW58CgkgIGluZGVudC8JaW5kZW50IHNjcmlwdHMgfGluZGVudC1leHByZXNzaW9ufAoJICBrZXltYXAvCWtleSBtYXBwaW5nIGZpbGVzIHxtYnl0ZS1rZXltYXB8CgkgIGxhbmcvCQltZW51IHRyYW5zbGF0aW9ucyB8Om1lbnV0cmFuc3wKCSAgbWVudS52aW0JR1VJIG1lbnVzIHxtZW51LnZpbXwKCSAgcGx1Z2luLwlwbHVnaW4gc2NyaXB0cyB8d3JpdGUtcGx1Z2lufAoJICBwcmludC8JZmlsZXMgZm9yIHByaW50aW5nIHxwb3N0c2NyaXB0LXByaW50LWVuY29kaW5nfAoJICBzeW50YXgvCXN5bnRheCBmaWxlcyB8bXlzeW50YXhmaWxlfAoJICB0dXRvci8JZmlsZXMgZm9yIHZpbXR1dG9yIHx0dXRvcnwKCglBbmQgYW55IG90aGVyIGZpbGUgc2VhcmNoZWQgZm9yIHdpdGggdGhlIHw6cnVudGltZXwgY29tbWFuZC4KCglUaGUgZGVmYXVsdHMgZm9yIG1vc3Qgc3lzdGVtcyBhcmUgc2V0dXAgdG8gc2VhcmNoIGZpdmUgbG9jYXRpb25zOgoJMS4gSW4geW91ciBob21lIGRpcmVjdG9yeSwgZm9yIHlvdXIgcGVyc29uYWwgcHJlZmVyZW5jZXMuCgkyLiBJbiBhIHN5c3RlbS13aWRlIFZpbSBkaXJlY3RvcnksIGZvciBwcmVmZXJlbmNlcyBmcm9tIHRoZSBzeXN0ZW0KCSAgIGFkbWluaXN0cmF0b3IuCgkzLiBJbiAkVklNUlVOVElNRSwgZm9yIGZpbGVzIGRpc3RyaWJ1dGVkIHdpdGggVmltLgoJCQkJCQkJKmFmdGVyLWRpcmVjdG9yeSoKCTQuIEluIHRoZSAiYWZ0ZXIiIGRpcmVjdG9yeSBpbiB0aGUgc3lzdGVtLXdpZGUgVmltIGRpcmVjdG9yeS4gIFRoaXMgaXMKCSAgIGZvciB0aGUgc3lzdGVtIGFkbWluaXN0cmF0b3IgdG8gb3ZlcnJ1bGUgb3IgYWRkIHRvIHRoZSBkaXN0cmlidXRlZAoJICAgZGVmYXVsdHMgKHJhcmVseSBuZWVkZWQpCgk1LiBJbiB0aGUgImFmdGVyIiBkaXJlY3RvcnkgaW4geW91ciBob21lIGRpcmVjdG9yeS4gIFRoaXMgaXMgZm9yCgkgICBwZXJzb25hbCBwcmVmZXJlbmNlcyB0byBvdmVycnVsZSBvciBhZGQgdG8gdGhlIGRpc3RyaWJ1dGVkIGRlZmF1bHRzCgkgICBvciBzeXN0ZW0td2lkZSBzZXR0aW5ncyAocmFyZWx5IG5lZWRlZCkuCgoJTm90ZSB0aGF0LCB1bmxpa2UgJ3BhdGgnLCBubyB3aWxkY2FyZHMgbGlrZSAiKioiIGFyZSBhbGxvd2VkLiAgTm9ybWFsCgl3aWxkY2FyZHMgYXJlIGFsbG93ZWQsIGJ1dCBjYW4gc2lnbmlmaWNhbnRseSBzbG93IGRvd24gc2VhcmNoaW5nIGZvcgoJcnVudGltZSBmaWxlcy4gIEZvciBzcGVlZCwgdXNlIGFzIGZldyBpdGVtcyBhcyBwb3NzaWJsZSBhbmQgYXZvaWQKCXdpbGRjYXJkcy4KCVNlZSB8OnJ1bnRpbWV8LgoJRXhhbXBsZTogPgoJCTpzZXQgcnVudGltZXBhdGg9fi92aW1ydW50aW1lLC9teWdyb3VwL3ZpbSwkVklNUlVOVElNRQo8CVRoaXMgd2lsbCB1c2UgdGhlIGRpcmVjdG9yeSAifi92aW1ydW50aW1lIiBmaXJzdCAoY29udGFpbmluZyB5b3VyCglwZXJzb25hbCBWaW0gcnVudGltZSBmaWxlcyksIHRoZW4gIi9teWdyb3VwL3ZpbSIgKHNoYXJlZCBiZXR3ZWVuIGEKCWdyb3VwIG9mIHBlb3BsZSkgYW5kIGZpbmFsbHkgIiRWSU1SVU5USU1FIiAodGhlIGRpc3RyaWJ1dGVkIHJ1bnRpbWUKCWZpbGVzKS4KCVlvdSBwcm9iYWJseSBzaG91bGQgYWx3YXlzIGluY2x1ZGUgJFZJTVJVTlRJTUUgc29tZXdoZXJlLCB0byB1c2UgdGhlCglkaXN0cmlidXRlZCBydW50aW1lIGZpbGVzLiAgWW91IGNhbiBwdXQgYSBkaXJlY3RvcnkgYmVmb3JlICRWSU1SVU5USU1FCgl0byBmaW5kIGZpbGVzIHdoaWNoIHJlcGxhY2UgYSBkaXN0cmlidXRlZCBydW50aW1lIGZpbGVzLiAgWW91IGNhbiBwdXQKCWEgZGlyZWN0b3J5IGFmdGVyICRWSU1SVU5USU1FIHRvIGZpbmQgZmlsZXMgd2hpY2ggYWRkIHRvIGRpc3RyaWJ1dGVkCglydW50aW1lIGZpbGVzLgoJVGhpcyBvcHRpb24gY2Fubm90IGJlIHNldCBmcm9tIGEgfG1vZGVsaW5lfCBvciBpbiB0aGUgfHNhbmRib3h8LCBmb3IKCXNlY3VyaXR5IHJlYXNvbnMuCgoJCQkJCQkqJ3Njcm9sbCcqIConc2NyJyoKJ3Njcm9sbCcgJ3NjcicJCW51bWJlcgkoZGVmYXVsdDogaGFsZiB0aGUgd2luZG93IGhlaWdodCkKCQkJbG9jYWwgdG8gd2luZG93CglOdW1iZXIgb2YgbGluZXMgdG8gc2Nyb2xsIHdpdGggQ1RSTC1VIGFuZCBDVFJMLUQgY29tbWFuZHMuICBXaWxsIGJlCglzZXQgdG8gaGFsZiB0aGUgbnVtYmVyIG9mIGxpbmVzIGluIHRoZSB3aW5kb3cgd2hlbiB0aGUgd2luZG93IHNpemUKCWNoYW5nZXMuICBJZiB5b3UgZ2l2ZSBhIGNvdW50IHRvIHRoZSBDVFJMLVUgb3IgQ1RSTC1EIGNvbW1hbmQgaXQgd2lsbAoJYmUgdXNlZCBhcyB0aGUgbmV3IHZhbHVlIGZvciAnc2Nyb2xsJy4gIFJlc2V0IHRvIGhhbGYgdGhlIHdpbmRvdwoJaGVpZ2h0IHdpdGggIjpzZXQgc2Nyb2xsPTAiLiAgIHtWaSBpcyBhIGJpdCBkaWZmZXJlbnQ6ICdzY3JvbGwnIGdpdmVzCgl0aGUgbnVtYmVyIG9mIHNjcmVlbiBsaW5lcyBpbnN0ZWFkIG9mIGZpbGUgbGluZXMsIG1ha2VzIGEgZGlmZmVyZW5jZQoJd2hlbiBsaW5lcyB3cmFwfQoKCQkJKidzY3JvbGxiaW5kJyogKidzY2InKiAqJ25vc2Nyb2xsYmluZCcqIConbm9zY2InKgonc2Nyb2xsYmluZCcgJ3NjYicJYm9vbGVhbiAgKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byB3aW5kb3cKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3Njcm9sbGJpbmR8CgkJCWZlYXR1cmV9CglTZWUgYWxzbyB8c2Nyb2xsLWJpbmRpbmd8LiAgV2hlbiB0aGlzIG9wdGlvbiBpcyBzZXQsIHRoZSBjdXJyZW50Cgl3aW5kb3cgc2Nyb2xscyBhcyBvdGhlciBzY3JvbGxiaW5kIHdpbmRvd3MgKHdpbmRvd3MgdGhhdCBhbHNvIGhhdmUKCXRoaXMgb3B0aW9uIHNldCkgc2Nyb2xsLiAgVGhpcyBvcHRpb24gaXMgdXNlZnVsIGZvciB2aWV3aW5nIHRoZQoJZGlmZmVyZW5jZXMgYmV0d2VlbiB0d28gdmVyc2lvbnMgb2YgYSBmaWxlLCBzZWUgJ2RpZmYnLgoJU2VlIHwnc2Nyb2xsb3B0J3wgZm9yIG9wdGlvbnMgdGhhdCBkZXRlcm1pbmUgaG93IHRoaXMgb3B0aW9uIHNob3VsZCBiZQoJaW50ZXJwcmV0ZWQuCglUaGlzIG9wdGlvbiBpcyBtb3N0bHkgcmVzZXQgd2hlbiBzcGxpdHRpbmcgYSB3aW5kb3cgdG8gZWRpdCBhbm90aGVyCglmaWxlLiAgVGhpcyBtZWFucyB0aGF0ICI6c3BsaXQgfCBlZGl0IGZpbGUiIHJlc3VsdHMgaW4gdHdvIHdpbmRvd3MKCXdpdGggc2Nyb2xsLWJpbmRpbmcsIGJ1dCAiOnNwbGl0IGZpbGUiIGRvZXMgbm90LgoKCQkJCQkJKidzY3JvbGxqdW1wJyogKidzaicqCidzY3JvbGxqdW1wJyAnc2onCW51bWJlcgkoZGVmYXVsdCAxKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCU1pbmltYWwgbnVtYmVyIG9mIGxpbmVzIHRvIHNjcm9sbCB3aGVuIHRoZSBjdXJzb3IgZ2V0cyBvZmYgdGhlCglzY3JlZW4gKGUuZy4sIHdpdGggImoiKS4gIE5vdCB1c2VkIGZvciBzY3JvbGwgY29tbWFuZHMgKGUuZy4sIENUUkwtRSwKCUNUUkwtRCkuICBVc2VmdWwgaWYgeW91ciB0ZXJtaW5hbCBzY3JvbGxzIHZlcnkgc2xvd2x5LgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIDEgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJKidzY3JvbGxvZmYnKiAqJ3NvJyoKJ3Njcm9sbG9mZicgJ3NvJwludW1iZXIJKGRlZmF1bHQgMCkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglNaW5pbWFsIG51bWJlciBvZiBzY3JlZW4gbGluZXMgdG8ga2VlcCBhYm92ZSBhbmQgYmVsb3cgdGhlIGN1cnNvci4KCVRoaXMgd2lsbCBtYWtlIHNvbWUgY29udGV4dCB2aXNpYmxlIGFyb3VuZCB3aGVyZSB5b3UgYXJlIHdvcmtpbmcuICBJZgoJeW91IHNldCBpdCB0byBhIHZlcnkgbGFyZ2UgdmFsdWUgKDk5OSkgdGhlIGN1cnNvciBsaW5lIHdpbGwgYWx3YXlzIGJlCglpbiB0aGUgbWlkZGxlIG9mIHRoZSB3aW5kb3cgKGV4Y2VwdCBhdCB0aGUgc3RhcnQgb3IgZW5kIG9mIHRoZSBmaWxlIG9yCgl3aGVuIGxvbmcgbGluZXMgd3JhcCkuCglGb3Igc2Nyb2xsaW5nIGhvcml6b250YWxseSBzZWUgJ3NpZGVzY3JvbGxvZmYnLgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIDAgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJKidzY3JvbGxvcHQnKiAqJ3NibycqCidzY3JvbGxvcHQnICdzYm8nCXN0cmluZwkoZGVmYXVsdCAidmVyLGp1bXAiKQoJCQlnbG9iYWwKCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3Njcm9sbGJpbmR8CgkJCWZlYXR1cmV9CgkJCXtub3QgaW4gVml9CglUaGlzIGlzIGEgY29tbWEtc2VwYXJhdGVkIGxpc3Qgb2Ygd29yZHMgdGhhdCBzcGVjaWZpZXMgaG93Cgknc2Nyb2xsYmluZCcgd2luZG93cyBzaG91bGQgYmVoYXZlLiAgJ3Nibycgc3RhbmRzIGZvciBTY3JvbGxCaW5kCglPcHRpb25zLgoJVGhlIGZvbGxvd2luZyB3b3JkcyBhcmUgYXZhaWxhYmxlOgoJICAgIHZlcgkJQmluZCB2ZXJ0aWNhbCBzY3JvbGxpbmcgZm9yICdzY3JvbGxiaW5kJyB3aW5kb3dzCgkgICAgaG9yCQlCaW5kIGhvcml6b250YWwgc2Nyb2xsaW5nIGZvciAnc2Nyb2xsYmluZCcgd2luZG93cwoJICAgIGp1bXAJQXBwbGllcyB0byB0aGUgb2Zmc2V0IGJldHdlZW4gdHdvIHdpbmRvd3MgZm9yIHZlcnRpY2FsCgkJCXNjcm9sbGluZy4gIFRoaXMgb2Zmc2V0IGlzIHRoZSBkaWZmZXJlbmNlIGluIHRoZSBmaXJzdAoJCQlkaXNwbGF5ZWQgbGluZSBvZiB0aGUgYm91bmQgd2luZG93cy4gIFdoZW4gbW92aW5nCgkJCWFyb3VuZCBpbiBhIHdpbmRvdywgYW5vdGhlciAnc2Nyb2xsYmluZCcgd2luZG93IG1heQoJCQlyZWFjaCBhIHBvc2l0aW9uIGJlZm9yZSB0aGUgc3RhcnQgb3IgYWZ0ZXIgdGhlIGVuZCBvZgoJCQl0aGUgYnVmZmVyLiAgVGhlIG9mZnNldCBpcyBub3QgY2hhbmdlZCB0aG91Z2gsIHdoZW4KCQkJbW92aW5nIGJhY2sgdGhlICdzY3JvbGxiaW5kJyB3aW5kb3cgd2lsbCB0cnkgdG8gc2Nyb2xsCgkJCXRvIHRoZSBkZXNpcmVkIHBvc2l0aW9uIHdoZW4gcG9zc2libGUuCgkJCVdoZW4gbm93IG1ha2luZyB0aGF0IHdpbmRvdyB0aGUgY3VycmVudCBvbmUsIHR3bwoJCQl0aGluZ3MgY2FuIGJlIGRvbmUgd2l0aCB0aGUgcmVsYXRpdmUgb2Zmc2V0OgoJCQkxLiBXaGVuICJqdW1wIiBpcyBub3QgaW5jbHVkZWQsIHRoZSByZWxhdGl2ZSBvZmZzZXQgaXMKCQkJICAgYWRqdXN0ZWQgZm9yIHRoZSBzY3JvbGwgcG9zaXRpb24gaW4gdGhlIG5ldyBjdXJyZW50CgkJCSAgIHdpbmRvdy4gIFdoZW4gZ29pbmcgYmFjayB0byB0aGUgb3RoZXIgd2luZG93LCB0aGUKCQkJICAgdGhlIG5ldyByZWxhdGl2ZSBvZmZzZXQgd2lsbCBiZSB1c2VkLgoJCQkyLiBXaGVuICJqdW1wIiBpcyBpbmNsdWRlZCwgdGhlIG90aGVyIHdpbmRvd3MgYXJlCgkJCSAgIHNjcm9sbGVkIHRvIGtlZXAgdGhlIHNhbWUgcmVsYXRpdmUgb2Zmc2V0LiAgV2hlbgoJCQkgICBnb2luZyBiYWNrIHRvIHRoZSBvdGhlciB3aW5kb3csIGl0IHN0aWxsIHVzZXMgdGhlCgkJCSAgIHNhbWUgcmVsYXRpdmUgb2Zmc2V0LgoJQWxzbyBzZWUgfHNjcm9sbC1iaW5kaW5nfC4KCgkJCQkJCSonc2VjdGlvbnMnKiAqJ3NlY3QnKgonc2VjdGlvbnMnICdzZWN0JwlzdHJpbmcJKGRlZmF1bHQgIlNITkhIIEhVbmhzaCIpCgkJCWdsb2JhbAoJU3BlY2lmaWVzIHRoZSBucm9mZiBtYWNyb3MgdGhhdCBzZXBhcmF0ZSBzZWN0aW9ucy4gIFRoZXNlIGFyZSBwYWlycyBvZgoJdHdvIGxldHRlcnMgKFNlZSB8b2JqZWN0LW1vdGlvbnN8KS4gIFRoZSBkZWZhdWx0IG1ha2VzIGEgc2VjdGlvbiBzdGFydAoJYXQgdGhlIG5yb2ZmIG1hY3JvcyAiLlNIIiwgIi5OSCIsICIuSCIsICIuSFUiLCAiLm5oIiBhbmQgIi5zaCIuCgoJCQkJCQkqJ3NlY3VyZScqIConbm9zZWN1cmUnKiAqRTUyMyoKJ3NlY3VyZScJCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVdoZW4gb24sICI6YXV0b2NtZCIsIHNoZWxsIGFuZCB3cml0ZSBjb21tYW5kcyBhcmUgbm90IGFsbG93ZWQgaW4KCSIudmltcmMiIGFuZCAiLmV4cmMiIGluIHRoZSBjdXJyZW50IGRpcmVjdG9yeSBhbmQgbWFwIGNvbW1hbmRzIGFyZQoJZGlzcGxheWVkLiAgU3dpdGNoIGl0IG9mZiBvbmx5IGlmIHlvdSBrbm93IHRoYXQgeW91IHdpbGwgbm90IHJ1biBpbnRvCglwcm9ibGVtcywgb3Igd2hlbiB0aGUgJ2V4cmMnIG9wdGlvbiBpcyBvZmYuICBPbiBVbml4IHRoaXMgb3B0aW9uIGlzCglvbmx5IHVzZWQgaWYgdGhlICIudmltcmMiIG9yICIuZXhyYyIgaXMgbm90IG93bmVkIGJ5IHlvdS4gIFRoaXMgY2FuIGJlCglkYW5nZXJvdXMgaWYgdGhlIHN5c3RlbXMgYWxsb3dzIHVzZXJzIHRvIGRvIGEgImNob3duIi4gIFlvdSBiZXR0ZXIgc2V0Cgknc2VjdXJlJyBhdCB0aGUgZW5kIG9mIHlvdXIgfi8udmltcmMgdGhlbi4KCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJCQkJKidzZWxlY3Rpb24nKiAqJ3NlbCcqCidzZWxlY3Rpb24nICdzZWwnCXN0cmluZwkoZGVmYXVsdCAiaW5jbHVzaXZlIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglUaGlzIG9wdGlvbiBkZWZpbmVzIHRoZSBiZWhhdmlvciBvZiB0aGUgc2VsZWN0aW9uLiAgSXQgaXMgb25seSB1c2VkCglpbiBWaXN1YWwgYW5kIFNlbGVjdCBtb2RlLgoJUG9zc2libGUgdmFsdWVzOgoJICAgdmFsdWUJcGFzdCBsaW5lICAgICBpbmNsdXNpdmUgfgoJICAgb2xkCQkgICBubwkJeWVzCgkgICBpbmNsdXNpdmUJICAgeWVzCQl5ZXMKCSAgIGV4Y2x1c2l2ZQkgICB5ZXMJCW5vCgkicGFzdCBsaW5lIiBtZWFucyB0aGF0IHRoZSBjdXJzb3IgaXMgYWxsb3dlZCB0byBiZSBwb3NpdGlvbmVkIG9uZQoJY2hhcmFjdGVyIHBhc3QgdGhlIGxpbmUuCgkiaW5jbHVzaXZlIiBtZWFucyB0aGF0IHRoZSBsYXN0IGNoYXJhY3RlciBvZiB0aGUgc2VsZWN0aW9uIGlzIGluY2x1ZGVkCglpbiBhbiBvcGVyYXRpb24uICBGb3IgZXhhbXBsZSwgd2hlbiAieCIgaXMgdXNlZCB0byBkZWxldGUgdGhlCglzZWxlY3Rpb24uCglOb3RlIHRoYXQgd2hlbiAiZXhjbHVzaXZlIiBpcyB1c2VkIGFuZCBzZWxlY3RpbmcgZnJvbSB0aGUgZW5kCgliYWNrd2FyZHMsIHlvdSBjYW5ub3QgaW5jbHVkZSB0aGUgbGFzdCBjaGFyYWN0ZXIgb2YgYSBsaW5lLCB3aGVuCglzdGFydGluZyBpbiBOb3JtYWwgbW9kZSBhbmQgJ3ZpcnR1YWxlZGl0JyBlbXB0eS4KCglUaGUgJ3NlbGVjdGlvbicgb3B0aW9uIGlzIHNldCBieSB0aGUgfDpiZWhhdmV8IGNvbW1hbmQuCgoJCQkJCQkqJ3NlbGVjdG1vZGUnKiAqJ3NsbScqCidzZWxlY3Rtb2RlJyAnc2xtJwlzdHJpbmcJKGRlZmF1bHQgIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJVGhpcyBpcyBhIGNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIHdvcmRzLCB3aGljaCBzcGVjaWZpZXMgd2hlbiB0byBzdGFydAoJU2VsZWN0IG1vZGUgaW5zdGVhZCBvZiBWaXN1YWwgbW9kZSwgd2hlbiBhIHNlbGVjdGlvbiBpcyBzdGFydGVkLgoJUG9zc2libGUgdmFsdWVzOgoJICAgbW91c2UJd2hlbiB1c2luZyB0aGUgbW91c2UKCSAgIGtleQkJd2hlbiB1c2luZyBzaGlmdGVkIHNwZWNpYWwga2V5cwoJICAgY21kCQl3aGVuIHVzaW5nICJ2IiwgIlYiIG9yIENUUkwtVgoJU2VlIHxTZWxlY3QtbW9kZXwuCglUaGUgJ3NlbGVjdG1vZGUnIG9wdGlvbiBpcyBzZXQgYnkgdGhlIHw6YmVoYXZlfCBjb21tYW5kLgoKCQkJCQkJKidzZXNzaW9ub3B0aW9ucycqIConc3NvcCcqCidzZXNzaW9ub3B0aW9ucycgJ3Nzb3AnCXN0cmluZwkoZGVmYXVsdDogImJsYW5rLGJ1ZmZlcnMsY3VyZGlyLGZvbGRzLAoJCQkJCQkJaGVscCxvcHRpb25zLHdpbnNpemUiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSArbWtzZXNzaW9uCgkJCWZlYXR1cmV9CglDaGFuZ2VzIHRoZSBlZmZlY3Qgb2YgdGhlIHw6bWtzZXNzaW9ufCBjb21tYW5kLiAgSXQgaXMgYSBjb21tYQoJc2VwYXJhdGVkIGxpc3Qgb2Ygd29yZHMuICBFYWNoIHdvcmQgZW5hYmxlcyBzYXZpbmcgYW5kIHJlc3RvcmluZwoJc29tZXRoaW5nOgoJICAgd29yZAkJc2F2ZSBhbmQgcmVzdG9yZSB+CgkgICBibGFuawllbXB0eSB3aW5kb3dzCgkgICBidWZmZXJzCWhpZGRlbiBhbmQgdW5sb2FkZWQgYnVmZmVycywgbm90IGp1c3QgdGhvc2UgaW4gd2luZG93cwoJICAgY3VyZGlyCXRoZSBjdXJyZW50IGRpcmVjdG9yeQoJICAgZm9sZHMJbWFudWFsbHkgY3JlYXRlZCBmb2xkcywgb3BlbmVkL2Nsb3NlZCBmb2xkcyBhbmQgbG9jYWwKCQkJZm9sZCBvcHRpb25zCgkgICBnbG9iYWxzCWdsb2JhbCB2YXJpYWJsZXMgdGhhdCBzdGFydCB3aXRoIGFuIHVwcGVyY2FzZSBsZXR0ZXIKCQkJYW5kIGNvbnRhaW4gYXQgbGVhc3Qgb25lIGxvd2VyY2FzZSBsZXR0ZXIuICBPbmx5CgkJCVN0cmluZyBhbmQgTnVtYmVyIHR5cGVzIGFyZSBzdG9yZWQuCgkgICBoZWxwCQl0aGUgaGVscCB3aW5kb3cKCSAgIGxvY2Fsb3B0aW9ucwlvcHRpb25zIGFuZCBtYXBwaW5ncyBsb2NhbCB0byBhIHdpbmRvdyBvciBidWZmZXIgKG5vdAoJCQlnbG9iYWwgdmFsdWVzIGZvciBsb2NhbCBvcHRpb25zKQoJICAgb3B0aW9ucwlhbGwgb3B0aW9ucyBhbmQgbWFwcGluZ3MgKGFsc28gZ2xvYmFsIHZhbHVlcyBmb3IgbG9jYWwKCQkJb3B0aW9ucykKCSAgIHJlc2l6ZQlzaXplIG9mIHRoZSBWaW0gd2luZG93OiAnbGluZXMnIGFuZCAnY29sdW1ucycKCSAgIHNlc2Rpcgl0aGUgZGlyZWN0b3J5IGluIHdoaWNoIHRoZSBzZXNzaW9uIGZpbGUgaXMgbG9jYXRlZAoJCQl3aWxsIGJlY29tZSB0aGUgY3VycmVudCBkaXJlY3RvcnkgKHVzZWZ1bCB3aXRoCgkJCXByb2plY3RzIGFjY2Vzc2VkIG92ZXIgYSBuZXR3b3JrIGZyb20gZGlmZmVyZW50CgkJCXN5c3RlbXMpCgkgICBzbGFzaAliYWNrc2xhc2hlcyBpbiBmaWxlIG5hbWVzIHJlcGxhY2VkIHdpdGggZm9yd2FyZAoJCQlzbGFzaGVzCgkgICB1bml4CQl3aXRoIFVuaXggZW5kLW9mLWxpbmUgZm9ybWF0IChzaW5nbGUgPE5MPiksIGV2ZW4gd2hlbgoJCQlvbiBXaW5kb3dzIG9yIERPUwoJICAgd2lucG9zCXBvc2l0aW9uIG9mIHRoZSB3aG9sZSBWaW0gd2luZG93CgkgICB3aW5zaXplCXdpbmRvdyBzaXplcwoKCURvbid0IGluY2x1ZGUgYm90aCAiY3VyZGlyIiBhbmQgInNlc2RpciIuCglXaGVuICJjdXJkaXIiIG5vciAic2VzZGlyIiBpcyBpbmNsdWRlZCwgZmlsZSBuYW1lcyBhcmUgc3RvcmVkIHdpdGgKCWFic29sdXRlIHBhdGhzLgoJInNsYXNoIiBhbmQgInVuaXgiIGFyZSB1c2VmdWwgb24gV2luZG93cyB3aGVuIHNoYXJpbmcgc2Vzc2lvbiBmaWxlcwoJd2l0aCBVbml4LiAgVGhlIFVuaXggdmVyc2lvbiBvZiBWaW0gY2Fubm90IHNvdXJjZSBkb3MgZm9ybWF0IHNjcmlwdHMsCglidXQgdGhlIFdpbmRvd3MgdmVyc2lvbiBvZiBWaW0gY2FuIHNvdXJjZSB1bml4IGZvcm1hdCBzY3JpcHRzLgoKCQkJCQkJKidzaGVsbCcqIConc2gnKiAqRTkxKgonc2hlbGwnICdzaCcJCXN0cmluZwkoZGVmYXVsdCAkU0hFTEwgb3IgInNoIiwKCQkJCQlNUy1ET1MgYW5kIFdpbjMyOiAiY29tbWFuZC5jb20iIG9yCgkJCQkJImNtZC5leGUiLCBPUy8yOiAiY21kIikKCQkJZ2xvYmFsCglOYW1lIG9mIHRoZSBzaGVsbCB0byB1c2UgZm9yICEgYW5kIDohIGNvbW1hbmRzLiAgV2hlbiBjaGFuZ2luZyB0aGUKCXZhbHVlIGFsc28gY2hlY2sgdGhlc2Ugb3B0aW9uczogJ3NoZWxsdHlwZScsICdzaGVsbHBpcGUnLCAnc2hlbGxzbGFzaCcKCSdzaGVsbHJlZGlyJywgJ3NoZWxscXVvdGUnLCAnc2hlbGx4cXVvdGUnIGFuZCAnc2hlbGxjbWRmbGFnJy4KCUl0IGlzIGFsbG93ZWQgdG8gZ2l2ZSBhbiBhcmd1bWVudCB0byB0aGUgY29tbWFuZCwgZS5nLiAgImNzaCAtZiIuCglTZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0IGluY2x1ZGluZyBzcGFjZXMgYW5kIGJhY2tzbGFzaGVzLgoJRW52aXJvbm1lbnQgdmFyaWFibGVzIGFyZSBleHBhbmRlZCB8OnNldF9lbnZ8LgoJSWYgdGhlIG5hbWUgb2YgdGhlIHNoZWxsIGNvbnRhaW5zIGEgc3BhY2UsIHlvdSBtaWdodCBuZWVkIHRvIGVuY2xvc2UKCWl0IGluIHF1b3Rlcy4gIEV4YW1wbGU6ID4KCQk6c2V0IHNoZWxsPVwiYzpccHJvZ3JhbVwgZmlsZXNcdW5peFxzaC5leGVcIlwgLWYKPAlOb3RlIHRoZSBiYWNrc2xhc2ggYmVmb3JlIGVhY2ggcXVvdGUgKHRvIGF2b2lkIHN0YXJ0aW5nIGEgY29tbWVudCkgYW5kCgllYWNoIHNwYWNlICh0byBhdm9pZCBlbmRpbmcgdGhlIG9wdGlvbiB2YWx1ZSkuICBBbHNvIG5vdGUgdGhhdCB0aGUKCSItZiIgaXMgbm90IGluc2lkZSB0aGUgcXVvdGVzLCBiZWNhdXNlIGl0IGlzIG5vdCBwYXJ0IG9mIHRoZSBjb21tYW5kCgluYW1lLiAgQW5kIFZpbSBhdXRvbWFnaWNhbGx5IHJlY29nbml6ZXMgdGhlIGJhY2tzbGFzaGVzIHRoYXQgYXJlIHBhdGgKCXNlcGFyYXRvcnMuCglGb3IgRG9zIDMyIGJpdHMgKERKR1BQKSwgeW91IGNhbiBzZXQgdGhlICRESlNZU0ZMQUdTIGVudmlyb25tZW50Cgl2YXJpYWJsZSB0byBjaGFuZ2UgdGhlIHdheSBleHRlcm5hbCBjb21tYW5kcyBhcmUgZXhlY3V0ZWQuICBTZWUgdGhlCglsaWJjLmluZiBmaWxlIG9mIERKR1BQLgoJVW5kZXIgTVMtV2luZG93cywgd2hlbiB0aGUgZXhlY3V0YWJsZSBlbmRzIGluICIuY29tIiBpdCBtdXN0IGJlCglpbmNsdWRlZC4gIFRodXMgc2V0dGluZyB0aGUgc2hlbGwgdG8gImNvbW1hbmQuY29tIiBvciAiNGRvcy5jb20iCgl3b3JrcywgYnV0ICJjb21tYW5kIiBhbmQgIjRkb3MiIGRvIG5vdCB3b3JrIGZvciBhbGwgY29tbWFuZHMgKGUuZy4sCglmaWx0ZXJpbmcpLgoJRm9yIHVua25vd24gcmVhc29ucywgd2hlbiB1c2luZyAiNGRvcy5jb20iIHRoZSBjdXJyZW50IGRpcmVjdG9yeSBpcwoJY2hhbmdlZCB0byAiQzpcIi4gIFRvIGF2b2lkIHRoaXMgc2V0ICdzaGVsbCcgbGlrZSB0aGlzOiA+CgkJOnNldCBzaGVsbD1jb21tYW5kLmNvbVwgL2NcIDRkb3MKPAlUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCgkJCQkJCSonc2hlbGxjbWRmbGFnJyogKidzaGNmJyoKJ3NoZWxsY21kZmxhZycgJ3NoY2YnCXN0cmluZwkoZGVmYXVsdDogIi1jIiwgTVMtRE9TIGFuZCBXaW4zMiwgd2hlbiAnc2hlbGwnCgkJCQkJZG9lcyBub3QgY29udGFpbiAic2giIHNvbWV3aGVyZTogIi9jIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglGbGFnIHBhc3NlZCB0byB0aGUgc2hlbGwgdG8gZXhlY3V0ZSAiISIgYW5kICI6ISIgY29tbWFuZHM7IGUuZy4sCgkiYmFzaC5leGUgLWMgbHMiIG9yICJjb21tYW5kLmNvbSAvYyBkaXIiLiAgRm9yIHRoZSBNUy1ET1MtbGlrZQoJc3lzdGVtcywgdGhlIGRlZmF1bHQgaXMgc2V0IGFjY29yZGluZyB0byB0aGUgdmFsdWUgb2YgJ3NoZWxsJywgdG8KCXJlZHVjZSB0aGUgbmVlZCB0byBzZXQgdGhpcyBvcHRpb24gYnkgdGhlIHVzZXIuICBJdCdzIG5vdCB1c2VkIGZvcgoJT1MvMiAoRU1YIGZpZ3VyZXMgdGhpcyBvdXQgaXRzZWxmKS4gIFNlZSB8b3B0aW9uLWJhY2tzbGFzaHwgYWJvdXQKCWluY2x1ZGluZyBzcGFjZXMgYW5kIGJhY2tzbGFzaGVzLiAgU2VlIHxkb3Mtc2hlbGx8LgoJVGhpcyBvcHRpb24gY2Fubm90IGJlIHNldCBmcm9tIGEgfG1vZGVsaW5lfCBvciBpbiB0aGUgfHNhbmRib3h8LCBmb3IKCXNlY3VyaXR5IHJlYXNvbnMuCgoJCQkJCQkqJ3NoZWxscGlwZScqIConc3AnKgonc2hlbGxwaXBlJyAnc3AnCXN0cmluZwkoZGVmYXVsdCAiPiIsICJ8IHRlZSIsICJ8JiB0ZWUiIG9yICIyPiYxfCB0ZWUiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3F1aWNrZml4fAoJCQlmZWF0dXJlfQoJU3RyaW5nIHRvIGJlIHVzZWQgdG8gcHV0IHRoZSBvdXRwdXQgb2YgdGhlICI6bWFrZSIgY29tbWFuZCBpbiB0aGUKCWVycm9yIGZpbGUuICBTZWUgYWxzbyB8Om1ha2VfbWFrZXByZ3wuICBTZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0CglpbmNsdWRpbmcgc3BhY2VzIGFuZCBiYWNrc2xhc2hlcy4KCVRoZSBuYW1lIG9mIHRoZSB0ZW1wb3JhcnkgZmlsZSBjYW4gYmUgcmVwcmVzZW50ZWQgYnkgIiVzIiBpZiBuZWNlc3NhcnkKCSh0aGUgZmlsZSBuYW1lIGlzIGFwcGVuZGVkIGF1dG9tYXRpY2FsbHkgaWYgbm8gJXMgYXBwZWFycyBpbiB0aGUgdmFsdWUKCW9mIHRoaXMgb3B0aW9uKS4KCUZvciB0aGUgQW1pZ2EgYW5kIE1TLURPUyB0aGUgZGVmYXVsdCBpcyAiPiIuICBUaGUgb3V0cHV0IGlzIGRpcmVjdGx5CglzYXZlZCBpbiBhIGZpbGUgYW5kIG5vdCBlY2hvZWQgdG8gdGhlIHNjcmVlbi4KCUZvciBVbml4IHRoZSBkZWZhdWx0IGl0ICJ8IHRlZSIuICBUaGUgc3Rkb3V0IG9mIHRoZSBjb21waWxlciBpcyBzYXZlZAoJaW4gYSBmaWxlIGFuZCBlY2hvZWQgdG8gdGhlIHNjcmVlbi4gIElmIHRoZSAnc2hlbGwnIG9wdGlvbiBpcyAiY3NoIiBvcgoJInRjc2giIGFmdGVyIGluaXRpYWxpemF0aW9ucywgdGhlIGRlZmF1bHQgYmVjb21lcyAifCYgdGVlIi4gIElmIHRoZQoJJ3NoZWxsJyBvcHRpb24gaXMgInNoIiwgImtzaCIsICJ6c2giIG9yICJiYXNoIiB0aGUgZGVmYXVsdCBiZWNvbWVzCgkiMj4mMXwgdGVlIi4gIFRoaXMgbWVhbnMgdGhhdCBzdGRlcnIgaXMgYWxzbyBpbmNsdWRlZC4KCVRoZSBpbml0aWFsaXphdGlvbiBvZiB0aGlzIG9wdGlvbiBpcyBkb25lIGFmdGVyIHJlYWRpbmcgdGhlICIudmltcmMiCglhbmQgdGhlIG90aGVyIGluaXRpYWxpemF0aW9ucywgc28gdGhhdCB3aGVuIHRoZSAnc2hlbGwnIG9wdGlvbiBpcyBzZXQKCXRoZXJlLCB0aGUgJ3NoZWxscGlwZScgb3B0aW9uIGNoYW5nZXMgYXV0b21hdGljYWxseSwgdW5sZXNzIGl0IHdhcwoJZXhwbGljaXRseSBzZXQgYmVmb3JlLgoJV2hlbiAnc2hlbGxwaXBlJyBpcyBzZXQgdG8gYW4gZW1wdHkgc3RyaW5nLCBubyByZWRpcmVjdGlvbiBvZiB0aGUKCSI6bWFrZSIgb3V0cHV0IHdpbGwgYmUgZG9uZS4gIFRoaXMgaXMgdXNlZnVsIGlmIHlvdSB1c2UgYSAnbWFrZXByZycKCXRoYXQgd3JpdGVzIHRvICdtYWtlZWYnIGJ5IGl0c2VsZi4gIElmIHlvdSB3YW50IG5vIHBpcGluZywgYnV0IGRvCgl3YW50IHRvIGluY2x1ZGUgdGhlICdtYWtlZWYnLCBzZXQgJ3NoZWxscGlwZScgdG8gYSBzaW5nbGUgc3BhY2UuCglEb24ndCBmb3JnZXQgdG8gcHJlY2VkZSB0aGUgc3BhY2Ugd2l0aCBhIGJhY2tzbGFzaDogIjpzZXQgc3A9XCAiLgoJSW4gdGhlIGZ1dHVyZSBwaXBlcyBtYXkgYmUgdXNlZCBmb3IgZmlsdGVyaW5nIGFuZCB0aGlzIG9wdGlvbiB3aWxsCgliZWNvbWUgb2Jzb2xldGUgKGF0IGxlYXN0IGZvciBVbml4KS4KCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJCQkJKidzaGVsbHF1b3RlJyogKidzaHEnKgonc2hlbGxxdW90ZScgJ3NocScJc3RyaW5nCShkZWZhdWx0OiAiIjsgTVMtRE9TIGFuZCBXaW4zMiwgd2hlbiAnc2hlbGwnCgkJCQkJY29udGFpbnMgInNoIiBzb21ld2hlcmU6ICJcIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJUXVvdGluZyBjaGFyYWN0ZXIocyksIHB1dCBhcm91bmQgdGhlIGNvbW1hbmQgcGFzc2VkIHRvIHRoZSBzaGVsbCwgZm9yCgl0aGUgIiEiIGFuZCAiOiEiIGNvbW1hbmRzLiAgVGhlIHJlZGlyZWN0aW9uIGlzIGtlcHQgb3V0c2lkZSBvZiB0aGUKCXF1b3RpbmcuICBTZWUgJ3NoZWxseHF1b3RlJyB0byBpbmNsdWRlIHRoZSByZWRpcmVjdGlvbi4gIEl0J3MKCXByb2JhYmx5IG5vdCB1c2VmdWwgdG8gc2V0IGJvdGggb3B0aW9ucy4KCVRoaXMgaXMgYW4gZW1wdHkgc3RyaW5nIGJ5IGRlZmF1bHQuICBPbmx5IGtub3duIHRvIGJlIHVzZWZ1bCBmb3IKCXRoaXJkLXBhcnR5IHNoZWxscyBvbiBNUy1ET1MtbGlrZSBzeXN0ZW1zLCBzdWNoIGFzIHRoZSBNS1MgS29ybiBTaGVsbAoJb3IgYmFzaCwgd2hlcmUgaXQgc2hvdWxkIGJlICJcIiIuICBUaGUgZGVmYXVsdCBpcyBhZGp1c3RlZCBhY2NvcmRpbmcKCXRoZSB2YWx1ZSBvZiAnc2hlbGwnLCB0byByZWR1Y2UgdGhlIG5lZWQgdG8gc2V0IHRoaXMgb3B0aW9uIGJ5IHRoZQoJdXNlci4gIFNlZSB8ZG9zLXNoZWxsfC4KCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJCQkJKidzaGVsbHJlZGlyJyogKidzcnInKgonc2hlbGxyZWRpcicgJ3NycicJc3RyaW5nCShkZWZhdWx0ICI+IiwgIj4mIiBvciAiPiVzIDI+JjEiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVN0cmluZyB0byBiZSB1c2VkIHRvIHB1dCB0aGUgb3V0cHV0IG9mIGEgZmlsdGVyIGNvbW1hbmQgaW4gYSB0ZW1wb3JhcnkKCWZpbGUuICBTZWUgYWxzbyB8OiF8LiAgU2VlIHxvcHRpb24tYmFja3NsYXNofCBhYm91dCBpbmNsdWRpbmcgc3BhY2VzCglhbmQgYmFja3NsYXNoZXMuCglUaGUgbmFtZSBvZiB0aGUgdGVtcG9yYXJ5IGZpbGUgY2FuIGJlIHJlcHJlc2VudGVkIGJ5ICIlcyIgaWYgbmVjZXNzYXJ5CgkodGhlIGZpbGUgbmFtZSBpcyBhcHBlbmRlZCBhdXRvbWF0aWNhbGx5IGlmIG5vICVzIGFwcGVhcnMgaW4gdGhlIHZhbHVlCglvZiB0aGlzIG9wdGlvbikuCglUaGUgZGVmYXVsdCBpcyAiPiIuICBGb3IgVW5peCwgaWYgdGhlICdzaGVsbCcgb3B0aW9uIGlzICJjc2giLCAidGNzaCIKCW9yICJ6c2giIGR1cmluZyBpbml0aWFsaXphdGlvbnMsIHRoZSBkZWZhdWx0IGJlY29tZXMgIj4mIi4gIElmIHRoZQoJJ3NoZWxsJyBvcHRpb24gaXMgInNoIiwgImtzaCIgb3IgImJhc2giIHRoZSBkZWZhdWx0IGJlY29tZXMKCSI+JXMgMj4mMSIuICBUaGlzIG1lYW5zIHRoYXQgc3RkZXJyIGlzIGFsc28gaW5jbHVkZWQuCglGb3IgV2luMzIsIHRoZSBVbml4IGNoZWNrcyBhcmUgZG9uZSBhbmQgYWRkaXRpb25hbGx5ICJjbWQiIGlzIGNoZWNrZWQKCWZvciwgd2hpY2ggbWFrZXMgdGhlIGRlZmF1bHQgIj4lcyAyPiYxIi4gIEFsc28sIHRoZSBzYW1lIG5hbWVzIHdpdGgKCSIuZXhlIiBhcHBlbmRlZCBhcmUgY2hlY2tlZCBmb3IuCglUaGUgaW5pdGlhbGl6YXRpb24gb2YgdGhpcyBvcHRpb24gaXMgZG9uZSBhZnRlciByZWFkaW5nIHRoZSAiLnZpbXJjIgoJYW5kIHRoZSBvdGhlciBpbml0aWFsaXphdGlvbnMsIHNvIHRoYXQgd2hlbiB0aGUgJ3NoZWxsJyBvcHRpb24gaXMgc2V0Cgl0aGVyZSwgdGhlICdzaGVsbHJlZGlyJyBvcHRpb24gY2hhbmdlcyBhdXRvbWF0aWNhbGx5IHVubGVzcyBpdCB3YXMKCWV4cGxpY2l0bHkgc2V0IGJlZm9yZS4KCUluIHRoZSBmdXR1cmUgcGlwZXMgbWF5IGJlIHVzZWQgZm9yIGZpbHRlcmluZyBhbmQgdGhpcyBvcHRpb24gd2lsbAoJYmVjb21lIG9ic29sZXRlIChhdCBsZWFzdCBmb3IgVW5peCkuCglUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCgkJCSonc2hlbGxzbGFzaCcqIConc3NsJyogKidub3NoZWxsc2xhc2gnKiAqJ25vc3NsJyoKJ3NoZWxsc2xhc2gnICdzc2wnCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0ge29ubHkgZm9yIE1TRE9TLCBNUy1XaW5kb3dzIGFuZCBPUy8yfQoJV2hlbiBzZXQsIGEgZm9yd2FyZCBzbGFzaCBpcyB1c2VkIHdoZW4gZXhwYW5kaW5nIGZpbGUgbmFtZXMuICBUaGlzIGlzCgl1c2VmdWwgd2hlbiBhIFVuaXgtbGlrZSBzaGVsbCBpcyB1c2VkIGluc3RlYWQgb2YgY29tbWFuZC5jb20gb3IKCWNtZC5leGUuICBCYWNrd2FyZCBzbGFzaGVzIGNhbiBzdGlsbCBiZSB0eXBlZCwgYnV0IHRoZXkgYXJlIGNoYW5nZWQgdG8KCWZvcndhcmQgc2xhc2hlcyBieSBWaW0uCglOb3RlIHRoYXQgc2V0dGluZyBvciByZXNldHRpbmcgdGhpcyBvcHRpb24gaGFzIG5vIGVmZmVjdCBmb3Igc29tZQoJZXhpc3RpbmcgZmlsZSBuYW1lcywgdGh1cyB0aGlzIG9wdGlvbiBuZWVkcyB0byBiZSBzZXQgYmVmb3JlIG9wZW5pbmcKCWFueSBmaWxlIGZvciBiZXN0IHJlc3VsdHMuICBUaGlzIG1pZ2h0IGNoYW5nZSBpbiB0aGUgZnV0dXJlLgoJJ3NoZWxsc2xhc2gnIG9ubHkgd29ya3Mgd2hlbiBhIGJhY2tzbGFzaCBjYW4gYmUgdXNlZCBhcyBhIHBhdGgKCXNlcGFyYXRvci4gIFRvIHRlc3QgaWYgdGhpcyBpcyBzbyB1c2U6ID4KCQlpZiBleGlzdHMoJytzaGVsbHNsYXNoJykKPAoJCQkqJ3NoZWxsdGVtcCcqIConc3RtcCcqIConbm9zaGVsbHRlbXAnKiAqJ25vc3RtcCcqCidzaGVsbHRlbXAnICdzdG1wJwlib29sZWFuCShWaSBkZWZhdWx0IG9mZiwgVmltIGRlZmF1bHQgb24pCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiBvbiwgdXNlIHRlbXAgZmlsZXMgZm9yIHNoZWxsIGNvbW1hbmRzLiAgV2hlbiBvZmYgdXNlIGEgcGlwZS4KCVdoZW4gdXNpbmcgYSBwaXBlIGlzIG5vdCBwb3NzaWJsZSB0ZW1wIGZpbGVzIGFyZSB1c2VkIGFueXdheS4KCUN1cnJlbnRseSBhIHBpcGUgaXMgb25seSBzdXBwb3J0ZWQgb24gVW5peC4gIFlvdSBjYW4gY2hlY2sgaXQgd2l0aDogPgoJCTppZiBoYXMoImZpbHRlcnBpcGUiKQo8CVRoZSBhZHZhbnRhZ2Ugb2YgdXNpbmcgYSBwaXBlIGlzIHRoYXQgbm9ib2R5IGNhbiByZWFkIHRoZSB0ZW1wIGZpbGUKCWFuZCB0aGUgJ3NoZWxsJyBjb21tYW5kIGRvZXMgbm90IG5lZWQgdG8gc3VwcG9ydCByZWRpcmVjdGlvbi4KCVRoZSBhZHZhbnRhZ2Ugb2YgdXNpbmcgYSB0ZW1wIGZpbGUgaXMgdGhhdCB0aGUgZmlsZSB0eXBlIGFuZCBlbmNvZGluZwoJY2FuIGJlIGRldGVjdGVkLgoJVGhlIHxGaWx0ZXJSZWFkUHJlfCwgfEZpbHRlclJlYWRQb3N0fCBhbmQgfEZpbHRlcldyaXRlUHJlfCwKCXxGaWx0ZXJXcml0ZVBvc3R8IGF1dG9jb21tYW5kcyBldmVudCBhcmUgbm90IHRyaWdnZXJlZCB3aGVuCgknc2hlbGx0ZW1wJyBpcyBvZmYuCgoJCQkJCQkqJ3NoZWxsdHlwZScqIConc3QnKgonc2hlbGx0eXBlJyAnc3QnCW51bWJlcgkoZGVmYXVsdCAwKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0ge29ubHkgZm9yIHRoZSBBbWlnYX0KCU9uIHRoZSBBbWlnYSB0aGlzIG9wdGlvbiBpbmZsdWVuY2VzIHRoZSB3YXkgaG93IHRoZSBjb21tYW5kcyB3b3JrCgl3aGljaCB1c2UgYSBzaGVsbC4KCTAgYW5kIDE6IGFsd2F5cyB1c2UgdGhlIHNoZWxsCgkyIGFuZCAzOiB1c2UgdGhlIHNoZWxsIG9ubHkgdG8gZmlsdGVyIGxpbmVzCgk0IGFuZCA1OiB1c2Ugc2hlbGwgb25seSBmb3IgJzpzaCcgY29tbWFuZAoJV2hlbiBub3QgdXNpbmcgdGhlIHNoZWxsLCB0aGUgY29tbWFuZCBpcyBleGVjdXRlZCBkaXJlY3RseS4KCgkwIGFuZCAyOiB1c2UgInNoZWxsICdzaGVsbGNtZGZsYWcnIGNtZCIgdG8gc3RhcnQgZXh0ZXJuYWwgY29tbWFuZHMKCTEgYW5kIDM6IHVzZSAic2hlbGwgY21kIiB0byBzdGFydCBleHRlcm5hbCBjb21tYW5kcwoKCQkJCQkJKidzaGVsbHhxdW90ZScqIConc3hxJyoKJ3NoZWxseHF1b3RlJyAnc3hxJwlzdHJpbmcJKGRlZmF1bHQ6ICIiOwoJCQkJCWZvciBXaW4zMiwgd2hlbiAnc2hlbGwnIGNvbnRhaW5zICJzaCIKCQkJCQlzb21ld2hlcmU6ICJcIiIKCQkJCQlmb3IgVW5peCwgd2hlbiB1c2luZyBzeXN0ZW0oKTogIlwiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglRdW90aW5nIGNoYXJhY3RlcihzKSwgcHV0IGFyb3VuZCB0aGUgY29tbWFuZCBwYXNzZWQgdG8gdGhlIHNoZWxsLCBmb3IKCXRoZSAiISIgYW5kICI6ISIgY29tbWFuZHMuICBJbmNsdWRlcyB0aGUgcmVkaXJlY3Rpb24uICBTZWUKCSdzaGVsbHF1b3RlJyB0byBleGNsdWRlIHRoZSByZWRpcmVjdGlvbi4gIEl0J3MgcHJvYmFibHkgbm90IHVzZWZ1bAoJdG8gc2V0IGJvdGggb3B0aW9ucy4KCVRoaXMgaXMgYW4gZW1wdHkgc3RyaW5nIGJ5IGRlZmF1bHQuICBLbm93biB0byBiZSB1c2VmdWwgZm9yCgl0aGlyZC1wYXJ0eSBzaGVsbHMgd2hlbiB1c2luZyB0aGUgV2luMzIgdmVyc2lvbiwgc3VjaCBhcyB0aGUgTUtTIEtvcm4KCVNoZWxsIG9yIGJhc2gsIHdoZXJlIGl0IHNob3VsZCBiZSAiXCIiLiAgVGhlIGRlZmF1bHQgaXMgYWRqdXN0ZWQKCWFjY29yZGluZyB0aGUgdmFsdWUgb2YgJ3NoZWxsJywgdG8gcmVkdWNlIHRoZSBuZWVkIHRvIHNldCB0aGlzIG9wdGlvbgoJYnkgdGhlIHVzZXIuICBTZWUgfGRvcy1zaGVsbHwuCglUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCgkJCSonc2hpZnRyb3VuZCcqIConc3InKiAqJ25vc2hpZnRyb3VuZCcqIConbm9zcicqCidzaGlmdHJvdW5kJyAnc3InCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVJvdW5kIGluZGVudCB0byBtdWx0aXBsZSBvZiAnc2hpZnR3aWR0aCcuICBBcHBsaWVzIHRvID4gYW5kIDwKCWNvbW1hbmRzLiAgQ1RSTC1UIGFuZCBDVFJMLUQgaW4gSW5zZXJ0IG1vZGUgYWx3YXlzIHJvdW5kIHRoZSBpbmRlbnQgdG8KCWEgbXVsdGlwbGUgb2YgJ3NoaWZ0d2lkdGgnICh0aGlzIGlzIFZpIGNvbXBhdGlibGUpLgoJTk9URTogVGhpcyBvcHRpb24gaXMgcmVzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJKidzaGlmdHdpZHRoJyogKidzdycqCidzaGlmdHdpZHRoJyAnc3cnCW51bWJlcgkoZGVmYXVsdCA4KQoJCQlsb2NhbCB0byBidWZmZXIKCU51bWJlciBvZiBzcGFjZXMgdG8gdXNlIGZvciBlYWNoIHN0ZXAgb2YgKGF1dG8paW5kZW50LiAgVXNlZCBmb3IKCXwnY2luZGVudCd8LCB8Pj58LCB8PDx8LCBldGMuCgoJCQkJCQkqJ3Nob3J0bWVzcycqIConc2htJyoKJ3Nob3J0bWVzcycgJ3NobScJc3RyaW5nCShWaW0gZGVmYXVsdCAiZmlsbnh0VG9PIiwgVmkgZGVmYXVsdDogIiIsCgkJCQkJCQlQT1NJWCBkZWZhdWx0OiAiQSIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJVGhpcyBvcHRpb24gaGVscHMgdG8gYXZvaWQgYWxsIHRoZSB8aGl0LWVudGVyfCBwcm9tcHRzIGNhdXNlZCBieSBmaWxlCgltZXNzYWdlcywgZm9yIGV4YW1wbGUgIHdpdGggQ1RSTC1HLCBhbmQgdG8gYXZvaWQgc29tZSBvdGhlciBtZXNzYWdlcy4KCUl0IGlzIGEgbGlzdCBvZiBmbGFnczoKCSBmbGFnCW1lYW5pbmcgd2hlbiBwcmVzZW50CX4KCSAgZgl1c2UgIigzIG9mIDUpIiBpbnN0ZWFkIG9mICIoZmlsZSAzIG9mIDUpIgoJICBpCXVzZSAiW25vZW9sXSIgaW5zdGVhZCBvZiAiW0luY29tcGxldGUgbGFzdCBsaW5lXSIKCSAgbAl1c2UgIjk5OUwsIDg4OEMiIGluc3RlYWQgb2YgIjk5OSBsaW5lcywgODg4IGNoYXJhY3RlcnMiCgkgIG0JdXNlICJbK10iIGluc3RlYWQgb2YgIltNb2RpZmllZF0iCgkgIG4JdXNlICJbTmV3XSIgaW5zdGVhZCBvZiAiW05ldyBGaWxlXSIKCSAgcgl1c2UgIltST10iIGluc3RlYWQgb2YgIltyZWFkb25seV0iCgkgIHcJdXNlICJbd10iIGluc3RlYWQgb2YgIndyaXR0ZW4iIGZvciBmaWxlIHdyaXRlIG1lc3NhZ2UKCQlhbmQgIlthXSIgaW5zdGVhZCBvZiAiYXBwZW5kZWQiIGZvciAnOncgPj4gZmlsZScgY29tbWFuZAoJICB4CXVzZSAiW2Rvc10iIGluc3RlYWQgb2YgIltkb3MgZm9ybWF0XSIsICJbdW5peF0iIGluc3RlYWQgb2YKCQkiW3VuaXggZm9ybWF0XSIgYW5kICJbbWFjXSIgaW5zdGVhZCBvZiAiW21hYyBmb3JtYXRdIi4KCSAgYQlhbGwgb2YgdGhlIGFib3ZlIGFiYnJldmlhdGlvbnMKCgkgIG8Jb3ZlcndyaXRlIG1lc3NhZ2UgZm9yIHdyaXRpbmcgYSBmaWxlIHdpdGggc3Vic2VxdWVudCBtZXNzYWdlCgkJZm9yIHJlYWRpbmcgYSBmaWxlICh1c2VmdWwgZm9yICI6d24iIG9yIHdoZW4gJ2F1dG93cml0ZScgb24pCgkgIE8JbWVzc2FnZSBmb3IgcmVhZGluZyBhIGZpbGUgb3ZlcndyaXRlcyBhbnkgcHJldmlvdXMgbWVzc2FnZS4KCQlBbHNvIGZvciBxdWlja2ZpeCBtZXNzYWdlIChlLmcuLCAiOmNuIikuCgkgIHMJZG9uJ3QgZ2l2ZSAic2VhcmNoIGhpdCBCT1RUT00sIGNvbnRpbnVpbmcgYXQgVE9QIiBvciAic2VhcmNoCgkJaGl0IFRPUCwgY29udGludWluZyBhdCBCT1RUT00iIG1lc3NhZ2VzCgkgIHQJdHJ1bmNhdGUgZmlsZSBtZXNzYWdlIGF0IHRoZSBzdGFydCBpZiBpdCBpcyB0b28gbG9uZyB0byBmaXQKCQlvbiB0aGUgY29tbWFuZC1saW5lLCAiPCIgd2lsbCBhcHBlYXIgaW4gdGhlIGxlZnQgbW9zdCBjb2x1bW4uCgkJSWdub3JlZCBpbiBFeCBtb2RlLgoJICBUCXRydW5jYXRlIG90aGVyIG1lc3NhZ2VzIGluIHRoZSBtaWRkbGUgaWYgdGhleSBhcmUgdG9vIGxvbmcgdG8KCQlmaXQgb24gdGhlIGNvbW1hbmQgbGluZS4gICIuLi4iIHdpbGwgYXBwZWFyIGluIHRoZSBtaWRkbGUuCgkJSWdub3JlZCBpbiBFeCBtb2RlLgoJICBXCWRvbid0IGdpdmUgIndyaXR0ZW4iIG9yICJbd10iIHdoZW4gd3JpdGluZyBhIGZpbGUKCSAgQQlkb24ndCBnaXZlIHRoZSAiQVRURU5USU9OIiBtZXNzYWdlIHdoZW4gYW4gZXhpc3Rpbmcgc3dhcCBmaWxlCgkJaXMgZm91bmQuCgkgIEkJZG9uJ3QgZ2l2ZSB0aGUgaW50cm8gbWVzc2FnZSB3aGVuIHN0YXJ0aW5nIFZpbSB8OmludHJvfC4KCglUaGlzIGdpdmVzIHlvdSB0aGUgb3Bwb3J0dW5pdHkgdG8gYXZvaWQgdGhhdCBhIGNoYW5nZSBiZXR3ZWVuIGJ1ZmZlcnMKCXJlcXVpcmVzIHlvdSB0byBoaXQgPEVudGVyPiwgYnV0IHN0aWxsIGdpdmVzIGFzIHVzZWZ1bCBhIG1lc3NhZ2UgYXMKCXBvc3NpYmxlIGZvciB0aGUgc3BhY2UgYXZhaWxhYmxlLiAgVG8gZ2V0IHRoZSB3aG9sZSBtZXNzYWdlIHRoYXQgeW91Cgl3b3VsZCBoYXZlIGdvdCB3aXRoICdzaG0nIGVtcHR5LCB1c2UgIjpmaWxlISIKCVVzZWZ1bCB2YWx1ZXM6CgkgICAgc2htPQlObyBhYmJyZXZpYXRpb24gb2YgbWVzc2FnZS4KCSAgICBzaG09YQlBYmJyZXZpYXRpb24sIGJ1dCBubyBsb3NzIG9mIGluZm9ybWF0aW9uLgoJICAgIHNobT1hdAlBYmJyZXZpYXRpb24sIGFuZCB0cnVuY2F0ZSBtZXNzYWdlIHdoZW4gbmVjZXNzYXJ5LgoKCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHNldCB0byB0aGUgVmkgZGVmYXVsdCB2YWx1ZSB3aGVuICdjb21wYXRpYmxlJyBpcwoJc2V0IGFuZCB0byB0aGUgVmltIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMgcmVzZXQuCgoJCQkJIConc2hvcnRuYW1lJyogKidzbicqIConbm9zaG9ydG5hbWUnKiAqJ25vc24nKgonc2hvcnRuYW1lJyAnc24nCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaSwgbm90IGluIE1TLURPUyB2ZXJzaW9uc30KCUZpbGVuYW1lcyBhcmUgYXNzdW1lZCB0byBiZSA4IGNoYXJhY3RlcnMgcGx1cyBvbmUgZXh0ZW5zaW9uIG9mIDMKCWNoYXJhY3RlcnMuICBNdWx0aXBsZSBkb3RzIGluIGZpbGUgbmFtZXMgYXJlIG5vdCBhbGxvd2VkLiAgV2hlbiB0aGlzCglvcHRpb24gaXMgb24sIGRvdHMgaW4gZmlsZSBuYW1lcyBhcmUgcmVwbGFjZWQgd2l0aCB1bmRlcnNjb3JlcyB3aGVuCglhZGRpbmcgYW4gZXh0ZW5zaW9uICgiLn4iIG9yICIuc3dwIikuICBUaGlzIG9wdGlvbiBpcyBub3QgYXZhaWxhYmxlCglmb3IgTVMtRE9TLCBiZWNhdXNlIHRoZW4gaXQgd291bGQgYWx3YXlzIGJlIG9uLiAgVGhpcyBvcHRpb24gaXMgdXNlZnVsCgl3aGVuIGVkaXRpbmcgZmlsZXMgb24gYW4gTVMtRE9TIGNvbXBhdGlibGUgZmlsZXN5c3RlbSwgZS5nLiwgbWVzc3lkb3MKCW9yIGNyb3NzZG9zLiAgV2hlbiBydW5uaW5nIHRoZSBXaW4zMiBHVUkgdmVyc2lvbiB1bmRlciBXaW4zMnMsIHRoaXMKCW9wdGlvbiBpcyBhbHdheXMgb24gYnkgZGVmYXVsdC4KCgkJCQkJCSonc2hvd2JyZWFrJyogKidzYnInKiAqRTU5NSoKJ3Nob3dicmVhaycgJ3NicicJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSAgfCtsaW5lYnJlYWt8CgkJCWZlYXR1cmV9CglTdHJpbmcgdG8gcHV0IGF0IHRoZSBzdGFydCBvZiBsaW5lcyB0aGF0IGhhdmUgYmVlbiB3cmFwcGVkLiAgVXNlZnVsCgl2YWx1ZXMgYXJlICI+ICIgb3IgIisrKyAiLgoJT25seSBwcmludGFibGUgc2luZ2xlLWNlbGwgY2hhcmFjdGVycyBhcmUgYWxsb3dlZCwgZXhjbHVkaW5nIDxUYWI+IGFuZAoJY29tbWEgKGluIGEgZnV0dXJlIHZlcnNpb24gdGhlIGNvbW1hIG1pZ2h0IGJlIHVzZWQgdG8gc2VwYXJhdGUgdGhlCglwYXJ0IHRoYXQgaXMgc2hvd24gYXQgdGhlIGVuZCBhbmQgYXQgdGhlIHN0YXJ0IG9mIGEgbGluZSkuCglUaGUgY2hhcmFjdGVycyBhcmUgaGlnaGxpZ2h0ZWQgYWNjb3JkaW5nIHRvIHRoZSAnQCcgZmxhZyBpbgoJJ2hpZ2hsaWdodCcuCglOb3RlIHRoYXQgdGFicyBhZnRlciB0aGUgc2hvd2JyZWFrIHdpbGwgYmUgZGlzcGxheWVkIGRpZmZlcmVudGx5LgoJSWYgeW91IHdhbnQgdGhlICdzaG93YnJlYWsnIHRvIGFwcGVhciBpbiBiZXR3ZWVuIGxpbmUgbnVtYmVycywgYWRkIHRoZQoJIm4iIGZsYWcgdG8gJ2Nwb3B0aW9ucycuCgoJCQkJICAgICAqJ3Nob3djbWQnKiAqJ3NjJyogKidub3Nob3djbWQnKiAqJ25vc2MnKgonc2hvd2NtZCcgJ3NjJwkJYm9vbGVhbgkoVmltIGRlZmF1bHQ6IG9uLCBvZmYgZm9yIFVuaXgsIFZpIGRlZmF1bHQ6CgkJCQkgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZQoJCQl8K2NtZGxpbmVfaW5mb3wgZmVhdHVyZX0KCVNob3cgKHBhcnRpYWwpIGNvbW1hbmQgaW4gc3RhdHVzIGxpbmUuICBTZXQgdGhpcyBvcHRpb24gb2ZmIGlmIHlvdXIKCXRlcm1pbmFsIGlzIHNsb3cuCglJbiBWaXN1YWwgbW9kZSB0aGUgc2l6ZSBvZiB0aGUgc2VsZWN0ZWQgYXJlYSBpcyBzaG93bjoKCS0gV2hlbiBzZWxlY3RpbmcgY2hhcmFjdGVycyB3aXRoaW4gYSBsaW5lLCB0aGUgbnVtYmVyIG9mIGNoYXJhY3RlcnMuCgktIFdoZW4gc2VsZWN0aW5nIG1vcmUgdGhhbiBvbmUgbGluZSwgdGhlIG51bWJlciBvZiBsaW5lcy4KCS0gV2hlbiBzZWxlY3RpbmcgYSBibG9jaywgdGhlIHNpemUgaW4gc2NyZWVuIGNoYXJhY3RlcnM6IGxpbmVzeGNvbHVtbnMuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyBzZXQgdG8gdGhlIFZpIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMKCXNldCBhbmQgdG8gdGhlIFZpbSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzIHJlc2V0LgoKCQkJKidzaG93ZnVsbHRhZycqIConc2Z0JyogKidub3Nob3dmdWxsdGFnJyogKidub3NmdCcqCidzaG93ZnVsbHRhZycgJ3NmdCcJYm9vbGVhbiAoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiBjb21wbGV0aW5nIGEgd29yZCBpbiBpbnNlcnQgbW9kZSAoc2VlIHxpbnMtY29tcGxldGlvbnwpIGZyb20gdGhlCgl0YWdzIGZpbGUsIHNob3cgYm90aCB0aGUgdGFnIG5hbWUgYW5kIGEgdGlkaWVkLXVwIGZvcm0gb2YgdGhlIHNlYXJjaAoJcGF0dGVybiAoaWYgdGhlcmUgaXMgb25lKSBhcyBwb3NzaWJsZSBtYXRjaGVzLiAgVGh1cywgaWYgeW91IGhhdmUKCW1hdGNoZWQgYSBDIGZ1bmN0aW9uLCB5b3UgY2FuIHNlZSBhIHRlbXBsYXRlIGZvciB3aGF0IGFyZ3VtZW50cyBhcmUKCXJlcXVpcmVkIChjb2Rpbmcgc3R5bGUgcGVybWl0dGluZykuCgoJCQkJIConc2hvd21hdGNoJyogKidzbScqIConbm9zaG93bWF0Y2gnKiAqJ25vc20nKgonc2hvd21hdGNoJyAnc20nCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCVdoZW4gYSBicmFja2V0IGlzIGluc2VydGVkLCBicmllZmx5IGp1bXAgdG8gdGhlIG1hdGNoaW5nIG9uZS4gIFRoZQoJanVtcCBpcyBvbmx5IGRvbmUgaWYgdGhlIG1hdGNoIGNhbiBiZSBzZWVuIG9uIHRoZSBzY3JlZW4uICBUaGUgdGltZSB0bwoJc2hvdyB0aGUgbWF0Y2ggY2FuIGJlIHNldCB3aXRoICdtYXRjaHRpbWUnLgoJQSBCZWVwIGlzIGdpdmVuIGlmIHRoZXJlIGlzIG5vIG1hdGNoIChubyBtYXR0ZXIgaWYgdGhlIG1hdGNoIGNhbiBiZQoJc2VlbiBvciBub3QpLiAgVGhpcyBvcHRpb24gaXMgcmVzZXQgd2hlbiB0aGUgJ3Bhc3RlJyBvcHRpb24gaXMgc2V0LgoJV2hlbiB0aGUgJ20nIGZsYWcgaXMgbm90IGluY2x1ZGVkIGluICdjcG9wdGlvbnMnLCB0eXBpbmcgYSBjaGFyYWN0ZXIKCXdpbGwgaW1tZWRpYXRlbHkgbW92ZSB0aGUgY3Vyc29yIGJhY2sgdG8gd2hlcmUgaXQgYmVsb25ncy4KCVNlZSB0aGUgInNtIiBmaWVsZCBpbiAnZ3VpY3Vyc29yJyBmb3Igc2V0dGluZyB0aGUgY3Vyc29yIHNoYXBlIGFuZAoJYmxpbmtpbmcgd2hlbiBzaG93aW5nIHRoZSBtYXRjaC4KCVRoZSAnbWF0Y2hwYWlycycgb3B0aW9uIGNhbiBiZSB1c2VkIHRvIHNwZWNpZnkgdGhlIGNoYXJhY3RlcnMgdG8gc2hvdwoJbWF0Y2hlcyBmb3IuICAncmlnaHRsZWZ0JyBhbmQgJ3JldmlucycgYXJlIHVzZWQgdG8gbG9vayBmb3Igb3Bwb3NpdGUKCW1hdGNoZXMuCglOb3RlOiBGb3IgdGhlIHVzZSBvZiB0aGUgc2hvcnQgZm9ybSBwYXJlbnRhbCBndWlkYW5jZSBpcyBhZHZpc2VkLgoKCQkJCSAqJ3Nob3dtb2RlJyogKidzbWQnKiAqJ25vc2hvd21vZGUnKiAqJ25vc21kJyoKJ3Nob3dtb2RlJyAnc21kJwlib29sZWFuCShWaW0gZGVmYXVsdDogb24sIFZpIGRlZmF1bHQ6IG9mZikKCQkJZ2xvYmFsCglJZiBpbiBJbnNlcnQsIFJlcGxhY2Ugb3IgVmlzdWFsIG1vZGUgcHV0IGEgbWVzc2FnZSBvbiB0aGUgbGFzdCBsaW5lLgoJVXNlIHRoZSAnTScgZmxhZyBpbiAnaGlnaGxpZ2h0JyB0byBzZXQgdGhlIHR5cGUgb2YgaGlnaGxpZ2h0aW5nIGZvcgoJdGhpcyBtZXNzYWdlLgoJV2hlbiB8WElNfCBtYXkgYmUgdXNlZCB0aGUgbWVzc2FnZSB3aWxsIGluY2x1ZGUgIlhJTSIuICBCdXQgdGhpcwoJZG9lc24ndCBtZWFuIFhJTSBpcyByZWFsbHkgYWN0aXZlLCBlc3BlY2lhbGx5IHdoZW4gJ2ltYWN0aXZhdGVrZXknIGlzCglub3Qgc2V0LgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIHRoZSBWaSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzCglzZXQgYW5kIHRvIHRoZSBWaW0gZGVmYXVsdCB2YWx1ZSB3aGVuICdjb21wYXRpYmxlJyBpcyByZXNldC4KCgkJCQkJCSonc2lkZXNjcm9sbCcqIConc3MnKgonc2lkZXNjcm9sbCcgJ3NzJwludW1iZXIJKGRlZmF1bHQgMCkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglUaGUgbWluaW1hbCBudW1iZXIgb2YgY29sdW1ucyB0byBzY3JvbGwgaG9yaXpvbnRhbGx5LiAgVXNlZCBvbmx5IHdoZW4KCXRoZSAnd3JhcCcgb3B0aW9uIGlzIG9mZiBhbmQgdGhlIGN1cnNvciBpcyBtb3ZlZCBvZmYgb2YgdGhlIHNjcmVlbi4KCVdoZW4gaXQgaXMgemVybyB0aGUgY3Vyc29yIHdpbGwgYmUgcHV0IGluIHRoZSBtaWRkbGUgb2YgdGhlIHNjcmVlbi4KCVdoZW4gdXNpbmcgYSBzbG93IHRlcm1pbmFsIHNldCBpdCB0byBhIGxhcmdlIG51bWJlciBvciAwLiAgV2hlbiB1c2luZwoJYSBmYXN0IHRlcm1pbmFsIHVzZSBhIHNtYWxsIG51bWJlciBvciAxLiAgTm90IHVzZWQgZm9yICJ6aCIgYW5kICJ6bCIKCWNvbW1hbmRzLgoKCQkJCQkJKidzaWRlc2Nyb2xsb2ZmJyogKidzaXNvJyoKJ3NpZGVzY3JvbGxvZmYnICdzaXNvJwludW1iZXIgKGRlZmF1bHQgMCkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglUaGUgbWluaW1hbCBudW1iZXIgb2Ygc2NyZWVuIGNvbHVtbnMgdG8ga2VlcCB0byB0aGUgbGVmdCBhbmQgdG8gdGhlCglyaWdodCBvZiB0aGUgY3Vyc29yIGlmICdub3dyYXAnIGlzIHNldC4gIFNldHRpbmcgdGhpcyBvcHRpb24gdG8gYSB2YWx1ZQoJZ3JlYXRlciB0aGFuIDAgd2hpbGUgaGF2aW5nIHwnc2lkZXNjcm9sbCd8IGFsc28gYXQgYSBub24temVybyB2YWx1ZQoJbWFrZXMgc29tZSBjb250ZXh0IHZpc2libGUgaW4gdGhlIGxpbmUgeW91IGFyZSBzY3JvbGxpbmcgaW4KCWhvcml6b250YWxseSAoZXhjZXB0IGF0IHRoZSBlbmQgYW5kIGJlZ2lubmluZyBvZiB0aGUgbGluZSkuICBTZXR0aW5nCgl0aGlzIG9wdGlvbiB0byBhIGxhcmdlIHZhbHVlIChsaWtlIDk5OSkgaGFzIHRoZSBlZmZlY3Qgb2Yga2VlcGluZyB0aGUKCWN1cnNvciBob3Jpem9udGFsbHkgY2VudGVyZWQgaW4gdGhlIHdpbmRvdywgYXMgbG9uZyBhcyBvbmUgZG9lcyBub3QKCWNvbWUgdG9vIGNsb3NlIHRvIHRoZSBiZWdpbm5pbmcgb3IgZW5kIG9mIHRoZSBsaW5lLgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIDAgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCUV4YW1wbGU6IFRyeSB0aGlzIHRvZ2V0aGVyIHdpdGggJ3NpZGVzY3JvbGwnIGFuZCAnbGlzdGNoYXJzJyBhcwoJCSBpbiB0aGUgZm9sbG93aW5nIGV4YW1wbGUgdG8gbmV2ZXIgYWxsb3cgdGhlIGN1cnNvciB0byBtb3ZlCgkJIG9udG8gdGhlICJleHRlbmRzIiBjaGFyYWN0ZXI6CgoJCSA6c2V0IG5vd3JhcCBzaWRlc2Nyb2xsPTEgbGlzdGNoYXJzPWV4dGVuZHM6PixwcmVjZWRlczo8CgkJIDpzZXQgc2lkZXNjcm9sbG9mZj0xCgoKCQkJKidzbWFydGNhc2UnKiAqJ3NjcycqIConbm9zbWFydGNhc2UnKiAqJ25vc2NzJyoKJ3NtYXJ0Y2FzZScgJ3NjcycJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJT3ZlcnJpZGUgdGhlICdpZ25vcmVjYXNlJyBvcHRpb24gaWYgdGhlIHNlYXJjaCBwYXR0ZXJuIGNvbnRhaW5zIHVwcGVyCgljYXNlIGNoYXJhY3RlcnMuICBPbmx5IHVzZWQgd2hlbiB0aGUgc2VhcmNoIHBhdHRlcm4gaXMgdHlwZWQgYW5kCgknaWdub3JlY2FzZScgb3B0aW9uIGlzIG9uLiAgVXNlZCBmb3IgdGhlIGNvbW1hbmRzICIvIiwgIj8iLCAibiIsICJOIiwKCSI6ZyIgYW5kICI6cyIuICBOb3QgdXNlZCBmb3IgIioiLCAiIyIsICJnZCIsIHRhZyBzZWFyY2gsIGV0Yy4uICBBZnRlcgoJIioiIGFuZCAiIyIgeW91IGNhbiBtYWtlICdzbWFydGNhc2UnIHVzZWQgYnkgZG9pbmcgYSAiLyIgY29tbWFuZCwKCXJlY2FsbGluZyB0aGUgc2VhcmNoIHBhdHRlcm4gZnJvbSBoaXN0b3J5IGFuZCBoaXR0aW5nIDxFbnRlcj4uCglOT1RFOiBUaGlzIG9wdGlvbiBpcyByZXNldCB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkgICAgIConc21hcnRpbmRlbnQnKiAqJ3NpJyogKidub3NtYXJ0aW5kZW50JyogKidub3NpJyoKJ3NtYXJ0aW5kZW50JyAnc2knCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZQoJCQl8K3NtYXJ0aW5kZW50fCBmZWF0dXJlfQoJRG8gc21hcnQgYXV0b2luZGVudGluZyB3aGVuIHN0YXJ0aW5nIGEgbmV3IGxpbmUuICBXb3JrcyBmb3IgQy1saWtlCglwcm9ncmFtcywgYnV0IGNhbiBhbHNvIGJlIHVzZWQgZm9yIG90aGVyIGxhbmd1YWdlcy4gICdjaW5kZW50JyBkb2VzCglzb21ldGhpbmcgbGlrZSB0aGlzLCB3b3JrcyBiZXR0ZXIgaW4gbW9zdCBjYXNlcywgYnV0IGlzIG1vcmUgc3RyaWN0LAoJc2VlIHxDLWluZGVudGluZ3wuICBXaGVuICdjaW5kZW50JyBpcyBvbiwgc2V0dGluZyAnc2knIGhhcyBubyBlZmZlY3QuCgknaW5kZW50ZXhwcicgaXMgYSBtb3JlIGFkdmFuY2VkIGFsdGVybmF0aXZlLgoJTm9ybWFsbHkgJ2F1dG9pbmRlbnQnIHNob3VsZCBhbHNvIGJlIG9uIHdoZW4gdXNpbmcgJ3NtYXJ0aW5kZW50Jy4KCUFuIGluZGVudCBpcyBhdXRvbWF0aWNhbGx5IGluc2VydGVkOgoJLSBBZnRlciBhIGxpbmUgZW5kaW5nIGluICd7Jy4KCS0gQWZ0ZXIgYSBsaW5lIHN0YXJ0aW5nIHdpdGggYSBrZXl3b3JkIGZyb20gJ2NpbndvcmRzJy4KCS0gQmVmb3JlIGEgbGluZSBzdGFydGluZyB3aXRoICd9JyAob25seSB3aXRoIHRoZSAiTyIgY29tbWFuZCkuCglXaGVuIHR5cGluZyAnfScgYXMgdGhlIGZpcnN0IGNoYXJhY3RlciBpbiBhIG5ldyBsaW5lLCB0aGF0IGxpbmUgaXMKCWdpdmVuIHRoZSBzYW1lIGluZGVudCBhcyB0aGUgbWF0Y2hpbmcgJ3snLgoJV2hlbiB0eXBpbmcgJyMnIGFzIHRoZSBmaXJzdCBjaGFyYWN0ZXIgaW4gYSBuZXcgbGluZSwgdGhlIGluZGVudCBmb3IKCXRoYXQgbGluZSBpcyByZW1vdmVkLCB0aGUgJyMnIGlzIHB1dCBpbiB0aGUgZmlyc3QgY29sdW1uLiAgVGhlIGluZGVudAoJaXMgcmVzdG9yZWQgZm9yIHRoZSBuZXh0IGxpbmUuICBJZiB5b3UgZG9uJ3Qgd2FudCB0aGlzLCB1c2UgdGhpcwoJbWFwcGluZzogIjppbm9yZW1hcCAjIFheSCMiLCB3aGVyZSBeSCBpcyBlbnRlcmVkIHdpdGggQ1RSTC1WIENUUkwtSC4KCVdoZW4gdXNpbmcgdGhlICI+PiIgY29tbWFuZCwgbGluZXMgc3RhcnRpbmcgd2l0aCAnIycgYXJlIG5vdCBzaGlmdGVkCglyaWdodC4KCU5PVEU6ICdzbWFydGluZGVudCcgaXMgcmVzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LiAgV2hlbiAncGFzdGUnCglpcyBzZXQgc21hcnQgaW5kZW50aW5nIGlzIGRpc2FibGVkLgoKCQkJCSAqJ3NtYXJ0dGFiJyogKidzdGEnKiAqJ25vc21hcnR0YWInKiAqJ25vc3RhJyoKJ3NtYXJ0dGFiJyAnc3RhJwlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglXaGVuIG9uLCBhIDxUYWI+IGluIGZyb250IG9mIGEgbGluZSBpbnNlcnRzIGJsYW5rcyBhY2NvcmRpbmcgdG8KCSdzaGlmdHdpZHRoJy4gICd0YWJzdG9wJyBpcyB1c2VkIGluIG90aGVyIHBsYWNlcy4gIEEgPEJTPiB3aWxsIGRlbGV0ZQoJYSAnc2hpZnR3aWR0aCcgd29ydGggb2Ygc3BhY2UgYXQgdGhlIHN0YXJ0IG9mIHRoZSBsaW5lLgoJV2hlbiBvZmYgYSA8VGFiPiBhbHdheXMgaW5zZXJ0cyBibGFua3MgYWNjb3JkaW5nIHRvICd0YWJzdG9wJy4KCSdzaGlmdHdpZHRoJyBpcyBvbmx5IHVzZWQgZm9yIHNoaWZ0aW5nIHRleHQgbGVmdCBvciByaWdodAoJfHNoaWZ0LWxlZnQtcmlnaHR8LgoJV2hhdCBnZXRzIGluc2VydGVkIChhIFRhYiBvciBzcGFjZXMpIGRlcGVuZHMgb24gdGhlICdleHBhbmR0YWInCglvcHRpb24uICBBbHNvIHNlZSB8aW5zLWV4cGFuZHRhYnwuICBXaGVuICdleHBhbmR0YWInIGlzIG5vdCBzZXQsIHRoZQoJbnVtYmVyIG9mIHNwYWNlcyBpcyBtaW5pbWl6ZWQgYnkgdXNpbmcgPFRhYj5zLgoJTk9URTogVGhpcyBvcHRpb24gaXMgcmVzZXQgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkqJ3NvZnR0YWJzdG9wJyogKidzdHMnKgonc29mdHRhYnN0b3AnICdzdHMnCW51bWJlcgkoZGVmYXVsdCAwKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCU51bWJlciBvZiBzcGFjZXMgdGhhdCBhIDxUYWI+IGNvdW50cyBmb3Igd2hpbGUgcGVyZm9ybWluZyBlZGl0aW5nCglvcGVyYXRpb25zLCBsaWtlIGluc2VydGluZyBhIDxUYWI+IG9yIHVzaW5nIDxCUz4uICBJdCAiZmVlbHMiIGxpa2UKCTxUYWI+cyBhcmUgYmVpbmcgaW5zZXJ0ZWQsIHdoaWxlIGluIGZhY3QgYSBtaXggb2Ygc3BhY2VzIGFuZCA8VGFiPnMgaXMKCXVzZWQuICBUaGlzIGlzIHVzZWZ1bCB0byBrZWVwIHRoZSAndHMnIHNldHRpbmcgYXQgaXRzIHN0YW5kYXJkIHZhbHVlCglvZiA4LCB3aGlsZSBiZWluZyBhYmxlIHRvIGVkaXQgbGlrZSBpdCBpcyBzZXQgdG8gJ3N0cycuICBIb3dldmVyLAoJY29tbWFuZHMgbGlrZSAieCIgc3RpbGwgd29yayBvbiB0aGUgYWN0dWFsIGNoYXJhY3RlcnMuCglXaGVuICdzdHMnIGlzIHplcm8sIHRoaXMgZmVhdHVyZSBpcyBvZmYuCgknc29mdHRhYnN0b3AnIGlzIHNldCB0byAwIHdoZW4gdGhlICdwYXN0ZScgb3B0aW9uIGlzIHNldC4KCVNlZSBhbHNvIHxpbnMtZXhwYW5kdGFifC4gIFdoZW4gJ2V4cGFuZHRhYicgaXMgbm90IHNldCwgdGhlIG51bWJlciBvZgoJc3BhY2VzIGlzIG1pbmltaXplZCBieSB1c2luZyA8VGFiPnMuCglUaGUgJ0wnIGZsYWcgaW4gJ2Nwb3B0aW9ucycgY2hhbmdlcyBob3cgdGFicyBhcmUgdXNlZCB3aGVuICdsaXN0JyBpcwoJc2V0LgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIDAgd2hlbiAnY29tcGF0aWJsZScgaXMgc2V0LgoKCQkJCQkJKidzcGVsbCcqIConbm9zcGVsbCcqCidzcGVsbCcJCQlib29sZWFuCShkZWZhdWx0IG9mZikKCQkJbG9jYWwgdG8gd2luZG93CgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCtzeW50YXh8CgkJCWZlYXR1cmV9CglXaGVuIG9uIHNwZWxsIGNoZWNraW5nIHdpbGwgYmUgZG9uZS4gIFNlZSB8c3BlbGx8LgoJVGhlIGxhbmd1YWdlcyBhcmUgc3BlY2lmaWVkIHdpdGggJ3NwZWxsbGFuZycuCgoJCQkJCQkqJ3NwZWxsY2FwY2hlY2snKiAqJ3NwYycqCidzcGVsbGNhcGNoZWNrJyAnc3BjJwlzdHJpbmcJKGRlZmF1bHQgIlsuPyFdW10pJyIgXHRcbl1cKyIpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrc3ludGF4fAoJCQlmZWF0dXJlfQoJUGF0dGVybiB0byBsb2NhdGUgdGhlIGVuZCBvZiBhIHNlbnRlbmNlLiAgVGhlIGZvbGxvd2luZyB3b3JkIHdpbGwgYmUKCWNoZWNrZWQgdG8gc3RhcnQgd2l0aCBhIGNhcGl0YWwgbGV0dGVyLiAgSWYgbm90IHRoZW4gaXQgaXMgaGlnaGxpZ2h0ZWQKCXdpdGggU3BlbGxDYXAgfGhsLVNwZWxsQ2FwfC4KCVdoZW4gdGhpcyBjaGVjayBpcyBub3Qgd2FudGVkIG1ha2UgdGhpcyBvcHRpb24gZW1wdHkuCglPbmx5IHVzZWQgd2hlbiAnc3BlbGwnIGlzIHNldC4KCgkJCQkJCSonc3BlbGxmaWxlJyogKidzcGYnKgonc3BlbGxmaWxlJyAnc3BmJwlzdHJpbmcJKGRlZmF1bHQgZW1wdHkpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrc3ludGF4fAoJCQlmZWF0dXJlfQoJTmFtZSBvZiB0aGUgd29yZCBsaXN0IGZpbGUgd2hlcmUgd29yZHMgYXJlIGFkZGVkIGZvciB0aGUgfHpnfCBhbmQgfHp3fAoJY29tbWFuZHMuICBJdCBtdXN0IGVuZCBpbiAiLntlbmNvZGluZ30uYWRkIi4KCQkJCQkJCQkqRTc2NSoKCUl0IG1heSBhbHNvIGJlIGEgY29tbWEgc2VwYXJhdGVkIGxpc3Qgb2YgbmFtZXMuICBBIGNvdW50IGJlZm9yZSB0aGUKCXx6Z3wgYW5kIHx6d3wgY29tbWFuZHMgY2FuIGJlIHVzZWQgdG8gYWNjZXNzIGVhY2guICBUaGlzIGFsbG93cyB1c2luZwoJYSBwZXJzb25hbCB3b3JkIGxpc3QgZmlsZSBhbmQgYSBwcm9qZWN0IHdvcmQgbGlzdCBmaWxlLgoJV2hlbiBhIHdvcmQgaXMgYWRkZWQgd2hpbGUgdGhpcyBvcHRpb24gaXMgZW1wdHkgVmltIHdpbGwgc2V0IGl0IGZvcgoJeW91OiBVc2luZyB0aGUgZmlyc3QgInNwZWxsIiBkaXJlY3RvcnkgaW4gJ3J1bnRpbWVwYXRoJyB0aGF0IGlzCgl3cml0YWJsZSBhbmQgdGhlIGZpcnN0IGxhbmd1YWdlIG5hbWUgdGhhdCBhcHBlYXJzIGluICdzcGVsbGxhbmcnLAoJaWdub3JpbmcgdGhlIHJlZ2lvbi4KCVRoZSByZXN1bHRpbmcgIi5zcGwiIGZpbGUgd2lsbCBiZSB1c2VkIGZvciBzcGVsbCBjaGVja2luZywgaXQgZG9lcyBub3QKCWhhdmUgdG8gYXBwZWFyIGluICdzcGVsbGxhbmcnLgoJTm9ybWFsbHkgb25lIGZpbGUgaXMgdXNlZCBmb3IgYWxsIHJlZ2lvbnMsIGJ1dCB5b3UgY2FuIGFkZCB0aGUgcmVnaW9uCgluYW1lIGlmIHlvdSB3YW50IHRvLiAgSG93ZXZlciwgaXQgd2lsbCB0aGVuIG9ubHkgYmUgdXNlZCB3aGVuCgknc3BlbGxmaWxlJyBpcyBzZXQgdG8gaXQsIGZvciBlbnRyaWVzIGluICdzcGVsbGxhbmcnIG9ubHkgZmlsZXMKCXdpdGhvdXQgcmVnaW9uIG5hbWUgd2lsbCBiZSBmb3VuZC4KCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJCQkJKidzcGVsbGxhbmcnKiAqJ3NwbCcqCidzcGVsbGxhbmcnICdzcGwnCXN0cmluZwkoZGVmYXVsdCAiZW4iKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3N5bnRheHwKCQkJZmVhdHVyZX0KCUEgY29tbWEgc2VwYXJhdGVkIGxpc3Qgb2Ygd29yZCBsaXN0IG5hbWVzLiAgV2hlbiB0aGUgJ3NwZWxsJyBvcHRpb24gaXMKCW9uIHNwZWxsY2hlY2tpbmcgd2lsbCBiZSBkb25lIGZvciB0aGVzZSBsYW5ndWFnZXMuICBFeGFtcGxlOiA+CgkJc2V0IHNwZWxsbGFuZz1lbl91cyxubCxtZWRpY2FsCjwJVGhpcyBtZWFucyBVUyBFbmdsaXNoLCBEdXRjaCBhbmQgbWVkaWNhbCB3b3JkcyBhcmUgcmVjb2duaXplZC4gIFdvcmRzCgl0aGF0IGFyZSBub3QgcmVjb2duaXplZCB3aWxsIGJlIGhpZ2hsaWdodGVkLgoJVGhlIHdvcmQgbGlzdCBuYW1lIG11c3Qgbm90IGluY2x1ZGUgYSBjb21tYSBvciBkb3QuICBVc2luZyBhIGRhc2ggaXMKCXJlY29tbWVuZGVkIHRvIHNlcGFyYXRlIHRoZSB0d28gbGV0dGVyIGxhbmd1YWdlIG5hbWUgZnJvbSBhCglzcGVjaWZpY2F0aW9uLiAgVGh1cyAiZW4tcmFyZSIgaXMgdXNlZCBmb3IgcmFyZSBFbmdsaXNoIHdvcmRzLgoJQSByZWdpb24gbmFtZSBtdXN0IGNvbWUgbGFzdCBhbmQgaGF2ZSB0aGUgZm9ybSAiX3h4Iiwgd2hlcmUgInh4IiBpcwoJdGhlIHR3by1sZXR0ZXIsIGxvd2VyIGNhc2UgcmVnaW9uIG5hbWUuICBZb3UgY2FuIHVzZSBtb3JlIHRoYW4gb25lCglyZWdpb24gYnkgbGlzdGluZyB0aGVtOiAiZW5fdXMsZW5fY2EiIHN1cHBvcnRzIGJvdGggVVMgYW5kIENhbmFkaWFuCglFbmdsaXNoLCBidXQgbm90IHdvcmRzIHNwZWNpZmljIGZvciBBdXN0cmFsaWEsIE5ldyBaZWFsYW5kIG9yIEdyZWF0CglCcml0YWluLgoJQXMgYSBzcGVjaWFsIGNhc2UgdGhlIG5hbWUgb2YgYSAuc3BsIGZpbGUgY2FuIGJlIGdpdmVuIGFzLWlzLiAgVGhpcyBpcwoJbWFpbmx5IGZvciB0ZXN0aW5nIHB1cnBvc2VzLiAgWW91IG11c3QgbWFrZSBzdXJlIHRoZSBjb3JyZWN0IGVuY29kaW5nCglpcyB1c2VkLCBWaW0gZG9lc24ndCBjaGVjayBpdC4KCVdoZW4gJ2VuY29kaW5nJyBpcyBzZXQgdGhlIHdvcmQgbGlzdHMgYXJlIHJlbG9hZGVkLiAgVGh1cyBpdCdzIGEgZ29vZAoJaWRlYSB0byBzZXQgJ3NwZWxsbGFuZycgYWZ0ZXIgc2V0dGluZyAnZW5jb2RpbmcnLgoJSG93IHRoZSByZWxhdGVkIHNwZWxsIGZpbGVzIGFyZSBmb3VuZCBpcyBleHBsYWluZWQgaGVyZTogfHNwZWxsLWxvYWR8LgoKCQkJCQkJKidzcGVsbHN1Z2dlc3QnKiAqJ3NwcycqCidzcGVsbHN1Z2dlc3QnICdzcHMnCXN0cmluZwkoZGVmYXVsdCAiYmVzdCIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrc3ludGF4fAoJCQlmZWF0dXJlfQoJTWV0aG9kcyB1c2VkIGZvciBzcGVsbGluZyBzdWdnZXN0aW9ucy4gIEJvdGggZm9yIHRoZSB8ej98IGNvbW1hbmQgYW5kCgl0aGUgfHNwZWxsc3VnZ2VzdCgpfCBmdW5jdGlvbi4gIFRoaXMgaXMgYSBjb21tYS1zZXBhcmF0ZWQgbGlzdCBvZgoJaXRlbXM6CgoJYmVzdAkJSW50ZXJuYWwgbWV0aG9kIHRoYXQgd29ya3MgYmVzdCBmb3IgRW5nbGlzaC4gIEZpbmRzCgkJCWNoYW5nZXMgbGlrZSAiZmFzdCIgYW5kIHVzZXMgYSBiaXQgb2Ygc291bmQtYS1saWtlCgkJCXNjb3JpbmcgdG8gaW1wcm92ZSB0aGUgb3JkZXJpbmcuCgoJZG91YmxlCQlJbnRlcm5hbCBtZXRob2QgdGhhdCB1c2VzIHR3byBtZXRob2RzIGFuZCBtaXhlcyB0aGUKCQkJcmVzdWx0cy4gIFRoZSBmaXJzdCBtZXRob2QgaXMgImZhc3QiLCB0aGUgb3RoZXIgbWV0aG9kCgkJCWNvbXB1dGVzIGhvdyBtdWNoIHRoZSBzdWdnZXN0aW9uIHNvdW5kcyBsaWtlIHRoZSBiYWQKCQkJd29yZC4gIFRoYXQgb25seSB3b3JrcyB3aGVuIHRoZSBsYW5ndWFnZSBzcGVjaWZpZXMKCQkJc291bmQgZm9sZGluZy4gIENhbiBiZSBzbG93IGFuZCBkb2Vzbid0IGFsd2F5cyBnaXZlCgkJCWJldHRlciByZXN1bHRzLgoKCWZhc3QJCUludGVybmFsIG1ldGhvZCB0aGF0IG9ubHkgY2hlY2tzIGZvciBzaW1wbGUgY2hhbmdlczoKCQkJY2hhcmFjdGVyIGluc2VydHMvZGVsZXRlcy9zd2Fwcy4gIFdvcmtzIHdlbGwgZm9yCgkJCXNpbXBsZSB0eXBpbmcgbWlzdGFrZXMuCgoJZmlsZTp7ZmlsZW5hbWV9IFJlYWQgZmlsZSB7ZmlsZW5hbWV9LCB3aGljaCBtdXN0IGhhdmUgdHdvIGNvbHVtbnMsCgkJCXNlcGFyYXRlZCBieSBhIHNsYXNoLiAgVGhlIGZpcnN0IGNvbHVtbiBjb250YWlucyB0aGUKCQkJYmFkIHdvcmQsIHRoZSBzZWNvbmQgY29sdW1uIHRoZSBzdWdnZXN0ZWQgZ29vZCB3b3JkLgoJCQlFeGFtcGxlOgoJCQkJdGhlcmliYWwvdGVycmlibGUgfgoJCQlVc2UgdGhpcyBmb3IgY29tbW9uIG1pc3Rha2VzIHRoYXQgZG8gbm90IGFwcGVhciBhdCB0aGUKCQkJdG9wIG9mIHRoZSBzdWdnZXN0aW9uIGxpc3Qgd2l0aCB0aGUgaW50ZXJuYWwgbWV0aG9kcy4KCQkJTGluZXMgd2l0aG91dCBhIHNsYXNoIGFyZSBpZ25vcmVkLCB1c2UgdGhpcyBmb3IKCQkJY29tbWVudHMuCgkJCVRoZSBmaWxlIGlzIHVzZWQgZm9yIGFsbCBsYW5ndWFnZXMuCgoJZXhwcjp7ZXhwcn0JRXZhbHVhdGUgZXhwcmVzc2lvbiB7ZXhwcn0uICBVc2UgYSBmdW5jdGlvbiB0byBhdm9pZAoJCQl0cm91YmxlIHdpdGggc3BhY2VzLiAgfHY6dmFsfCBob2xkcyB0aGUgYmFkbHkgc3BlbGxlZAoJCQl3b3JkLiAgVGhlIGV4cHJlc3Npb24gbXVzdCBldmFsdWF0ZSB0byBhIExpc3Qgb2YKCQkJTGlzdHMsIGVhY2ggd2l0aCBhIHN1Z2dlc3Rpb24gYW5kIGEgc2NvcmUuCgkJCUV4YW1wbGU6CgkJCQlbWyd0aGUnLCAzM10sIFsndGhhdCcsIDQ0XV0KCQkJU2V0ICd2ZXJib3NlJyBhbmQgdXNlIHx6P3wgdG8gc2VlIHRoZSBzY29yZXMgdGhhdCB0aGUKCQkJaW50ZXJuYWwgbWV0aG9kcyB1c2UuICBBIGxvd2VyIHNjb3JlIGlzIGJldHRlci4KCQkJVGhpcyBtYXkgaW52b2tlIHxzcGVsbHN1Z2dlc3QoKXwgaWYgeW91IHRlbXBvcmFyaWx5CgkJCXNldCAnc3BlbGxzdWdnZXN0JyB0byBleGNsdWRlIHRoZSAiZXhwcjoiIHBhcnQuCgkJCUVycm9ycyBhcmUgc2lsZW50bHkgaWdub3JlZCwgdW5sZXNzIHlvdSBzZXQgdGhlCgkJCSd2ZXJib3NlJyBvcHRpb24gdG8gYSBub24temVybyB2YWx1ZS4KCglPbmx5IG9uZSBvZiAiYmVzdCIsICJkb3VibGUiIG9yICJmYXN0IiBtYXkgYmUgdXNlZC4gIFRoZSBvdGhlcnMgbWF5CglhcHBlYXIgc2V2ZXJhbCB0aW1lcyBpbiBhbnkgb3JkZXIuICBFeGFtcGxlOiA+CgkJOnNldCBzcHM9ZmlsZTp+Ly52aW0vc3VnZyxiZXN0LGV4cHI6TXlTdWdnZXN0KCkKPAoJVGhpcyBvcHRpb24gY2Fubm90IGJlIHNldCBmcm9tIGEgfG1vZGVsaW5lfCBvciBpbiB0aGUgfHNhbmRib3h8LCBmb3IKCXNlY3VyaXR5IHJlYXNvbnMuCgoKCQkJKidzcGxpdGJlbG93JyogKidzYicqIConbm9zcGxpdGJlbG93JyogKidub3NiJyoKJ3NwbGl0YmVsb3cnICdzYicJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlICt3aW5kb3dzCgkJCWZlYXR1cmV9CglXaGVuIG9uLCBzcGxpdHRpbmcgYSB3aW5kb3cgd2lsbCBwdXQgdGhlIG5ldyB3aW5kb3cgYmVsb3cgdGhlIGN1cnJlbnQKCW9uZS4gfDpzcGxpdHwKCgkJCSonc3BsaXRyaWdodCcqIConc3ByJyogKidub3NwbGl0cmlnaHQnKiAqJ25vc3ByJyoKJ3NwbGl0cmlnaHQnICdzcHInCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSArdmVydHNwbGl0CgkJCWZlYXR1cmV9CglXaGVuIG9uLCBzcGxpdHRpbmcgYSB3aW5kb3cgd2lsbCBwdXQgdGhlIG5ldyB3aW5kb3cgcmlnaHQgb2YgdGhlCgljdXJyZW50IG9uZS4gfDp2c3BsaXR8CgoJCQkgICAqJ3N0YXJ0b2ZsaW5lJyogKidzb2wnKiAqJ25vc3RhcnRvZmxpbmUnKiAqJ25vc29sJyoKJ3N0YXJ0b2ZsaW5lJyAnc29sJwlib29sZWFuCShkZWZhdWx0IG9uKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVdoZW4gIm9uIiB0aGUgY29tbWFuZHMgbGlzdGVkIGJlbG93IG1vdmUgdGhlIGN1cnNvciB0byB0aGUgZmlyc3QKCW5vbi1ibGFuayBvZiB0aGUgbGluZS4gIFdoZW4gb2ZmIHRoZSBjdXJzb3IgaXMga2VwdCBpbiB0aGUgc2FtZSBjb2x1bW4KCShpZiBwb3NzaWJsZSkuICBUaGlzIGFwcGxpZXMgdG8gdGhlIGNvbW1hbmRzOiBDVFJMLUQsIENUUkwtVSwgQ1RSTC1CLAoJQ1RSTC1GLCAiRyIsICJIIiwgIk0iLCAiTCIsIGdnLCBhbmQgdG8gdGhlIGNvbW1hbmRzICJkIiwgIjw8IiBhbmQgIj4+IgoJd2l0aCBhIGxpbmV3aXNlIG9wZXJhdG9yLCB3aXRoICIlIiB3aXRoIGEgY291bnQgYW5kIHRvIGJ1ZmZlciBjaGFuZ2luZwoJY29tbWFuZHMgKENUUkwtXiwgOmJuZXh0LCA6Yk5leHQsIGV0Yy4pLiAgQWxzbyBmb3IgYW4gRXggY29tbWFuZCB0aGF0Cglvbmx5IGhhcyBhIGxpbmUgbnVtYmVyLCBlLmcuLCAiOjI1IiBvciAiOisiLgoJSW4gY2FzZSBvZiBidWZmZXIgY2hhbmdpbmcgY29tbWFuZHMgdGhlIGN1cnNvciBpcyBwbGFjZWQgYXQgdGhlIGNvbHVtbgoJd2hlcmUgaXQgd2FzIHRoZSBsYXN0IHRpbWUgdGhlIGJ1ZmZlciB3YXMgZWRpdGVkLgoJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHdoZW4gJ2NvbXBhdGlibGUnIGlzIHNldC4KCgkJCSAgIConc3RhdHVzbGluZScqIConc3RsJyogKkU1NDAqICpFNTQxKiAqRTU0MioKJ3N0YXR1c2xpbmUnICdzdGwnCXN0cmluZwkoZGVmYXVsdCBlbXB0eSkKCQkJZ2xvYmFsIG9yIGxvY2FsIHRvIHdpbmRvdyB8Z2xvYmFsLWxvY2FsfAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrc3RhdHVzbGluZXwKCQkJZmVhdHVyZX0KCVdoZW4gbm9uZW1wdHksIHRoaXMgb3B0aW9uIGRldGVybWluZXMgdGhlIGNvbnRlbnQgb2YgdGhlIHN0YXR1cyBsaW5lLgoJQWxzbyBzZWUgfHN0YXR1cy1saW5lfC4KCglUaGUgb3B0aW9uIGNvbnNpc3RzIG9mIHByaW50ZiBzdHlsZSAnJScgaXRlbXMgaW50ZXJzcGVyc2VkIHdpdGgKCW5vcm1hbCB0ZXh0LiAgRWFjaCBzdGF0dXMgbGluZSBpdGVtIGlzIG9mIHRoZSBmb3JtOgoJICAlLTB7bWlud2lkfS57bWF4d2lkfXtpdGVtfQoJQWxsIGZpZWxkcyBleGNlcHQgdGhlIHtpdGVtfSBpcyBvcHRpb25hbC4gIEEgc2luZ2xlIHBlcmNlbnQgc2lnbiBjYW4KCWJlIGdpdmVuIGFzICIlJSIuICBVcCB0byA4MCBpdGVtcyBjYW4gYmUgc3BlY2lmaWVkLgoKCU5vdGUgdGhhdCB0aGUgb25seSBlZmZlY3Qgb2YgJ3J1bGVyJyB3aGVuIHRoaXMgb3B0aW9uIGlzIHNldCAoYW5kCgknbGFzdHN0YXR1cycgaXMgMikgaXMgY29udHJvbGxpbmcgdGhlIG91dHB1dCBvZiB8Q1RSTC1HfC4KCglmaWVsZAkgICAgbWVhbmluZyB+CgktCSAgICBMZWZ0IGp1c3RpZnkgdGhlIGl0ZW0uICBUaGUgZGVmYXVsdCBpcyByaWdodCBqdXN0aWZpZWQKCQkgICAgd2hlbiBtaW53aWQgaXMgbGFyZ2VyIHRoYW4gdGhlIGxlbmd0aCBvZiB0aGUgaXRlbS4KCTAJICAgIExlYWRpbmcgemVyb2VzIGluIG51bWVyaWMgaXRlbXMuICBPdmVycmlkZGVuIGJ5ICctJy4KCW1pbndpZAkgICAgTWluaW11bSB3aWR0aCBvZiB0aGUgaXRlbSwgcGFkZGluZyBhcyBzZXQgYnkgJy0nICYgJzAnLgoJCSAgICBWYWx1ZSBtdXN0IGJlIDUwIG9yIGxlc3MuCgltYXh3aWQJICAgIE1heGltdW0gd2lkdGggb2YgdGhlIGl0ZW0uICBUcnVuY2F0aW9uIG9jY3VycyB3aXRoIGEgJzwnCgkJICAgIG9uIHRoZSBsZWZ0IGZvciB0ZXh0IGl0ZW1zLiAgTnVtZXJpYyBpdGVtcyB3aWxsIGJlCgkJICAgIHNoaWZ0ZWQgZG93biB0byBtYXh3aWQtMiBkaWdpdHMgZm9sbG93ZWQgYnkgJz4nbnVtYmVyCgkJICAgIHdoZXJlIG51bWJlciBpcyB0aGUgYW1vdW50IG9mIG1pc3NpbmcgZGlnaXRzLCBtdWNoIGxpa2UKCQkgICAgYW4gZXhwb25lbnRpYWwgbm90YXRpb24uCglpdGVtCSAgICBBIG9uZSBsZXR0ZXIgY29kZSBhcyBkZXNjcmliZWQgYmVsb3cuCgoJRm9sbG93aW5nIGlzIGEgZGVzY3JpcHRpb24gb2YgdGhlIHBvc3NpYmxlIHN0YXR1c2xpbmUgaXRlbXMuICBUaGUKCXNlY29uZCBjaGFyYWN0ZXIgaW4gIml0ZW0iIGlzIHRoZSB0eXBlOgoJCU4gZm9yIG51bWJlcgoJCVMgZm9yIHN0cmluZwoJCUYgZm9yIGZsYWdzIGFzIGRlc2NyaWJlZCBiZWxvdwoJCS0gbm90IGFwcGxpY2FibGUKCglpdGVtICBtZWFuaW5nIH4KCWYgUyAgIFBhdGggdG8gdGhlIGZpbGUgaW4gdGhlIGJ1ZmZlciwgcmVsYXRpdmUgdG8gY3VycmVudCBkaXJlY3RvcnkuCglGIFMgICBGdWxsIHBhdGggdG8gdGhlIGZpbGUgaW4gdGhlIGJ1ZmZlci4KCXQgUyAgIEZpbGUgbmFtZSAodGFpbCkgb2YgZmlsZSBpbiB0aGUgYnVmZmVyLgoJbSBGICAgTW9kaWZpZWQgZmxhZywgdGV4dCBpcyAiIFsrXSI7ICIgWy1dIiBpZiAnbW9kaWZpYWJsZScgaXMgb2ZmLgoJTSBGICAgTW9kaWZpZWQgZmxhZywgdGV4dCBpcyAiLCsiIG9yICIsLSIuCglyIEYgICBSZWFkb25seSBmbGFnLCB0ZXh0IGlzICIgW1JPXSIuCglSIEYgICBSZWFkb25seSBmbGFnLCB0ZXh0IGlzICIsUk8iLgoJaCBGICAgSGVscCBidWZmZXIgZmxhZywgdGV4dCBpcyAiIFtoZWxwXSIuCglIIEYgICBIZWxwIGJ1ZmZlciBmbGFnLCB0ZXh0IGlzICIsSExQIi4KCXcgRiAgIFByZXZpZXcgd2luZG93IGZsYWcsIHRleHQgaXMgIiBbUHJldmlld10iLgoJVyBGICAgUHJldmlldyB3aW5kb3cgZmxhZywgdGV4dCBpcyAiLFBSViIuCgl5IEYgICBUeXBlIG9mIGZpbGUgaW4gdGhlIGJ1ZmZlciwgZS5nLiwgIiBbdmltXSIuICBTZWUgJ2ZpbGV0eXBlJy4KCVkgRiAgIFR5cGUgb2YgZmlsZSBpbiB0aGUgYnVmZmVyLCBlLmcuLCAiLFZJTSIuICBTZWUgJ2ZpbGV0eXBlJy4KCSAgICAgIHtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB8K2F1dG9jbWR8IGZlYXR1cmV9CglrIFMgICBWYWx1ZSBvZiAiYjprZXltYXBfbmFtZSIgb3IgJ2tleW1hcCcgd2hlbiB8OmxtYXB8IG1hcHBpbmdzIGFyZQoJICAgICAgYmVpbmcgdXNlZDogIjxrZXltYXA+IgoJbiBOICAgQnVmZmVyIG51bWJlci4KCWIgTiAgIFZhbHVlIG9mIGJ5dGUgdW5kZXIgY3Vyc29yLgoJQiBOICAgQXMgYWJvdmUsIGluIGhleGFkZWNpbWFsLgoJbyBOICAgQnl0ZSBudW1iZXIgaW4gZmlsZSBvZiBieXRlIHVuZGVyIGN1cnNvciwgZmlyc3QgYnl0ZSBpcyAxLgoJICAgICAgTW5lbW9uaWM6IE9mZnNldCBmcm9tIHN0YXJ0IG9mIGZpbGUgKHdpdGggb25lIGFkZGVkKQoJICAgICAge25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHwrYnl0ZV9vZmZzZXR8IGZlYXR1cmV9CglPIE4gICBBcyBhYm92ZSwgaW4gaGV4YWRlY2ltYWwuCglOIE4gICBQcmludGVyIHBhZ2UgbnVtYmVyLiAgKE9ubHkgd29ya3MgaW4gdGhlICdwcmludGhlYWRlcicgb3B0aW9uLikKCWwgTiAgIExpbmUgbnVtYmVyLgoJTCBOICAgTnVtYmVyIG9mIGxpbmVzIGluIGJ1ZmZlci4KCWMgTiAgIENvbHVtbiBudW1iZXIuCgl2IE4gICBWaXJ0dWFsIGNvbHVtbiBudW1iZXIuCglWIE4gICBWaXJ0dWFsIGNvbHVtbiBudW1iZXIgYXMgLXtudW19LiAgTm90IGRpc3BsYXllZCBpZiBlcXVhbCB0byAnYycuCglwIE4gICBQZXJjZW50YWdlIHRocm91Z2ggZmlsZSBpbiBsaW5lcyBhcyBpbiB8Q1RSTC1HfC4KCVAgUyAgIFBlcmNlbnRhZ2UgdGhyb3VnaCBmaWxlIG9mIGRpc3BsYXllZCB3aW5kb3cuICBUaGlzIGlzIGxpa2UgdGhlCgkgICAgICBwZXJjZW50YWdlIGRlc2NyaWJlZCBmb3IgJ3J1bGVyJy4gIEFsd2F5cyAzIGluIGxlbmd0aC4KCWEgUyAgIEFyZ3VtZW50IGxpc3Qgc3RhdHVzIGFzIGluIGRlZmF1bHQgdGl0bGUuICAoe2N1cnJlbnR9IG9mIHttYXh9KQoJICAgICAgRW1wdHkgaWYgdGhlIGFyZ3VtZW50IGZpbGUgY291bnQgaXMgemVybyBvciBvbmUuCgl7IE5GICBFdmFsdWF0ZSBleHByZXNzaW9uIGJldHdlZW4gJ3snIGFuZCAnfScgYW5kIHN1YnN0aXR1dGUgcmVzdWx0LgoJKCAtICAgU3RhcnQgb2YgaXRlbSBncm91cC4gIENhbiBiZSB1c2VkIGZvciBzZXR0aW5nIHRoZSB3aWR0aCBhbmQKCSAgICAgIGFsaWdubWVudCBvZiBhIHNlY3Rpb24uICBNdXN0IGJlIGZvbGxvd2VkIGJ5ICUpIHNvbWV3aGVyZS4KCSkgLSAgIEVuZCBvZiBpdGVtIGdyb3VwLiAgTm8gd2lkdGggZmllbGRzIGFsbG93ZWQuCgk8IC0gICBXaGVyZSB0byB0cnVuY2F0ZSBsaW5lIGlmIHRvbyBsb25nLiAgRGVmYXVsdCBpcyBhdCB0aGUgc3RhcnQuCgkgICAgICBObyB3aWR0aCBmaWVsZHMgYWxsb3dlZC4KCT0gLSAgIFNlcGFyYXRpb24gcG9pbnQgYmV0d2VlbiBsZWZ0IGFuZCByaWdodCBhbGlnbmVkIGl0ZW1zLgoJICAgICAgTm8gd2lkdGggZmllbGRzIGFsbG93ZWQuCgkqIC0gICBTZXQgaGlnaGxpZ2h0IGdyb3VwIHRvIFVzZXJ7Tn0sIHdoZXJlIHtOfSBpcyB0YWtlbiBmcm9tIHRoZQoJICAgICAgbWlud2lkIGZpZWxkLCBlLmcuICUxKi4gIFJlc3RvcmUgbm9ybWFsIGhpZ2hsaWdodCB3aXRoICUqIG9yICUwKi4KCSAgICAgIFRoZSBkaWZmZXJlbmNlIGJldHdlZW4gVXNlcntOfSBhbmQgU3RhdHVzTGluZSAgd2lsbCBiZSBhcHBsaWVkCgkgICAgICB0byBTdGF0dXNMaW5lTkMgZm9yIHRoZSBzdGF0dXNsaW5lIG9mIG5vbi1jdXJyZW50IHdpbmRvd3MuCgkgICAgICBUaGUgbnVtYmVyIE4gbXVzdCBiZSBiZXR3ZWVuIDEgYW5kIDkuICBTZWUgfGhsLVVzZXIxLi45fAoKCURpc3BsYXkgb2YgZmxhZ3MgYXJlIGNvbnRyb2xsZWQgYnkgdGhlIGZvbGxvd2luZyBoZXVyaXN0aWM6CglJZiBhIGZsYWcgdGV4dCBzdGFydHMgd2l0aCBjb21tYSBpdCBpcyBhc3N1bWVkIHRoYXQgaXQgd2FudHMgdG8KCXNlcGFyYXRlIGl0c2VsZiBmcm9tIGFueXRoaW5nIGJ1dCBwcmVjZWRpbmcgcGxhaW50ZXh0LiAgSWYgaXQgc3RhcnRzCgl3aXRoIGEgc3BhY2UgaXQgaXMgYXNzdW1lZCB0aGF0IGl0IHdhbnRzIHRvIHNlcGFyYXRlIGl0c2VsZiBmcm9tCglhbnl0aGluZyBidXQgb3RoZXIgZmxhZ3MuICBUaGF0IGlzOiBBIGxlYWRpbmcgY29tbWEgaXMgcmVtb3ZlZCBpZiB0aGUKCXByZWNlZGluZyBjaGFyYWN0ZXIgc3RlbXMgZnJvbSBwbGFpbnRleHQuICBBIGxlYWRpbmcgc3BhY2UgaXMgcmVtb3ZlZAoJaWYgdGhlIHByZWNlZGluZyBjaGFyYWN0ZXIgc3RlbXMgZnJvbSBhbm90aGVyIGFjdGl2ZSBmbGFnLiAgVGhpcyB3aWxsCgltYWtlIGEgbmljZSBkaXNwbGF5IHdoZW4gZmxhZ3MgYXJlIHVzZWQgbGlrZSBpbiB0aGUgZXhhbXBsZXMgYmVsb3cuCgoJV2hlbiBhbGwgaXRlbXMgaW4gYSBncm91cCBiZWNvbWVzIGFuIGVtcHR5IHN0cmluZyAoaS5lLiBmbGFncyB0aGF0IGFyZQoJbm90IHNldCkgYW5kIGEgbWlud2lkIGlzIG5vdCBzZXQgZm9yIHRoZSBncm91cCwgdGhlIHdob2xlIGdyb3VwIHdpbGwKCWJlY29tZSBlbXB0eS4gIFRoaXMgd2lsbCBtYWtlIGEgZ3JvdXAgbGlrZSB0aGUgZm9sbG93aW5nIGRpc2FwcGVhcgoJY29tcGxldGVseSBmcm9tIHRoZSBzdGF0dXNsaW5lIHdoZW4gbm9uZSBvZiB0aGUgZmxhZ3MgYXJlIHNldC4gPgoJCTpzZXQgc3RhdHVzbGluZT0uLi4lKFwgWyVNJVIlSF0lKS4uLgo8CglCZXdhcmUgdGhhdCBhbiBleHByZXNzaW9uIGlzIGV2YWx1YXRlZCBlYWNoIGFuZCBldmVyeSB0aW1lIHRoZSBzdGF0dXMKCWxpbmUgaXMgZGlzcGxheWVkLiAgVGhlIGN1cnJlbnQgYnVmZmVyIGFuZCBjdXJyZW50IHdpbmRvdyB3aWxsIGJlIHNldAoJdGVtcG9yYXJpbHkgdG8gdGhhdCBvZiB0aGUgd2luZG93IChhbmQgYnVmZmVyKSB3aG9zZSBzdGF0dXNsaW5lIGlzCgljdXJyZW50bHkgYmVpbmcgZHJhd24uICBUaGUgZXhwcmVzc2lvbiB3aWxsIGV2YWx1YXRlIGluIHRoaXMgY29udGV4dC4KCVRoZSB2YXJpYWJsZSAiYWN0dWFsX2N1cmJ1ZiIgaXMgc2V0IHRvIHRoZSAnYnVmbnIoKScgbnVtYmVyIG9mIHRoZQoJcmVhbCBjdXJyZW50IGJ1ZmZlci4gIFRoZSBleHByZXNzaW9uIGlzIGV2YWx1YXRlZCBpbiB0aGUgfHNhbmRib3h8LgoKCUlmIHRoZSBzdGF0dXNsaW5lIGlzIG5vdCB1cGRhdGVkIHdoZW4geW91IHdhbnQgaXQgKGUuZy4sIGFmdGVyIHNldHRpbmcKCWEgdmFyaWFibGUgdGhhdCdzIHVzZWQgaW4gYW4gZXhwcmVzc2lvbiksIHlvdSBjYW4gZm9yY2UgYW4gdXBkYXRlIGJ5CglzZXR0aW5nIGFuIG9wdGlvbiB3aXRob3V0IGNoYW5naW5nIGl0cyB2YWx1ZS4gIEV4YW1wbGU6ID4KCQk6bGV0ICZybyA9ICZybwoKPAlBIHJlc3VsdCBvZiBhbGwgZGlnaXRzIGlzIHJlZ2FyZGVkIGEgbnVtYmVyIGZvciBkaXNwbGF5IHB1cnBvc2VzLgoJT3RoZXJ3aXNlIHRoZSByZXN1bHQgaXMgdGFrZW4gYXMgZmxhZyB0ZXh0IGFuZCBhcHBsaWVkIHRvIHRoZSBydWxlcwoJZGVzY3JpYmVkIGFib3ZlLgoKCVdhdGNoIG91dCBmb3IgZXJyb3JzIGluIGV4cHJlc3Npb25zLiAgVGhleSBtYXkgcmVuZGVyIFZpbSB1bnVzYWJsZSEKCUlmIHlvdSBhcmUgc3R1Y2ssIGhvbGQgZG93biAnOicgb3IgJ1EnIHRvIGdldCBhIHByb21wdCwgdGhlbiBxdWl0IGFuZAoJZWRpdCB5b3VyIC52aW1yYyBvciB3aGF0ZXZlciB3aXRoICJ2aW0gLXUgTk9ORSIgdG8gZ2V0IGl0IHJpZ2h0LgoKCUV4YW1wbGVzOgoJRW11bGF0ZSBzdGFuZGFyZCBzdGF0dXMgbGluZSB3aXRoICdydWxlcicgc2V0ID4KCSAgOnNldCBzdGF0dXNsaW5lPSU8JWZcICVoJW0lciU9JS0xNC4oJWwsJWMlViUpXCAlUAo8CVNpbWlsYXIsIGJ1dCBhZGQgQVNDSUkgdmFsdWUgb2YgY2hhciB1bmRlciB0aGUgY3Vyc29yIChsaWtlICJnYSIpID4KCSAgOnNldCBzdGF0dXNsaW5lPSU8JWYlaCVtJXIlPSViXCAweCVCXCBcICVsLCVjJVZcICVQCjwJRGlzcGxheSBieXRlIGNvdW50IGFuZCBieXRlIHZhbHVlLCBtb2RpZmllZCBmbGFnIGluIHJlZC4gPgoJICA6c2V0IHN0YXR1c2xpbmU9JTwlZiU9XCBbJTEqJU0lKiVuJVIlSF1cICUtMTkoJTNsLCUwMmMlMDNWJSklTyclMDJiJwoJICA6aGkgVXNlcjEgdGVybT1pbnZlcnNlLGJvbGQgY3Rlcm09aW52ZXJzZSxib2xkIGN0ZXJtZmc9cmVkCjwJRGlzcGxheSBhICxHWiBmbGFnIGlmIGEgY29tcHJlc3NlZCBmaWxlIGlzIGxvYWRlZCA+CgkgIDpzZXQgc3RhdHVzbGluZT0uLi4lciV7VmFyRXhpc3RzKCdiOmd6ZmxhZycsJ1wgW0daXScpfSVoLi4uCjwJSW4gdGhlIHw6YXV0b2NtZHwnczogPgoJICA6bGV0IGI6Z3pmbGFnID0gMQo8CUFuZDogPgoJICA6dW5sZXQgYjpnemZsYWcKPAlBbmQgZGVmaW5lIHRoaXMgZnVuY3Rpb246ID4KCSAgOmZ1bmN0aW9uIFZhckV4aXN0cyh2YXIsIHZhbCkKCSAgOiAgICBpZiBleGlzdHMoYTp2YXIpIHwgcmV0dXJuIGE6dmFsIHwgZWxzZSB8IHJldHVybiAnJyB8IGVuZGlmCgkgIDplbmRmdW5jdGlvbgo8CgkJCQkJCSonc3VmZml4ZXMnKiAqJ3N1JyoKJ3N1ZmZpeGVzJyAnc3UnCQlzdHJpbmcJKGRlZmF1bHQgIi5iYWssfiwubywuaCwuaW5mbywuc3dwLC5vYmoiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCUZpbGVzIHdpdGggdGhlc2Ugc3VmZml4ZXMgZ2V0IGEgbG93ZXIgcHJpb3JpdHkgd2hlbiBtdWx0aXBsZSBmaWxlcwoJbWF0Y2ggYSB3aWxkY2FyZC4gIFNlZSB8c3VmZml4ZXN8LiAgQ29tbWFzIGNhbiBiZSB1c2VkIHRvIHNlcGFyYXRlIHRoZQoJc3VmZml4ZXMuICBTcGFjZXMgYWZ0ZXIgdGhlIGNvbW1hIGFyZSBpZ25vcmVkLiAgQSBkb3QgaXMgYWxzbyBzZWVuIGFzCgl0aGUgc3RhcnQgb2YgYSBzdWZmaXguICBUbyBhdm9pZCBhIGRvdCBvciBjb21tYSBiZWluZyByZWNvZ25pemVkIGFzIGEKCXNlcGFyYXRvciwgcHJlY2VkZSBpdCB3aXRoIGEgYmFja3NsYXNoIChzZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0CglpbmNsdWRpbmcgc3BhY2VzIGFuZCBiYWNrc2xhc2hlcykuCglTZWUgJ3dpbGRpZ25vcmUnIGZvciBjb21wbGV0ZWx5IGlnbm9yaW5nIGZpbGVzLgoJVGhlIHVzZSBvZiB8OnNldCs9fCBhbmQgfDpzZXQtPXwgaXMgcHJlZmVycmVkIHdoZW4gYWRkaW5nIG9yIHJlbW92aW5nCglzdWZmaXhlcyBmcm9tIHRoZSBsaXN0LiAgVGhpcyBhdm9pZHMgcHJvYmxlbXMgd2hlbiBhIGZ1dHVyZSB2ZXJzaW9uCgl1c2VzIGFub3RoZXIgZGVmYXVsdC4KCgkJCQkJCSonc3VmZml4ZXNhZGQnKiAqJ3N1YScqCidzdWZmaXhlc2FkZCcgJ3N1YScJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZQoJCQl8K2ZpbGVfaW5fcGF0aHwgZmVhdHVyZX0KCUNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIHN1ZmZpeGVzLCB3aGljaCBhcmUgdXNlZCB3aGVuIHNlYXJjaGluZyBmb3IgYQoJZmlsZSBmb3IgdGhlICJnZiIsICJbSSIsIGV0Yy4gY29tbWFuZHMuICBFeGFtcGxlOiA+CgkJOnNldCBzdWZmaXhlc2FkZD0uamF2YQo8CgkJCQkqJ3N3YXBmaWxlJyogKidzd2YnKiAqJ25vc3dhcGZpbGUnKiAqJ25vc3dmJyoKJ3N3YXBmaWxlJyAnc3dmJwlib29sZWFuIChkZWZhdWx0IG9uKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCVVzZSBhIHN3YXBmaWxlIGZvciB0aGUgYnVmZmVyLiAgVGhpcyBvcHRpb24gY2FuIGJlIHJlc2V0IHdoZW4gYQoJc3dhcGZpbGUgaXMgbm90IHdhbnRlZCBmb3IgYSBzcGVjaWZpYyBidWZmZXIuICBGb3IgZXhhbXBsZSwgd2l0aAoJY29uZmlkZW50aWFsIGluZm9ybWF0aW9uIHRoYXQgZXZlbiByb290IG11c3Qgbm90IGJlIGFibGUgdG8gYWNjZXNzLgoJQ2FyZWZ1bDogQWxsIHRleHQgd2lsbCBiZSBpbiBtZW1vcnk6CgkJLSBEb24ndCB1c2UgdGhpcyBmb3IgYmlnIGZpbGVzLgoJCS0gUmVjb3Zlcnkgd2lsbCBiZSBpbXBvc3NpYmxlIQoJQSBzd2FwZmlsZSB3aWxsIG9ubHkgYmUgcHJlc2VudCB3aGVuIHwndXBkYXRlY291bnQnfCBpcyBub24temVybyBhbmQKCSdzd2FwZmlsZScgaXMgc2V0LgoJV2hlbiAnc3dhcGZpbGUnIGlzIHJlc2V0LCB0aGUgc3dhcCBmaWxlIGZvciB0aGUgY3VycmVudCBidWZmZXIgaXMKCWltbWVkaWF0ZWx5IGRlbGV0ZWQuICBXaGVuICdzd2FwZmlsZScgaXMgc2V0LCBhbmQgJ3VwZGF0ZWNvdW50JyBpcwoJbm9uLXplcm8sIGEgc3dhcCBmaWxlIGlzIGltbWVkaWF0ZWx5IGNyZWF0ZWQuCglBbHNvIHNlZSB8c3dhcC1maWxlfCBhbmQgfCdzd2Fwc3luYyd8LgoKCVRoaXMgb3B0aW9uIGlzIHVzZWQgdG9nZXRoZXIgd2l0aCAnYnVmaGlkZGVuJyBhbmQgJ2J1ZnR5cGUnIHRvCglzcGVjaWZ5IHNwZWNpYWwga2luZHMgb2YgYnVmZmVycy4gICBTZWUgfHNwZWNpYWwtYnVmZmVyc3wuCgoJCQkJCQkqJ3N3YXBzeW5jJyogKidzd3MnKgonc3dhcHN5bmMnICdzd3MnCXN0cmluZwkoZGVmYXVsdCAiZnN5bmMiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVdoZW4gdGhpcyBvcHRpb24gaXMgbm90IGVtcHR5IGEgc3dhcCBmaWxlIGlzIHN5bmNlZCB0byBkaXNrIGFmdGVyCgl3cml0aW5nIHRvIGl0LiAgVGhpcyB0YWtlcyBzb21lIHRpbWUsIGVzcGVjaWFsbHkgb24gYnVzeSB1bml4IHN5c3RlbXMuCglXaGVuIHRoaXMgb3B0aW9uIGlzIGVtcHR5IHBhcnRzIG9mIHRoZSBzd2FwIGZpbGUgbWF5IGJlIGluIG1lbW9yeSBhbmQKCW5vdCB3cml0dGVuIHRvIGRpc2suICBXaGVuIHRoZSBzeXN0ZW0gY3Jhc2hlcyB5b3UgbWF5IGxvc2UgbW9yZSB3b3JrLgoJT24gVW5peCB0aGUgc3lzdGVtIGRvZXMgYSBzeW5jIG5vdyBhbmQgdGhlbiB3aXRob3V0IFZpbSBhc2tpbmcgZm9yIGl0LAoJc28gdGhlIGRpc2FkdmFudGFnZSBvZiBzZXR0aW5nIHRoaXMgb3B0aW9uIG9mZiBpcyBzbWFsbC4gIE9uIHNvbWUKCXN5c3RlbXMgdGhlIHN3YXAgZmlsZSB3aWxsIG5vdCBiZSB3cml0dGVuIGF0IGFsbC4gIEZvciBhIHVuaXggc3lzdGVtCglzZXR0aW5nIGl0IHRvICJzeW5jIiB3aWxsIHVzZSB0aGUgc3luYygpIGNhbGwgaW5zdGVhZCBvZiB0aGUgZGVmYXVsdAoJZnN5bmMoKSwgd2hpY2ggbWF5IHdvcmsgYmV0dGVyIG9uIHNvbWUgc3lzdGVtcy4KCVRoZSAnZnN5bmMnIG9wdGlvbiBpcyB1c2VkIGZvciB0aGUgYWN0dWFsIGZpbGUuCgoJCQkJCQkqJ3N3aXRjaGJ1ZicqIConc3diJyoKJ3N3aXRjaGJ1ZicgJ3N3YicJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVRoaXMgb3B0aW9uIGNvbnRyb2xzIHRoZSBiZWhhdmlvciB3aGVuIHN3aXRjaGluZyBiZXR3ZWVuIGJ1ZmZlcnMuCglQb3NzaWJsZSB2YWx1ZXMgKGNvbW1hIHNlcGFyYXRlZCBsaXN0KToKCSAgIHVzZW9wZW4JSWYgaW5jbHVkZWQsIGp1bXAgdG8gdGhlIGZpcnN0IG9wZW4gd2luZG93IHRoYXQKCQkJY29udGFpbnMgdGhlIHNwZWNpZmllZCBidWZmZXIgKGlmIHRoZXJlIGlzIG9uZSkuCgkJCU90aGVyd2lzZTogRG8gbm90IGV4YW1pbmUgb3RoZXIgd2luZG93cy4KCQkJVGhpcyBzZXR0aW5nIGlzIGNoZWNrZWQgd2l0aCB8cXVpY2tmaXh8IGNvbW1hbmRzLCB3aGVuCgkJCWp1bXBpbmcgdG8gZXJyb3JzICgiOmNjIiwgIjpjbiIsICJjcCIsIGV0Yy4pLiAgSXQgaXMKCQkJYWxzbyB1c2VkIGluIGFsbCBidWZmZXIgcmVsYXRlZCBzcGxpdCBjb21tYW5kcywgZm9yCgkJCWV4YW1wbGUgIjpzYnVmZmVyIiwgIjpzYm5leHQiLCBvciAiOnNicmV3aW5kIi4KCSAgIHNwbGl0CUlmIGluY2x1ZGVkLCBzcGxpdCB0aGUgY3VycmVudCB3aW5kb3cgYmVmb3JlIGxvYWRpbmcKCQkJYSBidWZmZXIuICBPdGhlcndpc2U6IGRvIG5vdCBzcGxpdCwgdXNlIGN1cnJlbnQgd2luZG93LgoJCQlTdXBwb3J0ZWQgaW4gfHF1aWNrZml4fCBjb21tYW5kcyB0aGF0IGRpc3BsYXkgZXJyb3JzLgoKCQkJCQkJKidzeW50YXgnKiAqJ3N5bicqCidzeW50YXgnICdzeW4nCQlzdHJpbmcJKGRlZmF1bHQgZW1wdHkpCgkJCWxvY2FsIHRvIGJ1ZmZlcgoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrc3ludGF4fAoJCQlmZWF0dXJlfQoJV2hlbiB0aGlzIG9wdGlvbiBpcyBzZXQsIHRoZSBzeW50YXggd2l0aCB0aGlzIG5hbWUgaXMgbG9hZGVkLCB1bmxlc3MKCXN5bnRheCBoaWdobGlnaHRpbmcgaGFzIGJlZW4gc3dpdGNoZWQgb2ZmIHdpdGggIjpzeW50YXggb2ZmIi4KCU90aGVyd2lzZSB0aGlzIG9wdGlvbiBkb2VzIG5vdCBhbHdheXMgcmVmbGVjdCB0aGUgY3VycmVudCBzeW50YXggKHRoZQoJYjpjdXJyZW50X3N5bnRheCB2YXJpYWJsZSBkb2VzKS4KCVRoaXMgb3B0aW9uIGlzIG1vc3QgdXNlZnVsIGluIGEgbW9kZWxpbmUsIGZvciBhIGZpbGUgd2hpY2ggc3ludGF4IGlzCglub3QgYXV0b21hdGljYWxseSByZWNvZ25pemVkLiAgRXhhbXBsZSwgZm9yIGluIGFuIElETCBmaWxlOiA+CgkJLyogdmltOiBzZXQgc3ludGF4PWlkbCA6ICovCjwJVG8gc3dpdGNoIG9mZiBzeW50YXggaGlnaGxpZ2h0aW5nIGZvciB0aGUgY3VycmVudCBmaWxlLCB1c2U6ID4KCQk6c2V0IHN5bnRheD1PRkYKPAlUbyBzd2l0Y2ggc3ludGF4IGhpZ2hsaWdodGluZyBvbiBhY2NvcmRpbmcgdG8gdGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhlCgknZmlsZXR5cGUnIG9wdGlvbjogPgoJCTpzZXQgc3ludGF4PU9OCjwJV2hhdCBhY3R1YWxseSBoYXBwZW5zIHdoZW4gc2V0dGluZyB0aGUgJ3N5bnRheCcgb3B0aW9uIGlzIHRoYXQgdGhlCglTeW50YXggYXV0b2NvbW1hbmQgZXZlbnQgaXMgdHJpZ2dlcmVkIHdpdGggdGhlIHZhbHVlIGFzIGFyZ3VtZW50LgoJVGhpcyBvcHRpb24gaXMgbm90IGNvcGllZCB0byBhbm90aGVyIGJ1ZmZlciwgaW5kZXBlbmRlbnQgb2YgdGhlICdzJyBvcgoJJ1MnIGZsYWcgaW4gJ2Nwb3B0aW9ucycuCglPbmx5IG5vcm1hbCBmaWxlIG5hbWUgY2hhcmFjdGVycyBjYW4gYmUgdXNlZCwgIi9cKj9bfDw+IiBhcmUgaWxsZWdhbC4KCgkJCQkJKid0YWJzdG9wJyogKid0cycqCid0YWJzdG9wJyAndHMnCQludW1iZXIJKGRlZmF1bHQgOCkKCQkJbG9jYWwgdG8gYnVmZmVyCglOdW1iZXIgb2Ygc3BhY2VzIHRoYXQgYSA8VGFiPiBpbiB0aGUgZmlsZSBjb3VudHMgZm9yLiAgQWxzbyBzZWUKCXw6cmV0YWJ8IGNvbW1hbmQsIGFuZCAnc29mdHRhYnN0b3AnIG9wdGlvbi4KCglOb3RlOiBTZXR0aW5nICd0YWJzdG9wJyB0byBhbnkgb3RoZXIgdmFsdWUgdGhhbiA4IGNhbiBtYWtlIHlvdXIgZmlsZQoJYXBwZWFyIHdyb25nIGluIG1hbnkgcGxhY2VzIChlLmcuLCB3aGVuIHByaW50aW5nIGl0KS4KCglUaGVyZSBhcmUgZm91ciBtYWluIHdheXMgdG8gdXNlIHRhYnMgaW4gVmltOgoJMS4gQWx3YXlzIGtlZXAgJ3RhYnN0b3AnIGF0IDgsIHNldCAnc29mdHRhYnN0b3AnIGFuZCAnc2hpZnR3aWR0aCcgdG8gNAoJICAgKG9yIDMgb3Igd2hhdGV2ZXIgeW91IHByZWZlcikgYW5kIHVzZSAnbm9leHBhbmR0YWInLiAgVGhlbiBWaW0KCSAgIHdpbGwgdXNlIGEgbWl4IG9mIHRhYnMgYW5kIHNwYWNlcywgYnV0IHR5cGluZyBUYWIgYW5kIEJTIHdpbGwKCSAgIGJlaGF2ZSBsaWtlIGEgdGFiIGFwcGVhcnMgZXZlcnkgNCAob3IgMykgY2hhcmFjdGVycy4KCTIuIFNldCAndGFic3RvcCcgYW5kICdzaGlmdHdpZHRoJyB0byB3aGF0ZXZlciB5b3UgcHJlZmVyIGFuZCB1c2UKCSAgICdleHBhbmR0YWInLiAgVGhpcyB3YXkgeW91IHdpbGwgYWx3YXlzIGluc2VydCBzcGFjZXMuICBUaGUKCSAgIGZvcm1hdHRpbmcgd2lsbCBuZXZlciBiZSBtZXNzZWQgdXAgd2hlbiAndGFic3RvcCcgaXMgY2hhbmdlZC4KCTMuIFNldCAndGFic3RvcCcgYW5kICdzaGlmdHdpZHRoJyB0byB3aGF0ZXZlciB5b3UgcHJlZmVyIGFuZCB1c2UgYQoJICAgfG1vZGVsaW5lfCB0byBzZXQgdGhlc2UgdmFsdWVzIHdoZW4gZWRpdGluZyB0aGUgZmlsZSBhZ2Fpbi4gIE9ubHkKCSAgIHdvcmtzIHdoZW4gdXNpbmcgVmltIHRvIGVkaXQgdGhlIGZpbGUuCgk0LiBBbHdheXMgc2V0ICd0YWJzdG9wJyBhbmQgJ3NoaWZ0d2lkdGgnIHRvIHRoZSBzYW1lIHZhbHVlLCBhbmQKCSAgICdub2V4cGFuZHRhYicuICBUaGlzIHNob3VsZCB0aGVuIHdvcmsgKGZvciBpbml0aWFsIGluZGVudHMgb25seSkKCSAgIGZvciBhbnkgdGFic3RvcCBzZXR0aW5nIHRoYXQgcGVvcGxlIHVzZS4gIEl0IG1pZ2h0IGJlIG5pY2UgdG8gaGF2ZQoJICAgdGFicyBhZnRlciB0aGUgZmlyc3Qgbm9uLWJsYW5rIGluc2VydGVkIGFzIHNwYWNlcyBpZiB5b3UgZG8gdGhpcwoJICAgdGhvdWdoLiAgT3RoZXJ3aXNlIGFsaWduZWQgY29tbWVudHMgd2lsbCBiZSB3cm9uZyB3aGVuICd0YWJzdG9wJyBpcwoJICAgY2hhbmdlZC4KCgkJCSondGFnYnNlYXJjaCcqICondGJzJyogKidub3RhZ2JzZWFyY2gnKiAqJ25vdGJzJyoKJ3RhZ2JzZWFyY2gnICd0YnMnCWJvb2xlYW4JKGRlZmF1bHQgb24pCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiBzZWFyY2hpbmcgZm9yIGEgdGFnIChlLmcuLCBmb3IgdGhlIHw6dGF8IGNvbW1hbmQpLCBWaW0gY2FuIGVpdGhlcgoJdXNlIGEgYmluYXJ5IHNlYXJjaCBvciBhIGxpbmVhciBzZWFyY2ggaW4gYSB0YWdzIGZpbGUuICBCaW5hcnkKCXNlYXJjaGluZyBtYWtlcyBzZWFyY2hpbmcgZm9yIGEgdGFnIGEgTE9UIGZhc3RlciwgYnV0IGEgbGluZWFyIHNlYXJjaAoJd2lsbCBmaW5kIG1vcmUgdGFncyBpZiB0aGUgdGFncyBmaWxlIHdhc24ndCBwcm9wZXJseSBzb3J0ZWQuCglWaW0gbm9ybWFsbHkgYXNzdW1lcyB0aGF0IHlvdXIgdGFncyBmaWxlcyBhcmUgc29ydGVkLCBvciBpbmRpY2F0ZSB0aGF0Cgl0aGV5IGFyZSBub3Qgc29ydGVkLiAgT25seSB3aGVuIHRoaXMgaXMgbm90IHRoZSBjYXNlIGRvZXMgdGhlCgkndGFnYnNlYXJjaCcgb3B0aW9uIG5lZWQgdG8gYmUgc3dpdGNoZWQgb2ZmLgoKCVdoZW4gJ3RhZ2JzZWFyY2gnIGlzIG9uLCBiaW5hcnkgc2VhcmNoaW5nIGlzIGZpcnN0IHVzZWQgaW4gdGhlIHRhZ3MKCWZpbGVzLiAgSW4gY2VydGFpbiBzaXR1YXRpb25zLCBWaW0gd2lsbCBkbyBhIGxpbmVhciBzZWFyY2ggaW5zdGVhZCBmb3IKCWNlcnRhaW4gZmlsZXMsIG9yIHJldHJ5IGFsbCBmaWxlcyB3aXRoIGEgbGluZWFyIHNlYXJjaC4gIFdoZW4KCSd0YWdic2VhcmNoJyBpcyBvZmYsIG9ubHkgYSBsaW5lYXIgc2VhcmNoIGlzIGRvbmUuCgoJTGluZWFyIHNlYXJjaGluZyBpcyBkb25lIGFueXdheSwgZm9yIG9uZSBmaWxlLCB3aGVuIFZpbSBmaW5kcyBhIGxpbmUKCWF0IHRoZSBzdGFydCBvZiB0aGUgZmlsZSBpbmRpY2F0aW5nIHRoYXQgaXQncyBub3Qgc29ydGVkOiA+CiAgICFfVEFHX0ZJTEVfU09SVEVECTAJL3NvbWUgY29tbWFuZC8KPAlbVGhlIHdoaXRlc3BhY2UgYmVmb3JlIGFuZCBhZnRlciB0aGUgJzAnIG11c3QgYmUgYSBzaW5nbGUgPFRhYj5dCgoJV2hlbiBhIGJpbmFyeSBzZWFyY2ggd2FzIGRvbmUgYW5kIG5vIG1hdGNoIHdhcyBmb3VuZCBpbiBhbnkgb2YgdGhlCglmaWxlcyBsaXN0ZWQgaW4gJ3RhZ3MnLCBhbmQgJ2lnbm9yZWNhc2UnIGlzIHNldCBvciBhIHBhdHRlcm4gaXMgdXNlZAoJaW5zdGVhZCBvZiBhIG5vcm1hbCB0YWcgbmFtZSwgYSByZXRyeSBpcyBkb25lIHdpdGggYSBsaW5lYXIgc2VhcmNoLgoJVGFncyBpbiB1bnNvcnRlZCB0YWdzIGZpbGVzLCBhbmQgbWF0Y2hlcyB3aXRoIGRpZmZlcmVudCBjYXNlIHdpbGwgb25seQoJYmUgZm91bmQgaW4gdGhlIHJldHJ5LgoKCUlmIGEgdGFnIGZpbGUgaW5kaWNhdGVzIHRoYXQgaXQgaXMgY2FzZS1mb2xkIHNvcnRlZCwgdGhlIHNlY29uZCwKCWxpbmVhciBzZWFyY2ggY2FuIGJlIGF2b2lkZWQgZm9yIHRoZSAnaWdub3JlY2FzZScgY2FzZS4gIFVzZSBhIHZhbHVlCglvZiAnMicgaW4gdGhlICIhX1RBR19GSUxFX1NPUlRFRCIgbGluZSBmb3IgdGhpcy4gIEEgdGFnIGZpbGUgY2FuIGJlCgljYXNlLWZvbGQgc29ydGVkIHdpdGggdGhlIC1mIHN3aXRjaCB0byAic29ydCIgaW4gbW9zdCB1bmljZXMsIGFzIGluCgl0aGUgY29tbWFuZDogInNvcnQgLWYgLW8gdGFncyB0YWdzIi4gIEZvciAiRXh1YmVyYW50IGN0YWdzIiB2ZXJzaW9uCgk1LjMgb3IgaGlnaGVyIHRoZSAtZiBvciAtLWZvbGQtY2FzZS1zb3J0IHN3aXRjaCBjYW4gYmUgdXNlZCBmb3IgdGhpcwoJYXMgd2VsbC4gIE5vdGUgdGhhdCBjYXNlIG11c3QgYmUgZm9sZGVkIHRvIHVwcGVyY2FzZSBmb3IgdGhpcyB0byB3b3JrLgoKCVdoZW4gJ3RhZ2JzZWFyY2gnIGlzIG9mZiwgdGFncyBzZWFyY2hpbmcgaXMgc2xvd2VyIHdoZW4gYSBmdWxsIG1hdGNoCglleGlzdHMsIGJ1dCBmYXN0ZXIgd2hlbiBubyBmdWxsIG1hdGNoIGV4aXN0cy4gIFRhZ3MgaW4gdW5zb3J0ZWQgdGFncwoJZmlsZXMgbWF5IG9ubHkgYmUgZm91bmQgd2l0aCAndGFnYnNlYXJjaCcgb2ZmLgoJV2hlbiB0aGUgdGFncyBmaWxlIGlzIG5vdCBzb3J0ZWQsIG9yIHNvcnRlZCBpbiBhIHdyb25nIHdheSAobm90IG9uCglBU0NJSSBieXRlIHZhbHVlKSwgJ3RhZ2JzZWFyY2gnIHNob3VsZCBiZSBvZmYsIG9yIHRoZSBsaW5lIGdpdmVuIGFib3ZlCgltdXN0IGJlIGluY2x1ZGVkIGluIHRoZSB0YWdzIGZpbGUuCglUaGlzIG9wdGlvbiBkb2Vzbid0IGFmZmVjdCBjb21tYW5kcyB0aGF0IGZpbmQgYWxsIG1hdGNoaW5nIHRhZ3MgKGUuZy4sCgljb21tYW5kLWxpbmUgY29tcGxldGlvbiBhbmQgIjpoZWxwIikuCgl7Vmk6IGFsd2F5cyB1c2VzIGJpbmFyeSBzZWFyY2ggaW4gc29tZSB2ZXJzaW9uc30KCgkJCQkJCSondGFnbGVuZ3RoJyogKid0bCcqCid0YWdsZW5ndGgnICd0bCcJbnVtYmVyCShkZWZhdWx0IDApCgkJCWdsb2JhbAoJSWYgbm9uLXplcm8sIHRhZ3MgYXJlIHNpZ25pZmljYW50IHVwIHRvIHRoaXMgbnVtYmVyIG9mIGNoYXJhY3RlcnMuCgoJCQkqJ3RhZ3JlbGF0aXZlJyogKid0cicqIConbm90YWdyZWxhdGl2ZScqIConbm90cicqCid0YWdyZWxhdGl2ZScgJ3RyJwlib29sZWFuCShWaW0gZGVmYXVsdDogb24sIFZpIGRlZmF1bHQ6IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglJZiBvbiBhbmQgdXNpbmcgYSB0YWcgZmlsZSBpbiBhbm90aGVyIGRpcmVjdG9yeSwgZmlsZSBuYW1lcyBpbiB0aGF0Cgl0YWcgZmlsZSBhcmUgcmVsYXRpdmUgdG8gdGhlIGRpcmVjdG9yeSB3aGVyZSB0aGUgdGFnIGZpbGUgaXMuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyBzZXQgdG8gdGhlIFZpIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMKCXNldCBhbmQgdG8gdGhlIFZpbSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzIHJlc2V0LgoKCQkJCQkJKid0YWdzJyogKid0YWcnKiAqRTQzMyoKJ3RhZ3MnICd0YWcnCQlzdHJpbmcJKGRlZmF1bHQgIi4vdGFncyx0YWdzIiwgd2hlbiBjb21waWxlZCB3aXRoCgkJCQl8K2VtYWNzX3RhZ3N8OiAiLi90YWdzLC4vVEFHUyx0YWdzLFRBR1MiKQoJCQlnbG9iYWwgb3IgbG9jYWwgdG8gYnVmZmVyIHxnbG9iYWwtbG9jYWx8CglGaWxlbmFtZXMgZm9yIHRoZSB0YWcgY29tbWFuZCwgc2VwYXJhdGVkIGJ5IHNwYWNlcyBvciBjb21tYXMuICBUbwoJaW5jbHVkZSBhIHNwYWNlIG9yIGNvbW1hIGluIGEgZmlsZSBuYW1lLCBwcmVjZWRlIGl0IHdpdGggYSBiYWNrc2xhc2gKCShzZWUgfG9wdGlvbi1iYWNrc2xhc2h8IGFib3V0IGluY2x1ZGluZyBzcGFjZXMgYW5kIGJhY2tzbGFzaGVzKS4KCVdoZW4gYSBmaWxlIG5hbWUgc3RhcnRzIHdpdGggIi4vIiwgdGhlICcuJyBpcyByZXBsYWNlZCB3aXRoIHRoZSBwYXRoCglvZiB0aGUgY3VycmVudCBmaWxlLiAgQnV0IG9ubHkgd2hlbiB0aGUgJ2QnIGZsYWcgaXMgbm90IGluY2x1ZGVkIGluCgknY3BvcHRpb25zJy4gIEVudmlyb25tZW50IHZhcmlhYmxlcyBhcmUgZXhwYW5kZWQgfDpzZXRfZW52fC4gIEFsc28gc2VlCgl8dGFncy1vcHRpb258LgoJIioiLCAiKioiIGFuZCBvdGhlciB3aWxkY2FyZHMgY2FuIGJlIHVzZWQgdG8gc2VhcmNoIGZvciB0YWdzIGZpbGVzIGluCglhIGRpcmVjdG9yeSB0cmVlLiAgU2VlIHxmaWxlLXNlYXJjaGluZ3wuICB7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkCgl3aXRob3V0IHRoZSB8K3BhdGhfZXh0cmF8IGZlYXR1cmV9CglJZiBWaW0gd2FzIGNvbXBpbGVkIHdpdGggdGhlIHwrZW1hY3NfdGFnc3wgZmVhdHVyZSwgRW1hY3Mtc3R5bGUgdGFnCglmaWxlcyBhcmUgYWxzbyBzdXBwb3J0ZWQuICBUaGV5IGFyZSBhdXRvbWF0aWNhbGx5IHJlY29nbml6ZWQuICBUaGUKCWRlZmF1bHQgdmFsdWUgYmVjb21lcyAiLi90YWdzLC4vVEFHUyx0YWdzLFRBR1MiLCB1bmxlc3MgY2FzZQoJZGlmZmVyZW5jZXMgYXJlIGlnbm9yZWQgKE1TLVdpbmRvd3MpLiAgfGVtYWNzLXRhZ3N8CglUaGUgdXNlIG9mIHw6c2V0Kz18IGFuZCB8OnNldC09fCBpcyBwcmVmZXJyZWQgd2hlbiBhZGRpbmcgb3IgcmVtb3ZpbmcKCWZpbGUgbmFtZXMgZnJvbSB0aGUgbGlzdC4gIFRoaXMgYXZvaWRzIHByb2JsZW1zIHdoZW4gYSBmdXR1cmUgdmVyc2lvbgoJdXNlcyBhbm90aGVyIGRlZmF1bHQuCgl7Vmk6IGRlZmF1bHQgaXMgInRhZ3MgL3Vzci9saWIvdGFncyJ9CgoJCQkJKid0YWdzdGFjaycqICondGdzdCcqIConbm90YWdzdGFjaycqIConbm90Z3N0JyoKJ3RhZ3N0YWNrJyAndGdzdCcJYm9vbGVhbgkoZGVmYXVsdCBvbikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gYWxsIHZlcnNpb25zIG9mIFZpfQoJV2hlbiBvbiwgdGhlIHx0YWdzdGFja3wgaXMgdXNlZCBub3JtYWxseS4gIFdoZW4gb2ZmLCBhICI6dGFnIiBvcgoJIjp0c2VsZWN0IiBjb21tYW5kIHdpdGggYW4gYXJndW1lbnQgd2lsbCBub3QgcHVzaCB0aGUgdGFnIG9udG8gdGhlCgl0YWdzdGFjay4gIEEgZm9sbG93aW5nICI6dGFnIiB3aXRob3V0IGFuIGFyZ3VtZW50LCBhICI6cG9wIiBjb21tYW5kIG9yCglhbnkgb3RoZXIgY29tbWFuZCB0aGF0IHVzZXMgdGhlIHRhZ3N0YWNrIHdpbGwgdXNlIHRoZSB1bm1vZGlmaWVkCgl0YWdzdGFjaywgYnV0IGRvZXMgY2hhbmdlIHRoZSBwb2ludGVyIHRvIHRoZSBhY3RpdmUgZW50cnkuCglSZXNldHRpbmcgdGhpcyBvcHRpb24gaXMgdXNlZnVsIHdoZW4gdXNpbmcgYSAiOnRhZyIgY29tbWFuZCBpbiBhCgltYXBwaW5nIHdoaWNoIHNob3VsZCBub3QgY2hhbmdlIHRoZSB0YWdzdGFjay4KCgkJCQkJCSondGVybScqICpFNTI5KiAqRTUzMCogKkU1MzEqCid0ZXJtJwkJCXN0cmluZwkoZGVmYXVsdCBpcyAkVEVSTSwgaWYgdGhhdCBmYWlsczoKCQkJCSAgICAgIGluIHRoZSBHVUk6ICJidWlsdGluX2d1aSIKCQkJCQlvbiBBbWlnYTogImFtaWdhIgoJCQkJCSBvbiBCZU9TOiAiYmVvcy1hbnNpIgoJCQkJCSAgb24gTWFjOiAibWFjLWFuc2kiCgkJCQkJIG9uIE1pTlQ6ICJ2dDUyIgoJCQkJICAgICAgIG9uIE1TLURPUzogInBjdGVybSIKCQkJCQkgb24gT1MvMjogIm9zMmFuc2kiCgkJCQkJIG9uIFVuaXg6ICJhbnNpIgoJCQkJCSAgb24gVk1TOiAiYW5zaSIKCQkJCSAgICAgICBvbiBXaW4gMzI6ICJ3aW4zMiIpCgkJCWdsb2JhbAoJTmFtZSBvZiB0aGUgdGVybWluYWwuICBVc2VkIGZvciBjaG9vc2luZyB0aGUgdGVybWluYWwgY29udHJvbAoJY2hhcmFjdGVycy4gIEVudmlyb25tZW50IHZhcmlhYmxlcyBhcmUgZXhwYW5kZWQgfDpzZXRfZW52fC4KCUZvciBleGFtcGxlOiA+CgkJOnNldCB0ZXJtPSRURVJNCjwJU2VlIHx0ZXJtY2FwfC4KCgkJCQkJCSondGVybWJpZGknKiAqJ3RiaWRpJyoKCQkJCQkJKidub3Rlcm1iaWRpJyogKidub3RiaWRpJyoKJ3Rlcm1iaWRpJyAndGJpZGknCWJvb2xlYW4gKGRlZmF1bHQgb2ZmLCBvbiBmb3IgIm1sdGVybSIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K2FyYWJpY3wKCQkJZmVhdHVyZX0KCVRoZSB0ZXJtaW5hbCBpcyBpbiBjaGFyZ2Ugb2YgQmktZGlyZWN0aW9uYWxpdHkgb2YgdGV4dCAoYXMgc3BlY2lmaWVkCglieSBVbmljb2RlKS4gIFRoZSB0ZXJtaW5hbCBpcyBhbHNvIGV4cGVjdGVkIHRvIGRvIHRoZSByZXF1aXJlZCBzaGFwaW5nCgl0aGF0IHNvbWUgbGFuZ3VhZ2VzIChzdWNoIGFzIEFyYWJpYykgcmVxdWlyZS4KCVNldHRpbmcgdGhpcyBvcHRpb24gaW1wbGllcyB0aGF0ICdyaWdodGxlZnQnIHdpbGwgbm90IGJlIHNldCB3aGVuCgknYXJhYmljJyBpcyBzZXQgYW5kIHRoZSB2YWx1ZSBvZiAnYXJhYmljc2hhcGUnIHdpbGwgYmUgaWdub3JlZC4KCU5vdGUgdGhhdCBzZXR0aW5nICd0ZXJtYmlkaScgaGFzIHRoZSBpbW1lZGlhdGUgZWZmZWN0IHRoYXQKCSdhcmFiaWNzaGFwZScgaXMgaWdub3JlZCwgYnV0ICdyaWdodGxlZnQnIGlzbid0IGNoYW5nZWQgYXV0b21hdGljYWxseS4KCVRoaXMgb3B0aW9uIGlzIHJlc2V0IHdoZW4gdGhlIEdVSSBpcyBzdGFydGVkLgoJRm9yIGZ1cnRoZXIgZGV0YWlscyBzZWUgfGFyYWJpYy50eHR8LgoKCQkJCQkqJ3Rlcm1lbmNvZGluZycqICondGVuYycqCid0ZXJtZW5jb2RpbmcnICd0ZW5jJwlzdHJpbmcJKGRlZmF1bHQgIiI7IHdpdGggR1RLKyAyIEdVSTogInV0Zi04Ijsgd2l0aAoJCQkJCQkgICAgTWFjaW50b3NoIEdVSTogIm1hY3JvbWFuIikKCQkJZ2xvYmFsCgkJCXtvbmx5IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrbXVsdGlfYnl0ZXwKCQkJZmVhdHVyZX0KCQkJe25vdCBpbiBWaX0KCUVuY29kaW5nIHVzZWQgZm9yIHRoZSB0ZXJtaW5hbC4gIFRoaXMgc3BlY2lmaWVzIHdoYXQgY2hhcmFjdGVyCgllbmNvZGluZyB0aGUga2V5Ym9hcmQgcHJvZHVjZXMgYW5kIHRoZSBkaXNwbGF5IHdpbGwgdW5kZXJzdGFuZC4gIEZvcgoJdGhlIEdVSSBpdCBvbmx5IGFwcGxpZXMgdG8gdGhlIGtleWJvYXJkICgnZW5jb2RpbmcnIGlzIHVzZWQgZm9yIHRoZQoJZGlzcGxheSkuCglJbiB0aGUgV2luMzIgY29uc29sZSB2ZXJzaW9uIHRoZSBkZWZhdWx0IHZhbHVlIGlzIHRoZSBjb25zb2xlIGNvZGVwYWdlCgl3aGVuIGl0IGRpZmZlcnMgZnJvbSB0aGUgQU5TSSBjb2RlcGFnZS4KCQkJCQkJCQkqRTYxNyoKCU5vdGU6IFRoaXMgZG9lcyBub3QgYXBwbHkgdG8gdGhlIEdUSysgMiBHVUkuICBBZnRlciB0aGUgR1VJIGhhcyBiZWVuCglzdWNjZXNzZnVsbHkgaW5pdGlhbGl6ZWQsICd0ZXJtZW5jb2RpbmcnIGlzIGZvcmNpYmx5IHNldCB0byAidXRmLTgiLgoJQW55IGF0dGVtcHRzIHRvIHNldCBhIGRpZmZlcmVudCB2YWx1ZSB3aWxsIGJlIHJlamVjdGVkLCBhbmQgYW4gZXJyb3IKCW1lc3NhZ2UgaXMgc2hvd24uCglGb3IgdGhlIFdpbjMyIEdVSSAndGVybWVuY29kaW5nJyBpcyBub3QgdXNlZCBmb3IgdHlwZWQgY2hhcmFjdGVycywKCWJlY2F1c2UgdGhlIFdpbjMyIHN5c3RlbSBhbHdheXMgcGFzc2VzIFVuaWNvZGUgY2hhcmFjdGVycy4KCVdoZW4gZW1wdHksIHRoZSBzYW1lIGVuY29kaW5nIGlzIHVzZWQgYXMgZm9yIHRoZSAnZW5jb2RpbmcnIG9wdGlvbi4KCVRoaXMgaXMgdGhlIG5vcm1hbCB2YWx1ZS4KCU5vdCBhbGwgY29tYmluYXRpb25zIGZvciAndGVybWVuY29kaW5nJyBhbmQgJ2VuY29kaW5nJyBhcmUgdmFsaWQuICBTZWUKCXxlbmNvZGluZy10YWJsZXwuCglUaGUgdmFsdWUgZm9yIHRoaXMgb3B0aW9uIG11c3QgYmUgc3VwcG9ydGVkIGJ5IGludGVybmFsIGNvbnZlcnNpb25zIG9yCglpY29udigpLiAgV2hlbiB0aGlzIGlzIG5vdCBwb3NzaWJsZSBubyBjb252ZXJzaW9uIHdpbGwgYmUgZG9uZSBhbmQgeW91Cgl3aWxsIHByb2JhYmx5IGV4cGVyaWVuY2UgcHJvYmxlbXMgd2l0aCBub24tQVNDSUkgY2hhcmFjdGVycy4KCUV4YW1wbGU6IFlvdSBhcmUgd29ya2luZyB3aXRoIHRoZSBsb2NhbGUgc2V0IHRvIGV1Yy1qcCAoSmFwYW5lc2UpIGFuZAoJd2FudCB0byBlZGl0IGEgVVRGLTggZmlsZTogPgoJCTpsZXQgJnRlcm1lbmNvZGluZyA9ICZlbmNvZGluZwoJCTpzZXQgZW5jb2Rpbmc9dXRmLTgKPAlZb3UgbmVlZCB0byBkbyB0aGlzIHdoZW4geW91ciBzeXN0ZW0gaGFzIG5vIGxvY2FsZSBzdXBwb3J0IGZvciBVVEYtOC4KCgkJCQkJCSondGVyc2UnKiAqJ25vdGVyc2UnKgondGVyc2UnCQkJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJV2hlbiBzZXQ6IEFkZCAncycgZmxhZyB0byAnc2hvcnRtZXNzJyBvcHRpb24gKHRoaXMgbWFrZXMgdGhlIG1lc3NhZ2UKCWZvciBhIHNlYXJjaCB0aGF0IGhpdHMgdGhlIHN0YXJ0IG9yIGVuZCBvZiB0aGUgZmlsZSBub3QgYmVpbmcKCWRpc3BsYXllZCkuICBXaGVuIHJlc2V0OiBSZW1vdmUgJ3MnIGZsYWcgZnJvbSAnc2hvcnRtZXNzJyBvcHRpb24uICB7VmkKCXNob3J0ZW5zIGEgbG90IG9mIG1lc3NhZ2VzfQoKCQkJCSAgICondGV4dGF1dG8nKiAqJ3RhJyogKidub3RleHRhdXRvJyogKidub3RhJyoKJ3RleHRhdXRvJyAndGEnCQlib29sZWFuCShWaW0gZGVmYXVsdDogb24sIFZpIGRlZmF1bHQ6IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglUaGlzIG9wdGlvbiBpcyBvYnNvbGV0ZS4gIFVzZSAnZmlsZWZvcm1hdHMnLgoJRm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5LCB3aGVuICd0ZXh0YXV0bycgaXMgc2V0LCAnZmlsZWZvcm1hdHMnIGlzCglzZXQgdG8gdGhlIGRlZmF1bHQgdmFsdWUgZm9yIHRoZSBjdXJyZW50IHN5c3RlbS4gIFdoZW4gJ3RleHRhdXRvJyBpcwoJcmVzZXQsICdmaWxlZm9ybWF0cycgaXMgbWFkZSBlbXB0eS4KCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHNldCB0byB0aGUgVmkgZGVmYXVsdCB2YWx1ZSB3aGVuICdjb21wYXRpYmxlJyBpcwoJc2V0IGFuZCB0byB0aGUgVmltIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMgcmVzZXQuCgoJCQkJICAgKid0ZXh0bW9kZScqICondHgnKiAqJ25vdGV4dG1vZGUnKiAqJ25vdHgnKgondGV4dG1vZGUnICd0eCcJCWJvb2xlYW4JKE1TLURPUywgV2luMzIgYW5kIE9TLzI6IGRlZmF1bHQgb24sCgkJCQkgb3RoZXJzOiBkZWZhdWx0IG9mZikKCQkJbG9jYWwgdG8gYnVmZmVyCgkJCXtub3QgaW4gVml9CglUaGlzIG9wdGlvbiBpcyBvYnNvbGV0ZS4gIFVzZSAnZmlsZWZvcm1hdCcuCglGb3IgYmFja3dhcmRzIGNvbXBhdGliaWxpdHksIHdoZW4gJ3RleHRtb2RlJyBpcyBzZXQsICdmaWxlZm9ybWF0JyBpcwoJc2V0IHRvICJkb3MiLiAgV2hlbiAndGV4dG1vZGUnIGlzIHJlc2V0LCAnZmlsZWZvcm1hdCcgaXMgc2V0IHRvCgkidW5peCIuCgoJCQkJCQkqJ3RleHR3aWR0aCcqICondHcnKgondGV4dHdpZHRoJyAndHcnCW51bWJlcgkoZGVmYXVsdCAwKQoJCQlsb2NhbCB0byBidWZmZXIKCQkJe25vdCBpbiBWaX0KCU1heGltdW0gd2lkdGggb2YgdGV4dCB0aGF0IGlzIGJlaW5nIGluc2VydGVkLiAgQSBsb25nZXIgbGluZSB3aWxsIGJlCglicm9rZW4gYWZ0ZXIgd2hpdGUgc3BhY2UgdG8gZ2V0IHRoaXMgd2lkdGguICBBIHplcm8gdmFsdWUgZGlzYWJsZXMKCXRoaXMuICAndGV4dHdpZHRoJyBpcyBzZXQgdG8gMCB3aGVuIHRoZSAncGFzdGUnIG9wdGlvbiBpcyBzZXQuICBXaGVuCgkndGV4dHdpZHRoJyBpcyB6ZXJvLCAnd3JhcG1hcmdpbicgbWF5IGJlIHVzZWQuICBTZWUgYWxzbwoJJ2Zvcm1hdG9wdGlvbnMnIGFuZCB8aW5zLXRleHR3aWR0aHwuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyBzZXQgdG8gMCB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkJCQkqJ3RoZXNhdXJ1cycqICondHNyJyoKJ3RoZXNhdXJ1cycgJ3RzcicJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwgb3IgbG9jYWwgdG8gYnVmZmVyIHxnbG9iYWwtbG9jYWx8CgkJCXtub3QgaW4gVml9CglMaXN0IG9mIGZpbGUgbmFtZXMsIHNlcGFyYXRlZCBieSBjb21tYXMsIHRoYXQgYXJlIHVzZWQgdG8gbG9va3VwIHdvcmRzCglmb3IgdGhlc2F1cnVzIGNvbXBsZXRpb24gY29tbWFuZHMgfGlfQ1RSTC1YX0NUUkwtVHwuICBFYWNoIGxpbmUgaW4KCXRoZSBmaWxlIHNob3VsZCBjb250YWluIHdvcmRzIHdpdGggc2ltaWxhciBtZWFuaW5nLCBzZXBhcmF0ZWQgYnkKCW5vbi1rZXl3b3JkIGNoYXJhY3RlcnMgKHdoaXRlIHNwYWNlIGlzIHByZWZlcnJlZCkuICBNYXhpbXVtIGxpbmUKCWxlbmd0aCBpcyA1MTAgYnl0ZXMuCglUbyBvYnRhaW4gYSBmaWxlIHRvIGJlIHVzZWQgaGVyZSwgY2hlY2sgb3V0IHRoZSB3b3JkbGlzdCBGQVEgYXQKCWh0dHA6Ly93d3cuaHlwaGVub2xvZ2lzdC5jby51ayAuCglUbyBpbmNsdWRlIGEgY29tbWEgaW4gYSBmaWxlIG5hbWUgcHJlY2VkZSBpdCB3aXRoIGEgYmFja3NsYXNoLiAgU3BhY2VzCglhZnRlciBhIGNvbW1hIGFyZSBpZ25vcmVkLCBvdGhlcndpc2Ugc3BhY2VzIGFyZSBpbmNsdWRlZCBpbiB0aGUgZmlsZQoJbmFtZS4gIFNlZSB8b3B0aW9uLWJhY2tzbGFzaHwgYWJvdXQgdXNpbmcgYmFja3NsYXNoZXMuCglUaGUgdXNlIG9mIHw6c2V0Kz18IGFuZCB8OnNldC09fCBpcyBwcmVmZXJyZWQgd2hlbiBhZGRpbmcgb3IgcmVtb3ZpbmcKCWRpcmVjdG9yaWVzIGZyb20gdGhlIGxpc3QuICBUaGlzIGF2b2lkcyBwcm9ibGVtcyB3aGVuIGEgZnV0dXJlIHZlcnNpb24KCXVzZXMgYW5vdGhlciBkZWZhdWx0LgoJQmFja3RpY2tzIGNhbm5vdCBiZSB1c2VkIGluIHRoaXMgb3B0aW9uIGZvciBzZWN1cml0eSByZWFzb25zLgoKCQkJICAgICAqJ3RpbGRlb3AnKiAqJ3RvcCcqIConbm90aWxkZW9wJyogKidub3RvcCcqCid0aWxkZW9wJyAndG9wJwkJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJV2hlbiBvbjogVGhlIHRpbGRlIGNvbW1hbmQgIn4iIGJlaGF2ZXMgbGlrZSBhbiBvcGVyYXRvci4KCU5PVEU6IFRoaXMgb3B0aW9uIGlzIHJlc2V0IHdoZW4gJ2NvbXBhdGlibGUnIGlzIHNldC4KCgkJCQkqJ3RpbWVvdXQnKiAqJ3RvJyogKidub3RpbWVvdXQnKiAqJ25vdG8nKgondGltZW91dCcgJ3RvJwkJYm9vbGVhbiAoZGVmYXVsdCBvbikKCQkJZ2xvYmFsCgkJCQkJCSondHRpbWVvdXQnKiAqJ25vdHRpbWVvdXQnKgondHRpbWVvdXQnCQlib29sZWFuIChkZWZhdWx0IG9mZikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglUaGVzZSB0d28gb3B0aW9ucyB0b2dldGhlciBkZXRlcm1pbmUgdGhlIGJlaGF2aW9yIHdoZW4gcGFydCBvZiBhCgltYXBwZWQga2V5IHNlcXVlbmNlIG9yIGtleWJvYXJkIGNvZGUgaGFzIGJlZW4gcmVjZWl2ZWQ6CgoJJ3RpbWVvdXQnICAgICd0dGltZW91dCcJCWFjdGlvbgl+CgkgICBvZmYJCW9mZgkJZG8gbm90IHRpbWUgb3V0CgkgICBvbgkJb24gb3Igb2ZmCXRpbWUgb3V0IG9uIDptYXBwaW5ncyBhbmQga2V5IGNvZGVzCgkgICBvZmYJCW9uCQl0aW1lIG91dCBvbiBrZXkgY29kZXMKCglJZiBib3RoIG9wdGlvbnMgYXJlIG9mZiwgVmltIHdpbGwgd2FpdCB1bnRpbCBlaXRoZXIgdGhlIGNvbXBsZXRlCgltYXBwaW5nIG9yIGtleSBzZXF1ZW5jZSBoYXMgYmVlbiByZWNlaXZlZCwgb3IgaXQgaXMgY2xlYXIgdGhhdCB0aGVyZQoJaXMgbm8gbWFwcGluZyBvciBrZXkgc2VxdWVuY2UgZm9yIHRoZSByZWNlaXZlZCBjaGFyYWN0ZXJzLiAgRm9yCglleGFtcGxlOiBpZiB5b3UgaGF2ZSBtYXBwZWQgInZsIiBhbmQgVmltIGhhcyByZWNlaXZlZCAndicsIHRoZSBuZXh0CgljaGFyYWN0ZXIgaXMgbmVlZGVkIHRvIHNlZSBpZiB0aGUgJ3YnIGlzIGZvbGxvd2VkIGJ5IGFuICdsJy4KCVdoZW4gb25lIG9mIHRoZSBvcHRpb25zIGlzIG9uLCBWaW0gd2lsbCB3YWl0IGZvciBhYm91dCAxIHNlY29uZCBmb3IKCXRoZSBuZXh0IGNoYXJhY3RlciB0byBhcnJpdmUuICBBZnRlciB0aGF0IHRoZSBhbHJlYWR5IHJlY2VpdmVkCgljaGFyYWN0ZXJzIGFyZSBpbnRlcnByZXRlZCBhcyBzaW5nbGUgY2hhcmFjdGVycy4gIFRoZSB3YWl0aW5nIHRpbWUgY2FuCgliZSBjaGFuZ2VkIHdpdGggdGhlICd0aW1lb3V0bGVuJyBvcHRpb24uCglPbiBzbG93IHRlcm1pbmFscyBvciB2ZXJ5IGJ1c3kgc3lzdGVtcyB0aW1pbmcgb3V0IG1heSBjYXVzZQoJbWFsZnVuY3Rpb25pbmcgY3Vyc29yIGtleXMuICBJZiBib3RoIG9wdGlvbnMgYXJlIG9mZiwgVmltIHdhaXRzCglmb3JldmVyIGFmdGVyIGFuIGVudGVyZWQgPEVzYz4gaWYgdGhlcmUgYXJlIGtleSBjb2RlcyB0aGF0IHN0YXJ0Cgl3aXRoIDxFc2M+LiAgWW91IHdpbGwgaGF2ZSB0byB0eXBlIDxFc2M+IHR3aWNlLiAgSWYgeW91IGRvIG5vdCBoYXZlCglwcm9ibGVtcyB3aXRoIGtleSBjb2RlcywgYnV0IHdvdWxkIGxpa2UgdG8gaGF2ZSA6bWFwcGVkIGtleQoJc2VxdWVuY2VzIG5vdCB0aW1pbmcgb3V0IGluIDEgc2Vjb25kLCBzZXQgdGhlICd0dGltZW91dCcgb3B0aW9uIGFuZAoJcmVzZXQgdGhlICd0aW1lb3V0JyBvcHRpb24uCgoJTk9URTogJ3R0aW1lb3V0JyBpcyByZXNldCB3aGVuICdjb21wYXRpYmxlJyBpcyBzZXQuCgoJCQkJCQkqJ3RpbWVvdXRsZW4nKiAqJ3RtJyoKJ3RpbWVvdXRsZW4nICd0bScJbnVtYmVyCShkZWZhdWx0IDEwMDApCgkJCWdsb2JhbAoJCQl7bm90IGluIGFsbCB2ZXJzaW9ucyBvZiBWaX0KCQkJCQkJKid0dGltZW91dGxlbicqICondHRtJyoKJ3R0aW1lb3V0bGVuJyAndHRtJwludW1iZXIJKGRlZmF1bHQgLTEpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJVGhlIHRpbWUgaW4gbWlsbGlzZWNvbmRzIHRoYXQgaXMgd2FpdGVkIGZvciBhIGtleSBjb2RlIG9yIG1hcHBlZCBrZXkKCXNlcXVlbmNlIHRvIGNvbXBsZXRlLiAgQWxzbyB1c2VkIGZvciBDVFJMLVwgQ1RSTC1OIGFuZCBDVFJMLVwgQ1RSTC1HCgl3aGVuIHBhcnQgb2YgYSBjb21tYW5kIGhhcyBiZWVuIHR5cGVkLgoJTm9ybWFsbHkgb25seSAndGltZW91dGxlbicgaXMgdXNlZCBhbmQgJ3R0aW1lb3V0bGVuJyBpcyAtMS4gIFdoZW4gYQoJZGlmZmVyZW50IHRpbWVvdXQgdmFsdWUgZm9yIGtleSBjb2RlcyBpcyBkZXNpcmVkIHNldCAndHRpbWVvdXRsZW4nIHRvCglhIG5vbi1uZWdhdGl2ZSBudW1iZXIuCgoJCXR0aW1lb3V0bGVuCW1hcHBpbmcgZGVsYXkJICAga2V5IGNvZGUgZGVsYXkJfgoJCSAgIDwgMAkJJ3RpbWVvdXRsZW4nCSAgICd0aW1lb3V0bGVuJwoJCSAgPj0gMAkJJ3RpbWVvdXRsZW4nCSAgICd0dGltZW91dGxlbicKCglUaGUgdGltZW91dCBvbmx5IGhhcHBlbnMgd2hlbiB0aGUgJ3RpbWVvdXQnIGFuZCAndHRpbWVvdXQnIG9wdGlvbnMKCXRlbGwgc28uICBBIHVzZWZ1bCBzZXR0aW5nIHdvdWxkIGJlID4KCQk6c2V0IHRpbWVvdXQgdGltZW91dGxlbj0zMDAwIHR0aW1lb3V0bGVuPTEwMAo8CSh0aW1lIG91dCBvbiBtYXBwaW5nIGFmdGVyIHRocmVlIHNlY29uZHMsIHRpbWUgb3V0IG9uIGtleSBjb2RlcyBhZnRlcgoJYSB0ZW50aCBvZiBhIHNlY29uZCkuCgoJCQkJCQkqJ3RpdGxlJyogKidub3RpdGxlJyoKJ3RpdGxlJwkJCWJvb2xlYW4JKGRlZmF1bHQgb2ZmLCBvbiB3aGVuIHRpdGxlIGNhbiBiZSByZXN0b3JlZCkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCt0aXRsZXwKCQkJZmVhdHVyZX0KCVdoZW4gb24sIHRoZSB0aXRsZSBvZiB0aGUgd2luZG93IHdpbGwgYmUgc2V0IHRvIHRoZSB2YWx1ZSBvZgoJJ3RpdGxlc3RyaW5nJyAoaWYgaXQgaXMgbm90IGVtcHR5KSwgb3IgdG86CgkJZmlsZW5hbWUgWys9LV0gKHBhdGgpIC0gVklNCglXaGVyZToKCQlmaWxlbmFtZQl0aGUgbmFtZSBvZiB0aGUgZmlsZSBiZWluZyBlZGl0ZWQKCQktCQlpbmRpY2F0ZXMgdGhlIGZpbGUgY2Fubm90IGJlIG1vZGlmaWVkLCAnbWEnIG9mZgoJCSsJCWluZGljYXRlcyB0aGUgZmlsZSB3YXMgbW9kaWZpZWQKCQk9CQlpbmRpY2F0ZXMgdGhlIGZpbGUgaXMgcmVhZC1vbmx5CgkJPSsJCWluZGljYXRlcyB0aGUgZmlsZSBpcyByZWFkLW9ubHkgYW5kIG1vZGlmaWVkCgkJKHBhdGgpCQlpcyB0aGUgcGF0aCBvZiB0aGUgZmlsZSBiZWluZyBlZGl0ZWQKCQktIFZJTQkJdGhlIHNlcnZlciBuYW1lIHx2OnNlcnZlcm5hbWV8IG9yICJWSU0iCglPbmx5IHdvcmtzIGlmIHRoZSB0ZXJtaW5hbCBzdXBwb3J0cyBzZXR0aW5nIHdpbmRvdyB0aXRsZXMKCShjdXJyZW50bHkgQW1pZ2EgY29uc29sZSwgV2luMzIgY29uc29sZSwgYWxsIEdVSSB2ZXJzaW9ucyBhbmQKCXRlcm1pbmFscyB3aXRoIGEgbm9uLSBlbXB0eSAndF90cycgb3B0aW9uIC0gdGhlc2UgYXJlIFVuaXggeHRlcm0gYW5kCglpcmlzLWFuc2kgYnkgZGVmYXVsdCwgd2hlcmUgJ3RfdHMnIGlzIHRha2VuIGZyb20gdGhlIGJ1aWx0aW4gdGVybWNhcCkuCgkJCQkJCQkJKlgxMSoKCVdoZW4gVmltIHdhcyBjb21waWxlZCB3aXRoIEhBVkVfWDExIGRlZmluZWQsIHRoZSBvcmlnaW5hbCB0aXRsZSB3aWxsCgliZSByZXN0b3JlZCBpZiBwb3NzaWJsZS4gIFRoZSBvdXRwdXQgb2YgIjp2ZXJzaW9uIiB3aWxsIGluY2x1ZGUgIitYMTEiCgl3aGVuIEhBVkVfWDExIHdhcyBkZWZpbmVkLCBvdGhlcndpc2UgaXQgd2lsbCBiZSAiLVgxMSIuICBUaGlzIGFsc28KCXdvcmtzIGZvciB0aGUgaWNvbiBuYW1lIHwnaWNvbid8LgoJQnV0OiBXaGVuIFZpbSB3YXMgc3RhcnRlZCB3aXRoIHRoZSB8LVh8IGFyZ3VtZW50LCByZXN0b3JpbmcgdGhlIHRpdGxlCgl3aWxsIG5vdCB3b3JrIChleGNlcHQgaW4gdGhlIEdVSSkuCglJZiB0aGUgdGl0bGUgY2Fubm90IGJlIHJlc3RvcmVkLCBpdCBpcyBzZXQgdG8gdGhlIHZhbHVlIG9mICd0aXRsZW9sZCcuCglZb3UgbWlnaHQgd2FudCB0byByZXN0b3JlIHRoZSB0aXRsZSBvdXRzaWRlIG9mIFZpbSB0aGVuLgoJV2hlbiB1c2luZyBhbiB4dGVybSBmcm9tIGEgcmVtb3RlIG1hY2hpbmUgeW91IGNhbiB1c2UgdGhpcyBjb21tYW5kOgoJICAgIHJzaCBtYWNoaW5lX25hbWUgeHRlcm0gLWRpc3BsYXkgJERJU1BMQVkgJgoJdGhlbiB0aGUgV0lORE9XSUQgZW52aXJvbm1lbnQgdmFyaWFibGUgc2hvdWxkIGJlIGluaGVyaXRlZCBhbmQgdGhlCgl0aXRsZSBvZiB0aGUgd2luZG93IHNob3VsZCBjaGFuZ2UgYmFjayB0byB3aGF0IGl0IHNob3VsZCBiZSBhZnRlcgoJZXhpdGluZyBWaW0uCgoJCQkJCQkJCSondGl0bGVsZW4nKgondGl0bGVsZW4nCQludW1iZXIJKGRlZmF1bHQgODUpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrdGl0bGV8CgkJCWZlYXR1cmV9CglHaXZlcyB0aGUgcGVyY2VudGFnZSBvZiAnY29sdW1ucycgdG8gdXNlIGZvciB0aGUgbGVuZ3RoIG9mIHRoZSB3aW5kb3cKCXRpdGxlLiAgV2hlbiB0aGUgdGl0bGUgaXMgbG9uZ2VyLCBvbmx5IHRoZSBlbmQgb2YgdGhlIHBhdGggbmFtZSBpcwoJc2hvd24uICBBICc8JyBjaGFyYWN0ZXIgYmVmb3JlIHRoZSBwYXRoIG5hbWUgaXMgdXNlZCB0byBpbmRpY2F0ZSB0aGlzLgoJVXNpbmcgYSBwZXJjZW50YWdlIG1ha2VzIHRoaXMgYWRhcHQgdG8gdGhlIHdpZHRoIG9mIHRoZSB3aW5kb3cuICBCdXQKCWl0IHdvbid0IHdvcmsgcGVyZmVjdGx5LCBiZWNhdXNlIHRoZSBhY3R1YWwgbnVtYmVyIG9mIGNoYXJhY3RlcnMKCWF2YWlsYWJsZSBhbHNvIGRlcGVuZHMgb24gdGhlIGZvbnQgdXNlZCBhbmQgb3RoZXIgdGhpbmdzIGluIHRoZSB0aXRsZQoJYmFyLiAgV2hlbiAndGl0bGVsZW4nIGlzIHplcm8gdGhlIGZ1bGwgcGF0aCBpcyB1c2VkLiAgT3RoZXJ3aXNlLAoJdmFsdWVzIGZyb20gMSB0byAzMDAwMCBwZXJjZW50IGNhbiBiZSB1c2VkLgoJJ3RpdGxlbGVuJyBpcyBhbHNvIHVzZWQgZm9yIHRoZSAndGl0bGVzdHJpbmcnIG9wdGlvbi4KCgkJCQkJCSondGl0bGVvbGQnKgondGl0bGVvbGQnCQlzdHJpbmcJKGRlZmF1bHQgIlRoYW5rcyBmb3IgZmx5aW5nIFZpbSIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7b25seSBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRoIHRoZSB8K3RpdGxlfAoJCQlmZWF0dXJlfQoJVGhpcyBvcHRpb24gd2lsbCBiZSB1c2VkIGZvciB0aGUgd2luZG93IHRpdGxlIHdoZW4gZXhpdGluZyBWaW0gaWYgdGhlCglvcmlnaW5hbCB0aXRsZSBjYW5ub3QgYmUgcmVzdG9yZWQuICBPbmx5IGhhcHBlbnMgaWYgJ3RpdGxlJyBpcyBvbiBvcgoJJ3RpdGxlc3RyaW5nJyBpcyBub3QgZW1wdHkuCglUaGlzIG9wdGlvbiBjYW5ub3QgYmUgc2V0IGZyb20gYSB8bW9kZWxpbmV8IG9yIGluIHRoZSB8c2FuZGJveHwsIGZvcgoJc2VjdXJpdHkgcmVhc29ucy4KCQkJCQkJKid0aXRsZXN0cmluZycqCid0aXRsZXN0cmluZycJCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCt0aXRsZXwKCQkJZmVhdHVyZX0KCVdoZW4gdGhpcyBvcHRpb24gaXMgbm90IGVtcHR5LCBpdCB3aWxsIGJlIHVzZWQgZm9yIHRoZSB0aXRsZSBvZiB0aGUKCXdpbmRvdy4gIFRoaXMgaGFwcGVucyBvbmx5IHdoZW4gdGhlICd0aXRsZScgb3B0aW9uIGlzIG9uLgoJT25seSB3b3JrcyBpZiB0aGUgdGVybWluYWwgc3VwcG9ydHMgc2V0dGluZyB3aW5kb3cgdGl0bGVzIChjdXJyZW50bHkKCUFtaWdhIGNvbnNvbGUsIFdpbjMyIGNvbnNvbGUsIGFsbCBHVUkgdmVyc2lvbnMgYW5kIHRlcm1pbmFscyB3aXRoIGEKCW5vbi1lbXB0eSAndF90cycgb3B0aW9uKS4KCVdoZW4gVmltIHdhcyBjb21waWxlZCB3aXRoIEhBVkVfWDExIGRlZmluZWQsIHRoZSBvcmlnaW5hbCB0aXRsZSB3aWxsCgliZSByZXN0b3JlZCBpZiBwb3NzaWJsZSB8WDExfC4KCVdoZW4gdGhpcyBvcHRpb24gY29udGFpbnMgcHJpbnRmLXN0eWxlICclJyBpdGVtcywgdGhleSB3aWxsIGJlCglleHBhbmRlZCBhY2NvcmRpbmcgdG8gdGhlIHJ1bGVzIHVzZWQgZm9yICdzdGF0dXNsaW5lJy4KCUV4YW1wbGU6ID4KICAgIDphdXRvIEJ1ZkVudGVyICogbGV0ICZ0aXRsZXN0cmluZyA9IGhvc3RuYW1lKCkgLiAiLyIgLiBleHBhbmQoIiU6cCIpCiAgICA6c2V0IHRpdGxlIHRpdGxlc3RyaW5nPSU8JUYlPSVsLyVMLSVQIHRpdGxlbGVuPTcwCjwJVGhlIHZhbHVlIG9mICd0aXRsZWxlbicgaXMgdXNlZCB0byBhbGlnbiBpdGVtcyBpbiB0aGUgbWlkZGxlIG9yIHJpZ2h0CglvZiB0aGUgYXZhaWxhYmxlIHNwYWNlLgoJU29tZSBwZW9wbGUgcHJlZmVyIHRvIGhhdmUgdGhlIGZpbGUgbmFtZSBmaXJzdDogPgogICAgOnNldCB0aXRsZXN0cmluZz0ldCUoXCAlTSUpJShcICgle2V4cGFuZChcIiU6fjouOmhcIil9KSUpJShcICVhJSkKPAlOb3RlIHRoZSB1c2Ugb2YgIiV7IH0iIGFuZCBhbiBleHByZXNzaW9uIHRvIGdldCB0aGUgcGF0aCBvZiB0aGUgZmlsZSwKCXdpdGhvdXQgdGhlIGZpbGUgbmFtZS4gIFRoZSAiJSggJSkiIGNvbnN0cnVjdHMgYXJlIHVzZWQgdG8gYWRkIGEKCXNlcGFyYXRpbmcgc3BhY2Ugb25seSB3aGVuIG5lZWRlZC4KCU5PVEU6IFVzZSBvZiBzcGVjaWFsIGNoYXJhY3RlcnMgaW4gJ3RpdGxlc3RyaW5nJyBtYXkgY2F1c2UgdGhlIGRpc3BsYXkKCXRvIGJlIGdhcmJsZWQgKGUuZy4sIHdoZW4gaXQgY29udGFpbnMgYSBDUiBvciBOTCBjaGFyYWN0ZXIpLgoJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3N0YXR1c2xpbmV8IGZlYXR1cmV9CgoJCQkJKid0b29sYmFyJyogKid0YicqCid0b29sYmFyJyAndGInCQlzdHJpbmcJKGRlZmF1bHQgImljb25zLHRvb2x0aXBzIikKCQkJZ2xvYmFsCgkJCXtvbmx5IGZvciB8K0dVSV9HVEt8LCB8K0dVSV9BdGhlbmF8LCB8K0dVSV9Nb3RpZnwgYW5kCgkJCXwrR1VJX1Bob3Rvbnx9CglUaGUgY29udGVudHMgb2YgdGhpcyBvcHRpb24gY29udHJvbHMgdmFyaW91cyB0b29sYmFyIHNldHRpbmdzLiAgVGhlCglwb3NzaWJsZSB2YWx1ZXMgYXJlOgoJCWljb25zCQlUb29sYmFyIGJ1dHRvbnMgYXJlIHNob3duIHdpdGggaWNvbnMuCgkJdGV4dAkJVG9vbGJhciBidXR0b25zIHNob3duIHdpdGggdGV4dC4KCQlob3JpegkJSWNvbiBhbmQgdGV4dCBvZiBhIHRvb2xiYXIgYnV0dG9uIGFyZQoJCQkJaG9yaXpvbnRhbGx5IGFycmFuZ2VkLiAge29ubHkgaW4gR1RLKyAyIEdVSX0KCQl0b29sdGlwcwlUb29sdGlwcyBhcmUgYWN0aXZlIGZvciB0b29sYmFyIGJ1dHRvbnMuCglUb29sdGlwcyByZWZlciB0byB0aGUgcG9wdXAgaGVscCB0ZXh0IHdoaWNoIGFwcGVhcnMgYWZ0ZXIgdGhlIG1vdXNlCgljdXJzb3IgaXMgcGxhY2VkIG92ZXIgYSB0b29sYmFyIGJ1dHRvbiBmb3IgYSBicmllZiBtb21lbnQuCgoJSWYgeW91IHdhbnQgdGhlIHRvb2xiYXIgdG8gYmUgc2hvd24gd2l0aCBpY29ucyBhcyB3ZWxsIGFzIHRleHQsIGRvIHRoZQoJZm9sbG93aW5nOiA+CgkJOnNldCB0Yj1pY29ucyx0ZXh0CjwJTW90aWYgYW5kIEF0aGVuYSBjYW5ub3QgZGlzcGxheSBpY29ucyBhbmQgdGV4dCBhdCB0aGUgc2FtZSB0aW1lLiAgVGhleQoJd2lsbCBzaG93IGljb25zIGlmIGJvdGggYXJlIHJlcXVlc3RlZC4KCglJZiBub25lIG9mIHRoZSBzdHJpbmdzIHNwZWNpZmllZCBpbiAndG9vbGJhcicgYXJlIHZhbGlkIG9yIGlmCgkndG9vbGJhcicgaXMgZW1wdHksIHRoaXMgb3B0aW9uIGlzIGlnbm9yZWQuICBJZiB5b3Ugd2FudCB0byBkaXNhYmxlCgl0aGUgdG9vbGJhciwgeW91IG5lZWQgdG8gc2V0IHRoZSAnZ3Vpb3B0aW9ucycgb3B0aW9uLiAgRm9yIGV4YW1wbGU6ID4KCQk6c2V0IGd1aW9wdGlvbnMtPVQKPAlBbHNvIHNlZSB8Z3VpLXRvb2xiYXJ8LgoKCQkJCQkJKid0b29sYmFyaWNvbnNpemUnKiAqJ3RiaXMnKgondG9vbGJhcmljb25zaXplJyAndGJpcycJc3RyaW5nCShkZWZhdWx0ICJzbWFsbCIpCgkJCQlnbG9iYWwKCQkJCXtub3QgaW4gVml9CgkJCQl7b25seSBpbiB0aGUgR1RLKyAyIEdVSX0KCUNvbnRyb2xzIHRoZSBzaXplIG9mIHRvb2xiYXIgaWNvbnMuICBUaGUgcG9zc2libGUgdmFsdWVzIGFyZToKCQl0aW55CQlVc2UgdGlueSB0b29sYmFyIGljb25zLgoJCXNtYWxsCQlVc2Ugc21hbGwgdG9vbGJhciBpY29ucyAoZGVmYXVsdCkuCgkJbWVkaXVtCQlVc2UgbWVkaXVtLXNpemVkIHRvb2xiYXIgaWNvbnMuCgkJbGFyZ2UJCVVzZSBsYXJnZSB0b29sYmFyIGljb25zLgoJVGhlIGV4YWN0IGRpbWVuc2lvbnMgaW4gcGl4ZWxzIG9mIHRoZSB2YXJpb3VzIGljb24gc2l6ZXMgZGVwZW5kIG9uCgl0aGUgY3VycmVudCB0aGVtZS4gIENvbW1vbiBkaW1lbnNpb25zIGFyZSBsYXJnZT0zMngzMiwgbWVkaXVtPTI0eDI0LAoJc21hbGw9MjB4MjAgYW5kIHRpbnk9MTZ4MTYuCgoJSWYgJ3Rvb2xiYXJpY29uc2l6ZScgaXMgZW1wdHksIHRoZSBnbG9iYWwgZGVmYXVsdCBzaXplIGFzIGRldGVybWluZWQKCWJ5IHVzZXIgcHJlZmVyZW5jZXMgb3IgdGhlIGN1cnJlbnQgdGhlbWUgaXMgdXNlZC4KCgkJCSAgICAgKid0dHlidWlsdGluJyogKid0YmknKiAqJ25vdHR5YnVpbHRpbicqIConbm90YmknKgondHR5YnVpbHRpbicgJ3RiaScJYm9vbGVhbgkoZGVmYXVsdCBvbikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglXaGVuIG9uLCB0aGUgYnVpbHRpbiB0ZXJtY2FwcyBhcmUgc2VhcmNoZWQgYmVmb3JlIHRoZSBleHRlcm5hbCBvbmVzLgoJV2hlbiBvZmYgdGhlIGJ1aWx0aW4gdGVybWNhcHMgYXJlIHNlYXJjaGVkIGFmdGVyIHRoZSBleHRlcm5hbCBvbmVzLgoJV2hlbiB0aGlzIG9wdGlvbiBpcyBjaGFuZ2VkLCB5b3Ugc2hvdWxkIHNldCB0aGUgJ3Rlcm0nIG9wdGlvbiBuZXh0IGZvcgoJdGhlIGNoYW5nZSB0byB0YWtlIGVmZmVjdCwgZm9yIGV4YW1wbGU6ID4KCQk6c2V0IG5vdGJpIHRlcm09JFRFUk0KPAlTZWUgYWxzbyB8dGVybWNhcHwuCglSYXRpb25hbGU6IFRoZSBkZWZhdWx0IGZvciB0aGlzIG9wdGlvbiBpcyAib24iLCBiZWNhdXNlIHRoZSBidWlsdGluCgl0ZXJtY2FwIGVudHJpZXMgYXJlIGdlbmVyYWxseSBiZXR0ZXIgKG1hbnkgc3lzdGVtcyBjb250YWluIGZhdWx0eQoJeHRlcm0gZW50cmllcy4uLikuCgoJCQkJICAgICAqJ3R0eWZhc3QnKiAqJ3RmJyogKidub3R0eWZhc3QnKiAqJ25vdGYnKgondHR5ZmFzdCcgJ3RmJwkJYm9vbGVhbgkoZGVmYXVsdCBvZmYsIG9uIHdoZW4gJ3Rlcm0nIGlzIHh0ZXJtLCBocHRlcm0sCgkJCQkJc3VuLWNtZCwgc2NyZWVuLCByeHZ0LCBkdHRlcm0gb3IKCQkJCQlpcmlzLWFuc2k7IGFsc28gb24gd2hlbiBydW5uaW5nIFZpbSBpbgoJCQkJCWEgRE9TIGNvbnNvbGUpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJSW5kaWNhdGVzIGEgZmFzdCB0ZXJtaW5hbCBjb25uZWN0aW9uLiAgTW9yZSBjaGFyYWN0ZXJzIHdpbGwgYmUgc2VudCB0bwoJdGhlIHNjcmVlbiBmb3IgcmVkcmF3aW5nLCBpbnN0ZWFkIG9mIHVzaW5nIGluc2VydC9kZWxldGUgbGluZQoJY29tbWFuZHMuICBJbXByb3ZlcyBzbW9vdGhuZXNzIG9mIHJlZHJhd2luZyB3aGVuIHRoZXJlIGFyZSBtdWx0aXBsZQoJd2luZG93cyBhbmQgdGhlIHRlcm1pbmFsIGRvZXMgbm90IHN1cHBvcnQgYSBzY3JvbGxpbmcgcmVnaW9uLgoJQWxzbyBlbmFibGVzIHRoZSBleHRyYSB3cml0aW5nIG9mIGNoYXJhY3RlcnMgYXQgdGhlIGVuZCBvZiBlYWNoIHNjcmVlbgoJbGluZSBmb3IgbGluZXMgdGhhdCB3cmFwLiAgVGhpcyBoZWxwcyB3aGVuIHVzaW5nIGNvcHkvcGFzdGUgd2l0aCB0aGUKCW1vdXNlIGluIGFuIHh0ZXJtIGFuZCBvdGhlciB0ZXJtaW5hbHMuCgoJCQkJCQkqJ3R0eW1vdXNlJyogKid0dHltJyoKJ3R0eW1vdXNlJyAndHR5bScJc3RyaW5nCShkZWZhdWx0IGRlcGVuZHMgb24gJ3Rlcm0nKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe29ubHkgaW4gVW5peCBhbmQgVk1TLCBkb2Vzbid0IHdvcmsgaW4gdGhlIEdVSTsgbm90CgkJCWF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgfCttb3VzZXx9CglOYW1lIG9mIHRoZSB0ZXJtaW5hbCB0eXBlIGZvciB3aGljaCBtb3VzZSBjb2RlcyBhcmUgdG8gYmUgcmVjb2duaXplZC4KCUN1cnJlbnRseSB0aGVzZSB0aHJlZSBzdHJpbmdzIGFyZSB2YWxpZDoKCQkJCQkJCSp4dGVybS1tb3VzZSoKCSAgIHh0ZXJtCXh0ZXJtLWxpa2UgbW91c2UgaGFuZGxpbmcuICBUaGUgbW91c2UgZ2VuZXJhdGVzCgkJCSI8RXNjPltNc2NyIiwgd2hlcmUgInNjciIgaXMgdGhyZWUgYnl0ZXM6CgkJCQkicyIgID0gYnV0dG9uIHN0YXRlCgkJCQkiYyIgID0gY29sdW1uIHBsdXMgMzMKCQkJCSJyIiAgPSByb3cgcGx1cyAzMwoJICAgCQlUaGlzIG9ubHkgd29ya3MgdXAgdG8gMjIzIGNvbHVtbnMhICBTZWUgImRlYyIgZm9yIGEKCQkJc29sdXRpb24uCgkgICB4dGVybTIJV29ya3MgbGlrZSAieHRlcm0iLCBidXQgd2l0aCB0aGUgeHRlcm0gcmVwb3J0aW5nIHRoZQoJCQltb3VzZSBwb3NpdGlvbiB3aGlsZSB0aGUgbW91c2UgaXMgZHJhZ2dlZC4gIFRoaXMgd29ya3MKCQkJbXVjaCBmYXN0ZXIgYW5kIG1vcmUgcHJlY2lzZS4gIFlvdXIgeHRlcm0gbXVzdCBhdAoJCQlsZWFzdCBhdCBwYXRjaGxldmVsIDg4IC8gWEZyZWUgMy4zLjMgZm9yIHRoaXMgdG8KCQkJd29yay4gIFNlZSBiZWxvdyBmb3IgaG93IFZpbSBkZXRlY3RzIHRoaXMKCQkJYXV0b21hdGljYWxseS4KCQkJCQkJCSpuZXR0ZXJtLW1vdXNlKgoJICAgbmV0dGVybQlOZXRUZXJtIG1vdXNlIGhhbmRsaW5nLiAgVGhlIG1vdXNlIGdlbmVyYXRlcwoJCQkiPEVzYz59cixjPENSPiIsIHdoZXJlICJyLGMiIGFyZSB0d28gZGVjaW1hbCBudW1iZXJzCgkJCWZvciB0aGUgcm93IGFuZCBjb2x1bW4uCgkJCQkJCQkqZGVjLW1vdXNlKgoJICAgZGVjCQlERUMgdGVybWluYWwgbW91c2UgaGFuZGxpbmcuICBUaGUgbW91c2UgZ2VuZXJhdGVzIGEKCQkJcmF0aGVyIGNvbXBsZXggc2VxdWVuY2UsIHN0YXJ0aW5nIHdpdGggIjxFc2M+WyIuCgkJCVRoaXMgaXMgYWxzbyBhdmFpbGFibGUgZm9yIGFuIFh0ZXJtLCBpZiBpdCB3YXMKCQkJY29uZmlndXJlZCB3aXRoICItLWVuYWJsZS1kZWMtbG9jYXRvciIuCgkJCQkJCQkqanNidGVybS1tb3VzZSoKCSAgIGpzYnRlcm0JSlNCIHRlcm0gbW91c2UgaGFuZGxpbmcuCgkJCQkJCQkqcHRlcm0tbW91c2UqCgkgICBwdGVybQlRTlggcHRlcm0gbW91c2UgaGFuZGxpbmcuCgoJVGhlIG1vdXNlIGhhbmRsaW5nIG11c3QgYmUgZW5hYmxlZCBhdCBjb21waWxlIHRpbWUgfCttb3VzZV94dGVybXwKCXwrbW91c2VfZGVjfCB8K21vdXNlX25ldHRlcm18LgoJT25seSAieHRlcm0iKDIpIGlzIHJlYWxseSByZWNvZ25pemVkLiAgTmV0VGVybSBtb3VzZSBjb2RlcyBhcmUgYWx3YXlzCglyZWNvZ25pemVkLCBpZiBlbmFibGVkIGF0IGNvbXBpbGUgdGltZS4gIERFQyB0ZXJtaW5hbCBtb3VzZSBjb2RlcwoJYXJlIHJlY29nbml6ZWQgaWYgZW5hYmxlZCBhdCBjb21waWxlIHRpbWUsIGFuZCAndHR5bW91c2UnIGlzIG5vdAoJInh0ZXJtIiAoYmVjYXVzZSB0aGUgeHRlcm0gYW5kIGRlYyBtb3VzZSBjb2RlcyBjb25mbGljdCkuCglUaGlzIG9wdGlvbiBpcyBhdXRvbWF0aWNhbGx5IHNldCB0byAieHRlcm0iLCB3aGVuIHRoZSAndGVybScgb3B0aW9uIGlzCglzZXQgdG8gYSBuYW1lIHRoYXQgc3RhcnRzIHdpdGggInh0ZXJtIiwgYW5kICd0dHltb3VzZScgaXMgbm90ICJ4dGVybSIKCW9yICJ4dGVybTIiIGFscmVhZHkuICBUaGUgbWFpbiB1c2Ugb2YgdGhpcyBvcHRpb24gaXMgdG8gc2V0IGl0IHRvCgkieHRlcm0iLCB3aGVuIHRoZSB0ZXJtaW5hbCBuYW1lIGRvZXNuJ3Qgc3RhcnQgd2l0aCAieHRlcm0iLCBidXQgaXQgY2FuCgloYW5kbGUgeHRlcm0gbW91c2UgY29kZXMuCglUaGUgInh0ZXJtMiIgdmFsdWUgd2lsbCBiZSBzZXQgaWYgdGhlIHh0ZXJtIHZlcnNpb24gaXMgcmVwb3J0ZWQgdG8gYmUKCTk1IG9mIGhpZ2hlci4gIFRoaXMgb25seSB3b3JrcyB3aGVuIGNvbXBpbGVkIHdpdGggdGhlIHwrdGVybXJlc3BvbnNlfAoJZmVhdHVyZSBhbmQgaWYgfHRfUlZ8IGlzIHNldCB0byB0aGUgZXNjYXBlIHNlcXVlbmNlIHRvIHJlcXVlc3QgdGhlCgl4dGVybSB2ZXJzaW9uIG51bWJlci4gIE90aGVyd2lzZSAieHRlcm0yIiBtdXN0IGJlIHNldCBleHBsaWNpdGx5LgoJSWYgeW91IGRvIG5vdCB3YW50ICd0dHltb3VzZScgdG8gYmUgc2V0IHRvICJ4dGVybTIiIGF1dG9tYXRpY2FsbHksIHNldAoJdF9SViB0byBhbiBlbXB0eSBzdHJpbmc6ID4KCQk6c2V0IHRfUlY9CjwKCQkJCQkJKid0dHlzY3JvbGwnKiAqJ3RzbCcqCid0dHlzY3JvbGwnICd0c2wnCW51bWJlcgkoZGVmYXVsdCA5OTkpCgkJCWdsb2JhbAoJTWF4aW11bSBudW1iZXIgb2YgbGluZXMgdG8gc2Nyb2xsIHRoZSBzY3JlZW4uICBJZiB0aGVyZSBhcmUgbW9yZSBsaW5lcwoJdG8gc2Nyb2xsIHRoZSB3aW5kb3cgaXMgcmVkcmF3bi4gIEZvciB0ZXJtaW5hbHMgd2hlcmUgc2Nyb2xsaW5nIGlzCgl2ZXJ5IHNsb3cgYW5kIHJlZHJhd2luZyBpcyBub3Qgc2xvdyB0aGlzIGNhbiBiZSBzZXQgdG8gYSBzbWFsbCBudW1iZXIsCgllLmcuLCAzLCB0byBzcGVlZCB1cCBkaXNwbGF5aW5nLgoKCQkJCQkJKid0dHl0eXBlJyogKid0dHknKgondHR5dHlwZScgJ3R0eScJCXN0cmluZwkoZGVmYXVsdCBmcm9tICRURVJNKQoJCQlnbG9iYWwKCUFsaWFzIGZvciAndGVybScsIHNlZSBhYm92ZS4KCgkJCQkJCSondW5kb2xldmVscycqICondWwnKgondW5kb2xldmVscycgJ3VsJwludW1iZXIJKGRlZmF1bHQgMTAwLCAxMDAwIGZvciBVbml4LCBWTVMsCgkJCQkJCVdpbjMyIGFuZCBPUy8yKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCU1heGltdW0gbnVtYmVyIG9mIGNoYW5nZXMgdGhhdCBjYW4gYmUgdW5kb25lLiAgU2luY2UgdW5kbyBpbmZvcm1hdGlvbgoJaXMga2VwdCBpbiBtZW1vcnksIGhpZ2hlciBudW1iZXJzIHdpbGwgY2F1c2UgbW9yZSBtZW1vcnkgdG8gYmUgdXNlZAoJKG5ldmVydGhlbGVzcywgYSBzaW5nbGUgY2hhbmdlIGNhbiB1c2UgYW4gdW5saW1pdGVkIGFtb3VudCBvZiBtZW1vcnkpLgoJU2V0IHRvIDAgZm9yIFZpIGNvbXBhdGliaWxpdHk6IE9uZSBsZXZlbCBvZiB1bmRvIGFuZCAidSIgdW5kb2VzCglpdHNlbGY6ID4KCQlzZXQgdWw9MAo8CUJ1dCB5b3UgY2FuIGFsc28gZ2V0IFZpIGNvbXBhdGliaWxpdHkgYnkgaW5jbHVkaW5nIHRoZSAndScgZmxhZyBpbgoJJ2Nwb3B0aW9ucycsIGFuZCBzdGlsbCBiZSBhYmxlIHRvIHVzZSBDVFJMLVIgdG8gcmVwZWF0IHVuZG8uCglTZXQgdG8gYSBuZWdhdGl2ZSBudW1iZXIgZm9yIG5vIHVuZG8gYXQgYWxsOiA+CgkJc2V0IHVsPS0xCjwJVGhpcyBoZWxwcyB3aGVuIHlvdSBydW4gb3V0IG9mIG1lbW9yeSBmb3IgYSBzaW5nbGUgY2hhbmdlLgoJQWxzbyBzZWUgfHVuZG8tdHdvLXdheXN8LgoKCQkJCQkJKid1cGRhdGVjb3VudCcqICondWMnKgondXBkYXRlY291bnQnICd1YycJbnVtYmVyCShkZWZhdWx0OiAyMDApCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJQWZ0ZXIgdHlwaW5nIHRoaXMgbWFueSBjaGFyYWN0ZXJzIHRoZSBzd2FwIGZpbGUgd2lsbCBiZSB3cml0dGVuIHRvCglkaXNrLiAgV2hlbiB6ZXJvLCBubyBzd2FwIGZpbGUgd2lsbCBiZSBjcmVhdGVkIGF0IGFsbCAoc2VlIGNoYXB0ZXIgb24KCXJlY292ZXJ5IHxjcmFzaC1yZWNvdmVyeXwpLiAgJ3VwZGF0ZWNvdW50JyBpcyBzZXQgdG8gemVybyBieSBzdGFydGluZwoJVmltIHdpdGggdGhlICItbiIgb3B0aW9uLCBzZWUgfHN0YXJ0dXB8LiAgV2hlbiBlZGl0aW5nIGluIHJlYWRvbmx5Cgltb2RlIHRoaXMgb3B0aW9uIHdpbGwgYmUgaW5pdGlhbGl6ZWQgdG8gMTAwMDAuCglUaGUgc3dhcGZpbGUgY2FuIGJlIGRpc2FibGVkIHBlciBidWZmZXIgd2l0aCB8J3N3YXBmaWxlJ3wuCglXaGVuICd1cGRhdGVjb3VudCcgaXMgc2V0IGZyb20gemVybyB0byBub24temVybywgc3dhcCBmaWxlcyBhcmUKCWNyZWF0ZWQgZm9yIGFsbCBidWZmZXJzIHRoYXQgaGF2ZSAnc3dhcGZpbGUnIHNldC4gIFdoZW4gJ3VwZGF0ZWNvdW50JwoJaXMgc2V0IHRvIHplcm8sIGV4aXN0aW5nIHN3YXAgZmlsZXMgYXJlIG5vdCBkZWxldGVkLgoJQWxzbyBzZWUgfCdzd2Fwc3luYyd8LgoJVGhpcyBvcHRpb24gaGFzIG5vIG1lYW5pbmcgaW4gYnVmZmVycyB3aGVyZSB8J2J1ZnR5cGUnfCBpcyAibm9maWxlIgoJb3IgIm5vd3JpdGUiLgoKCQkJCQkJKid1cGRhdGV0aW1lJyogKid1dCcqCid1cGRhdGV0aW1lJyAndXQnCW51bWJlcgkoZGVmYXVsdCA0MDAwKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCUlmIHRoaXMgbWFueSBtaWxsaXNlY29uZHMgbm90aGluZyBpcyB0eXBlZCB0aGUgc3dhcCBmaWxlIHdpbGwgYmUKCXdyaXR0ZW4gdG8gZGlzayAoc2VlIHxjcmFzaC1yZWNvdmVyeXwpLiAgQWxzbyB1c2VkIGZvciB0aGUKCXxDdXJzb3JIb2xkfCBhdXRvY29tbWFuZCBldmVudC4KCgkJCQkJCSondmVyYm9zZScqICondmJzJyoKJ3ZlcmJvc2UnICd2YnMnCQludW1iZXIJKGRlZmF1bHQgMCkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVmksIGFsdGhvdWdoIHNvbWUgdmVyc2lvbnMgaGF2ZSBhIGJvb2xlYW4KCQkJdmVyYm9zZSBvcHRpb259CglXaGVuIGJpZ2dlciB0aGFuIHplcm8sIFZpbSB3aWxsIGdpdmUgbWVzc2FnZXMgYWJvdXQgd2hhdCBpdCBpcyBkb2luZy4KCUN1cnJlbnRseSwgdGhlc2UgbWVzc2FnZXMgYXJlIGdpdmVuOgoJPj0gMQlXaGVuIHRoZSB2aW1pbmZvIGZpbGUgaXMgcmVhZCBvciB3cml0dGVuLgoJPj0gMglXaGVuIGEgZmlsZSBpcyAiOnNvdXJjZSInZWQuCgk+PSA1CUV2ZXJ5IHNlYXJjaGVkIHRhZ3MgZmlsZS4KCT49IDgJRmlsZXMgZm9yIHdoaWNoIGEgZ3JvdXAgb2YgYXV0b2NvbW1hbmRzIGlzIGV4ZWN1dGVkLgoJPj0gOQlFdmVyeSBleGVjdXRlZCBhdXRvY29tbWFuZC4KCT49IDEyCUV2ZXJ5IGV4ZWN1dGVkIGZ1bmN0aW9uLgoJPj0gMTMJV2hlbiBhbiBleGNlcHRpb24gaXMgdGhyb3duLCBjYXVnaHQsIGZpbmlzaGVkLCBvciBkaXNjYXJkZWQuCgk+PSAxNAlBbnl0aGluZyBwZW5kaW5nIGluIGEgIjpmaW5hbGx5IiBjbGF1c2UuCgk+PSAxNQlFdmVyeSBleGVjdXRlZCBFeCBjb21tYW5kICh0cnVuY2F0ZWQgYXQgMjAwIGNoYXJhY3RlcnMpLgoKCVRoaXMgb3B0aW9uIGNhbiBhbHNvIGJlIHNldCB3aXRoIHRoZSAiLVYiIGFyZ3VtZW50LiAgU2VlIHwtVnwuCglUaGlzIG9wdGlvbiBpcyBhbHNvIHNldCBieSB0aGUgfDp2ZXJib3NlfCBjb21tYW5kLgoKCVdoZW4gdGhlICd2ZXJib3NlZmlsZScgb3B0aW9uIGlzIHNldCB0aGVuIHRoZSB2ZXJib3NlIG1lc3NhZ2VzIGFyZSBub3QKCWRpc3BsYXllZC4KCgkJCQkJCSondmVyYm9zZWZpbGUnKiAqJ3ZmaWxlJyoKJ3ZlcmJvc2VmaWxlJyAndmZpbGUnCXN0cmluZwkoZGVmYXVsdCBlbXB0eSkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglXaGVuIG5vdCBlbXB0eSBhbGwgbWVzc2FnZXMgYXJlIHdyaXR0ZW4gaW4gYSBmaWxlIHdpdGggdGhpcyBuYW1lLgoJV2hlbiB0aGUgZmlsZSBleGlzdHMgbWVzc2FnZXMgYXJlIGFwcGVuZGVkLgoJV3JpdGluZyB0byB0aGUgZmlsZSBlbmRzIHdoZW4gVmltIGV4aXRzIG9yIHdoZW4gJ3ZlcmJvc2VmaWxlJyBpcyBtYWRlCgllbXB0eS4KCVNldHRpbmcgJ3ZlcmJvc2VmaWxlJyB0byBhIG5ldyB2YWx1ZSBpcyBsaWtlIG1ha2luZyBpdCBlbXB0eSBmaXJzdC4KCVRoZSBkaWZmZXJlbmNlIHdpdGggfDpyZWRpcnwgaXMgdGhhdCB2ZXJib3NlIG1lc3NhZ2VzIGFyZSBub3QKCWRpc3BsYXllZCB3aGVuICd2ZXJib3NlZmlsZScgaXMgc2V0LgoKCQkJCQkJKid2aWV3ZGlyJyogKid2ZGlyJyoKJ3ZpZXdkaXInICd2ZGlyJwlzdHJpbmcJKGRlZmF1bHQgZm9yIEFtaWdhLCBNUy1ET1MsIE9TLzIgYW5kIFdpbjMyOgoJCQkJCQkJICIkVklNL3ZpbWZpbGVzL3ZpZXciLAoJCQkJIGZvciBVbml4OiAifi8udmltL3ZpZXciLAoJCQkJIGZvciBNYWNpbnRvc2g6ICIkVklNOnZpbWZpbGVzOnZpZXciCgkJCQkgZm9yIFZNUzogInN5cyRsb2dpbjp2aW1maWxlcy92aWV3IgoJCQkJIGZvciBSaXNjT1M6ICJDaG9pY2VzOnZpbWZpbGVzL3ZpZXciKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSArbWtzZXNzaW9uCgkJCWZlYXR1cmV9CglOYW1lIG9mIHRoZSBkaXJlY3Rvcnkgd2hlcmUgdG8gc3RvcmUgZmlsZXMgZm9yIHw6bWt2aWV3fC4KCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJCQkJKid2aWV3b3B0aW9ucycqICondm9wJyoKJ3ZpZXdvcHRpb25zJyAndm9wJwlzdHJpbmcJKGRlZmF1bHQ6ICJmb2xkcyxvcHRpb25zLGN1cnNvciIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlICtta3Nlc3Npb24KCQkJZmVhdHVyZX0KCUNoYW5nZXMgdGhlIGVmZmVjdCBvZiB0aGUgfDpta3ZpZXd8IGNvbW1hbmQuICBJdCBpcyBhIGNvbW1hIHNlcGFyYXRlZAoJbGlzdCBvZiB3b3Jkcy4gIEVhY2ggd29yZCBlbmFibGVzIHNhdmluZyBhbmQgcmVzdG9yaW5nIHNvbWV0aGluZzoKCSAgIHdvcmQJCXNhdmUgYW5kIHJlc3RvcmUgfgoJICAgY3Vyc29yCWN1cnNvciBwb3NpdGlvbiBpbiBmaWxlIGFuZCBpbiB3aW5kb3cKCSAgIGZvbGRzCW1hbnVhbGx5IGNyZWF0ZWQgZm9sZHMsIG9wZW5lZC9jbG9zZWQgZm9sZHMgYW5kIGxvY2FsCgkJCWZvbGQgb3B0aW9ucwoJICAgb3B0aW9ucwlvcHRpb25zIGFuZCBtYXBwaW5ncyBsb2NhbCB0byBhIHdpbmRvdyBvciBidWZmZXIgKG5vdAoJCQlnbG9iYWwgdmFsdWVzIGZvciBsb2NhbCBvcHRpb25zKQoJICAgc2xhc2gJYmFja3NsYXNoZXMgaW4gZmlsZSBuYW1lcyByZXBsYWNlZCB3aXRoIGZvcndhcmQKCQkJc2xhc2hlcwoJICAgdW5peAkJd2l0aCBVbml4IGVuZC1vZi1saW5lIGZvcm1hdCAoc2luZ2xlIDxOTD4pLCBldmVuIHdoZW4KCQkJb24gV2luZG93cyBvciBET1MKCgkic2xhc2giIGFuZCAidW5peCIgYXJlIHVzZWZ1bCBvbiBXaW5kb3dzIHdoZW4gc2hhcmluZyB2aWV3IGZpbGVzCgl3aXRoIFVuaXguICBUaGUgVW5peCB2ZXJzaW9uIG9mIFZpbSBjYW5ub3Qgc291cmNlIGRvcyBmb3JtYXQgc2NyaXB0cywKCWJ1dCB0aGUgV2luZG93cyB2ZXJzaW9uIG9mIFZpbSBjYW4gc291cmNlIHVuaXggZm9ybWF0IHNjcmlwdHMuCgoJCQkJKid2aW1pbmZvJyogKid2aScqICpFNTI2KiAqRTUyNyogKkU1MjgqCid2aW1pbmZvJyAndmknCQlzdHJpbmcJKFZpIGRlZmF1bHQ6ICIiLCBWaW0gZGVmYXVsdCBmb3IgTVMtRE9TLAoJCQkJICAgV2luZG93cyBhbmQgT1MvMjogJzIwLDw1MCxzMTAsaCxyQTosckI6LAoJCQkJICAgZm9yIEFtaWdhOiAnMjAsPDUwLHMxMCxoLHJkZjA6LHJkZjE6LHJkZjI6CgkJCQkgICBmb3Igb3RoZXJzOiAnMjAsPDUwLHMxMCxoKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSAgfCt2aW1pbmZvfAoJCQlmZWF0dXJlfQoJV2hlbiBub24tZW1wdHksIHRoZSB2aW1pbmZvIGZpbGUgaXMgcmVhZCB1cG9uIHN0YXJ0dXAgYW5kIHdyaXR0ZW4KCXdoZW4gZXhpdGluZyBWaW0gKHNlZSB8dmltaW5mby1maWxlfCkuICBUaGUgc3RyaW5nIHNob3VsZCBiZSBhIGNvbW1hCglzZXBhcmF0ZWQgbGlzdCBvZiBwYXJhbWV0ZXJzLCBlYWNoIGNvbnNpc3Rpbmcgb2YgYSBzaW5nbGUgY2hhcmFjdGVyCglpZGVudGlmeWluZyB0aGUgcGFydGljdWxhciBwYXJhbWV0ZXIsIGZvbGxvd2VkIGJ5IGEgbnVtYmVyIG9yIHN0cmluZwoJd2hpY2ggc3BlY2lmaWVzIHRoZSB2YWx1ZSBvZiB0aGF0IHBhcmFtZXRlci4gIElmIGEgcGFydGljdWxhcgoJY2hhcmFjdGVyIGlzIGxlZnQgb3V0LCB0aGVuIHRoZSBkZWZhdWx0IHZhbHVlIGlzIHVzZWQgZm9yIHRoYXQKCXBhcmFtZXRlci4gIFRoZSBmb2xsb3dpbmcgaXMgYSBsaXN0IG9mIHRoZSBpZGVudGlmeWluZyBjaGFyYWN0ZXJzIGFuZAoJdGhlIGVmZmVjdCBvZiB0aGVpciB2YWx1ZS4KCUNIQVIJVkFMVUUJfgoJIQlXaGVuIGluY2x1ZGVkLCBzYXZlIGFuZCByZXN0b3JlIGdsb2JhbCB2YXJpYWJsZXMgdGhhdCBzdGFydAoJCXdpdGggYW4gdXBwZXJjYXNlIGxldHRlciwgYW5kIGRvbid0IGNvbnRhaW4gYSBsb3dlcmNhc2UKCQlsZXR0ZXIuICBUaHVzICJLRUVQVEhJUyBhbmQgIktfTF9NIiBhcmUgc3RvcmVkLCBidXQgIktlZXBUaGlzIgoJCWFuZCAiX0tfTF9NIiBhcmUgbm90LiAgT25seSBTdHJpbmcgYW5kIE51bWJlciB0eXBlcyBhcmUKCQlzdG9yZWQuCgkiCU1heGltdW0gbnVtYmVyIG9mIGxpbmVzIHNhdmVkIGZvciBlYWNoIHJlZ2lzdGVyLiAgT2xkIG5hbWUgb2YKCQl0aGUgJzwnIGl0ZW0sIHdpdGggdGhlIGRpc2FkdmFudGFnZSB0aGF0IHlvdSBuZWVkIHRvIHB1dCBhCgkJYmFja3NsYXNoIGJlZm9yZSB0aGUgIiwgb3RoZXJ3aXNlIGl0IHdpbGwgYmUgcmVjb2duaXplZCBhcyB0aGUKCQlzdGFydCBvZiBhIGNvbW1lbnQhCgklCVdoZW4gaW5jbHVkZWQsIHNhdmUgYW5kIHJlc3RvcmUgdGhlIGJ1ZmZlciBsaXN0LiAgSWYgVmltIGlzCgkJc3RhcnRlZCB3aXRoIGEgZmlsZSBuYW1lIGFyZ3VtZW50LCB0aGUgYnVmZmVyIGxpc3QgaXMgbm90CgkJcmVzdG9yZWQuICBJZiBWaW0gaXMgc3RhcnRlZCB3aXRob3V0IGEgZmlsZSBuYW1lIGFyZ3VtZW50LCB0aGUKCQlidWZmZXIgbGlzdCBpcyByZXN0b3JlZCBmcm9tIHRoZSB2aW1pbmZvIGZpbGUuICBCdWZmZXJzCgkJd2l0aG91dCBhIGZpbGUgbmFtZSBhbmQgYnVmZmVycyBmb3IgaGVscCBmaWxlcyBhcmUgbm90IHdyaXR0ZW4KCQl0byB0aGUgdmltaW5mbyBmaWxlLgoJCVdoZW4gZm9sbG93ZWQgYnkgYSBudW1iZXIsIHRoZSBudW1iZXIgc3BlY2lmaWVzIHRoZSBtYXhpbXVtCgkJbnVtYmVyIG9mIGJ1ZmZlcnMgdGhhdCBhcmUgc3RvcmVkLiAgV2l0aG91dCBhIG51bWJlciBhbGwKCQlidWZmZXJzIGFyZSBzdG9yZWQuCgknCU1heGltdW0gbnVtYmVyIG9mIHByZXZpb3VzbHkgZWRpdGVkIGZpbGVzIGZvciB3aGljaCB0aGUgbWFya3MKCQlhcmUgcmVtZW1iZXJlZC4gIFRoaXMgcGFyYW1ldGVyIG11c3QgYWx3YXlzIGJlIGluY2x1ZGVkIHdoZW4KCQkndmltaW5mbycgaXMgbm9uLWVtcHR5LgoJCUluY2x1ZGluZyB0aGlzIGl0ZW0gYWxzbyBtZWFucyB0aGF0IHRoZSB8anVtcGxpc3R8IGFuZCB0aGUKCQl8Y2hhbmdlbGlzdHwgYXJlIHN0b3JlZCBpbiB0aGUgdmltaW5mbyBmaWxlLgoJLwlNYXhpbXVtIG51bWJlciBvZiBpdGVtcyBpbiB0aGUgc2VhcmNoIHBhdHRlcm4gaGlzdG9yeSB0byBiZQoJCXNhdmVkLiAgSWYgbm9uLXplcm8sIHRoZW4gdGhlIHByZXZpb3VzIHNlYXJjaCBhbmQgc3Vic3RpdHV0ZQoJCXBhdHRlcm5zIGFyZSBhbHNvIHNhdmVkLiAgV2hlbiBub3QgaW5jbHVkZWQsIHRoZSB2YWx1ZSBvZgoJCSdoaXN0b3J5JyBpcyB1c2VkLgoJOglNYXhpbXVtIG51bWJlciBvZiBpdGVtcyBpbiB0aGUgY29tbWFuZC1saW5lIGhpc3RvcnkgdG8gYmUKCQlzYXZlZC4gIFdoZW4gbm90IGluY2x1ZGVkLCB0aGUgdmFsdWUgb2YgJ2hpc3RvcnknIGlzIHVzZWQuCgk8CU1heGltdW0gbnVtYmVyIG9mIGxpbmVzIHNhdmVkIGZvciBlYWNoIHJlZ2lzdGVyLiAgSWYgemVybyB0aGVuCgkJcmVnaXN0ZXJzIGFyZSBub3Qgc2F2ZWQuICBXaGVuIG5vdCBpbmNsdWRlZCwgYWxsIGxpbmVzIGFyZQoJCXNhdmVkLiAgJyInIGlzIHRoZSBvbGQgbmFtZSBmb3IgdGhpcyBpdGVtLgoJCUFsc28gc2VlIHRoZSAncycgaXRlbSBiZWxvdzogbGltaXQgc3BlY2lmaWVkIGluIEtieXRlLgoJQAlNYXhpbXVtIG51bWJlciBvZiBpdGVtcyBpbiB0aGUgaW5wdXQtbGluZSBoaXN0b3J5IHRvIGJlCgkJc2F2ZWQuICBXaGVuIG5vdCBpbmNsdWRlZCwgdGhlIHZhbHVlIG9mICdoaXN0b3J5JyBpcyB1c2VkLgoJYwlXaGVuIGluY2x1ZGVkLCBjb252ZXJ0IHRoZSB0ZXh0IGluIHRoZSB2aW1pbmZvIGZpbGUgZnJvbSB0aGUKCQknZW5jb2RpbmcnIHVzZWQgd2hlbiB3cml0aW5nIHRoZSBmaWxlIHRvIHRoZSBjdXJyZW50CgkJJ2VuY29kaW5nJy4gIFNlZSB8dmltaW5mby1lbmNvZGluZ3wuCglmCVdoZXRoZXIgZmlsZSBtYXJrcyBuZWVkIHRvIGJlIHN0b3JlZC4gIElmIHplcm8sIGZpbGUgbWFya3MgKCcwCgkJdG8gJzksICdBIHRvICdaKSBhcmUgbm90IHN0b3JlZC4gIFdoZW4gbm90IHByZXNlbnQgb3Igd2hlbgoJCW5vbi16ZXJvLCB0aGV5IGFyZSBhbGwgc3RvcmVkLiAgJzAgaXMgdXNlZCBmb3IgdGhlIGN1cnJlbnQKCQljdXJzb3IgcG9zaXRpb24gKHdoZW4gZXhpdGluZyBvciB3aGVuIGRvaW5nICI6d3ZpbWluZm8iKS4KCWgJRGlzYWJsZSB0aGUgZWZmZWN0IG9mICdobHNlYXJjaCcgd2hlbiBsb2FkaW5nIHRoZSB2aW1pbmZvCgkJZmlsZS4gIFdoZW4gbm90IGluY2x1ZGVkLCBpdCBkZXBlbmRzIG9uIHdoZXRoZXIgIjpub2hsc2VhcmNoIgoJCWhhcyBiZWVuIHVzZWQgc2luY2UgdGhlIGxhc3Qgc2VhcmNoIGNvbW1hbmQuCgluCU5hbWUgb2YgdGhlIHZpbWluZm8gZmlsZS4gIFRoZSBuYW1lIG11c3QgaW1tZWRpYXRlbHkgZm9sbG93CgkJdGhlICduJy4gIE11c3QgYmUgdGhlIGxhc3Qgb25lISAgSWYgdGhlICItaSIgYXJndW1lbnQgd2FzCgkJZ2l2ZW4gd2hlbiBzdGFydGluZyBWaW0sIHRoYXQgZmlsZSBuYW1lIG92ZXJyaWRlcyB0aGUgb25lCgkJZ2l2ZW4gaGVyZSB3aXRoICd2aW1pbmZvJy4gIEVudmlyb25tZW50IHZhcmlhYmxlcyBhcmUgZXhwYW5kZWQKCQl3aGVuIG9wZW5pbmcgdGhlIGZpbGUsIG5vdCB3aGVuIHNldHRpbmcgdGhlIG9wdGlvbi4KCXIJUmVtb3ZhYmxlIG1lZGlhLiAgVGhlIGFyZ3VtZW50IGlzIGEgc3RyaW5nICh1cCB0byB0aGUgbmV4dAoJCScsJykuICBUaGlzIHBhcmFtZXRlciBjYW4gYmUgZ2l2ZW4gc2V2ZXJhbCB0aW1lcy4gIEVhY2gKCQlzcGVjaWZpZXMgdGhlIHN0YXJ0IG9mIGEgcGF0aCBmb3Igd2hpY2ggbm8gbWFya3Mgd2lsbCBiZQoJCXN0b3JlZC4gIFRoaXMgaXMgdG8gYXZvaWQgcmVtb3ZhYmxlIG1lZGlhLiAgRm9yIE1TLURPUyB5b3UKCQljb3VsZCB1c2UgInJhOixyYjoiLCBmb3IgQW1pZ2EgInJkZjA6LHJkZjE6LHJkZjI6Ii4gIFlvdSBjYW4KCQlhbHNvIHVzZSBpdCBmb3IgdGVtcCBmaWxlcywgZS5nLiwgZm9yIFVuaXg6ICJyL3RtcCIuICBDYXNlIGlzCgkJaWdub3JlZC4gIE1heGltdW0gbGVuZ3RoIG9mIGVhY2ggJ3InIGFyZ3VtZW50IGlzIDUwCgkJY2hhcmFjdGVycy4KCXMJTWF4aW11bSBzaXplIG9mIGFuIGl0ZW0gaW4gS2J5dGUuICBJZiB6ZXJvIHRoZW4gcmVnaXN0ZXJzIGFyZQoJCW5vdCBzYXZlZC4gIEN1cnJlbnRseSBvbmx5IGFwcGxpZXMgdG8gcmVnaXN0ZXJzLiAgVGhlIGRlZmF1bHQKCQkiczEwIiB3aWxsIGV4Y2x1ZGUgcmVnaXN0ZXJzIHdpdGggbW9yZSB0aGFuIDEwIEtieXRlIG9mIHRleHQuCgkJQWxzbyBzZWUgdGhlICc8JyBpdGVtIGFib3ZlOiBsaW5lIGNvdW50IGxpbWl0LgoKCUV4YW1wbGU6ID4KCSAgICA6c2V0IHZpbWluZm89JzUwLDwxMDAwLHMxMDAsOjAsbn4vdmltL3ZpbWluZm8KPAoJJzUwCQlNYXJrcyB3aWxsIGJlIHJlbWVtYmVyZWQgZm9yIHRoZSBsYXN0IDUwIGZpbGVzIHlvdQoJCQllZGl0ZWQuCgk8MTAwMAkJQ29udGVudHMgb2YgcmVnaXN0ZXJzICh1cCB0byAxMDAwIGxpbmVzIGVhY2gpIHdpbGwgYmUKCQkJcmVtZW1iZXJlZC4KCXMxMDAJCVJlZ2lzdGVycyB3aXRoIG1vcmUgdGhhbiAxMDAgS2J5dGUgdGV4dCBhcmUgc2tpcHBlZC4KCTowCQlDb21tYW5kLWxpbmUgaGlzdG9yeSB3aWxsIG5vdCBiZSBzYXZlZC4KCW5+L3ZpbS92aW1pbmZvCVRoZSBuYW1lIG9mIHRoZSBmaWxlIHRvIHVzZSBpcyAifi92aW0vdmltaW5mbyIuCglubyAvCQlTaW5jZSAnLycgaXMgbm90IHNwZWNpZmllZCwgdGhlIGRlZmF1bHQgd2lsbCBiZSB1c2VkLAoJCQl0aGF0IGlzLCBzYXZlIGFsbCBvZiB0aGUgc2VhcmNoIGhpc3RvcnksIGFuZCBhbHNvIHRoZQoJCQlwcmV2aW91cyBzZWFyY2ggYW5kIHN1YnN0aXR1dGUgcGF0dGVybnMuCglubyAlCQlUaGUgYnVmZmVyIGxpc3Qgd2lsbCBub3QgYmUgc2F2ZWQgbm9yIHJlYWQgYmFjay4KCW5vIGgJCSdobHNlYXJjaCcgaGlnaGxpZ2h0aW5nIHdpbGwgYmUgcmVzdG9yZWQuCgoJV2hlbiBzZXR0aW5nICd2aW1pbmZvJyBmcm9tIGFuIGVtcHR5IHZhbHVlIHlvdSBjYW4gdXNlIHw6cnZpbWluZm98IHRvCglsb2FkIHRoZSBjb250ZW50cyBvZiB0aGUgZmlsZSwgdGhpcyBpcyBub3QgZG9uZSBhdXRvbWF0aWNhbGx5LgoKCVRoaXMgb3B0aW9uIGNhbm5vdCBiZSBzZXQgZnJvbSBhIHxtb2RlbGluZXwgb3IgaW4gdGhlIHxzYW5kYm94fCwgZm9yCglzZWN1cml0eSByZWFzb25zLgoKCQkJCQkgICAgKid2aXJ0dWFsZWRpdCcqICondmUnKgondmlydHVhbGVkaXQnICd2ZScJc3RyaW5nCShkZWZhdWx0ICIiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZQoJCQl8K3ZpcnR1YWxlZGl0fCBmZWF0dXJlfQoJQSBjb21tYSBzZXBhcmF0ZWQgbGlzdCBvZiB0aGVzZSB3b3JkczoKCSAgICBibG9jawlBbGxvdyB2aXJ0dWFsIGVkaXRpbmcgaW4gVmlzdWFsIGJsb2NrIG1vZGUuCgkgICAgaW5zZXJ0CUFsbG93IHZpcnR1YWwgZWRpdGluZyBpbiBJbnNlcnQgbW9kZS4KCSAgICBhbGwJCUFsbG93IHZpcnR1YWwgZWRpdGluZyBpbiBhbGwgbW9kZXMuCglWaXJ0dWFsIGVkaXRpbmcgbWVhbnMgdGhhdCB0aGUgY3Vyc29yIGNhbiBiZSBwb3NpdGlvbmVkIHdoZXJlIHRoZXJlIGlzCglubyBhY3R1YWwgY2hhcmFjdGVyLiAgVGhpcyBjYW4gYmUgaGFsZndheSBpbnRvIGEgVGFiIG9yIGJleW9uZCB0aGUgZW5kCglvZiB0aGUgbGluZS4gIFVzZWZ1bCBmb3Igc2VsZWN0aW5nIGEgcmVjdGFuZ2xlIGluIFZpc3VhbCBtb2RlIGFuZAoJZWRpdGluZyBhIHRhYmxlLgoKCQkJKid2aXN1YWxiZWxsJyogKid2YicqIConbm92aXN1YWxiZWxsJyogKidub3ZiJyogKmJlZXAqCid2aXN1YWxiZWxsJyAndmInCWJvb2xlYW4JKGRlZmF1bHQgb2ZmKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCVVzZSB2aXN1YWwgYmVsbCBpbnN0ZWFkIG9mIGJlZXBpbmcuICBUaGUgdGVybWluYWwgY29kZSB0byBkaXNwbGF5IHRoZQoJdmlzdWFsIGJlbGwgaXMgZ2l2ZW4gd2l0aCAndF92YicuICBXaGVuIG5vIGJlZXAgb3IgZmxhc2ggaXMgd2FudGVkLAoJdXNlICI6c2V0IHZiIHRfdmI9Ii4KCU5vdGU6IFdoZW4gdGhlIEdVSSBzdGFydHMsICd0X3ZiJyBpcyByZXNldCB0byBpdHMgZGVmYXVsdCB2YWx1ZS4gIFlvdQoJbWlnaHQgd2FudCB0byBzZXQgaXQgYWdhaW4gaW4geW91ciB8Z3ZpbXJjfC4KCUluIHRoZSBHVUksICd0X3ZiJyBkZWZhdWx0cyB0byAiPEVzYz58ZiIsIHdoaWNoIGludmVydHMgdGhlIGRpc3BsYXkKCWZvciAyMCBtc2VjLiAgSWYgeW91IHdhbnQgdG8gdXNlIGEgZGlmZmVyZW50IHRpbWUsIHVzZSAiPEVzYz58NDBmIiwKCXdoZXJlIDQwIGlzIHRoZSB0aW1lIGluIG1zZWMuCglEb2VzIG5vdCB3b3JrIG9uIHRoZSBBbWlnYSwgeW91IGFsd2F5cyBnZXQgYSBzY3JlZW4gZmxhc2guCglBbHNvIHNlZSAnZXJyb3JiZWxscycuCgoJCQkJCQkqJ3dhcm4nKiAqJ25vd2FybicqCid3YXJuJwkJCWJvb2xlYW4JKGRlZmF1bHQgb24pCgkJCWdsb2JhbAoJR2l2ZSBhIHdhcm5pbmcgbWVzc2FnZSB3aGVuIGEgc2hlbGwgY29tbWFuZCBpcyB1c2VkIHdoaWxlIHRoZSBidWZmZXIKCWhhcyBiZWVuIGNoYW5nZWQuCgoJCSAgICAgKid3ZWlyZGludmVydCcqICond2l2JyogKidub3dlaXJkaW52ZXJ0JyogKidub3dpdicqCid3ZWlyZGludmVydCcgJ3dpdicJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJVGhpcyBvcHRpb24gaGFzIHRoZSBzYW1lIGVmZmVjdCBhcyB0aGUgJ3RfeHMnIHRlcm1jYXAgb3B0aW9uLgoJSXQgaXMgcHJvdmlkZWQgZm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5IHdpdGggdmVyc2lvbiA0LnguCglTZXR0aW5nICd3ZWlyZGludmVydCcgaGFzIHRoZSBlZmZlY3Qgb2YgbWFraW5nICd0X3hzJyBub24tZW1wdHksIGFuZAoJdmljZSB2ZXJzYS4gIEhhcyBubyBlZmZlY3Qgd2hlbiB0aGUgR1VJIGlzIHJ1bm5pbmcuCgoJCQkJCQkqJ3doaWNod3JhcCcqICond3cnKgond2hpY2h3cmFwJyAnd3cnCXN0cmluZwkoVmltIGRlZmF1bHQ6ICJiLHMiLCBWaSBkZWZhdWx0OiAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglBbGxvdyBzcGVjaWZpZWQga2V5cyB0aGF0IG1vdmUgdGhlIGN1cnNvciBsZWZ0L3JpZ2h0IHRvIG1vdmUgdG8gdGhlCglwcmV2aW91cy9uZXh0IGxpbmUgd2hlbiB0aGUgY3Vyc29yIGlzIG9uIHRoZSBmaXJzdC9sYXN0IGNoYXJhY3RlciBpbgoJdGhlIGxpbmUuICBDb25jYXRlbmF0ZSBjaGFyYWN0ZXJzIHRvIGFsbG93IHRoaXMgZm9yIHRoZXNlIGtleXM6CgkJY2hhciAgIGtleQkgIG1vZGUJfgoJCSBiICAgIDxCUz4JIE5vcm1hbCBhbmQgVmlzdWFsCgkJIHMgICAgPFNwYWNlPgkgTm9ybWFsIGFuZCBWaXN1YWwKCQkgaCAgICAiaCIJIE5vcm1hbCBhbmQgVmlzdWFsCgkJIGwgICAgImwiCSBOb3JtYWwgYW5kIFZpc3VhbAoJCSA8ICAgIDxMZWZ0PgkgTm9ybWFsIGFuZCBWaXN1YWwKCQkgPiAgICA8UmlnaHQ+CSBOb3JtYWwgYW5kIFZpc3VhbAoJCSB+ICAgICJ+IgkgTm9ybWFsCgkJIFsgICAgPExlZnQ+CSBJbnNlcnQgYW5kIFJlcGxhY2UKCQkgXSAgICA8UmlnaHQ+CSBJbnNlcnQgYW5kIFJlcGxhY2UKCUZvciBleGFtcGxlOiA+CgkJOnNldCB3dz08LD4sWyxdCjwJYWxsb3dzIHdyYXAgb25seSB3aGVuIGN1cnNvciBrZXlzIGFyZSB1c2VkLgoJV2hlbiB0aGUgbW92ZW1lbnQga2V5cyBhcmUgdXNlZCBpbiBjb21iaW5hdGlvbiB3aXRoIGEgZGVsZXRlIG9yIGNoYW5nZQoJb3BlcmF0b3IsIHRoZSA8RU9MPiBhbHNvIGNvdW50cyBmb3IgYSBjaGFyYWN0ZXIuICBUaGlzIG1ha2VzICIzaCIKCWRpZmZlcmVudCBmcm9tICIzZGgiIHdoZW4gdGhlIGN1cnNvciBjcm9zc2VzIHRoZSBlbmQgb2YgYSBsaW5lLiAgVGhpcwoJaXMgYWxzbyB0cnVlIGZvciAieCIgYW5kICJYIiwgYmVjYXVzZSB0aGV5IGRvIHRoZSBzYW1lIGFzICJkbCIgYW5kCgkiZGgiLiAgSWYgeW91IHVzZSB0aGlzLCB5b3UgbWF5IGFsc28gd2FudCB0byB1c2UgdGhlIG1hcHBpbmcKCSI6bWFwIDxCUz4gWCIgdG8gbWFrZSBiYWNrc3BhY2UgZGVsZXRlIHRoZSBjaGFyYWN0ZXIgaW4gZnJvbnQgb2YgdGhlCgljdXJzb3IuCglXaGVuICdsJyBpcyBpbmNsdWRlZCwgeW91IGdldCBhIHNpZGUgZWZmZWN0OiAieWwiIG9uIGFuIGVtcHR5IGxpbmUKCXdpbGwgaW5jbHVkZSB0aGUgPEVPTD4sIHNvIHRoYXQgInAiIHdpbGwgaW5zZXJ0IGEgbmV3IGxpbmUuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyBzZXQgdG8gdGhlIFZpIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMKCXNldCBhbmQgdG8gdGhlIFZpbSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzIHJlc2V0LgoKCQkJCQkJKid3aWxkY2hhcicqICond2MnKgond2lsZGNoYXInICd3YycJCW51bWJlcgkoVmltIGRlZmF1bHQ6IDxUYWI+LCBWaSBkZWZhdWx0OiBDVFJMLUUpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJQ2hhcmFjdGVyIHlvdSBoYXZlIHRvIHR5cGUgdG8gc3RhcnQgd2lsZGNhcmQgZXhwYW5zaW9uIGluIHRoZQoJY29tbWFuZC1saW5lLCBhcyBzcGVjaWZpZWQgd2l0aCAnd2lsZG1vZGUnLgoJVGhlIGNoYXJhY3RlciBpcyBub3QgcmVjb2duaXplZCB3aGVuIHVzZWQgaW5zaWRlIGEgbWFjcm8uICBTZWUKCSd3aWxkY2hhcm0nIGZvciB0aGF0LgoJQWx0aG91Z2ggJ3djJyBpcyBhIG51bWJlciBvcHRpb24sIHlvdSBjYW4gc2V0IGl0IHRvIGEgc3BlY2lhbCBrZXk6ID4KCQk6c2V0IHdjPTxFc2M+CjwJTk9URTogVGhpcyBvcHRpb24gaXMgc2V0IHRvIHRoZSBWaSBkZWZhdWx0IHZhbHVlIHdoZW4gJ2NvbXBhdGlibGUnIGlzCglzZXQgYW5kIHRvIHRoZSBWaW0gZGVmYXVsdCB2YWx1ZSB3aGVuICdjb21wYXRpYmxlJyBpcyByZXNldC4KCgkJCQkJCSond2lsZGNoYXJtJyogKid3Y20nKgond2lsZGNoYXJtJyAnd2NtJwludW1iZXIJKGRlZmF1bHQ6IG5vbmUgKDApKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCSd3aWxkY2hhcm0nIHdvcmtzIGV4YWN0bHkgbGlrZSAnd2lsZGNoYXInLCBleGNlcHQgdGhhdCBpdCBpcwoJcmVjb2duaXplZCB3aGVuIHVzZWQgaW5zaWRlIGEgbWFjcm8uICBZb3UgY2FuIGZpbmQgInNwYXJlIiBjb21tYW5kLWxpbmUKCWtleXMgc3VpdGFibGUgZm9yIHRoaXMgb3B0aW9uIGJ5IGxvb2tpbmcgYXQgfGV4LWVkaXQtaW5kZXh8LiAgTm9ybWFsbHkKCXlvdSdsbCBuZXZlciBhY3R1YWxseSB0eXBlICd3aWxkY2hhcm0nLCBqdXN0IHVzZSBpdCBpbiBtYXBwaW5ncyB0aGF0CglhdXRvbWF0aWNhbGx5IGludm9rZSBjb21wbGV0aW9uIG1vZGUsIGUuZy46ID4KCQk6c2V0IHdjbT08Qy1aPgoJCTpjbWFwIHNzIHNvICR2aW0vc2Vzc2lvbnMvKi52aW08Qy1aPgo8CVRoZW4gYWZ0ZXIgdHlwaW5nIDpzcyB5b3UgY2FuIHVzZSBDVFJMLVAgJiBDVFJMLU4uCgoJCQkJCQkqJ3dpbGRpZ25vcmUnKiAqJ3dpZycqCid3aWxkaWdub3JlJyAnd2lnJwlzdHJpbmcJKGRlZmF1bHQgIiIpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlIHwrd2lsZGlnbm9yZXwKCQkJZmVhdHVyZX0KCUEgbGlzdCBvZiBmaWxlIHBhdHRlcm5zLiAgQSBmaWxlIHRoYXQgbWF0Y2hlcyB3aXRoIG9uZSBvZiB0aGVzZQoJcGF0dGVybnMgaXMgaWdub3JlZCB3aGVuIGNvbXBsZXRpbmcgZmlsZSBvciBkaXJlY3RvcnkgbmFtZXMuCglUaGUgcGF0dGVybiBpcyB1c2VkIGxpa2Ugd2l0aCB8OmF1dG9jbWR8LCBzZWUgfGF1dG9jbWQtcGF0dGVybnN8LgoJQWxzbyBzZWUgJ3N1ZmZpeGVzJy4KCUV4YW1wbGU6ID4KCQk6c2V0IHdpbGRpZ25vcmU9Ki5vLCoub2JqCjwJVGhlIHVzZSBvZiB8OnNldCs9fCBhbmQgfDpzZXQtPXwgaXMgcHJlZmVycmVkIHdoZW4gYWRkaW5nIG9yIHJlbW92aW5nCglhIHBhdHRlcm4gZnJvbSB0aGUgbGlzdC4gIFRoaXMgYXZvaWRzIHByb2JsZW1zIHdoZW4gYSBmdXR1cmUgdmVyc2lvbgoJdXNlcyBhbm90aGVyIGRlZmF1bHQuCgoJCQkJKid3aWxkbWVudScqICond21udScqIConbm93aWxkbWVudScqIConbm93bW51JyoKJ3dpbGRtZW51JyAnd21udScJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSBpZiBjb21waWxlZCB3aXRob3V0IHRoZSB8K3dpbGRtZW51fAoJCQlmZWF0dXJlfQoJV2hlbiAnd2lsZG1lbnUnIGlzIG9uLCBjb21tYW5kLWxpbmUgY29tcGxldGlvbiBvcGVyYXRlcyBpbiBhbiBlbmhhbmNlZAoJbW9kZS4gIE9uIHByZXNzaW5nICd3aWxkY2hhcicgKHVzdWFsbHkgPFRhYj4pIHRvIGludm9rZSBjb21wbGV0aW9uLAoJdGhlIHBvc3NpYmxlIG1hdGNoZXMgYXJlIHNob3duIGp1c3QgYWJvdmUgdGhlIGNvbW1hbmQgbGluZSwgd2l0aCB0aGUKCWZpcnN0IG1hdGNoIGhpZ2hsaWdodGVkIChvdmVyd3JpdGluZyB0aGUgc3RhdHVzIGxpbmUsIGlmIHRoZXJlIGlzCglvbmUpLiAgS2V5cyB0aGF0IHNob3cgdGhlIHByZXZpb3VzL25leHQgbWF0Y2gsIHN1Y2ggYXMgPFRhYj4gb3IKCUNUUkwtUC9DVFJMLU4sIGNhdXNlIHRoZSBoaWdobGlnaHQgdG8gbW92ZSB0byB0aGUgYXBwcm9wcmlhdGUgbWF0Y2guCglXaGVuICd3aWxkbW9kZScgaXMgdXNlZCwgIndpbGRtZW51IiBtb2RlIGlzIHVzZWQgd2hlcmUgImZ1bGwiIGlzCglzcGVjaWZpZWQuICAibG9uZ2VzdCIgYW5kICJsaXN0IiBkbyBub3Qgc3RhcnQgIndpbGRtZW51IiBtb2RlLgoJSWYgdGhlcmUgYXJlIG1vcmUgbWF0Y2hlcyB0aGFuIGNhbiBmaXQgaW4gdGhlIGxpbmUsIGEgIj4iIGlzIHNob3duIG9uCgl0aGUgcmlnaHQgYW5kL29yIGEgIjwiIGlzIHNob3duIG9uIHRoZSBsZWZ0LiAgVGhlIHN0YXR1cyBsaW5lIHNjcm9sbHMKCWFzIG5lZWRlZC4KCVRoZSAid2lsZG1lbnUiIG1vZGUgaXMgYWJhbmRvbmVkIHdoZW4gYSBrZXkgaXMgaGl0IHRoYXQgaXMgbm90IHVzZWQKCWZvciBzZWxlY3RpbmcgYSBjb21wbGV0aW9uLgoJV2hpbGUgdGhlICJ3aWxkbWVudSIgaXMgYWN0aXZlIHRoZSBmb2xsb3dpbmcga2V5cyBoYXZlIHNwZWNpYWwKCW1lYW5pbmdzOgoKCTxMZWZ0PiA8UmlnaHQ+CS0gc2VsZWN0IHByZXZpb3VzL25leHQgbWF0Y2ggKGxpa2UgQ1RSTC1QL0NUUkwtTikKCTxEb3duPgkJLSBpbiBmaWxlbmFtZS9tZW51IG5hbWUgY29tcGxldGlvbjogbW92ZSBpbnRvIGEKCQkJICBzdWJkaXJlY3Rvcnkgb3Igc3VibWVudS4KCTxDUj4JCS0gaW4gbWVudSBjb21wbGV0aW9uLCB3aGVuIHRoZSBjdXJzb3IgaXMganVzdCBhZnRlciBhCgkJCSAgZG90OiBtb3ZlIGludG8gYSBzdWJtZW51LgoJPFVwPgkJLSBpbiBmaWxlbmFtZS9tZW51IG5hbWUgY29tcGxldGlvbjogbW92ZSB1cCBpbnRvCgkJCSAgcGFyZW50IGRpcmVjdG9yeSBvciBwYXJlbnQgbWVudS4KCglUaGlzIG1ha2VzIHRoZSBtZW51cyBhY2Nlc3NpYmxlIGZyb20gdGhlIGNvbnNvbGUgfGNvbnNvbGUtbWVudXN8LgoKCUlmIHlvdSBwcmVmZXIgdGhlIDxMZWZ0PiBhbmQgPFJpZ2h0PiBrZXlzIHRvIG1vdmUgdGhlIGN1cnNvciBpbnN0ZWFkCglvZiBzZWxlY3RpbmcgYSBkaWZmZXJlbnQgbWF0Y2gsIHVzZSB0aGlzOiA+CgkJOmNub3JlbWFwIDxMZWZ0PiA8U3BhY2U+PEJTPjxMZWZ0PgoJCTpjbm9yZW1hcCA8UmlnaHQ+IDxTcGFjZT48QlM+PFJpZ2h0Pgo8CglUaGUgIldpbGRNZW51IiBoaWdobGlnaHRpbmcgaXMgdXNlZCBmb3IgZGlzcGxheWluZyB0aGUgY3VycmVudCBtYXRjaAoJfGhsLVdpbGRNZW51fC4KCgkJCQkJCSond2lsZG1vZGUnKiAqJ3dpbScqCid3aWxkbW9kZScgJ3dpbScJc3RyaW5nCShWaW0gZGVmYXVsdDogImZ1bGwiKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCUNvbXBsZXRpb24gbW9kZSB0aGF0IGlzIHVzZWQgZm9yIHRoZSBjaGFyYWN0ZXIgc3BlY2lmaWVkIHdpdGgKCSd3aWxkY2hhcicuICBJdCBpcyBhIGNvbW1hIHNlcGFyYXRlZCBsaXN0IG9mIHVwIHRvIGZvdXIgcGFydHMuICBFYWNoCglwYXJ0IHNwZWNpZmllcyB3aGF0IHRvIGRvIGZvciBlYWNoIGNvbnNlY3V0aXZlIHVzZSBvZiAnd2lsZGNoYXIuICBUaGUKCWZpcnN0IHBhcnQgc3BlY2lmaWVzIHRoZSBiZWhhdmlvciBmb3IgdGhlIGZpcnN0IHVzZSBvZiAnd2lsZGNoYXInLAoJVGhlIHNlY29uZCBwYXJ0IGZvciB0aGUgc2Vjb25kIHVzZSwgZXRjLgoJVGhlc2UgYXJlIHRoZSBwb3NzaWJsZSB2YWx1ZXMgZm9yIGVhY2ggcGFydDoKCSIiCQlDb21wbGV0ZSBvbmx5IHRoZSBmaXJzdCBtYXRjaC4KCSJmdWxsIgkJQ29tcGxldGUgdGhlIG5leHQgZnVsbCBtYXRjaC4gIEFmdGVyIHRoZSBsYXN0IG1hdGNoLAoJCQl0aGUgb3JpZ2luYWwgc3RyaW5nIGlzIHVzZWQgYW5kIHRoZW4gdGhlIGZpcnN0IG1hdGNoCgkJCWFnYWluLgoJImxvbmdlc3QiCUNvbXBsZXRlIHRpbGwgbG9uZ2VzdCBjb21tb24gc3RyaW5nLiAgSWYgdGhpcyBkb2Vzbid0CgkJCXJlc3VsdCBpbiBhIGxvbmdlciBzdHJpbmcsIHVzZSB0aGUgbmV4dCBwYXJ0LgoJImxvbmdlc3Q6ZnVsbCIJTGlrZSAibG9uZ2VzdCIsIGJ1dCBhbHNvIHN0YXJ0ICd3aWxkbWVudScgaWYgaXQgaXMKCQkJZW5hYmxlZC4KCSJsaXN0IgkJV2hlbiBtb3JlIHRoYW4gb25lIG1hdGNoLCBsaXN0IGFsbCBtYXRjaGVzLgoJImxpc3Q6ZnVsbCIJV2hlbiBtb3JlIHRoYW4gb25lIG1hdGNoLCBsaXN0IGFsbCBtYXRjaGVzIGFuZAoJCQljb21wbGV0ZSBmaXJzdCBtYXRjaC4KCSJsaXN0Omxvbmdlc3QiCVdoZW4gbW9yZSB0aGFuIG9uZSBtYXRjaCwgbGlzdCBhbGwgbWF0Y2hlcyBhbmQKCQkJY29tcGxldGUgdGlsbCBsb25nZXN0IGNvbW1vbiBzdHJpbmcuCglXaGVuIHRoZXJlIGlzIG9ubHkgYSBzaW5nbGUgbWF0Y2gsIGl0IGlzIGZ1bGx5IGNvbXBsZXRlZCBpbiBhbGwgY2FzZXMuCgoJRXhhbXBsZXM6ID4KCQk6c2V0IHdpbGRtb2RlPWZ1bGwKPAlDb21wbGV0ZSBmaXJzdCBmdWxsIG1hdGNoLCBuZXh0IG1hdGNoLCBldGMuICAodGhlIGRlZmF1bHQpID4KCQk6c2V0IHdpbGRtb2RlPWxvbmdlc3QsZnVsbAo8CUNvbXBsZXRlIGxvbmdlc3QgY29tbW9uIHN0cmluZywgdGhlbiBlYWNoIGZ1bGwgbWF0Y2ggPgoJCTpzZXQgd2lsZG1vZGU9bGlzdDpmdWxsCjwJTGlzdCBhbGwgbWF0Y2hlcyBhbmQgY29tcGxldGUgZWFjaCBmdWxsIG1hdGNoID4KCQk6c2V0IHdpbGRtb2RlPWxpc3QsZnVsbAo8CUxpc3QgYWxsIG1hdGNoZXMgd2l0aG91dCBjb21wbGV0aW5nLCB0aGVuIGVhY2ggZnVsbCBtYXRjaCA+CgkJOnNldCB3aWxkbW9kZT1sb25nZXN0LGxpc3QKPAlDb21wbGV0ZSBsb25nZXN0IGNvbW1vbiBzdHJpbmcsIHRoZW4gbGlzdCBhbHRlcm5hdGl2ZXMuCgoJCQkJCQkqJ3dpbGRvcHRpb25zJyogKid3b3AnKgond2lsZG9wdGlvbnMnICd3b3AnCXN0cmluZwkoZGVmYXVsdCAiIikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgfCt3aWxkaWdub3JlfAoJCQlmZWF0dXJlfQoJQSBsaXN0IG9mIHdvcmRzIHRoYXQgY2hhbmdlIGhvdyBjb21tYW5kIGxpbmUgY29tcGxldGlvbiBpcyBkb25lLgoJQ3VycmVudGx5IG9ubHkgb25lIHdvcmQgaXMgYWxsb3dlZDoKCSAgdGFnZmlsZQlXaGVuIHVzaW5nIENUUkwtRCB0byBsaXN0IG1hdGNoaW5nIHRhZ3MsIHRoZSBraW5kIG9mCgkgICAJCXRhZyBhbmQgdGhlIGZpbGUgb2YgdGhlIHRhZyBpcyBsaXN0ZWQuICBPbmx5IG9uZSBtYXRjaAoJCQlpcyBkaXNwbGF5ZWQgcGVyIGxpbmUuICBPZnRlbiB1c2VkIHRhZyBraW5kcyBhcmU6CgkJCQlkCSNkZWZpbmUKCQkJCWYJZnVuY3Rpb24KCUFsc28gc2VlIHxjbWRsaW5lLWNvbXBsZXRpb258LgoKCQkJCQkJKid3aW5hbHRrZXlzJyogKid3YWsnKgond2luYWx0a2V5cycgJ3dhaycJc3RyaW5nCShkZWZhdWx0ICJtZW51IikKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtvbmx5IHVzZWQgaW4gV2luMzIsIE1vdGlmLCBHVEsgYW5kIFBob3RvbiBHVUl9CglTb21lIEdVSSB2ZXJzaW9ucyBhbGxvdyB0aGUgYWNjZXNzIHRvIG1lbnUgZW50cmllcyBieSB1c2luZyB0aGUgQUxUCglrZXkgaW4gY29tYmluYXRpb24gd2l0aCBhIGNoYXJhY3RlciB0aGF0IGFwcGVhcnMgdW5kZXJsaW5lZCBpbiB0aGUKCW1lbnUuICBUaGlzIGNvbmZsaWN0cyB3aXRoIHRoZSB1c2Ugb2YgdGhlIEFMVCBrZXkgZm9yIG1hcHBpbmdzIGFuZAoJZW50ZXJpbmcgc3BlY2lhbCBjaGFyYWN0ZXJzLiAgVGhpcyBvcHRpb24gdGVsbHMgd2hhdCB0byBkbzoKCSAgbm8JRG9uJ3QgdXNlIEFMVCBrZXlzIGZvciBtZW51cy4gIEFMVCBrZXkgY29tYmluYXRpb25zIGNhbiBiZQoJCW1hcHBlZCwgYnV0IHRoZXJlIGlzIG5vIGF1dG9tYXRpYyBoYW5kbGluZy4gIFRoaXMgY2FuIHRoZW4gYmUKCQlkb25lIHdpdGggdGhlIHw6c2ltYWx0fCBjb21tYW5kLgoJICB5ZXMJQUxUIGtleSBoYW5kbGluZyBpcyBkb25lIGJ5IHRoZSB3aW5kb3dpbmcgc3lzdGVtLiAgQUxUIGtleQoJCWNvbWJpbmF0aW9ucyBjYW5ub3QgYmUgbWFwcGVkLgoJICBtZW51CVVzaW5nIEFMVCBpbiBjb21iaW5hdGlvbiB3aXRoIGEgY2hhcmFjdGVyIHRoYXQgaXMgYSBtZW51CgkJc2hvcnRjdXQga2V5LCB3aWxsIGJlIGhhbmRsZWQgYnkgdGhlIHdpbmRvd2luZyBzeXN0ZW0uICBPdGhlcgoJCWtleXMgY2FuIGJlIG1hcHBlZC4KCUlmIHRoZSBtZW51IGlzIGRpc2FibGVkIGJ5IGV4Y2x1ZGluZyAnbScgZnJvbSAnZ3Vpb3B0aW9ucycsIHRoZSBBTFQKCWtleSBpcyBuZXZlciB1c2VkIGZvciB0aGUgbWVudS4KCVRoaXMgb3B0aW9uIGlzIG5vdCB1c2VkIGZvciA8RjEwPjsgb24gV2luMzIgYW5kIHdpdGggR1RLIDxGMTA+IHdpbGwKCXNlbGVjdCB0aGUgbWVudSwgdW5sZXNzIGl0IGhhcyBiZWVuIG1hcHBlZC4KCgkJCQkJCSond2luZG93JyogKid3aScqCid3aW5kb3cnICd3aScJCW51bWJlciAgKGRlZmF1bHQgc2NyZWVuIGhlaWdodCAtIDEpCgkJCWdsb2JhbAoJV2luZG93IGhlaWdodC4gIERvIG5vdCBjb25mdXNlIHRoaXMgd2l0aCB0aGUgaGVpZ2h0IG9mIHRoZSBWaW0gd2luZG93LAoJdXNlICdsaW5lcycgZm9yIHRoYXQuCglVc2VkIGZvciB8Q1RSTC1GfCBhbmQgfENUUkwtQnwgd2hlbiB0aGVyZSBpcyBvbmx5IG9uZSB3aW5kb3cgYW5kIHRoZQoJdmFsdWUgaXMgc21hbGxlciB0aGFuICdsaW5lcycgbWludXMgb25lLiAgVGhlIHNjcmVlbiB3aWxsIHNjcm9sbAoJJ3dpbmRvdycgbWludXMgdHdvIGxpbmVzLCB3aXRoIGEgbWluaW11bSBvZiBvbmUuCglXaGVuICd3aW5kb3cnIGlzIGVxdWFsIHRvICdsaW5lcycgbWludXMgb25lIENUUkwtRiBhbmQgQ1RSTC1CIHNjcm9sbAoJaW4gYSBtdWNoIHNtYXJ0ZXIgd2F5LCB0YWtpbmcgY2FyZSBvZiB3cmFwcGluZyBsaW5lcy4KCVdoZW4gcmVzaXppbmcgdGhlIFZpbSB3aW5kb3csIHRoZSB2YWx1ZSBpcyBzbWFsbGVyIHRoYW4gMSBvciBtb3JlIHRoYW4KCW9yIGVxdWFsIHRvICdsaW5lcycgaXQgd2lsbCBiZSBzZXQgdG8gJ2xpbmVzJyBtaW51cyAxLgoJe1ZpIGFsc28gdXNlcyB0aGUgb3B0aW9uIHRvIHNwZWNpZnkgdGhlIG51bWJlciBvZiBkaXNwbGF5ZWQgbGluZXN9CgoJCQkJCQkqJ3dpbmhlaWdodCcqICond2gnKiAqRTU5MSoKJ3dpbmhlaWdodCcgJ3doJwludW1iZXIJKGRlZmF1bHQgMSkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CgkJCXtub3QgYXZhaWxhYmxlIHdoZW4gY29tcGlsZWQgd2l0aG91dCB0aGUgK3dpbmRvd3MKCQkJZmVhdHVyZX0KCU1pbmltYWwgbnVtYmVyIG9mIGxpbmVzIGZvciB0aGUgY3VycmVudCB3aW5kb3cuICBUaGlzIGlzIG5vdCBhIGhhcmQKCW1pbmltdW0sIFZpbSB3aWxsIHVzZSBmZXdlciBsaW5lcyBpZiB0aGVyZSBpcyBub3QgZW5vdWdoIHJvb20uICBJZiB0aGUKCWN1cnJlbnQgd2luZG93IGlzIHNtYWxsZXIsIGl0cyBzaXplIGlzIGluY3JlYXNlZCwgYXQgdGhlIGNvc3Qgb2YgdGhlCgloZWlnaHQgb2Ygb3RoZXIgd2luZG93cy4gIFNldCBpdCB0byA5OTkgdG8gbWFrZSB0aGUgY3VycmVudCB3aW5kb3cKCWFsd2F5cyBmaWxsIHRoZSBzY3JlZW4gKGFsdGhvdWdoIHRoaXMgaGFzIHRoZSBkcmF3YmFjayB0aGF0ICI6YWxsIgoJd2lsbCBjcmVhdGUgb25seSB0d28gd2luZG93cykuICBTZXQgaXQgdG8gYSBzbWFsbCBudW1iZXIgZm9yIG5vcm1hbAoJZWRpdGluZy4KCU1pbmltdW0gdmFsdWUgaXMgMS4KCVRoZSBoZWlnaHQgaXMgbm90IGFkanVzdGVkIGFmdGVyIG9uZSBvZiB0aGUgY29tbWFuZHMgdG8gY2hhbmdlIHRoZQoJaGVpZ2h0IG9mIHRoZSBjdXJyZW50IHdpbmRvdy4KCSd3aW5oZWlnaHQnIGFwcGxpZXMgdG8gdGhlIGN1cnJlbnQgd2luZG93LiAgVXNlICd3aW5taW5oZWlnaHQnIHRvIHNldAoJdGhlIG1pbmltYWwgaGVpZ2h0IGZvciBvdGhlciB3aW5kb3dzLgoKCQkJKid3aW5maXhoZWlnaHQnKiAqJ3dmaCcqIConbm93aW5maXhoZWlnaHQnKiAqJ25vd2ZoJyoKJ3dpbmZpeGhlaWdodCcgJ3dmaCcJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWxvY2FsIHRvIHdpbmRvdwoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlICt3aW5kb3dzCgkJCWZlYXR1cmV9CglLZWVwIHRoZSB3aW5kb3cgaGVpZ2h0IHdoZW4gd2luZG93cyBhcmUgb3BlbmVkIG9yIGNsb3NlZCBhbmQKCSdlcXVhbGFsd2F5cycgaXMgc2V0LiAgU2V0IGJ5IGRlZmF1bHQgZm9yIHRoZSB8cHJldmlldy13aW5kb3d8IGFuZAoJfHF1aWNrZml4LXdpbmRvd3wuCglUaGUgaGVpZ2h0IG1heSBiZSBjaGFuZ2VkIGFueXdheSB3aGVuIHJ1bm5pbmcgb3V0IG9mIHJvb20uCgoJCQkJCQkqJ3dpbm1pbmhlaWdodCcqICond21oJyoKJ3dpbm1pbmhlaWdodCcgJ3dtaCcJbnVtYmVyCShkZWZhdWx0IDEpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlICt3aW5kb3dzCgkJCWZlYXR1cmV9CglUaGUgbWluaW1hbCBoZWlnaHQgb2YgYSB3aW5kb3csIHdoZW4gaXQncyBub3QgdGhlIGN1cnJlbnQgd2luZG93LgoJVGhpcyBpcyBhIGhhcmQgbWluaW11bSwgd2luZG93cyB3aWxsIG5ldmVyIGJlY29tZSBzbWFsbGVyLgoJV2hlbiBzZXQgdG8gemVybywgd2luZG93cyBtYXkgYmUgInNxdWFzaGVkIiB0byB6ZXJvIGxpbmVzIChpLmUuIGp1c3QgYQoJc3RhdHVzIGJhcikgaWYgbmVjZXNzYXJ5LiAgVGhleSB3aWxsIHJldHVybiB0byBhdCBsZWFzdCBvbmUgbGluZSB3aGVuCgl0aGV5IGJlY29tZSBhY3RpdmUgKHNpbmNlIHRoZSBjdXJzb3IgaGFzIHRvIGhhdmUgc29tZXdoZXJlIHRvIGdvLikKCVVzZSAnd2luaGVpZ2h0JyB0byBzZXQgdGhlIG1pbmltYWwgaGVpZ2h0IG9mIHRoZSBjdXJyZW50IHdpbmRvdy4KCVRoaXMgb3B0aW9uIGlzIG9ubHkgY2hlY2tlZCB3aGVuIG1ha2luZyBhIHdpbmRvdyBzbWFsbGVyLiAgRG9uJ3QgdXNlIGEKCWxhcmdlIG51bWJlciwgaXQgd2lsbCBjYXVzZSBlcnJvcnMgd2hlbiBvcGVuaW5nIG1vcmUgdGhhbiBhIGZldwoJd2luZG93cy4gIEEgdmFsdWUgb2YgMCB0byAzIGlzIHJlYXNvbmFibGUuCgoJCQkJCQkqJ3dpbm1pbndpZHRoJyogKid3bXcnKgond2lubWlud2lkdGgnICd3bXcnCW51bWJlcgkoZGVmYXVsdCAxKQoJCQlnbG9iYWwKCQkJe25vdCBpbiBWaX0KCQkJe25vdCBhdmFpbGFibGUgd2hlbiBjb21waWxlZCB3aXRob3V0IHRoZSArdmVydHNwbGl0CgkJCWZlYXR1cmV9CglUaGUgbWluaW1hbCB3aWR0aCBvZiBhIHdpbmRvdywgd2hlbiBpdCdzIG5vdCB0aGUgY3VycmVudCB3aW5kb3cuCglUaGlzIGlzIGEgaGFyZCBtaW5pbXVtLCB3aW5kb3dzIHdpbGwgbmV2ZXIgYmVjb21lIHNtYWxsZXIuCglXaGVuIHNldCB0byB6ZXJvLCB3aW5kb3dzIG1heSBiZSAic3F1YXNoZWQiIHRvIHplcm8gY29sdW1ucyAoaS5lLiBqdXN0CglhIHZlcnRpY2FsIHNlcGFyYXRvcikgaWYgbmVjZXNzYXJ5LiAgVGhleSB3aWxsIHJldHVybiB0byBhdCBsZWFzdCBvbmUKCWxpbmUgd2hlbiB0aGV5IGJlY29tZSBhY3RpdmUgKHNpbmNlIHRoZSBjdXJzb3IgaGFzIHRvIGhhdmUgc29tZXdoZXJlCgl0byBnby4pCglVc2UgJ3dpbndpZHRoJyB0byBzZXQgdGhlIG1pbmltYWwgd2lkdGggb2YgdGhlIGN1cnJlbnQgd2luZG93LgoJVGhpcyBvcHRpb24gaXMgb25seSBjaGVja2VkIHdoZW4gbWFraW5nIGEgd2luZG93IHNtYWxsZXIuICBEb24ndCB1c2UgYQoJbGFyZ2UgbnVtYmVyLCBpdCB3aWxsIGNhdXNlIGVycm9ycyB3aGVuIG9wZW5pbmcgbW9yZSB0aGFuIGEgZmV3Cgl3aW5kb3dzLiAgQSB2YWx1ZSBvZiAwIHRvIDEyIGlzIHJlYXNvbmFibGUuCgoJCQkJCQkqJ3dpbndpZHRoJyogKid3aXcnKiAqRTU5MioKJ3dpbndpZHRoJyAnd2l3JwludW1iZXIJKGRlZmF1bHQgMjApCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJCQl7bm90IGF2YWlsYWJsZSB3aGVuIGNvbXBpbGVkIHdpdGhvdXQgdGhlICt2ZXJ0c3BsaXQKCQkJZmVhdHVyZX0KCU1pbmltYWwgbnVtYmVyIG9mIGNvbHVtbnMgZm9yIHRoZSBjdXJyZW50IHdpbmRvdy4gIFRoaXMgaXMgbm90IGEgaGFyZAoJbWluaW11bSwgVmltIHdpbGwgdXNlIGZld2VyIGNvbHVtbnMgaWYgdGhlcmUgaXMgbm90IGVub3VnaCByb29tLiAgSWYKCXRoZSBjdXJyZW50IHdpbmRvdyBpcyBzbWFsbGVyLCBpdHMgc2l6ZSBpcyBpbmNyZWFzZWQsIGF0IHRoZSBjb3N0IG9mCgl0aGUgd2lkdGggb2Ygb3RoZXIgd2luZG93cy4gIFNldCBpdCB0byA5OTkgdG8gbWFrZSB0aGUgY3VycmVudCB3aW5kb3cKCWFsd2F5cyBmaWxsIHRoZSBzY3JlZW4uICBTZXQgaXQgdG8gYSBzbWFsbCBudW1iZXIgZm9yIG5vcm1hbCBlZGl0aW5nLgoJVGhlIHdpZHRoIGlzIG5vdCBhZGp1c3RlZCBhZnRlciBvbmUgb2YgdGhlIGNvbW1hbmRzIHRvIGNoYW5nZSB0aGUKCXdpZHRoIG9mIHRoZSBjdXJyZW50IHdpbmRvdy4KCSd3aW53aWR0aCcgYXBwbGllcyB0byB0aGUgY3VycmVudCB3aW5kb3cuICBVc2UgJ3dpbm1pbndpZHRoJyB0byBzZXQKCXRoZSBtaW5pbWFsIHdpZHRoIGZvciBvdGhlciB3aW5kb3dzLgoKCQkJCQkJKid3cmFwJyogKidub3dyYXAnKgond3JhcCcJCQlib29sZWFuCShkZWZhdWx0IG9uKQoJCQlsb2NhbCB0byB3aW5kb3cKCQkJe25vdCBpbiBWaX0KCVRoaXMgb3B0aW9uIGNoYW5nZXMgaG93IHRleHQgaXMgZGlzcGxheWVkLiAgSXQgZG9lc24ndCBjaGFuZ2UgdGhlIHRleHQKCWluIHRoZSBidWZmZXIsIHNlZSAndGV4dHdpZHRoJyBmb3IgdGhhdC4KCVdoZW4gb24sIGxpbmVzIGxvbmdlciB0aGFuIHRoZSB3aWR0aCBvZiB0aGUgd2luZG93IHdpbGwgd3JhcCBhbmQKCWRpc3BsYXlpbmcgY29udGludWVzIG9uIHRoZSBuZXh0IGxpbmUuICBXaGVuIG9mZiBsaW5lcyB3aWxsIG5vdCB3cmFwCglhbmQgb25seSBwYXJ0IG9mIGxvbmcgbGluZXMgd2lsbCBiZSBkaXNwbGF5ZWQuICBXaGVuIHRoZSBjdXJzb3IgaXMKCW1vdmVkIHRvIGEgcGFydCB0aGF0IGlzIG5vdCBzaG93biwgdGhlIHNjcmVlbiB3aWxsIHNjcm9sbAoJaG9yaXpvbnRhbGx5LgoJVGhlIGxpbmUgd2lsbCBiZSBicm9rZW4gaW4gdGhlIG1pZGRsZSBvZiBhIHdvcmQgaWYgbmVjZXNzYXJ5LiAgU2VlCgknbGluZWJyZWFrJyB0byBnZXQgdGhlIGJyZWFrIGF0IGEgd29yZCBib3VuZGFyeS4KCVRvIG1ha2Ugc2Nyb2xsaW5nIGhvcml6b250YWxseSBhIGJpdCBtb3JlIHVzZWZ1bCwgdHJ5IHRoaXM6ID4KCQk6c2V0IHNpZGVzY3JvbGw9NQoJCTpzZXQgbGlzdGNoYXJzKz1wcmVjZWRlczo8LGV4dGVuZHM6Pgo8CVNlZSAnc2lkZXNjcm9sbCcsICdsaXN0Y2hhcnMnIGFuZCB8d3JhcC1vZmZ8LgoKCQkJCQkJKid3cmFwbWFyZ2luJyogKid3bScqCid3cmFwbWFyZ2luJyAnd20nCW51bWJlcgkoZGVmYXVsdCAwKQoJCQlsb2NhbCB0byBidWZmZXIKCU51bWJlciBvZiBjaGFyYWN0ZXJzIGZyb20gdGhlIHJpZ2h0IHdpbmRvdyBib3JkZXIgd2hlcmUgd3JhcHBpbmcKCXN0YXJ0cy4gIFdoZW4gdHlwaW5nIHRleHQgYmV5b25kIHRoaXMgbGltaXQsIGFuIDxFT0w+IHdpbGwgYmUgaW5zZXJ0ZWQKCWFuZCBpbnNlcnRpbmcgY29udGludWVzIG9uIHRoZSBuZXh0IGxpbmUuCglPcHRpb25zIHRoYXQgYWRkIGEgbWFyZ2luLCBzdWNoIGFzICdudW1iZXInIGFuZCAnZm9sZGNvbHVtbicsIGNhdXNlCgl0aGUgdGV4dCB3aWR0aCB0byBiZSBmdXJ0aGVyIHJlZHVjZWQuICBUaGlzIGlzIFZpIGNvbXBhdGlibGUuCglXaGVuICd0ZXh0d2lkdGgnIGlzIG5vbi16ZXJvLCB0aGlzIG9wdGlvbiBpcyBub3QgdXNlZC4KCVNlZSBhbHNvICdmb3JtYXRvcHRpb25zJyBhbmQgfGlucy10ZXh0d2lkdGh8LiAge1ZpOiB3b3JrcyBkaWZmZXJlbnRseQoJYW5kIGxlc3MgdXNlZnVsbHl9CgoJCQkJICAgKid3cmFwc2NhbicqICond3MnKiAqJ25vd3JhcHNjYW4nKiAqJ25vd3MnKgond3JhcHNjYW4nICd3cycJCWJvb2xlYW4JKGRlZmF1bHQgb24pCQkJKkUzODQqICpFMzg1KgoJCQlnbG9iYWwKCVNlYXJjaGVzIHdyYXAgYXJvdW5kIHRoZSBlbmQgb2YgdGhlIGZpbGUuCgoJCQkJCQkgICAqJ3dyaXRlJyogKidub3dyaXRlJyoKJ3dyaXRlJwkJCWJvb2xlYW4JKGRlZmF1bHQgb24pCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJQWxsb3dzIHdyaXRpbmcgZmlsZXMuICBXaGVuIG5vdCBzZXQsIHdyaXRpbmcgYSBmaWxlIGlzIG5vdCBhbGxvd2VkLgoJQ2FuIGJlIHVzZWQgZm9yIGEgdmlldy1vbmx5IG1vZGUsIHdoZXJlIG1vZGlmaWNhdGlvbnMgdG8gdGhlIHRleHQgYXJlCglzdGlsbCBhbGxvd2VkLiAgQ2FuIGJlIHJlc2V0IHdpdGggdGhlIHwtbXwgb3IgfC1NfCBjb21tYW5kIGxpbmUKCWFyZ3VtZW50LiAgRmlsdGVyaW5nIHRleHQgaXMgc3RpbGwgcG9zc2libGUsIGV2ZW4gdGhvdWdoIHRoaXMgcmVxdWlyZXMKCXdyaXRpbmcgYSB0ZW1wb3JhcnkgZmlsZS4KCgkJCQkgICAqJ3dyaXRlYW55JyogKid3YScqIConbm93cml0ZWFueScqIConbm93YScqCid3cml0ZWFueScgJ3dhJwkJYm9vbGVhbgkoZGVmYXVsdCBvZmYpCgkJCWdsb2JhbAoJQWxsb3dzIHdyaXRpbmcgdG8gYW55IGZpbGUgd2l0aCBubyBuZWVkIGZvciAiISIgb3ZlcnJpZGUuCgoJCQkgICAgICond3JpdGViYWNrdXAnKiAqJ3diJyogKidub3dyaXRlYmFja3VwJyogKidub3diJyoKJ3dyaXRlYmFja3VwJyAnd2InCWJvb2xlYW4JKGRlZmF1bHQgb24gd2l0aCB8K3dyaXRlYmFja3VwfCBmZWF0dXJlLCBvZmYKCQkJCQlvdGhlcndpc2UpCgkJCWdsb2JhbAoJCQl7bm90IGluIFZpfQoJTWFrZSBhIGJhY2t1cCBiZWZvcmUgb3ZlcndyaXRpbmcgYSBmaWxlLiAgVGhlIGJhY2t1cCBpcyByZW1vdmVkIGFmdGVyCgl0aGUgZmlsZSB3YXMgc3VjY2Vzc2Z1bGx5IHdyaXR0ZW4sIHVubGVzcyB0aGUgJ2JhY2t1cCcgb3B0aW9uIGlzCglhbHNvIG9uLiAgUmVzZXQgdGhpcyBvcHRpb24gaWYgeW91ciBmaWxlIHN5c3RlbSBpcyBhbG1vc3QgZnVsbC4gIFNlZQoJfGJhY2t1cC10YWJsZXwgZm9yIGFub3RoZXIgZXhwbGFuYXRpb24uCglXaGVuIHRoZSAnYmFja3Vwc2tpcCcgcGF0dGVybiBtYXRjaGVzLCBhIGJhY2t1cCBpcyBub3QgbWFkZSBhbnl3YXkuCglOT1RFOiBUaGlzIG9wdGlvbiBpcyBzZXQgdG8gdGhlIGRlZmF1bHQgdmFsdWUgd2hlbiAnY29tcGF0aWJsZScgaXMKCXNldC4KCgkJCQkJCSond3JpdGVkZWxheScqICond2QnKgond3JpdGVkZWxheScgJ3dkJwludW1iZXIJKGRlZmF1bHQgMCkKCQkJZ2xvYmFsCgkJCXtub3QgaW4gVml9CglUaGUgbnVtYmVyIG9mIG1pY3Jvc2Vjb25kcyB0byB3YWl0IGZvciBlYWNoIGNoYXJhY3RlciBzZW50IHRvIHRoZQoJc2NyZWVuLiAgV2hlbiBub24temVybywgY2hhcmFjdGVycyBhcmUgc2VudCB0byB0aGUgdGVybWluYWwgb25lIGJ5CglvbmUuICBGb3IgTVMtRE9TIHBjdGVybSB0aGlzIGRvZXMgbm90IHdvcmsuICBGb3IgZGVidWdnaW5nIHB1cnBvc2VzLgoKIHZpbTp0dz03ODp0cz04OmZ0PWhlbHA6bm9ybDoK